id
int64 0
755k
| file_name
stringlengths 3
109
| file_path
stringlengths 13
185
| content
stringlengths 31
9.38M
| size
int64 31
9.38M
| language
stringclasses 1
value | extension
stringclasses 11
values | total_lines
int64 1
340k
| avg_line_length
float64 2.18
149k
| max_line_length
int64 7
2.22M
| alphanum_fraction
float64 0
1
| repo_name
stringlengths 6
65
| repo_stars
int64 100
47.3k
| repo_forks
int64 0
12k
| repo_open_issues
int64 0
3.4k
| repo_license
stringclasses 9
values | repo_extraction_date
stringclasses 92
values | exact_duplicates_redpajama
bool 2
classes | near_duplicates_redpajama
bool 2
classes | exact_duplicates_githubcode
bool 2
classes | exact_duplicates_stackv2
bool 1
class | exact_duplicates_stackv1
bool 2
classes | near_duplicates_githubcode
bool 2
classes | near_duplicates_stackv1
bool 2
classes | near_duplicates_stackv2
bool 1
class |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
15,776
|
loader.h
|
shadps4-emu_shadPS4/src/core/loader.h
|
// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
#pragma once
#include <string>
namespace Loader {
constexpr static u32 PkgMagic = 0x544e437f;
enum class FileTypes {
Unknown,
Pkg,
};
FileTypes DetectFileType(const std::filesystem::path& filepath);
} // namespace Loader
| 347
|
C++
|
.h
| 12
| 26.75
| 66
| 0.787234
|
shadps4-emu/shadPS4
| 9,253
| 501
| 185
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
15,777
|
virtual_memory.h
|
shadps4-emu_shadPS4/src/core/virtual_memory.h
|
// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
#pragma once
#include "common/types.h"
constexpr u64 SYSTEM_RESERVED = 0x800000000u;
constexpr u64 CODE_BASE_OFFSET = 0x100000000u;
constexpr u64 SYSTEM_MANAGED_MIN = 0x0000040000u;
constexpr u64 SYSTEM_MANAGED_MAX = 0x07FFFFBFFFu;
constexpr u64 USER_MIN = 0x1000000000u;
constexpr u64 USER_MAX = 0xFBFFFFFFFFu;
namespace VirtualMemory {
enum class MemoryMode : u32 {
NoAccess = 0,
Read = 1,
Write = 2,
ReadWrite = 3,
Execute = 4,
ExecuteRead = 5,
ExecuteWrite = 6,
ExecuteReadWrite = 7,
};
u64 memory_alloc(u64 address, u64 size, MemoryMode mode);
u64 memory_alloc_aligned(u64 address, u64 size, MemoryMode mode, u64 alignment);
bool memory_protect(u64 address, u64 size, MemoryMode mode, MemoryMode* old_mode);
bool memory_flush(u64 address, u64 size);
bool memory_patch(u64 vaddr, u64 value);
inline bool containsExecuteMode(MemoryMode mode) {
switch (mode) {
case MemoryMode::Execute:
return true;
case MemoryMode::ExecuteRead:
return true;
case MemoryMode::ExecuteWrite:
return true;
case MemoryMode::ExecuteReadWrite:
return true;
default:
return false;
}
}
} // namespace VirtualMemory
| 1,311
|
C++
|
.h
| 41
| 28.390244
| 82
| 0.740506
|
shadps4-emu/shadPS4
| 9,253
| 501
| 185
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
15,778
|
tls.h
|
shadps4-emu_shadPS4/src/core/tls.h
|
// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
#pragma once
#include "common/types.h"
namespace Xbyak {
class CodeGenerator;
}
namespace Core {
union DtvEntry {
size_t counter;
u8* pointer;
};
struct Tcb {
Tcb* tcb_self;
DtvEntry* tcb_dtv;
void* tcb_thread;
};
#ifdef _WIN32
/// Gets the thread local storage key for the TCB block.
u32 GetTcbKey();
#endif
/// Sets the data pointer to the TCB block.
void SetTcbBase(void* image_address);
/// Retrieves Tcb structure for the calling thread.
Tcb* GetTcbBase();
} // namespace Core
| 624
|
C++
|
.h
| 26
| 21.846154
| 66
| 0.746599
|
shadps4-emu/shadPS4
| 9,253
| 501
| 185
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
15,779
|
memory.h
|
shadps4-emu_shadPS4/src/core/memory.h
|
// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
#pragma once
#include <map>
#include <mutex>
#include <string_view>
#include "common/enum.h"
#include "common/singleton.h"
#include "common/types.h"
#include "core/address_space.h"
#include "core/libraries/kernel/memory_management.h"
namespace Vulkan {
class Rasterizer;
}
namespace Libraries::Kernel {
struct OrbisQueryInfo;
}
namespace Core {
enum class MemoryProt : u32 {
NoAccess = 0,
CpuRead = 1,
CpuReadWrite = 2,
GpuRead = 16,
GpuWrite = 32,
GpuReadWrite = 48,
};
DECLARE_ENUM_FLAG_OPERATORS(MemoryProt)
enum class MemoryMapFlags : u32 {
NoFlags = 0,
Shared = 1,
Private = 2,
Fixed = 0x10,
NoOverwrite = 0x0080,
NoSync = 0x800,
NoCore = 0x20000,
NoCoalesce = 0x400000,
};
DECLARE_ENUM_FLAG_OPERATORS(MemoryMapFlags)
enum class VMAType : u32 {
Free = 0,
Reserved = 1,
Direct = 2,
Flexible = 3,
Pooled = 4,
PoolReserved = 5,
Stack = 6,
Code = 7,
File = 8,
};
struct DirectMemoryArea {
PAddr base = 0;
size_t size = 0;
int memory_type = 0;
bool is_pooled = false;
bool is_free = true;
PAddr GetEnd() const {
return base + size;
}
bool CanMergeWith(const DirectMemoryArea& next) const {
if (base + size != next.base) {
return false;
}
if (is_free != next.is_free) {
return false;
}
return true;
}
};
struct VirtualMemoryArea {
VAddr base = 0;
size_t size = 0;
PAddr phys_base = 0;
VMAType type = VMAType::Free;
MemoryProt prot = MemoryProt::NoAccess;
bool disallow_merge = false;
std::string name = "";
uintptr_t fd = 0;
bool is_exec = false;
bool Contains(VAddr addr, size_t size) const {
return addr >= base && (addr + size) <= (base + this->size);
}
bool IsFree() const noexcept {
return type == VMAType::Free;
}
bool IsMapped() const noexcept {
return type != VMAType::Free && type != VMAType::Reserved && type != VMAType::PoolReserved;
}
bool CanMergeWith(const VirtualMemoryArea& next) const {
if (disallow_merge || next.disallow_merge) {
return false;
}
if (base + size != next.base) {
return false;
}
if (type == VMAType::Direct && phys_base + size != next.phys_base) {
return false;
}
if (prot != next.prot || type != next.type) {
return false;
}
return true;
}
};
class MemoryManager {
using DMemMap = std::map<PAddr, DirectMemoryArea>;
using DMemHandle = DMemMap::iterator;
using VMAMap = std::map<VAddr, VirtualMemoryArea>;
using VMAHandle = VMAMap::iterator;
public:
explicit MemoryManager();
~MemoryManager();
void SetRasterizer(Vulkan::Rasterizer* rasterizer_) {
rasterizer = rasterizer_;
}
u64 GetTotalDirectSize() const {
return total_direct_size;
}
u64 GetTotalFlexibleSize() const {
return total_flexible_size;
}
u64 GetAvailableFlexibleSize() const {
return total_flexible_size - flexible_usage;
}
VAddr SystemReservedVirtualBase() noexcept {
return impl.SystemReservedVirtualBase();
}
bool TryWriteBacking(void* address, const void* data, u32 num_bytes);
void SetupMemoryRegions(u64 flexible_size);
PAddr PoolExpand(PAddr search_start, PAddr search_end, size_t size, u64 alignment);
PAddr Allocate(PAddr search_start, PAddr search_end, size_t size, u64 alignment,
int memory_type);
void Free(PAddr phys_addr, size_t size);
int PoolReserve(void** out_addr, VAddr virtual_addr, size_t size, MemoryMapFlags flags,
u64 alignment = 0);
int Reserve(void** out_addr, VAddr virtual_addr, size_t size, MemoryMapFlags flags,
u64 alignment = 0);
int PoolCommit(VAddr virtual_addr, size_t size, MemoryProt prot);
int MapMemory(void** out_addr, VAddr virtual_addr, size_t size, MemoryProt prot,
MemoryMapFlags flags, VMAType type, std::string_view name = "",
bool is_exec = false, PAddr phys_addr = -1, u64 alignment = 0);
int MapFile(void** out_addr, VAddr virtual_addr, size_t size, MemoryProt prot,
MemoryMapFlags flags, uintptr_t fd, size_t offset);
void PoolDecommit(VAddr virtual_addr, size_t size);
void UnmapMemory(VAddr virtual_addr, size_t size);
int QueryProtection(VAddr addr, void** start, void** end, u32* prot);
int Protect(VAddr addr, size_t size, MemoryProt prot);
int VirtualQuery(VAddr addr, int flags, ::Libraries::Kernel::OrbisVirtualQueryInfo* info);
int DirectMemoryQuery(PAddr addr, bool find_next,
::Libraries::Kernel::OrbisQueryInfo* out_info);
int DirectQueryAvailable(PAddr search_start, PAddr search_end, size_t alignment,
PAddr* phys_addr_out, size_t* size_out);
int GetDirectMemoryType(PAddr addr, int* directMemoryTypeOut, void** directMemoryStartOut,
void** directMemoryEndOut);
void NameVirtualRange(VAddr virtual_addr, size_t size, std::string_view name);
private:
VMAHandle FindVMA(VAddr target) {
return std::prev(vma_map.upper_bound(target));
}
DMemHandle FindDmemArea(PAddr target) {
return std::prev(dmem_map.upper_bound(target));
}
template <typename Handle>
Handle MergeAdjacent(auto& handle_map, Handle iter) {
const auto next_vma = std::next(iter);
if (next_vma != handle_map.end() && iter->second.CanMergeWith(next_vma->second)) {
iter->second.size += next_vma->second.size;
handle_map.erase(next_vma);
}
if (iter != handle_map.begin()) {
auto prev_vma = std::prev(iter);
if (prev_vma->second.CanMergeWith(iter->second)) {
prev_vma->second.size += iter->second.size;
handle_map.erase(iter);
iter = prev_vma;
}
}
return iter;
}
VAddr SearchFree(VAddr virtual_addr, size_t size, u32 alignment = 0);
VMAHandle CarveVMA(VAddr virtual_addr, size_t size);
DMemHandle CarveDmemArea(PAddr addr, size_t size);
VMAHandle Split(VMAHandle vma_handle, size_t offset_in_vma);
DMemHandle Split(DMemHandle dmem_handle, size_t offset_in_area);
void UnmapMemoryImpl(VAddr virtual_addr, size_t size);
private:
AddressSpace impl;
DMemMap dmem_map;
VMAMap vma_map;
std::mutex mutex;
size_t total_direct_size{};
size_t total_flexible_size{};
size_t flexible_usage{};
Vulkan::Rasterizer* rasterizer{};
};
using Memory = Common::Singleton<MemoryManager>;
} // namespace Core
| 6,914
|
C++
|
.h
| 196
| 28.688776
| 99
| 0.645849
|
shadps4-emu/shadPS4
| 9,253
| 501
| 185
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
15,780
|
module.h
|
shadps4-emu_shadPS4/src/core/module.h
|
// 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"
#include "core/loader/elf.h"
#include "core/loader/symbols_resolver.h"
namespace Core {
static constexpr size_t SCE_DBG_MAX_NAME_LENGTH = 256;
static constexpr size_t SCE_DBG_MAX_SEGMENTS = 4;
static constexpr size_t SCE_DBG_NUM_FINGERPRINT = 20;
struct OrbisKernelModuleSegmentInfo {
VAddr address;
u32 size;
s32 prot;
};
struct OrbisKernelModuleInfo {
u64 st_size = sizeof(OrbisKernelModuleInfo);
std::array<char, SCE_DBG_MAX_NAME_LENGTH> name;
std::array<OrbisKernelModuleSegmentInfo, SCE_DBG_MAX_SEGMENTS> segments;
u32 num_segments;
std::array<u8, SCE_DBG_NUM_FINGERPRINT> fingerprint;
};
struct OrbisKernelModuleInfoEx {
u64 st_size = sizeof(OrbisKernelModuleInfoEx);
std::array<char, SCE_DBG_MAX_NAME_LENGTH> name;
s32 id;
u32 tls_index;
VAddr tls_init_addr;
u32 tls_init_size;
u32 tls_size;
u32 tls_offset;
u32 tls_align;
VAddr init_proc_addr;
VAddr fini_proc_addr;
u64 reserved1;
u64 reserved2;
VAddr eh_frame_hdr_addr;
VAddr eh_frame_addr;
u32 eh_frame_hdr_size;
u32 eh_frame_size;
std::array<OrbisKernelModuleSegmentInfo, SCE_DBG_MAX_SEGMENTS> segments;
u32 segment_count;
};
struct ModuleInfo {
bool operator==(const ModuleInfo& other) const {
return version_major == other.version_major && version_minor == other.version_minor &&
name == other.name;
}
std::string name;
union {
u64 value;
struct {
u32 name_offset;
u8 version_minor;
u8 version_major;
u16 id;
};
};
std::string enc_id;
};
struct LibraryInfo {
bool operator==(const LibraryInfo& other) const {
return version == other.version && name == other.name;
}
std::string name;
union {
u64 value;
struct {
u32 name_offset;
u16 version;
u16 id;
};
};
std::string enc_id;
};
struct ThreadLocalImage {
u32 align;
u32 image_size;
u32 offset;
u32 modid;
VAddr image_virtual_addr;
u32 init_image_size;
};
struct DynamicModuleInfo {
void* hash_table = nullptr;
u64 hash_table_size = 0;
char* str_table = nullptr;
u64 str_table_size = 0;
elf_symbol* symbol_table = nullptr;
u64 symbol_table_total_size = 0;
u64 symbol_table_entries_size = 0;
u64 init_virtual_addr = 0;
u64 fini_virtual_addr = 0;
u64 pltgot_virtual_addr = 0;
u64 init_array_virtual_addr = 0;
u64 fini_array_virtual_addr = 0;
u64 preinit_array_virtual_addr = 0;
u64 init_array_size = 0;
u64 fini_array_size = 0;
u64 preinit_array_size = 0;
elf_relocation* jmp_relocation_table = nullptr;
u64 jmp_relocation_table_size = 0;
s64 jmp_relocation_type = 0;
elf_relocation* relocation_table = nullptr;
u64 relocation_table_size = 0;
u64 relocation_table_entries_size = 0;
u64 debug = 0;
u64 textrel = 0;
u64 flags = 0;
std::vector<const char*> needed;
std::vector<ModuleInfo> import_modules;
std::vector<ModuleInfo> export_modules;
std::vector<LibraryInfo> import_libs;
std::vector<LibraryInfo> export_libs;
std::string filename;
};
using ModuleFunc = int (*)(size_t, const void*);
class MemoryManager;
class Module {
public:
explicit Module(Core::MemoryManager* memory, const std::filesystem::path& file,
u32& max_tls_index);
~Module();
VAddr GetBaseAddress() const noexcept {
return base_virtual_addr;
}
VAddr GetEntryAddress() const noexcept {
return base_virtual_addr + elf.GetElfEntry();
}
OrbisKernelModuleInfo GetModuleInfo() const noexcept {
return info;
}
bool IsValid() const noexcept {
return base_virtual_addr != 0;
}
bool IsSharedLib() const noexcept {
return elf.IsSharedLib();
}
void* FindByName(std::string_view name) {
const auto symbols = export_sym.GetSymbols();
const auto it = std::ranges::find(symbols, name, &Loader::SymbolRecord::nid_name);
if (it != symbols.end()) {
return reinterpret_cast<void*>(it->virtual_address);
}
return nullptr;
}
template <typename T = VAddr>
T GetProcParam() const noexcept {
return reinterpret_cast<T>(proc_param_virtual_addr);
}
std::span<const ModuleInfo> GetImportModules() const {
return dynamic_info.import_modules;
}
std::span<const ModuleInfo> GetExportModules() const {
return dynamic_info.export_modules;
}
std::span<const LibraryInfo> GetImportLibs() const {
return dynamic_info.import_libs;
}
std::span<const LibraryInfo> GetExportLibs() const {
return dynamic_info.export_libs;
}
void ForEachRelocation(auto&& func) {
for (u32 i = 0; i < dynamic_info.relocation_table_size / sizeof(elf_relocation); i++) {
func(&dynamic_info.relocation_table[i], i, false);
}
for (u32 i = 0; i < dynamic_info.jmp_relocation_table_size / sizeof(elf_relocation); i++) {
func(&dynamic_info.jmp_relocation_table[i], i, true);
}
}
void SetRelaBit(u32 index) {
rela_bits[index >> 3] |= (1 << (index & 7));
}
bool TestRelaBit(u32 index) const {
return (rela_bits[index >> 3] >> (index & 7)) & 1;
}
s32 Start(size_t args, const void* argp, void* param);
void LoadModuleToMemory(u32& max_tls_index);
void LoadDynamicInfo();
void LoadSymbols();
OrbisKernelModuleInfoEx GetModuleInfoEx() const;
const ModuleInfo* FindModule(std::string_view id);
const LibraryInfo* FindLibrary(std::string_view id);
public:
Core::MemoryManager* memory;
std::filesystem::path file;
std::string name;
Loader::Elf elf;
u64 aligned_base_size{};
VAddr base_virtual_addr{};
VAddr proc_param_virtual_addr{};
VAddr eh_frame_hdr_addr{};
VAddr eh_frame_addr{};
u32 eh_frame_hdr_size{};
u32 eh_frame_size{};
DynamicModuleInfo dynamic_info{};
std::vector<u8> m_dynamic;
std::vector<u8> m_dynamic_data;
Loader::SymbolsResolver export_sym;
Loader::SymbolsResolver import_sym;
ThreadLocalImage tls{};
OrbisKernelModuleInfo info{};
std::vector<u8> rela_bits;
};
} // namespace Core
| 6,552
|
C++
|
.h
| 207
| 26.024155
| 99
| 0.659055
|
shadps4-emu/shadPS4
| 9,253
| 501
| 185
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
15,781
|
linker.h
|
shadps4-emu_shadPS4/src/core/linker.h
|
// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
#pragma once
#include <algorithm>
#include <mutex>
#include <vector>
#include "core/module.h"
namespace Core {
struct DynamicModuleInfo;
class Linker;
class MemoryManager;
struct OrbisKernelMemParam {
u64 size;
u64* extended_page_table;
u64* flexible_memory_size;
u8* extended_memory_1;
u64* extended_gpu_page_table;
u8* extended_memory_2;
u64* exnteded_cpu_page_table;
};
struct OrbisProcParam {
u64 size;
u32 magic;
u32 entry_count;
u64 sdk_version;
char* process_name;
char* main_thread_name;
u32* main_thread_prio;
u32* main_thread_stack_size;
void* libc_param;
OrbisKernelMemParam* mem_param;
void* fs_param;
u32* process_preload_enable;
u64 unknown1;
};
struct EntryParams {
int argc;
u32 padding;
const char* argv[3];
};
struct HeapAPI {
PS4_SYSV_ABI void* (*heap_malloc)(size_t);
PS4_SYSV_ABI void (*heap_free)(void*);
PS4_SYSV_ABI void* (*heap_calloc)(size_t, size_t);
PS4_SYSV_ABI void* (*heap_realloc)(void*, size_t);
PS4_SYSV_ABI void* (*heap_memalign)(size_t, size_t);
PS4_SYSV_ABI int (*heap_posix_memalign)(void**, size_t, size_t);
// NOTE: Fields below may be inaccurate
PS4_SYSV_ABI int (*heap_reallocalign)(void);
PS4_SYSV_ABI void (*heap_malloc_stats)(void);
PS4_SYSV_ABI int (*heap_malloc_stats_fast)(void);
PS4_SYSV_ABI size_t (*heap_malloc_usable_size)(void*);
};
using AppHeapAPI = HeapAPI*;
class Linker {
public:
explicit Linker();
~Linker();
Loader::SymbolsResolver& GetHLESymbols() {
return m_hle_symbols;
}
OrbisProcParam* GetProcParam() const {
return m_modules[0]->GetProcParam<OrbisProcParam*>();
}
Module* GetModule(s32 index) const {
return m_modules.at(index).get();
}
void RelocateAnyImports(Module* m) {
Relocate(m);
for (auto& module : m_modules) {
const auto imports = module->GetImportModules();
if (std::ranges::contains(imports, m->name, &ModuleInfo::name)) {
Relocate(module.get());
}
}
}
void SetHeapAPI(void* func[]) {
heap_api = reinterpret_cast<AppHeapAPI>(func);
}
void AdvanceGenerationCounter() noexcept {
dtv_generation_counter++;
}
void* TlsGetAddr(u64 module_index, u64 offset);
s32 LoadModule(const std::filesystem::path& elf_name, bool is_dynamic = false);
Module* FindByAddress(VAddr address);
void Relocate(Module* module);
bool Resolve(const std::string& name, Loader::SymbolType type, Module* module,
Loader::SymbolRecord* return_info);
void Execute();
void DebugDump();
template <class ReturnType, class... FuncArgs, class... CallArgs>
ReturnType ExecuteGuest(PS4_SYSV_ABI ReturnType (*func)(FuncArgs...),
CallArgs&&... args) const {
// Make sure TLS is initialized for the thread before entering guest.
EnsureThreadInitialized();
return ExecuteGuestWithoutTls(func, args...);
}
private:
const Module* FindExportedModule(const ModuleInfo& m, const LibraryInfo& l);
void EnsureThreadInitialized(bool is_primary = false) const;
void InitTlsForThread(bool is_primary) const;
template <class ReturnType, class... FuncArgs, class... CallArgs>
ReturnType ExecuteGuestWithoutTls(PS4_SYSV_ABI ReturnType (*func)(FuncArgs...),
CallArgs&&... args) const {
return func(std::forward<CallArgs>(args)...);
}
MemoryManager* memory;
std::mutex mutex;
u32 dtv_generation_counter{1};
size_t static_tls_size{};
u32 max_tls_index{};
u32 num_static_modules{};
AppHeapAPI heap_api{};
std::vector<std::unique_ptr<Module>> m_modules;
Loader::SymbolsResolver m_hle_symbols{};
};
} // namespace Core
| 3,992
|
C++
|
.h
| 117
| 28.444444
| 83
| 0.664243
|
shadps4-emu/shadPS4
| 9,253
| 501
| 185
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
15,782
|
platform.h
|
shadps4-emu_shadPS4/src/core/platform.h
|
// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
#pragma once
#include "common/assert.h"
#include "common/logging/log.h"
#include "common/singleton.h"
#include "common/types.h"
#include "magic_enum.hpp"
#include <functional>
#include <mutex>
#include <unordered_map>
#include <queue>
namespace Platform {
enum class InterruptId : u32 {
Compute0RelMem = 0x00,
Compute1RelMem = 0x01,
Compute2RelMem = 0x02,
Compute3RelMem = 0x03,
Compute4RelMem = 0x04,
Compute5RelMem = 0x05,
Compute6RelMem = 0x06,
GfxEop = 0x40,
GfxFlip = 0x08,
GpuIdle = 0x09,
InterruptIdMax = 0x40, ///< Max possible value (GfxEop)
};
using IrqHandler = std::function<void(InterruptId)>;
struct IrqController {
void RegisterOnce(InterruptId irq, IrqHandler handler) {
ASSERT_MSG(static_cast<u32>(irq) <= static_cast<u32>(InterruptId::InterruptIdMax),
"Invalid IRQ number");
auto& ctx = irq_contexts.try_emplace(irq).first->second;
std::unique_lock lock{ctx.m_lock};
ctx.one_time_subscribers.emplace(handler);
}
void Register(InterruptId irq, IrqHandler handler, void* uid) {
ASSERT_MSG(static_cast<u32>(irq) <= static_cast<u32>(InterruptId::InterruptIdMax),
"Invalid IRQ number");
auto& ctx = irq_contexts.try_emplace(irq).first->second;
std::unique_lock lock{ctx.m_lock};
ASSERT_MSG(ctx.persistent_handlers.find(uid) == ctx.persistent_handlers.cend(),
"The handler is already registered!");
ctx.persistent_handlers.emplace(uid, handler);
}
void Unregister(InterruptId irq, void* uid) {
ASSERT_MSG(static_cast<u32>(irq) <= static_cast<u32>(InterruptId::InterruptIdMax),
"Invalid IRQ number");
auto& ctx = irq_contexts.try_emplace(irq).first->second;
std::unique_lock lock{ctx.m_lock};
ctx.persistent_handlers.erase(uid);
}
void Signal(InterruptId irq) {
ASSERT_MSG(static_cast<u32>(irq) <= static_cast<u32>(InterruptId::InterruptIdMax),
"Unexpected IRQ signaled");
auto& ctx = irq_contexts.try_emplace(irq).first->second;
std::unique_lock lock{ctx.m_lock};
LOG_TRACE(Core, "IRQ signaled: {}", magic_enum::enum_name(irq));
for (auto& [uid, h] : ctx.persistent_handlers) {
h(irq);
}
if (!ctx.one_time_subscribers.empty()) {
const auto& h = ctx.one_time_subscribers.front();
h(irq);
ctx.one_time_subscribers.pop();
}
}
private:
struct IrqContext {
std::unordered_map<void*, IrqHandler> persistent_handlers{};
std::queue<IrqHandler> one_time_subscribers{};
std::mutex m_lock{};
};
std::unordered_map<InterruptId, IrqContext> irq_contexts{};
};
using IrqC = Common::Singleton<IrqController>;
} // namespace Platform
| 2,984
|
C++
|
.h
| 76
| 32.447368
| 90
| 0.654552
|
shadps4-emu/shadPS4
| 9,253
| 501
| 185
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
15,783
|
cpu_patches.h
|
shadps4-emu_shadPS4/src/core/cpu_patches.h
|
// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
#pragma once
namespace Core {
/// Initializes a stack for the current thread for use by patch implementations.
void InitializeThreadPatchStack();
/// Cleans up the patch stack for the current thread.
void CleanupThreadPatchStack();
/// Registers a module for patching, providing an area to generate trampoline code.
void RegisterPatchModule(void* module_ptr, u64 module_size, void* trampoline_area_ptr,
u64 trampoline_area_size);
/// Applies CPU patches that need to be done before beginning executions.
void PrePatchInstructions(u64 segment_addr, u64 segment_size);
} // namespace Core
| 731
|
C++
|
.h
| 14
| 48.928571
| 86
| 0.778873
|
shadps4-emu/shadPS4
| 9,253
| 501
| 185
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
15,784
|
debug_state.h
|
shadps4-emu_shadPS4/src/core/debug_state.h
|
// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
#pragma once
#include <atomic>
#include <mutex>
#include <shared_mutex>
#include <unordered_map>
#include <vector>
#include <queue>
#include "common/types.h"
#include "video_core/amdgpu/liverpool.h"
#include "video_core/renderer_vulkan/vk_pipeline_cache.h"
#ifdef _WIN32
#ifndef WIN32_LEAN_AND_MEAN
#define WIN32_LEAN_AND_MEAN 1
#endif
#include <Windows.h>
using ThreadID = DWORD;
#else
#include <pthread.h>
#include <signal.h>
using ThreadID = pthread_t;
#endif
namespace Core::Devtools {
class Layer;
namespace Widget {
class FrameGraph;
}
} // namespace Core::Devtools
namespace DebugStateType {
enum class QueueType {
dcb = 0,
ccb = 1,
acb = 2,
};
struct QueueDump {
QueueType type;
u32 submit_num;
u32 num2; // acb: queue_num; else: buffer_in_submit
std::vector<u32> data;
uintptr_t base_addr;
};
struct ShaderDump {
Vulkan::Liverpool::ShaderProgram user_data{};
std::vector<u32> code{};
};
struct ComputerShaderDump {
Vulkan::Liverpool::ComputeProgram cs_program{};
std::vector<u32> code{};
};
struct RegDump {
bool is_compute{false};
static constexpr size_t MaxShaderStages = 5;
Vulkan::Liverpool::Regs regs{};
std::array<ShaderDump, MaxShaderStages> stages{};
ComputerShaderDump cs_data{};
};
struct FrameDump {
u32 frame_id;
std::vector<QueueDump> queues;
std::unordered_map<uintptr_t, RegDump> regs; // address -> reg dump
};
class DebugStateImpl {
friend class Core::Devtools::Layer;
friend class Core::Devtools::Widget::FrameGraph;
std::mutex guest_threads_mutex{};
std::vector<ThreadID> guest_threads{};
std::atomic_bool is_guest_threads_paused = false;
u64 pause_time{};
std::atomic_int32_t flip_frame_count = 0;
std::atomic_int32_t gnm_frame_count = 0;
s32 gnm_frame_dump_request_count = -1;
std::unordered_map<size_t, FrameDump*> waiting_reg_dumps;
std::unordered_map<size_t, std::string> waiting_reg_dumps_dbg;
bool waiting_submit_pause = false;
bool should_show_frame_dump = false;
std::shared_mutex frame_dump_list_mutex;
std::vector<FrameDump> frame_dump_list{};
std::queue<std::string> debug_message_popup;
public:
void ShowDebugMessage(std::string message) {
if (message.empty()) {
return;
}
debug_message_popup.push(std::move(message));
}
void AddCurrentThreadToGuestList();
void RemoveCurrentThreadFromGuestList();
void PauseGuestThreads();
void ResumeGuestThreads();
bool IsGuestThreadsPaused() const {
return is_guest_threads_paused;
}
void IncFlipFrameNum() {
++flip_frame_count;
}
void IncGnmFrameNum() {
++gnm_frame_count;
--gnm_frame_dump_request_count;
}
u32 GetFrameNum() const {
return flip_frame_count;
}
bool DumpingCurrentFrame() const {
return gnm_frame_dump_request_count > 0;
}
bool DumpingCurrentReg() {
std::shared_lock lock{frame_dump_list_mutex};
return !waiting_reg_dumps.empty();
}
bool ShouldPauseInSubmit() const {
return waiting_submit_pause && gnm_frame_dump_request_count == 0;
}
void RequestFrameDump(s32 count = 1);
FrameDump& GetFrameDump() {
return frame_dump_list[frame_dump_list.size() - gnm_frame_dump_request_count];
}
void PushQueueDump(QueueDump dump);
void PushRegsDump(uintptr_t base_addr, uintptr_t header_addr,
const AmdGpu::Liverpool::Regs& regs, bool is_compute = false);
};
} // namespace DebugStateType
extern DebugStateType::DebugStateImpl& DebugState;
| 3,751
|
C++
|
.h
| 123
| 26.105691
| 86
| 0.696911
|
shadps4-emu/shadPS4
| 9,253
| 501
| 185
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
15,785
|
address_space.h
|
shadps4-emu_shadPS4/src/core/address_space.h
|
// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
#pragma once
#include <memory>
#include "common/arch.h"
#include "common/enum.h"
#include "common/types.h"
namespace Core {
enum class MemoryPermission : u32 {
Read = 1 << 0,
Write = 1 << 1,
ReadWrite = Read | Write,
Execute = 1 << 2,
ReadWriteExecute = Read | Write | Execute,
};
DECLARE_ENUM_FLAG_OPERATORS(MemoryPermission)
constexpr VAddr CODE_BASE_OFFSET = 0x100000000ULL;
constexpr VAddr SYSTEM_MANAGED_MIN = 0x00000400000ULL;
constexpr VAddr SYSTEM_MANAGED_MAX = 0x07FFFFBFFFULL;
constexpr VAddr SYSTEM_RESERVED_MIN = 0x07FFFFC000ULL;
#if defined(__APPLE__) && defined(ARCH_X86_64)
// Can only comfortably reserve the first 0x7C0000000 of system reserved space.
constexpr VAddr SYSTEM_RESERVED_MAX = 0xFBFFFFFFFULL;
#else
constexpr VAddr SYSTEM_RESERVED_MAX = 0xFFFFFFFFFULL;
#endif
constexpr VAddr USER_MIN = 0x1000000000ULL;
constexpr VAddr USER_MAX = 0xFBFFFFFFFFULL;
static constexpr size_t SystemManagedSize = SYSTEM_MANAGED_MAX - SYSTEM_MANAGED_MIN + 1;
static constexpr size_t SystemReservedSize = SYSTEM_RESERVED_MAX - SYSTEM_RESERVED_MIN + 1;
static constexpr size_t UserSize = 1ULL << 40;
/**
* Represents the user virtual address space backed by a dmem memory block
*/
class AddressSpace {
public:
explicit AddressSpace();
~AddressSpace();
[[nodiscard]] u8* BackingBase() const noexcept {
return backing_base;
}
[[nodiscard]] VAddr SystemManagedVirtualBase() noexcept {
return reinterpret_cast<VAddr>(system_managed_base);
}
[[nodiscard]] const u8* SystemManagedVirtualBase() const noexcept {
return system_managed_base;
}
[[nodiscard]] size_t SystemManagedVirtualSize() const noexcept {
return system_managed_size;
}
[[nodiscard]] VAddr SystemReservedVirtualBase() noexcept {
return reinterpret_cast<VAddr>(system_reserved_base);
}
[[nodiscard]] const u8* SystemReservedVirtualBase() const noexcept {
return system_reserved_base;
}
[[nodiscard]] size_t SystemReservedVirtualSize() const noexcept {
return system_reserved_size;
}
[[nodiscard]] VAddr UserVirtualBase() noexcept {
return reinterpret_cast<VAddr>(user_base);
}
[[nodiscard]] const u8* UserVirtualBase() const noexcept {
return user_base;
}
[[nodiscard]] size_t UserVirtualSize() const noexcept {
return user_size;
}
/**
* @brief Maps memory to the specified virtual address.
* @param virtual_addr The base address to place the mapping.
* If zero is provided an address in system managed area is picked.
* @param size The size of the area to map.
* @param phys_addr The offset of the backing file handle to map.
* The same backing region may be aliased into different virtual regions.
* If zero is provided the mapping is considered as private.
* @return A pointer to the mapped memory.
*/
void* Map(VAddr virtual_addr, size_t size, u64 alignment = 0, PAddr phys_addr = -1,
bool exec = false);
/// Memory maps a specified file descriptor.
void* MapFile(VAddr virtual_addr, size_t size, size_t offset, u32 prot, uintptr_t fd);
/// Unmaps specified virtual memory area.
void Unmap(VAddr virtual_addr, size_t size, VAddr start_in_vma, VAddr end_in_vma,
PAddr phys_base, bool is_exec, bool has_backing, bool readonly_file);
void Protect(VAddr virtual_addr, size_t size, MemoryPermission perms);
private:
struct Impl;
std::unique_ptr<Impl> impl;
u8* backing_base{};
u8* system_managed_base{};
size_t system_managed_size{};
u8* system_reserved_base{};
size_t system_reserved_size{};
u8* user_base{};
size_t user_size{};
};
} // namespace Core
| 3,916
|
C++
|
.h
| 98
| 35.428571
| 94
| 0.705263
|
shadps4-emu/shadPS4
| 9,253
| 501
| 185
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
15,786
|
signals.h
|
shadps4-emu_shadPS4/src/core/signals.h
|
// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
#pragma once
#include <set>
#include "common/singleton.h"
namespace Core {
using AccessViolationHandler = bool (*)(void* context, void* fault_address);
using IllegalInstructionHandler = bool (*)(void* context);
/// Receives OS signals and dispatches to the appropriate handlers.
class SignalDispatch {
public:
SignalDispatch();
~SignalDispatch();
/// Registers a handler for memory access violation signals.
void RegisterAccessViolationHandler(const AccessViolationHandler& handler, u32 priority) {
access_violation_handlers.emplace(handler, priority);
}
/// Registers a handler for illegal instruction signals.
void RegisterIllegalInstructionHandler(const IllegalInstructionHandler& handler, u32 priority) {
illegal_instruction_handlers.emplace(handler, priority);
}
/// Dispatches an access violation signal, returning whether it was successfully handled.
bool DispatchAccessViolation(void* context, void* fault_address) const;
/// Dispatches an illegal instruction signal, returning whether it was successfully handled.
bool DispatchIllegalInstruction(void* context) const;
private:
template <typename T>
struct HandlerEntry {
T handler;
u32 priority;
std::strong_ordering operator<=>(const HandlerEntry& right) const {
return priority <=> right.priority;
}
};
std::set<HandlerEntry<AccessViolationHandler>> access_violation_handlers;
std::set<HandlerEntry<IllegalInstructionHandler>> illegal_instruction_handlers;
#ifdef _WIN32
void* handle{};
#endif
};
using Signals = Common::Singleton<SignalDispatch>;
} // namespace Core
| 1,786
|
C++
|
.h
| 42
| 38.071429
| 100
| 0.756788
|
shadps4-emu/shadPS4
| 9,253
| 501
| 185
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
15,787
|
libs.h
|
shadps4-emu_shadPS4/src/core/libraries/libs.h
|
// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
#pragma once
#include <functional>
#include "common/logging/log.h"
#include "core/loader/elf.h"
#include "core/loader/symbols_resolver.h"
template <size_t N>
struct StringLiteral {
constexpr StringLiteral(const char (&str)[N]) {
std::copy_n(str, N, value);
}
char value[N];
};
template <StringLiteral name, class F, F f>
struct wrapper_impl;
template <StringLiteral name, class R, class... Args, PS4_SYSV_ABI R (*f)(Args...)>
struct wrapper_impl<name, PS4_SYSV_ABI R (*)(Args...), f> {
static R PS4_SYSV_ABI wrap(Args... args) {
if (std::string_view(name.value) != "scePthreadEqual" &&
std::string_view(name.value) != "sceUserServiceGetEvent") {
// LOG_WARNING(Core_Linker, "Function {} called", name.value);
}
if constexpr (std::is_same_v<R, s32> || std::is_same_v<R, u32>) {
const u32 ret = f(args...);
if (ret != 0 && std::string_view(name.value) != "scePthreadEqual") {
LOG_WARNING(Core_Linker, "Function {} returned {:#x}", name.value, ret);
}
return ret;
}
// stuff
return f(args...);
}
};
template <StringLiteral name, class F, F f>
constexpr auto wrapper = wrapper_impl<name, F, f>::wrap;
// #define W(foo) wrapper<#foo, decltype(&foo), foo>
#define W(foo) foo
#define LIB_FUNCTION(nid, lib, libversion, mod, moduleVersionMajor, moduleVersionMinor, function) \
{ \
Core::Loader::SymbolResolver sr{}; \
sr.name = nid; \
sr.library = lib; \
sr.library_version = libversion; \
sr.module = mod; \
sr.module_version_major = moduleVersionMajor; \
sr.module_version_minor = moduleVersionMinor; \
sr.type = Core::Loader::SymbolType::Function; \
auto func = reinterpret_cast<u64>(W(function)); \
sym->AddSymbol(sr, func); \
}
#define LIB_OBJ(nid, lib, libversion, mod, moduleVersionMajor, moduleVersionMinor, function) \
{ \
Core::Loader::SymbolResolver sr{}; \
sr.name = nid; \
sr.library = lib; \
sr.library_version = libversion; \
sr.module = mod; \
sr.module_version_major = moduleVersionMajor; \
sr.module_version_minor = moduleVersionMinor; \
sr.type = Core::Loader::SymbolType::Object; \
auto func = reinterpret_cast<u64>(function); \
sym->AddSymbol(sr, func); \
}
namespace Libraries {
void InitHLELibs(Core::Loader::SymbolsResolver* sym);
} // namespace Libraries
| 3,996
|
C++
|
.h
| 67
| 53.358209
| 100
| 0.409962
|
shadps4-emu/shadPS4
| 9,253
| 501
| 185
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
15,788
|
error_codes.h
|
shadps4-emu_shadPS4/src/core/libraries/error_codes.h
|
// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
#pragma once
// posix error codes
constexpr int POSIX_EPERM = 1;
constexpr int POSIX_ENOENT = 2;
constexpr int POSIX_ESRCH = 3;
constexpr int POSIX_EINTR = 4;
constexpr int POSIX_EIO = 5;
constexpr int POSIX_ENXIO = 6;
constexpr int POSIX_E2BIG = 7;
constexpr int POSIX_ENOEXEC = 8;
constexpr int POSIX_EBADF = 9;
constexpr int POSIX_ECHILD = 10;
constexpr int POSIX_EDEADLK = 11;
constexpr int POSIX_ENOMEM = 12;
constexpr int POSIX_EACCES = 13;
constexpr int POSIX_EFAULT = 14;
constexpr int POSIX_ENOTBLK = 15;
constexpr int POSIX_EBUSY = 16;
constexpr int POSIX_EEXIST = 17;
constexpr int POSIX_EXDEV = 18;
constexpr int POSIX_ENODEV = 19;
constexpr int POSIX_ENOTDIR = 20;
constexpr int POSIX_EISDIR = 21;
constexpr int POSIX_EINVAL = 22;
constexpr int POSIX_ENFILE = 23;
constexpr int POSIX_EMFILE = 24;
constexpr int POSIX_ENOTTY = 25;
constexpr int POSIX_ETXTBSY = 26;
constexpr int POSIX_EFBIG = 27;
constexpr int POSIX_ENOSPC = 28;
constexpr int POSIX_ESPIPE = 29;
constexpr int POSIX_EROFS = 30;
constexpr int POSIX_EMLINK = 31;
constexpr int POSIX_EPIPE = 32;
constexpr int POSIX_EDOM = 33;
constexpr int POSIX_ERANGE = 34;
constexpr int POSIX_EAGAIN = 35;
constexpr int POSIX_EWOULDBLOCK = 35;
constexpr int POSIX_EINPROGRESS = 36;
constexpr int POSIX_EALREADY = 37;
constexpr int POSIX_ENOTSOCK = 38;
constexpr int POSIX_EDESTADDRREQ = 39;
constexpr int POSIX_EMSGSIZE = 40;
constexpr int POSIX_EPROTOTYPE = 41;
constexpr int POSIX_ENOPROTOOPT = 42;
constexpr int POSIX_EPROTONOSUPPORT = 43;
constexpr int POSIX_ESOCKTNOSUPPORT = 44;
constexpr int POSIX_EOPNOTSUPP = 45;
constexpr int POSIX_ENOTSUP = 45;
constexpr int POSIX_EPFNOSUPPORT = 46;
constexpr int POSIX_EAFNOSUPPORT = 47;
constexpr int POSIX_EADDRINUSE = 48;
constexpr int POSIX_EADDRNOTAVAIL = 49;
constexpr int POSIX_ENETDOWN = 50;
constexpr int POSIX_ENETUNREACH = 51;
constexpr int POSIX_ENETRESET = 52;
constexpr int POSIX_ECONNABORTED = 53;
constexpr int POSIX_ECONNRESET = 54;
constexpr int POSIX_ENOBUFS = 55;
constexpr int POSIX_EISCONN = 56;
constexpr int POSIX_ENOTCONN = 57;
constexpr int POSIX_ESHUTDOWN = 58;
constexpr int POSIX_ETOOMANYREFS = 59;
constexpr int POSIX_ETIMEDOUT = 60;
constexpr int POSIX_ECONNREFUSED = 61;
constexpr int POSIX_ELOOP = 62;
constexpr int POSIX_ENAMETOOLONG = 63;
constexpr int POSIX_EHOSTDOWN = 64;
constexpr int POSIX_EHOSTUNREACH = 65;
constexpr int POSIX_ENOTEMPTY = 66;
constexpr int POSIX_EPROCLIM = 67;
constexpr int POSIX_EUSERS = 68;
constexpr int POSIX_EDQUOT = 69;
constexpr int POSIX_ESTALE = 70;
constexpr int POSIX_EREMOTE = 71;
constexpr int POSIX_EBADRPC = 72;
constexpr int POSIX_ERPCMISMATCH = 73;
constexpr int POSIX_EPROGUNAVAIL = 74;
constexpr int POSIX_EPROGMISMATCH = 75;
constexpr int POSIX_EPROCUNAVAIL = 76;
constexpr int POSIX_ENOLCK = 77;
constexpr int POSIX_ENOSYS = 78;
constexpr int POSIX_EFTYPE = 79;
constexpr int POSIX_EAUTH = 80;
constexpr int POSIX_ENEEDAUTH = 81;
constexpr int POSIX_EIDRM = 82;
constexpr int POSIX_ENOMSG = 83;
constexpr int POSIX_EOVERFLOW = 84;
constexpr int POSIX_ECANCELED = 85;
constexpr int POSIX_EILSEQ = 86;
constexpr int POSIX_ENOATTR = 87;
constexpr int POSIX_EDOOFUS = 88;
constexpr int POSIX_EBADMSG = 89;
constexpr int POSIX_EMULTIHOP = 90;
constexpr int POSIX_ENOLINK = 91;
constexpr int POSIX_EPROTO = 92;
constexpr int POSIX_ENOTCAPABLE = 93;
constexpr int POSIX_ECAPMODE = 94;
constexpr int POSIX_ENOBLK = 95;
constexpr int POSIX_EICV = 96;
constexpr int POSIX_ENOPLAYGOENT = 97;
constexpr int POSIX_EREVOKE = 98;
constexpr int POSIX_ESDKVERSION = 99;
constexpr int POSIX_ESTART = 100;
constexpr int POSIX_ESTOP = 101;
constexpr int POSIX_EINVALID2MB = 102;
constexpr int POSIX_ELAST = 102;
constexpr int POSIX_EADHOC = 160;
constexpr int POSIX_EINACTIVEDISABLED = 163;
constexpr int POSIX_ENETNODATA = 164;
constexpr int POSIX_ENETDESC = 165;
constexpr int POSIX_ENETDESCTIMEDOUT = 166;
constexpr int POSIX_ENETINTR = 167;
constexpr int POSIX_ERETURN = 205;
constexpr int POSIX_EFPOS = 152;
constexpr int POSIX_ENODATA = 1040;
constexpr int POSIX_ENOSR = 1050;
constexpr int POSIX_ENOSTR = 1051;
constexpr int POSIX_ENOTRECOVERABLE = 1056;
constexpr int POSIX_EOTHER = 1062;
constexpr int POSIX_EOWNERDEAD = 1064;
constexpr int POSIX_ETIME = 1074;
constexpr int SCE_OK = 0;
// kernel error codes
constexpr int SCE_KERNEL_ERROR_UNKNOWN = 0x80020000;
constexpr int SCE_KERNEL_ERROR_EPERM = 0x80020001;
constexpr int SCE_KERNEL_ERROR_ENOENT = 0x80020002;
constexpr int SCE_KERNEL_ERROR_ESRCH = 0x80020003;
constexpr int SCE_KERNEL_ERROR_EINTR = 0x80020004;
constexpr int SCE_KERNEL_ERROR_EIO = 0x80020005;
constexpr int SCE_KERNEL_ERROR_ENXIO = 0x80020006;
constexpr int SCE_KERNEL_ERROR_E2BIG = 0x80020007;
constexpr int SCE_KERNEL_ERROR_ENOEXEC = 0x80020008;
constexpr int SCE_KERNEL_ERROR_EBADF = 0x80020009;
constexpr int SCE_KERNEL_ERROR_ECHILD = 0x8002000A;
constexpr int SCE_KERNEL_ERROR_EDEADLK = 0x8002000B;
constexpr int SCE_KERNEL_ERROR_ENOMEM = 0x8002000C;
constexpr int SCE_KERNEL_ERROR_EACCES = 0x8002000D;
constexpr int SCE_KERNEL_ERROR_EFAULT = 0x8002000E;
constexpr int SCE_KERNEL_ERROR_ENOTBLK = 0x8002000F;
constexpr int SCE_KERNEL_ERROR_EBUSY = 0x80020010;
constexpr int SCE_KERNEL_ERROR_EEXIST = 0x80020011;
constexpr int SCE_KERNEL_ERROR_EXDEV = 0x80020012;
constexpr int SCE_KERNEL_ERROR_ENODEV = 0x80020013;
constexpr int SCE_KERNEL_ERROR_ENOTDIR = 0x80020014;
constexpr int SCE_KERNEL_ERROR_EISDIR = 0x80020015;
constexpr int SCE_KERNEL_ERROR_EINVAL = 0x80020016;
constexpr int SCE_KERNEL_ERROR_ENFILE = 0x80020017;
constexpr int SCE_KERNEL_ERROR_EMFILE = 0x80020018;
constexpr int SCE_KERNEL_ERROR_ENOTTY = 0x80020019;
constexpr int SCE_KERNEL_ERROR_ETXTBSY = 0x8002001A;
constexpr int SCE_KERNEL_ERROR_EFBIG = 0x8002001B;
constexpr int SCE_KERNEL_ERROR_ENOSPC = 0x8002001C;
constexpr int SCE_KERNEL_ERROR_ESPIPE = 0x8002001D;
constexpr int SCE_KERNEL_ERROR_EROFS = 0x8002001E;
constexpr int SCE_KERNEL_ERROR_EMLINK = 0x8002001F;
constexpr int SCE_KERNEL_ERROR_EPIPE = 0x80020020;
constexpr int SCE_KERNEL_ERROR_EDOM = 0x80020021;
constexpr int SCE_KERNEL_ERROR_ERANGE = 0x80020022;
constexpr int SCE_KERNEL_ERROR_EAGAIN = 0x80020023;
constexpr int SCE_KERNEL_ERROR_EWOULDBLOCK = 0x80020023;
constexpr int SCE_KERNEL_ERROR_EINPROGRESS = 0x80020024;
constexpr int SCE_KERNEL_ERROR_EALREADY = 0x80020025;
constexpr int SCE_KERNEL_ERROR_ENOTSOCK = 0x80020026;
constexpr int SCE_KERNEL_ERROR_EDESTADDRREQ = 0x80020027;
constexpr int SCE_KERNEL_ERROR_EMSGSIZE = 0x80020028;
constexpr int SCE_KERNEL_ERROR_EPROTOTYPE = 0x80020029;
constexpr int SCE_KERNEL_ERROR_ENOPROTOOPT = 0x8002002A;
constexpr int SCE_KERNEL_ERROR_EPROTONOSUPPORT = 0x8002002B;
constexpr int SCE_KERNEL_ERROR_ESOCKTNOSUPPORT = 0x8002002C;
constexpr int SCE_KERNEL_ERROR_EOPNOTSUPP = 0x8002002D;
constexpr int SCE_KERNEL_ERROR_ENOTSUP = 0x8002002D;
constexpr int SCE_KERNEL_ERROR_EPFNOSUPPORT = 0x8002002E;
constexpr int SCE_KERNEL_ERROR_EAFNOSUPPORT = 0x8002002F;
constexpr int SCE_KERNEL_ERROR_EADDRINUSE = 0x80020030;
constexpr int SCE_KERNEL_ERROR_EADDRNOTAVAIL = 0x80020031;
constexpr int SCE_KERNEL_ERROR_ENETDOWN = 0x80020032;
constexpr int SCE_KERNEL_ERROR_ENETUNREACH = 0x80020033;
constexpr int SCE_KERNEL_ERROR_ENETRESET = 0x80020034;
constexpr int SCE_KERNEL_ERROR_ECONNABORTED = 0x80020035;
constexpr int SCE_KERNEL_ERROR_ECONNRESET = 0x80020036;
constexpr int SCE_KERNEL_ERROR_ENOBUFS = 0x80020037;
constexpr int SCE_KERNEL_ERROR_EISCONN = 0x80020038;
constexpr int SCE_KERNEL_ERROR_ENOTCONN = 0x80020039;
constexpr int SCE_KERNEL_ERROR_ESHUTDOWN = 0x8002003A;
constexpr int SCE_KERNEL_ERROR_ETOOMANYREFS = 0x8002003B;
constexpr int SCE_KERNEL_ERROR_ETIMEDOUT = 0x8002003C;
constexpr int SCE_KERNEL_ERROR_ECONNREFUSED = 0x8002003D;
constexpr int SCE_KERNEL_ERROR_ELOOP = 0x8002003E;
constexpr int SCE_KERNEL_ERROR_ENAMETOOLONG = 0x8002003F;
constexpr int SCE_KERNEL_ERROR_EHOSTDOWN = 0x80020040;
constexpr int SCE_KERNEL_ERROR_EHOSTUNREACH = 0x80020041;
constexpr int SCE_KERNEL_ERROR_ENOTEMPTY = 0x80020042;
constexpr int SCE_KERNEL_ERROR_EPROCLIM = 0x80020043;
constexpr int SCE_KERNEL_ERROR_EUSERS = 0x80020044;
constexpr int SCE_KERNEL_ERROR_EDQUOT = 0x80020045;
constexpr int SCE_KERNEL_ERROR_ESTALE = 0x80020046;
constexpr int SCE_KERNEL_ERROR_EREMOTE = 0x80020047;
constexpr int SCE_KERNEL_ERROR_EBADRPC = 0x80020048;
constexpr int SCE_KERNEL_ERROR_ERPCMISMATCH = 0x80020049;
constexpr int SCE_KERNEL_ERROR_EPROGUNAVAIL = 0x8002004A;
constexpr int SCE_KERNEL_ERROR_EPROGMISMATCH = 0x8002004B;
constexpr int SCE_KERNEL_ERROR_EPROCUNAVAIL = 0x8002004C;
constexpr int SCE_KERNEL_ERROR_ENOLCK = 0x8002004D;
constexpr int SCE_KERNEL_ERROR_ENOSYS = 0x8002004E;
constexpr int SCE_KERNEL_ERROR_EFTYPE = 0x8002004F;
constexpr int SCE_KERNEL_ERROR_EAUTH = 0x80020050;
constexpr int SCE_KERNEL_ERROR_ENEEDAUTH = 0x80020051;
constexpr int SCE_KERNEL_ERROR_EIDRM = 0x80020052;
constexpr int SCE_KERNEL_ERROR_ENOMSG = 0x80020053;
constexpr int SCE_KERNEL_ERROR_EOVERFLOW = 0x80020054;
constexpr int SCE_KERNEL_ERROR_ECANCELED = 0x80020055;
constexpr int SCE_KERNEL_ERROR_EILSEQ = 0x80020056;
constexpr int SCE_KERNEL_ERROR_ENOATTR = 0x80020057;
constexpr int SCE_KERNEL_ERROR_EDOOFUS = 0x80020058;
constexpr int SCE_KERNEL_ERROR_EBADMSG = 0x80020059;
constexpr int SCE_KERNEL_ERROR_EMULTIHOP = 0x8002005A;
constexpr int SCE_KERNEL_ERROR_ENOLINK = 0x8002005B;
constexpr int SCE_KERNEL_ERROR_EPROTO = 0x8002005C;
constexpr int SCE_KERNEL_ERROR_ENOTCAPABLE = 0x8002005D;
constexpr int SCE_KERNEL_ERROR_ECAPMODE = 0x8002005E;
constexpr int SCE_KERNEL_ERROR_ENOBLK = 0x8002005F;
constexpr int SCE_KERNEL_ERROR_EICV = 0x80020060;
constexpr int SCE_KERNEL_ERROR_ENOPLAYGOENT = 0x80020061;
constexpr int SCE_KERNEL_ERROR_EREVOKE = 0x80020062;
constexpr int SCE_KERNEL_ERROR_ESDKVERSION = 0x80020063;
constexpr int SCE_KERNEL_ERROR_ESTART = 0x80020064;
constexpr int SCE_KERNEL_ERROR_ESTOP = 0x80020065;
// videoOut
constexpr int SCE_VIDEO_OUT_ERROR_INVALID_VALUE = 0x80290001; // invalid argument
constexpr int SCE_VIDEO_OUT_ERROR_INVALID_ADDRESS = 0x80290002; // invalid addresses
constexpr int SCE_VIDEO_OUT_ERROR_INVALID_TILING_MODE = 0x80290007; // invalid tiling mode
constexpr int SCE_VIDEO_OUT_ERROR_INVALID_ASPECT_RATIO = 0x80290008; // invalid aspect ration
constexpr int SCE_VIDEO_OUT_ERROR_RESOURCE_BUSY = 0x80290009; // already opened
constexpr int SCE_VIDEO_OUT_ERROR_INVALID_INDEX = 0x8029000A; // invalid buffer index
constexpr int SCE_VIDEO_OUT_ERROR_INVALID_HANDLE = 0x8029000B; // invalid handle
constexpr int SCE_VIDEO_OUT_ERROR_INVALID_EVENT_QUEUE = 0x8029000C; // Invalid event queue
constexpr int SCE_VIDEO_OUT_ERROR_SLOT_OCCUPIED = 0x80290010; // slot already used
constexpr int SCE_VIDEO_OUT_ERROR_FLIP_QUEUE_FULL = 0x80290012; // flip queue is full
constexpr int SCE_VIDEO_OUT_ERROR_INVALID_OPTION = 0x8029001A; // Invalid buffer attribute option
// Generic
constexpr int ORBIS_OK = 0x00000000;
constexpr int ORBIS_FAIL = 0xFFFFFFFF;
// Libkernel library
constexpr int ORBIS_KERNEL_ERROR_UNKNOWN = 0x80020000;
constexpr int ORBIS_KERNEL_ERROR_EPERM = 0x80020001;
constexpr int ORBIS_KERNEL_ERROR_ENOENT = 0x80020002;
constexpr int ORBIS_KERNEL_ERROR_ESRCH = 0x80020003;
constexpr int ORBIS_KERNEL_ERROR_EINTR = 0x80020004;
constexpr int ORBIS_KERNEL_ERROR_EIO = 0x80020005;
constexpr int ORBIS_KERNEL_ERROR_ENXIO = 0x80020006;
constexpr int ORBIS_KERNEL_ERROR_E2BIG = 0x80020007;
constexpr int ORBIS_KERNEL_ERROR_ENOEXEC = 0x80020008;
constexpr int ORBIS_KERNEL_ERROR_EBADF = 0x80020009;
constexpr int ORBIS_KERNEL_ERROR_ECHILD = 0x8002000A;
constexpr int ORBIS_KERNEL_ERROR_EDEADLK = 0x8002000B;
constexpr int ORBIS_KERNEL_ERROR_ENOMEM = 0x8002000C;
constexpr int ORBIS_KERNEL_ERROR_EACCES = 0x8002000D;
constexpr int ORBIS_KERNEL_ERROR_EFAULT = 0x8002000E;
constexpr int ORBIS_KERNEL_ERROR_ENOTBLK = 0x8002000F;
constexpr int ORBIS_KERNEL_ERROR_EBUSY = 0x80020010;
constexpr int ORBIS_KERNEL_ERROR_EEXIST = 0x80020011;
constexpr int ORBIS_KERNEL_ERROR_EXDEV = 0x80020012;
constexpr int ORBIS_KERNEL_ERROR_ENODEV = 0x80020013;
constexpr int ORBIS_KERNEL_ERROR_ENOTDIR = 0x80020014;
constexpr int ORBIS_KERNEL_ERROR_EISDIR = 0x80020015;
constexpr int ORBIS_KERNEL_ERROR_EINVAL = 0x80020016;
constexpr int ORBIS_KERNEL_ERROR_ENFILE = 0x80020017;
constexpr int ORBIS_KERNEL_ERROR_EMFILE = 0x80020018;
constexpr int ORBIS_KERNEL_ERROR_ENOTTY = 0x80020019;
constexpr int ORBIS_KERNEL_ERROR_ETXTBSY = 0x8002001A;
constexpr int ORBIS_KERNEL_ERROR_EFBIG = 0x8002001B;
constexpr int ORBIS_KERNEL_ERROR_ENOSPC = 0x8002001C;
constexpr int ORBIS_KERNEL_ERROR_ESPIPE = 0x8002001D;
constexpr int ORBIS_KERNEL_ERROR_EROFS = 0x8002001E;
constexpr int ORBIS_KERNEL_ERROR_EMLINK = 0x8002001F;
constexpr int ORBIS_KERNEL_ERROR_EPIPE = 0x80020020;
constexpr int ORBIS_KERNEL_ERROR_EDOM = 0x80020021;
constexpr int ORBIS_KERNEL_ERROR_ERANGE = 0x80020022;
constexpr int ORBIS_KERNEL_ERROR_EAGAIN = 0x80020023;
constexpr int ORBIS_KERNEL_ERROR_EWOULDBLOCK = 0x80020023;
constexpr int ORBIS_KERNEL_ERROR_EINPROGRESS = 0x80020024;
constexpr int ORBIS_KERNEL_ERROR_EALREADY = 0x80020025;
constexpr int ORBIS_KERNEL_ERROR_ENOTSOCK = 0x80020026;
constexpr int ORBIS_KERNEL_ERROR_EDESTADDRREQ = 0x80020027;
constexpr int ORBIS_KERNEL_ERROR_EMSGSIZE = 0x80020028;
constexpr int ORBIS_KERNEL_ERROR_EPROTOTYPE = 0x80020029;
constexpr int ORBIS_KERNEL_ERROR_ENOPROTOOPT = 0x8002002A;
constexpr int ORBIS_KERNEL_ERROR_EPROTONOSUPPORT = 0x8002002B;
constexpr int ORBIS_KERNEL_ERROR_ESOCKTNOSUPPORT = 0x8002002C;
constexpr int ORBIS_KERNEL_ERROR_ENOTSUP = 0x8002002D;
constexpr int ORBIS_KERNEL_ERROR_EOPNOTSUPP = 0x8002002D;
constexpr int ORBIS_KERNEL_ERROR_EPFNOSUPPORT = 0x8002002E;
constexpr int ORBIS_KERNEL_ERROR_EAFNOSUPPORT = 0x8002002F;
constexpr int ORBIS_KERNEL_ERROR_EADDRINUSE = 0x80020030;
constexpr int ORBIS_KERNEL_ERROR_EADDRNOTAVAIL = 0x80020031;
constexpr int ORBIS_KERNEL_ERROR_ENETDOWN = 0x80020032;
constexpr int ORBIS_KERNEL_ERROR_ENETUNREACH = 0x80020033;
constexpr int ORBIS_KERNEL_ERROR_ENETRESET = 0x80020034;
constexpr int ORBIS_KERNEL_ERROR_ECONNABORTED = 0x80020035;
constexpr int ORBIS_KERNEL_ERROR_ECONNRESET = 0x80020036;
constexpr int ORBIS_KERNEL_ERROR_ENOBUFS = 0x80020037;
constexpr int ORBIS_KERNEL_ERROR_EISCONN = 0x80020038;
constexpr int ORBIS_KERNEL_ERROR_ENOTCONN = 0x80020039;
constexpr int ORBIS_KERNEL_ERROR_ESHUTDOWN = 0x8002003A;
constexpr int ORBIS_KERNEL_ERROR_ETOOMANYREFS = 0x8002003B;
constexpr int ORBIS_KERNEL_ERROR_ETIMEDOUT = 0x8002003C;
constexpr int ORBIS_KERNEL_ERROR_ECONNREFUSED = 0x8002003D;
constexpr int ORBIS_KERNEL_ERROR_ELOOP = 0x8002003E;
constexpr int ORBIS_KERNEL_ERROR_ENAMETOOLONG = 0x8002003F;
constexpr int ORBIS_KERNEL_ERROR_EHOSTDOWN = 0x80020040;
constexpr int ORBIS_KERNEL_ERROR_EHOSTUNREACH = 0x80020041;
constexpr int ORBIS_KERNEL_ERROR_ENOTEMPTY = 0x80020042;
constexpr int ORBIS_KERNEL_ERROR_EPROCLIM = 0x80020043;
constexpr int ORBIS_KERNEL_ERROR_EUSERS = 0x80020044;
constexpr int ORBIS_KERNEL_ERROR_EDQUOT = 0x80020045;
constexpr int ORBIS_KERNEL_ERROR_ESTALE = 0x80020046;
constexpr int ORBIS_KERNEL_ERROR_EREMOTE = 0x80020047;
constexpr int ORBIS_KERNEL_ERROR_EBADRPC = 0x80020048;
constexpr int ORBIS_KERNEL_ERROR_ERPCMISMATCH = 0x80020049;
constexpr int ORBIS_KERNEL_ERROR_EPROGUNAVAIL = 0x8002004A;
constexpr int ORBIS_KERNEL_ERROR_EPROGMISMATCH = 0x8002004B;
constexpr int ORBIS_KERNEL_ERROR_EPROCUNAVAIL = 0x8002004C;
constexpr int ORBIS_KERNEL_ERROR_ENOLCK = 0x8002004D;
constexpr int ORBIS_KERNEL_ERROR_ENOSYS = 0x8002004E;
constexpr int ORBIS_KERNEL_ERROR_EFTYPE = 0x8002004F;
constexpr int ORBIS_KERNEL_ERROR_EAUTH = 0x80020050;
constexpr int ORBIS_KERNEL_ERROR_ENEEDAUTH = 0x80020051;
constexpr int ORBIS_KERNEL_ERROR_EIDRM = 0x80020052;
constexpr int ORBIS_KERNEL_ERROR_ENOMSG = 0x80020053;
constexpr int ORBIS_KERNEL_ERROR_EOVERFLOW = 0x80020054;
constexpr int ORBIS_KERNEL_ERROR_ECANCELED = 0x80020055;
constexpr int ORBIS_KERNEL_ERROR_EILSEQ = 0x80020056;
constexpr int ORBIS_KERNEL_ERROR_ENOATTR = 0x80020057;
constexpr int ORBIS_KERNEL_ERROR_EDOOFUS = 0x80020058;
constexpr int ORBIS_KERNEL_ERROR_EBADMSG = 0x80020059;
constexpr int ORBIS_KERNEL_ERROR_EMULTIHOP = 0x8002005A;
constexpr int ORBIS_KERNEL_ERROR_ENOLINK = 0x8002005B;
constexpr int ORBIS_KERNEL_ERROR_EPROTO = 0x8002005C;
constexpr int ORBIS_KERNEL_ERROR_ENOTCAPABLE = 0x8002005D;
constexpr int ORBIS_KERNEL_ERROR_ECAPMODE = 0x8002005E;
constexpr int ORBIS_KERNEL_ERROR_ENOBLK = 0x8002005F;
constexpr int ORBIS_KERNEL_ERROR_EICV = 0x80020060;
constexpr int ORBIS_KERNEL_ERROR_ENOPLAYGOENT = 0x80020061;
// AudioOut library
constexpr int ORBIS_AUDIO_OUT_ERROR_NOT_OPENED = 0x80260001;
constexpr int ORBIS_AUDIO_OUT_ERROR_BUSY = 0x80260002;
constexpr int ORBIS_AUDIO_OUT_ERROR_INVALID_PORT = 0x80260003;
constexpr int ORBIS_AUDIO_OUT_ERROR_INVALID_POINTER = 0x80260004;
constexpr int ORBIS_AUDIO_OUT_ERROR_PORT_FULL = 0x80260005;
constexpr int ORBIS_AUDIO_OUT_ERROR_INVALID_SIZE = 0x80260006;
constexpr int ORBIS_AUDIO_OUT_ERROR_INVALID_FORMAT = 0x80260007;
constexpr int ORBIS_AUDIO_OUT_ERROR_INVALID_SAMPLE_FREQ = 0x80260008;
constexpr int ORBIS_AUDIO_OUT_ERROR_INVALID_VOLUME = 0x80260009;
constexpr int ORBIS_AUDIO_OUT_ERROR_INVALID_PORT_TYPE = 0x8026000A;
constexpr int ORBIS_AUDIO_OUT_ERROR_INVALID_CONF_TYPE = 0x8026000C;
constexpr int ORBIS_AUDIO_OUT_ERROR_OUT_OF_MEMORY = 0x8026000D;
constexpr int ORBIS_AUDIO_OUT_ERROR_ALREADY_INIT = 0x8026000E;
constexpr int ORBIS_AUDIO_OUT_ERROR_NOT_INIT = 0x8026000F;
constexpr int ORBIS_AUDIO_OUT_ERROR_MEMORY = 0x80260010;
constexpr int ORBIS_AUDIO_OUT_ERROR_SYSTEM_RESOURCE = 0x80260011;
constexpr int ORBIS_AUDIO_OUT_ERROR_TRANS_EVENT = 0x80260012;
constexpr int ORBIS_AUDIO_OUT_ERROR_INVALID_FLAG = 0x80260013;
constexpr int ORBIS_AUDIO_OUT_ERROR_INVALID_MIXLEVEL = 0x80260014;
constexpr int ORBIS_AUDIO_OUT_ERROR_INVALID_ARG = 0x80260015;
constexpr int ORBIS_AUDIO_OUT_ERROR_INVALID_PARAM = 0x80260016;
constexpr int ORBIS_AUDIO_OUT_ERROR_MASTERING_FATAL = 0x80260200;
constexpr int ORBIS_AUDIO_OUT_ERROR_MASTERING_INVALID_API_PARAM = 0x80260201;
constexpr int ORBIS_AUDIO_OUT_ERROR_MASTERING_INVALID_CONFIG = 0x80260202;
constexpr int ORBIS_AUDIO_OUT_ERROR_MASTERING_NOT_INITIALIZED = 0x80260203;
constexpr int ORBIS_AUDIO_OUT_ERROR_MASTERING_INVALID_STATES_ID = 0x80260204;
// VideoOut library
constexpr int ORBIS_VIDEO_OUT_ERROR_INVALID_VALUE = 0x80290001;
constexpr int ORBIS_VIDEO_OUT_ERROR_INVALID_ADDRESS = 0x80290002;
constexpr int ORBIS_VIDEO_OUT_ERROR_INVALID_PIXEL_FORMAT = 0x80290003;
constexpr int ORBIS_VIDEO_OUT_ERROR_INVALID_PITCH = 0x80290004;
constexpr int ORBIS_VIDEO_OUT_ERROR_INVALID_RESOLUTION = 0x80290005;
constexpr int ORBIS_VIDEO_OUT_ERROR_INVALID_FLIP_MODE = 0x80290006;
constexpr int ORBIS_VIDEO_OUT_ERROR_INVALID_TILING_MODE = 0x80290007;
constexpr int ORBIS_VIDEO_OUT_ERROR_INVALID_ASPECT_RATIO = 0x80290008;
constexpr int ORBIS_VIDEO_OUT_ERROR_RESOURCE_BUSY = 0x80290009;
constexpr int ORBIS_VIDEO_OUT_ERROR_INVALID_INDEX = 0x8029000A;
constexpr int ORBIS_VIDEO_OUT_ERROR_INVALID_HANDLE = 0x8029000B;
constexpr int ORBIS_VIDEO_OUT_ERROR_INVALID_EVENT_QUEUE = 0x8029000C;
constexpr int ORBIS_VIDEO_OUT_ERROR_INVALID_EVENT = 0x8029000D;
constexpr int ORBIS_VIDEO_OUT_ERROR_NO_EMPTY_SLOT = 0x8029000F;
constexpr int ORBIS_VIDEO_OUT_ERROR_SLOT_OCCUPIED = 0x80290010;
constexpr int ORBIS_VIDEO_OUT_ERROR_FLIP_QUEUE_FULL = 0x80290012;
constexpr int ORBIS_VIDEO_OUT_ERROR_INVALID_MEMORY = 0x80290013;
constexpr int ORBIS_VIDEO_OUT_ERROR_MEMORY_NOT_PHYSICALLY_CONTIGUOUS = 0x80290014;
constexpr int ORBIS_VIDEO_OUT_ERROR_MEMORY_INVALID_ALIGNMENT = 0x80290015;
constexpr int ORBIS_VIDEO_OUT_ERROR_UNSUPPORTED_OUTPUT_MODE = 0x80290016;
constexpr int ORBIS_VIDEO_OUT_ERROR_OVERFLOW = 0x80290017;
constexpr int ORBIS_VIDEO_OUT_ERROR_NO_DEVICE = 0x80290018;
constexpr int ORBIS_VIDEO_OUT_ERROR_UNAVAILABLE_OUTPUT_MODE = 0x80290019;
constexpr int ORBIS_VIDEO_OUT_ERROR_INVALID_OPTION = 0x8029001A;
constexpr int ORBIS_VIDEO_OUT_ERROR_UNKNOWN = 0x802900FE;
constexpr int ORBIS_VIDEO_OUT_ERROR_FATAL = 0x802900FF;
constexpr int ORBIS_VIDEO_OUT_ERROR_ENOMEM = 0x8029100C;
// Pad library
constexpr int ORBIS_PAD_ERROR_INVALID_ARG = 0x80920001;
constexpr int ORBIS_PAD_ERROR_INVALID_PORT = 0x80920002;
constexpr int ORBIS_PAD_ERROR_INVALID_HANDLE = 0x80920003;
constexpr int ORBIS_PAD_ERROR_ALREADY_OPENED = 0x80920004;
constexpr int ORBIS_PAD_ERROR_NOT_INITIALIZED = 0x80920005;
constexpr int ORBIS_PAD_ERROR_INVALID_LIGHTBAR_SETTING = 0x80920006;
constexpr int ORBIS_PAD_ERROR_DEVICE_NOT_CONNECTED = 0x80920007;
constexpr int ORBIS_PAD_ERROR_DEVICE_NO_HANDLE = 0x80920008;
constexpr int ORBIS_PAD_ERROR_FATAL = 0x809200FF;
constexpr int ORBIS_PAD_ERROR_NOT_PERMITTED = 0x80920101;
constexpr int ORBIS_PAD_ERROR_INVALID_BUFFER_LENGTH = 0x80920102;
constexpr int ORBIS_PAD_ERROR_INVALID_REPORT_LENGTH = 0x80920103;
constexpr int ORBIS_PAD_ERROR_INVALID_REPORT_ID = 0x80920104;
constexpr int ORBIS_PAD_ERROR_SEND_AGAIN = 0x80920105;
// UserService library
constexpr int ORBIS_USER_SERVICE_ERROR_INTERNAL = 0x80960001;
constexpr int ORBIS_USER_SERVICE_ERROR_NOT_INITIALIZED = 0x80960002;
constexpr int ORBIS_USER_SERVICE_ERROR_ALREADY_INITIALIZED = 0x80960003;
constexpr int ORBIS_USER_SERVICE_ERROR_NO_MEMORY = 0x80960004;
constexpr int ORBIS_USER_SERVICE_ERROR_INVALID_ARGUMENT = 0x80960005;
constexpr int ORBIS_USER_SERVICE_ERROR_OPERATION_NOT_SUPPORTED = 0x80960006;
constexpr int ORBIS_USER_SERVICE_ERROR_NO_EVENT = 0x80960007;
constexpr int ORBIS_USER_SERVICE_ERROR_NOT_LOGGED_IN = 0x80960009;
constexpr int ORBIS_USER_SERVICE_ERROR_BUFFER_TOO_SHORT = 0x8096000A;
// SystemService library
constexpr int ORBIS_SYSTEM_SERVICE_ERROR_PARAMETER = 0x80A10003;
constexpr int ORBIS_SYSTEM_SERVICE_ERROR_NO_EVENT = 0x80A10004;
// NpTrophy library
constexpr int ORBIS_NP_TROPHY_ERROR_UNKNOWN = 0x80551600;
constexpr int ORBIS_NP_TROPHY_ERROR_NOT_INITIALIZED = 0x80551601;
constexpr int ORBIS_NP_TROPHY_ERROR_ALREADY_INITIALIZED = 0x80551602;
constexpr int ORBIS_NP_TROPHY_ERROR_OUT_OF_MEMORY = 0x80551603;
constexpr int ORBIS_NP_TROPHY_ERROR_INVALID_ARGUMENT = 0x80551604;
constexpr int ORBIS_NP_TROPHY_ERROR_INSUFFICIENT_BUFFER = 0x80551605;
constexpr int ORBIS_NP_TROPHY_ERROR_EXCEEDS_MAX = 0x80551606;
constexpr int ORBIS_NP_TROPHY_ERROR_ABORT = 0x80551607;
constexpr int ORBIS_NP_TROPHY_ERROR_INVALID_HANDLE = 0x80551608;
constexpr int ORBIS_NP_TROPHY_ERROR_INVALID_CONTEXT = 0x80551609;
constexpr int ORBIS_NP_TROPHY_ERROR_INVALID_TROPHY_ID = 0x8055160A;
constexpr int ORBIS_NP_TROPHY_ERROR_INVALID_GROUP_ID = 0x8055160B;
constexpr int ORBIS_NP_TROPHY_ERROR_TROPHY_ALREADY_UNLOCKED = 0x8055160C;
constexpr int ORBIS_NP_TROPHY_ERROR_PLATINUM_CANNOT_UNLOCK = 0x8055160D;
constexpr int ORBIS_NP_TROPHY_ERROR_ACCOUNTID_NOT_MATCH = 0x8055160E;
constexpr int ORBIS_NP_TROPHY_ERROR_NOT_REGISTERED = 0x8055160F;
constexpr int ORBIS_NP_TROPHY_ERROR_ALREADY_REGISTERED = 0x80551610;
constexpr int ORBIS_NP_TROPHY_ERROR_BROKEN_DATA = 0x80551611;
constexpr int ORBIS_NP_TROPHY_ERROR_INSUFFICIENT_SPACE = 0x80551612;
constexpr int ORBIS_NP_TROPHY_ERROR_CONTEXT_ALREADY_EXISTS = 0x80551613;
constexpr int ORBIS_NP_TROPHY_ERROR_ICON_FILE_NOT_FOUND = 0x80551614;
constexpr int ORBIS_NP_TROPHY_ERROR_INVALID_TRP_FILE_FORMAT = 0x80551616;
constexpr int ORBIS_NP_TROPHY_ERROR_UNSUPPORTED_TRP_FILE = 0x80551617;
constexpr int ORBIS_NP_TROPHY_ERROR_INVALID_TROPHY_CONF_FORMAT = 0x80551618;
constexpr int ORBIS_NP_TROPHY_ERROR_UNSUPPORTED_TROPHY_CONF = 0x80551619;
constexpr int ORBIS_NP_TROPHY_ERROR_TROPHY_NOT_UNLOCKED = 0x8055161A;
constexpr int ORBIS_NP_TROPHY_ERROR_USER_NOT_FOUND = 0x8055161C;
constexpr int ORBIS_NP_TROPHY_ERROR_USER_NOT_LOGGED_IN = 0x8055161D;
constexpr int ORBIS_NP_TROPHY_ERROR_CONTEXT_USER_LOGOUT = 0x8055161E;
constexpr int ORBIS_NP_TROPHY_ERROR_USE_TRP_FOR_DEVELOPMENT = 0x8055161F;
constexpr int ORBIS_NP_TROPHY_ERROR_INVALID_NP_SERVICE_LABEL = 0x80551621;
constexpr int ORBIS_NP_TROPHY_ERROR_NOT_SUPPORTED = 0x80551622;
constexpr int ORBIS_NP_TROPHY_ERROR_CONTEXT_EXCEEDS_MAX = 0x80551623;
constexpr int ORBIS_NP_TROPHY_ERROR_HANDLE_EXCEEDS_MAX = 0x80551624;
constexpr int ORBIS_NP_TROPHY_ERROR_INVALID_USER_ID = 0x80551625;
constexpr int ORBIS_NP_TROPHY_ERROR_TITLE_CONF_NOT_INSTALLED = 0x80551626;
constexpr int ORBIS_NP_TROPHY_ERROR_BROKEN_TITLE_CONF = 0x80551627;
constexpr int ORBIS_NP_TROPHY_ERROR_INCONSISTENT_TITLE_CONF = 0x80551628;
constexpr int ORBIS_NP_TROPHY_ERROR_TITLE_BACKGROUND = 0x80551629;
constexpr int ORBIS_NP_TROPHY_ERROR_SCREENSHOT_DISABLED = 0x8055162B;
constexpr int ORBIS_NP_TROPHY_ERROR_SCREENSHOT_DISPLAY_BUFFER_NOT_IN_USE = 0x8055162D;
// AvPlayer library
constexpr int ORBIS_AVPLAYER_ERROR_INVALID_PARAMS = 0x806A0001;
constexpr int ORBIS_AVPLAYER_ERROR_OPERATION_FAILED = 0x806A0002;
constexpr int ORBIS_AVPLAYER_ERROR_NO_MEMORY = 0x806A0003;
constexpr int ORBIS_AVPLAYER_ERROR_NOT_SUPPORTED = 0x806A0004;
constexpr int ORBIS_AVPLAYER_ERROR_WAR_FILE_NONINTERLEAVED = 0x806A00A0;
constexpr int ORBIS_AVPLAYER_ERROR_WAR_LOOPING_BACK = 0x806A00A1;
constexpr int ORBIS_AVPLAYER_ERROR_WAR_JUMP_COMPLETE = 0x806A00A3;
constexpr int ORBIS_AVPLAYER_ERROR_INFO_MARLIN_ENCRY = 0x806A00B0;
constexpr int ORBIS_AVPLAYER_ERROR_INFO_PLAYREADY_ENCRY = 0x806A00B4;
constexpr int ORBIS_AVPLAYER_ERROR_INFO_AES_ENCRY = 0x806A00B5;
constexpr int ORBIS_AVPLAYER_ERROR_INFO_OTHER_ENCRY = 0x806A00BF;
// AppContent library
constexpr int ORBIS_APP_CONTENT_ERROR_PARAMETER = 0x80D90002;
constexpr int ORBIS_APP_CONTENT_ERROR_DRM_NO_ENTITLEMENT = 0x80D90007;
constexpr int ORBIS_APP_CONTENT_ERROR_NOT_FOUND = 0x80D90005;
// Fiber library
constexpr int ORBIS_FIBER_ERROR_NULL = 0x80590001;
constexpr int ORBIS_FIBER_ERROR_ALIGNMENT = 0x80590002;
constexpr int ORBIS_FIBER_ERROR_RANGE = 0x80590003;
constexpr int ORBIS_FIBER_ERROR_INVALID = 0x80590004;
constexpr int ORBIS_FIBER_ERROR_PERMISSION = 0x80590005;
constexpr int ORBIS_FIBER_ERROR_STATE = 0x80590006;
// ImeDialog library
constexpr int ORBIS_ERROR_DIALOG_ERROR_NOT_INITIALIZED = 0x80ED0001;
constexpr int ORBIS_ERROR_DIALOG_ERROR_ALREADY_INITIALIZED = 0x80ED0002;
constexpr int ORBIS_ERROR_DIALOG_ERROR_PARAM_INVALID = 0x80ED0003;
constexpr int ORBIS_ERROR_DIALOG_ERROR_UNEXPECTED_FATAL = 0x80ED0004;
constexpr int ORBIS_ERROR_DIALOG_ERROR_INVALID_STATE = 0x80ED0005;
constexpr int ORBIS_ERROR_DIALOG_ERROR_SERVICE_BUSY = 0x80ED0006;
constexpr int ORBIS_ERROR_DIALOG_ERROR_INVALID_USER_ID = 0x80ED0007;
// Ime library
constexpr int ORBIS_IME_ERROR_BUSY = 0x80BC0001;
constexpr int ORBIS_IME_ERROR_NOT_OPENED = 0x80BC0002;
constexpr int ORBIS_IME_ERROR_NO_MEMORY = 0x80BC0003;
constexpr int ORBIS_IME_ERROR_CONNECTION_FAILED = 0x80BC0004;
constexpr int ORBIS_IME_ERROR_TOO_MANY_REQUESTS = 0x80BC0005;
constexpr int ORBIS_IME_ERROR_INVALID_TEXT = 0x80BC0006;
constexpr int ORBIS_IME_ERROR_EVENT_OVERFLOW = 0x80BC0007;
constexpr int ORBIS_IME_ERROR_NOT_ACTIVE = 0x80BC0008;
constexpr int ORBIS_IME_ERROR_IME_SUSPENDING = 0x80BC0009;
constexpr int ORBIS_IME_ERROR_DEVICE_IN_USE = 0x80BC000A;
constexpr int ORBIS_IME_ERROR_INVALID_USER_ID = 0x80BC0010;
constexpr int ORBIS_IME_ERROR_INVALID_TYPE = 0x80BC0011;
constexpr int ORBIS_IME_ERROR_INVALID_SUPPORTED_LANGUAGES = 0x80BC0012;
constexpr int ORBIS_IME_ERROR_INVALID_ENTER_LABEL = 0x80BC0013;
constexpr int ORBIS_IME_ERROR_INVALID_INPUT_METHOD = 0x80BC0014;
constexpr int ORBIS_IME_ERROR_INVALID_OPTION = 0x80BC0015;
constexpr int ORBIS_IME_ERROR_INVALID_MAX_TEXT_LENGTH = 0x80BC0016;
constexpr int ORBIS_IME_ERROR_INVALID_INPUT_TEXT_BUFFER = 0x80BC0017;
constexpr int ORBIS_IME_ERROR_INVALID_POSX = 0x80BC0018;
constexpr int ORBIS_IME_ERROR_INVALID_POSY = 0x80BC0019;
constexpr int ORBIS_IME_ERROR_INVALID_HORIZONTAL_ALIGNMENT = 0x80BC001A;
constexpr int ORBIS_IME_ERROR_INVALID_VERTICAL_ALIGNMENT = 0x80BC001B;
constexpr int ORBIS_IME_ERROR_INVALID_EXTENDED = 0x80BC001C;
constexpr int ORBIS_IME_ERROR_INVALID_KEYBOARD_TYPE = 0x80BC001D;
constexpr int ORBIS_IME_ERROR_INVALID_WORK = 0x80BC0020;
constexpr int ORBIS_IME_ERROR_INVALID_ARG = 0x80BC0021;
constexpr int ORBIS_IME_ERROR_INVALID_HANDLER = 0x80BC0022;
constexpr int ORBIS_IME_ERROR_NO_RESOURCE_ID = 0x80BC0023;
constexpr int ORBIS_IME_ERROR_INVALID_MODE = 0x80BC0024;
constexpr int ORBIS_IME_ERROR_INVALID_PARAM = 0x80BC0030;
constexpr int ORBIS_IME_ERROR_INVALID_ADDRESS = 0x80BC0031;
constexpr int ORBIS_IME_ERROR_INVALID_RESERVED = 0x80BC0032;
constexpr int ORBIS_IME_ERROR_INVALID_TIMING = 0x80BC0033;
constexpr int ORBIS_IME_ERROR_INTERNAL = 0x80BC00FF;
// Videodec2 library
constexpr int ORBIS_VIDEODEC2_ERROR_API_FAIL = 0x811D0100;
constexpr int ORBIS_VIDEODEC2_ERROR_STRUCT_SIZE = 0x811D0101;
constexpr int ORBIS_VIDEODEC2_ERROR_ARGUMENT_POINTER = 0x811D0102;
constexpr int ORBIS_VIDEODEC2_ERROR_DECODER_INSTANCE = 0x811D0103;
constexpr int ORBIS_VIDEODEC2_ERROR_MEMORY_SIZE = 0x811D0104;
constexpr int ORBIS_VIDEODEC2_ERROR_MEMORY_POINTER = 0x811D0105;
constexpr int ORBIS_VIDEODEC2_ERROR_FRAME_BUFFER_SIZE = 0x811D0106;
constexpr int ORBIS_VIDEODEC2_ERROR_FRAME_BUFFER_POINTER = 0x811D0107;
constexpr int ORBIS_VIDEODEC2_ERROR_FRAME_BUFFER_ALIGNMENT = 0x811D0108;
constexpr int ORBIS_VIDEODEC2_ERROR_NOT_ONION_MEMORY = 0x811D0109;
constexpr int ORBIS_VIDEODEC2_ERROR_NOT_GARLIC_MEMORY = 0x811D010A;
constexpr int ORBIS_VIDEODEC2_ERROR_NOT_DIRECT_MEMORY = 0x811D010B;
constexpr int ORBIS_VIDEODEC2_ERROR_MEMORY_INFO = 0x811D010C;
constexpr int ORBIS_VIDEODEC2_ERROR_ACCESS_UNIT_SIZE = 0x811D010D;
constexpr int ORBIS_VIDEODEC2_ERROR_ACCESS_UNIT_POINTER = 0x811D010E;
constexpr int ORBIS_VIDEODEC2_ERROR_OUTPUT_INFO = 0x811D010F;
constexpr int ORBIS_VIDEODEC2_ERROR_COMPUTE_QUEUE = 0x811D0110;
constexpr int ORBIS_VIDEODEC2_ERROR_FATAL_STATE = 0x811D0111;
constexpr int ORBIS_VIDEODEC2_ERROR_PRESET_VALUE = 0x811D0112;
constexpr int ORBIS_VIDEODEC2_ERROR_CONFIG_INFO = 0x811D0200;
constexpr int ORBIS_VIDEODEC2_ERROR_COMPUTE_PIPE_ID = 0x811D0201;
constexpr int ORBIS_VIDEODEC2_ERROR_COMPUTE_QUEUE_ID = 0x811D0202;
constexpr int ORBIS_VIDEODEC2_ERROR_RESOURCE_TYPE = 0x811D0203;
constexpr int ORBIS_VIDEODEC2_ERROR_CODEC_TYPE = 0x811D0204;
constexpr int ORBIS_VIDEODEC2_ERROR_PROFILE_LEVEL = 0x811D0205;
constexpr int ORBIS_VIDEODEC2_ERROR_PIPELINE_DEPTH = 0x811D0206;
constexpr int ORBIS_VIDEODEC2_ERROR_AFFINITY_MASK = 0x811D0207;
constexpr int ORBIS_VIDEODEC2_ERROR_THREAD_PRIORITY = 0x811D0208;
constexpr int ORBIS_VIDEODEC2_ERROR_DPB_FRAME_COUNT = 0x811D0209;
constexpr int ORBIS_VIDEODEC2_ERROR_FRAME_WIDTH_HEIGHT = 0x811D020A;
constexpr int ORBIS_VIDEODEC2_ERROR_EXTRA_CONFIG_INFO = 0x811D020B;
constexpr int ORBIS_VIDEODEC2_ERROR_NEW_SEQUENCE = 0x811D0300;
constexpr int ORBIS_VIDEODEC2_ERROR_ACCESS_UNIT = 0x811D0301;
constexpr int ORBIS_VIDEODEC2_ERROR_OVERSIZE_DECODE = 0x811D0302;
constexpr int ORBIS_VIDEODEC2_ERROR_INVALID_SEQUENCE = 0x811D0303;
constexpr int ORBIS_VIDEODEC2_ERROR_FATAL_STREAM = 0x811D0304;
// Videodec library
constexpr int ORBIS_VIDEODEC_ERROR_API_FAIL = 0x80C10000;
constexpr int ORBIS_VIDEODEC_ERROR_CODEC_TYPE = 0x80C10001;
constexpr int ORBIS_VIDEODEC_ERROR_STRUCT_SIZE = 0x80C10002;
constexpr int ORBIS_VIDEODEC_ERROR_HANDLE = 0x80C10003;
constexpr int ORBIS_VIDEODEC_ERROR_CPU_MEMORY_SIZE = 0x80C10004;
constexpr int ORBIS_VIDEODEC_ERROR_CPU_MEMORY_POINTER = 0x80C10005;
constexpr int ORBIS_VIDEODEC_ERROR_CPU_GPU_MEMORY_SIZE = 0x80C10006;
constexpr int ORBIS_VIDEODEC_ERROR_CPU_GPU_MEMORY_POINTER = 0x80C10007;
constexpr int ORBIS_VIDEODEC_ERROR_SHADER_CONTEXT_POINTER = 0x80C10008;
constexpr int ORBIS_VIDEODEC_ERROR_AU_SIZE = 0x80C10009;
constexpr int ORBIS_VIDEODEC_ERROR_AU_POINTER = 0x80C1000A;
constexpr int ORBIS_VIDEODEC_ERROR_FRAME_BUFFER_SIZE = 0x80C1000B;
constexpr int ORBIS_VIDEODEC_ERROR_FRAME_BUFFER_POINTER = 0x80C1000C;
constexpr int ORBIS_VIDEODEC_ERROR_FRAME_BUFFER_ALIGNMENT = 0x80C1000D;
constexpr int ORBIS_VIDEODEC_ERROR_CONFIG_INFO = 0x80C1000E;
constexpr int ORBIS_VIDEODEC_ERROR_ARGUMENT_POINTER = 0x80C1000F;
constexpr int ORBIS_VIDEODEC_ERROR_NEW_SEQUENCE = 0x80C10010;
constexpr int ORBIS_VIDEODEC_ERROR_DECODE_AU = 0x80C10011;
constexpr int ORBIS_VIDEODEC_ERROR_MISMATCH_SPEC = 0x80C10012;
constexpr int ORBIS_VIDEODEC_ERROR_INVALID_SEQUENCE = 0x80C10013;
constexpr int ORBIS_VIDEODEC_ERROR_FATAL_STREAM = 0x80C10014;
constexpr int ORBIS_VIDEODEC_ERROR_FATAL_STATE = 0x80C10015;
| 32,418
|
C++
|
.h
| 597
| 53.266332
| 97
| 0.823491
|
shadps4-emu/shadPS4
| 9,253
| 501
| 185
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
15,789
|
error_dialog.h
|
shadps4-emu_shadPS4/src/core/libraries/ime/error_dialog.h
|
// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
#pragma once
#include "common/types.h"
#include "core/libraries/system/commondialog.h"
namespace Core::Loader {
class SymbolsResolver;
}
namespace Libraries::ErrorDialog {
using OrbisUserServiceUserId = s32;
struct Param;
CommonDialog::Error PS4_SYSV_ABI sceErrorDialogClose();
CommonDialog::Status PS4_SYSV_ABI sceErrorDialogGetStatus();
CommonDialog::Error PS4_SYSV_ABI sceErrorDialogInitialize();
CommonDialog::Error PS4_SYSV_ABI sceErrorDialogOpen(const Param* param);
int PS4_SYSV_ABI sceErrorDialogOpenDetail();
int PS4_SYSV_ABI sceErrorDialogOpenWithReport();
CommonDialog::Error PS4_SYSV_ABI sceErrorDialogTerminate();
CommonDialog::Status PS4_SYSV_ABI sceErrorDialogUpdateStatus();
void RegisterlibSceErrorDialog(Core::Loader::SymbolsResolver* sym);
} // namespace Libraries::ErrorDialog
| 915
|
C++
|
.h
| 21
| 42.285714
| 72
| 0.835586
|
shadps4-emu/shadPS4
| 9,253
| 501
| 185
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
15,790
|
ime_dialog_ui.h
|
shadps4-emu_shadPS4/src/core/libraries/ime/ime_dialog_ui.h
|
// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
#pragma once
#include <mutex>
#include <vector>
#include <imgui.h>
#include "common/cstring.h"
#include "common/types.h"
#include "core/libraries/ime/ime_dialog.h"
#include "imgui/imgui_layer.h"
namespace Libraries::ImeDialog {
class ImeDialogUi;
class ImeDialogState final {
friend ImeDialogUi;
bool input_changed = false;
s32 userId{};
bool is_multiLine{};
bool is_numeric{};
OrbisImeType type{};
OrbisImeEnterLabel enter_label{};
OrbisImeTextFilter text_filter{};
OrbisImeExtKeyboardFilter keyboard_filter{};
u32 max_text_length{};
char16_t* text_buffer{};
std::vector<char> title;
std::vector<char> placeholder;
// A character can hold up to 4 bytes in UTF-8
Common::CString<ORBIS_IME_DIALOG_MAX_TEXT_LENGTH * 4> current_text;
public:
ImeDialogState(const OrbisImeDialogParam* param = nullptr,
const OrbisImeParamExtended* extended = nullptr);
ImeDialogState(const ImeDialogState& other) = delete;
ImeDialogState(ImeDialogState&& other) noexcept;
ImeDialogState& operator=(ImeDialogState&& other);
bool CopyTextToOrbisBuffer();
bool CallTextFilter();
private:
bool CallKeyboardFilter(const OrbisImeKeycode* src_keycode, u16* out_keycode, u32* out_status);
bool ConvertOrbisToUTF8(const char16_t* orbis_text, std::size_t orbis_text_len, char* utf8_text,
std::size_t native_text_len);
bool ConvertUTF8ToOrbis(const char* native_text, std::size_t utf8_text_len,
char16_t* orbis_text, std::size_t orbis_text_len);
};
class ImeDialogUi final : public ImGui::Layer {
ImeDialogState* state{};
OrbisImeDialogStatus* status{};
OrbisImeDialogResult* result{};
bool first_render = true;
std::mutex draw_mutex;
public:
explicit ImeDialogUi(ImeDialogState* state = nullptr, OrbisImeDialogStatus* status = nullptr,
OrbisImeDialogResult* result = nullptr);
~ImeDialogUi() override;
ImeDialogUi(const ImeDialogUi& other) = delete;
ImeDialogUi(ImeDialogUi&& other) noexcept;
ImeDialogUi& operator=(ImeDialogUi&& other);
void Draw() override;
private:
void Free();
void DrawInputText();
void DrawMultiLineInputText();
static int InputTextCallback(ImGuiInputTextCallbackData* data);
};
} // namespace Libraries::ImeDialog
| 2,495
|
C++
|
.h
| 64
| 33.671875
| 100
| 0.718789
|
shadps4-emu/shadPS4
| 9,253
| 501
| 185
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
15,791
|
ime_ui.h
|
shadps4-emu_shadPS4/src/core/libraries/ime/ime_ui.h
|
// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
#pragma once
#include <mutex>
#include <imgui.h>
#include <queue>
#include "imgui/imgui_layer.h"
#include "common/cstring.h"
#include "common/types.h"
#include "ime.h"
namespace Libraries::Ime {
class ImeHandler;
class ImeUi;
class ImeState {
friend class ImeHandler;
friend class ImeUi;
bool input_changed = false;
void* work_buffer{};
char16_t* text_buffer{};
// A character can hold up to 4 bytes in UTF-8
Common::CString<ORBIS_IME_MAX_TEXT_LENGTH * 4> current_text;
std::queue<OrbisImeEvent> event_queue;
std::mutex queue_mutex;
public:
ImeState(const OrbisImeParam* param = nullptr);
ImeState(ImeState&& other) noexcept;
ImeState& operator=(ImeState&& other) noexcept;
void SendEvent(OrbisImeEvent* event);
void SendEnterEvent();
void SendCloseEvent();
private:
bool ConvertOrbisToUTF8(const char16_t* orbis_text, std::size_t orbis_text_len, char* utf8_text,
std::size_t native_text_len);
bool ConvertUTF8ToOrbis(const char* native_text, std::size_t utf8_text_len,
char16_t* orbis_text, std::size_t orbis_text_len);
};
class ImeUi : public ImGui::Layer {
ImeState* state{};
const OrbisImeParam* ime_param{};
bool first_render = true;
std::mutex draw_mutex;
public:
explicit ImeUi(ImeState* state = nullptr, const OrbisImeParam* param = nullptr);
~ImeUi() override;
ImeUi(const ImeUi& other) = delete;
ImeUi& operator=(ImeUi&& other);
void Draw() override;
private:
void Free();
void DrawInputText();
static int InputTextCallback(ImGuiInputTextCallbackData* data);
};
}; // namespace Libraries::Ime
| 1,884
|
C++
|
.h
| 53
| 29.471698
| 101
| 0.682531
|
shadps4-emu/shadPS4
| 9,253
| 501
| 185
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
15,792
|
ime_common.h
|
shadps4-emu_shadPS4/src/core/libraries/ime/ime_common.h
|
// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
#pragma once
#include <sys/types.h>
#include "common/enum.h"
#include "common/types.h"
#include "core/libraries/rtc/rtc.h"
enum class OrbisImeType : u32 {
DEFAULT = 0,
BASIC_LATIN = 1,
URL = 2,
MAIL = 3,
NUMBER = 4,
};
enum class OrbisImeHorizontalAlignment : u32 {
LEFT = 0,
CENTER = 1,
RIGHT = 2,
};
enum class OrbisImeVerticalAlignment : u32 {
TOP = 0,
CENTER = 1,
BOTTOM = 2,
};
enum class OrbisImeEnterLabel : u32 {
DEFAULT = 0,
SEND = 1,
SEARCH = 2,
GO = 3,
};
enum class OrbisImeInputMethod : u32 {
DEFAULT = 0,
};
enum class OrbisImeEventId : u32 {
OPEN = 0,
UPDATE_TEXT = 1,
UPDATE_CARET = 2,
PRESS_CLOSE = 4,
PRESS_ENTER = 5,
ABORT = 6,
CANDIDATE_LIST_START = 7,
CANDIDATE_LIST_END = 8,
CANDIDATE_WORD = 9,
CANDIDATE_INDEX = 10,
CANDIDATE_DONE = 11,
CANDIDATE_CANCEL = 12,
CHANGE_DEVICE = 14,
CHANGE_INPUT_METHOD_STATE = 18,
KEYBOARD_OPEN = 256,
KEYBOARD_KEYCODE_DOWN = 257,
KEYBOARD_KEYCODE_UP = 258,
KEYBOARD_KEYCODE_REPEAT = 259,
KEYBOARD_CONNECTION = 260,
KEYBOARD_DISCONNECTION = 261,
KEYBOARD_ABORT = 262,
};
enum class OrbisImeKeyboardType : u32 {
NONE = 0,
DANISH = 1,
GERMAN = 2,
GERMAN_SW = 3,
ENGLISH_US = 4,
ENGLISH_GB = 5,
SPANISH = 6,
SPANISH_LA = 7,
FINNISH = 8,
FRENCH = 9,
FRENCH_BR = 10,
FRENCH_CA = 11,
FRENCH_SW = 12,
ITALIAN = 13,
DUTCH = 14,
NORWEGIAN = 15,
POLISH = 16,
PORTUGUESE_BR = 17,
PORTUGUESE_PT = 18,
RUSSIAN = 19,
SWEDISH = 20,
TURKISH = 21,
JAPANESE_ROMAN = 22,
JAPANESE_KANA = 23,
KOREAN = 24,
SM_CHINESE = 25,
TR_CHINESE_ZY = 26,
TR_CHINESE_PY_HK = 27,
TR_CHINESE_PY_TW = 28,
TR_CHINESE_CG = 29,
ARABIC_AR = 30,
THAI = 31,
CZECH = 32,
GREEK = 33,
INDONESIAN = 34,
VIETNAMESE = 35,
ROMANIAN = 36,
HUNGARIAN = 37,
};
enum class OrbisImeDeviceType : u32 {
NONE = 0,
CONTROLLER = 1,
EXT_KEYBOARD = 2,
REMOTE_OSK = 3,
};
struct OrbisImeRect {
f32 x;
f32 y;
u32 width;
u32 height;
};
struct OrbisImeTextAreaProperty {
u32 mode; // OrbisImeTextAreaMode
u32 index;
s32 length;
};
struct OrbisImeEditText {
char16_t* str;
u32 caretIndex;
u32 areaNum;
OrbisImeTextAreaProperty textArea[4];
};
struct OrbisImeKeycode {
u16 keycode;
char16_t character;
u32 status;
OrbisImeKeyboardType type;
s32 userId;
u32 resourceId;
Libraries::Rtc::OrbisRtcTick timestamp;
};
struct OrbisImeKeyboardResourceIdArray {
s32 userId;
u32 resourceId[6];
};
enum class OrbisImeCaretMovementDirection : u32 {
STILL = 0,
LEFT = 1,
RIGHT = 2,
UP = 3,
DOWN = 4,
HOME = 5,
END = 6,
PAGE_UP = 7,
PAGE_DOWN = 8,
TOP = 9,
BOTTOM = 10,
};
union OrbisImeEventParam {
OrbisImeRect rect;
OrbisImeEditText text;
OrbisImeCaretMovementDirection caretMove;
OrbisImeKeycode keycode;
OrbisImeKeyboardResourceIdArray resourceIdArray;
char16_t* candidateWord;
s32 candidateIndex;
OrbisImeDeviceType deviceType;
u32 inputMethodState;
s8 reserved[64];
};
struct OrbisImeEvent {
OrbisImeEventId id;
OrbisImeEventParam param;
};
typedef PS4_SYSV_ABI int (*OrbisImeTextFilter)(char16_t* outText, u32* outTextLength,
const char16_t* srcText, u32 srcTextLength);
typedef PS4_SYSV_ABI void (*OrbisImeEventHandler)(void* arg, const OrbisImeEvent* e);
| 3,887
|
C++
|
.h
| 164
| 18.195122
| 92
| 0.618518
|
shadps4-emu/shadPS4
| 9,253
| 501
| 185
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
15,793
|
ime_dialog.h
|
shadps4-emu_shadPS4/src/core/libraries/ime/ime_dialog.h
|
// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
#pragma once
#include "common/enum.h"
#include "common/types.h"
#include "ime_common.h"
namespace Core::Loader {
class SymbolsResolver;
}
namespace Libraries::ImeDialog {
constexpr u32 ORBIS_IME_DIALOG_MAX_TEXT_LENGTH = 0x78;
enum class Error : u32 {
OK = 0x0,
BUSY = 0x80bc0001,
NOT_OPENED = 0x80bc0002,
NO_MEMORY = 0x80bc0003,
CONNECTION_FAILED = 0x80bc0004,
TOO_MANY_REQUESTS = 0x80bc0005,
INVALID_TEXT = 0x80bc0006,
EVENT_OVERFLOW = 0x80bc0007,
NOT_ACTIVE = 0x80bc0008,
IME_SUSPENDING = 0x80bc0009,
DEVICE_IN_USE = 0x80bc000a,
INVALID_USER_ID = 0x80bc0010,
INVALID_TYPE = 0x80bc0011,
INVALID_SUPPORTED_LANGUAGES = 0x80bc0012,
INVALID_ENTER_LABEL = 0x80bc0013,
INVALID_INPUT_METHOD = 0x80bc0014,
INVALID_OPTION = 0x80bc0015,
INVALID_MAX_TEXT_LENGTH = 0x80bc0016,
INVALID_INPUT_TEXT_BUFFER = 0x80bc0017,
INVALID_POSX = 0x80bc0018,
INVALID_POSY = 0x80bc0019,
INVALID_HORIZONTALIGNMENT = 0x80bc001a,
INVALID_VERTICALALIGNMENT = 0x80bc001b,
INVALID_EXTENDED = 0x80bc001c,
INVALID_KEYBOARD_TYPE = 0x80bc001d,
INVALID_WORK = 0x80bc0020,
INVALID_ARG = 0x80bc0021,
INVALID_HANDLER = 0x80bc0022,
NO_RESOURCE_ID = 0x80bc0023,
INVALID_MODE = 0x80bc0024,
INVALID_PARAM = 0x80bc0030,
INVALID_ADDRESS = 0x80bc0031,
INVALID_RESERVED = 0x80bc0032,
INVALID_TIMING = 0x80bc0033,
INTERNAL = 0x80bc00ff,
DIALOG_INVALID_TITLE = 0x80bc0101,
DIALOG_NOT_RUNNING = 0x80bc0105,
DIALOG_NOT_FINISHED = 0x80bc0106,
DIALOG_NOT_IN_USE = 0x80bc0107,
};
enum class OrbisImeDialogStatus : u32 {
NONE = 0,
RUNNING = 1,
FINISHED = 2,
};
enum class OrbisImeDialogEndStatus : u32 {
OK = 0,
USER_CANCELED = 1,
ABORTED = 2,
};
enum class OrbisImeDialogOption : u32 {
DEFAULT = 0,
MULTILINE = 1,
NO_AUTO_CORRECTION = 2,
NO_AUTO_COMPLETION = 4,
// TODO: Document missing options
LARGE_RESOLUTION = 1024,
};
DECLARE_ENUM_FLAG_OPERATORS(OrbisImeDialogOption)
enum class OrbisImePanelPriority : u32 {
DEFAULT = 0,
ALPHABET = 1,
SYMBOL = 2,
ACCENT = 3,
};
struct OrbisImeColor {
u8 r;
u8 g;
u8 b;
u8 a;
};
struct OrbisImeDialogResult {
OrbisImeDialogEndStatus endstatus;
s32 reserved[12];
};
struct OrbisImeKeycode {
u16 keycode;
char16_t character;
u32 status;
OrbisImeKeyboardType type;
s32 userId;
u32 resourceId;
u64 timestamp;
};
typedef PS4_SYSV_ABI int (*OrbisImeExtKeyboardFilter)(const OrbisImeKeycode* srcKeycode,
u16* outKeycode, u32* outStatus,
void* reserved);
struct OrbisImeDialogParam {
s32 userId;
OrbisImeType type;
u64 supportedLanguages;
OrbisImeEnterLabel enterLabel;
OrbisImeInputMethod inputMethod;
OrbisImeTextFilter filter;
OrbisImeDialogOption option;
u32 maxTextLength;
char16_t* inputTextBuffer;
float posx;
float posy;
OrbisImeHorizontalAlignment horizontalAlignment;
OrbisImeVerticalAlignment verticalAlignment;
const char16_t* placeholder;
const char16_t* title;
s8 reserved[16];
};
struct OrbisImeParamExtended {
u32 option; // OrbisImeDialogOptionExtended
OrbisImeColor colorBase;
OrbisImeColor colorLine;
OrbisImeColor colorTextField;
OrbisImeColor colorPreedit;
OrbisImeColor colorButtonDefault;
OrbisImeColor colorButtonFunction;
OrbisImeColor colorButtonSymbol;
OrbisImeColor colorText;
OrbisImeColor colorSpecial;
OrbisImePanelPriority priority;
char* additionalDictionaryPath;
OrbisImeExtKeyboardFilter extKeyboardFilter;
uint32_t disableDevice;
uint32_t extKeyboardMode;
int8_t reserved[60];
};
Error PS4_SYSV_ABI sceImeDialogAbort();
Error PS4_SYSV_ABI sceImeDialogForceClose();
Error PS4_SYSV_ABI sceImeDialogForTestFunction();
int PS4_SYSV_ABI sceImeDialogGetCurrentStarState();
int PS4_SYSV_ABI sceImeDialogGetPanelPositionAndForm();
int PS4_SYSV_ABI sceImeDialogGetPanelSize();
int PS4_SYSV_ABI sceImeDialogGetPanelSizeExtended();
Error PS4_SYSV_ABI sceImeDialogGetResult(OrbisImeDialogResult* result);
OrbisImeDialogStatus PS4_SYSV_ABI sceImeDialogGetStatus();
Error PS4_SYSV_ABI sceImeDialogInit(OrbisImeDialogParam* param, OrbisImeParamExtended* extended);
int PS4_SYSV_ABI sceImeDialogInitInternal();
int PS4_SYSV_ABI sceImeDialogInitInternal2();
int PS4_SYSV_ABI sceImeDialogInitInternal3();
int PS4_SYSV_ABI sceImeDialogSetPanelPosition();
Error PS4_SYSV_ABI sceImeDialogTerm();
void RegisterlibSceImeDialog(Core::Loader::SymbolsResolver* sym);
} // namespace Libraries::ImeDialog
| 4,826
|
C++
|
.h
| 152
| 27.296053
| 97
| 0.742753
|
shadps4-emu/shadPS4
| 9,253
| 501
| 185
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
15,794
|
ime.h
|
shadps4-emu_shadPS4/src/core/libraries/ime/ime.h
|
// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
#pragma once
#include "common/types.h"
#include "ime_common.h"
namespace Core::Loader {
class SymbolsResolver;
}
namespace Libraries::Ime {
constexpr u32 ORBIS_IME_MAX_TEXT_LENGTH = 2048;
enum class OrbisImeKeyboardOption : u32 {
DEFAULT = 0,
REPEAT = 1,
REPEAT_EACH_KEY = 2,
ADD_OSK = 4,
EFFECTIVE_WITH_TIME = 8,
DISABLE_RESUME = 16,
DISABLE_CAPSLOCK_WITHOUT_SHIFT = 32,
};
DECLARE_ENUM_FLAG_OPERATORS(OrbisImeKeyboardOption)
struct OrbisImeKeyboardParam {
OrbisImeKeyboardOption option;
s8 reserved1[4];
void* arg;
OrbisImeEventHandler handler;
s8 reserved2[8];
};
struct OrbisImeParam {
s32 userId;
OrbisImeType type;
u64 supportedLanguages;
OrbisImeEnterLabel enterLabel;
OrbisImeInputMethod inputMethod;
OrbisImeTextFilter filter;
u32 option;
u32 maxTextLength;
char16_t* inputTextBuffer;
float posx;
float posy;
OrbisImeHorizontalAlignment horizontalAlignment;
OrbisImeVerticalAlignment verticalAlignment;
void* work;
void* arg;
OrbisImeEventHandler handler;
s8 reserved[8];
};
struct OrbisImeCaret {
f32 x;
f32 y;
u32 height;
u32 index;
};
int PS4_SYSV_ABI FinalizeImeModule();
int PS4_SYSV_ABI InitializeImeModule();
int PS4_SYSV_ABI sceImeCheckFilterText();
int PS4_SYSV_ABI sceImeCheckRemoteEventParam();
int PS4_SYSV_ABI sceImeCheckUpdateTextInfo();
int PS4_SYSV_ABI sceImeClose();
int PS4_SYSV_ABI sceImeConfigGet();
int PS4_SYSV_ABI sceImeConfigSet();
int PS4_SYSV_ABI sceImeConfirmCandidate();
int PS4_SYSV_ABI sceImeDicAddWord();
int PS4_SYSV_ABI sceImeDicDeleteLearnDics();
int PS4_SYSV_ABI sceImeDicDeleteUserDics();
int PS4_SYSV_ABI sceImeDicDeleteWord();
int PS4_SYSV_ABI sceImeDicGetWords();
int PS4_SYSV_ABI sceImeDicReplaceWord();
int PS4_SYSV_ABI sceImeDisableController();
int PS4_SYSV_ABI sceImeFilterText();
int PS4_SYSV_ABI sceImeForTestFunction();
int PS4_SYSV_ABI sceImeGetPanelPositionAndForm();
s32 PS4_SYSV_ABI sceImeGetPanelSize(const OrbisImeParam* param, u32* width, u32* height);
s32 PS4_SYSV_ABI sceImeKeyboardClose(s32 userId);
int PS4_SYSV_ABI sceImeKeyboardGetInfo();
int PS4_SYSV_ABI sceImeKeyboardGetResourceId();
s32 PS4_SYSV_ABI sceImeKeyboardOpen(s32 userId, const OrbisImeKeyboardParam* param);
int PS4_SYSV_ABI sceImeKeyboardOpenInternal();
int PS4_SYSV_ABI sceImeKeyboardSetMode();
int PS4_SYSV_ABI sceImeKeyboardUpdate();
s32 PS4_SYSV_ABI sceImeOpen(const OrbisImeParam* param, const void* extended);
int PS4_SYSV_ABI sceImeOpenInternal();
void PS4_SYSV_ABI sceImeParamInit(OrbisImeParam* param);
int PS4_SYSV_ABI sceImeSetCandidateIndex();
s32 PS4_SYSV_ABI sceImeSetCaret(const OrbisImeCaret* caret);
int PS4_SYSV_ABI sceImeSetText();
int PS4_SYSV_ABI sceImeSetTextGeometry();
s32 PS4_SYSV_ABI sceImeUpdate(OrbisImeEventHandler handler);
int PS4_SYSV_ABI sceImeVshClearPreedit();
int PS4_SYSV_ABI sceImeVshClose();
int PS4_SYSV_ABI sceImeVshConfirmPreedit();
int PS4_SYSV_ABI sceImeVshDisableController();
int PS4_SYSV_ABI sceImeVshGetPanelPositionAndForm();
int PS4_SYSV_ABI sceImeVshInformConfirmdString();
int PS4_SYSV_ABI sceImeVshInformConfirmdString2();
int PS4_SYSV_ABI sceImeVshOpen();
int PS4_SYSV_ABI sceImeVshSendTextInfo();
int PS4_SYSV_ABI sceImeVshSetCaretGeometry();
int PS4_SYSV_ABI sceImeVshSetCaretIndexInPreedit();
int PS4_SYSV_ABI sceImeVshSetPanelPosition();
int PS4_SYSV_ABI sceImeVshSetParam();
int PS4_SYSV_ABI sceImeVshSetPreeditGeometry();
int PS4_SYSV_ABI sceImeVshSetSelectGeometry();
int PS4_SYSV_ABI sceImeVshSetSelectionText();
int PS4_SYSV_ABI sceImeVshUpdate();
int PS4_SYSV_ABI sceImeVshUpdateContext();
int PS4_SYSV_ABI sceImeVshUpdateContext2();
void RegisterlibSceIme(Core::Loader::SymbolsResolver* sym);
} // namespace Libraries::Ime
| 3,877
|
C++
|
.h
| 108
| 33.574074
| 89
| 0.801224
|
shadps4-emu/shadPS4
| 9,253
| 501
| 185
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
15,795
|
libc_internal.h
|
shadps4-emu_shadPS4/src/core/libraries/libc_internal/libc_internal.h
|
// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
#pragma once
#include "common/types.h"
namespace Core::Loader {
class SymbolsResolver;
}
namespace Libraries::LibcInternal {
void* PS4_SYSV_ABI internal_memset(void* s, int c, size_t n);
void* PS4_SYSV_ABI internal_memcpy(void* dest, const void* src, size_t n);
int PS4_SYSV_ABI internal_memcpy_s(void* dest, size_t destsz, const void* src, size_t count);
int PS4_SYSV_ABI internal_strcpy_s(char* dest, size_t dest_size, const char* src);
int PS4_SYSV_ABI internal_memcmp(const void* s1, const void* s2, size_t n);
float PS4_SYSV_ABI internal_expf(float x);
void RegisterlibSceLibcInternal(Core::Loader::SymbolsResolver* sym);
} // namespace Libraries::LibcInternal
| 782
|
C++
|
.h
| 16
| 47.625
| 93
| 0.774278
|
shadps4-emu/shadPS4
| 9,253
| 501
| 185
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
15,796
|
disc_map.h
|
shadps4-emu_shadPS4/src/core/libraries/disc_map/disc_map.h
|
// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
#pragma once
#include "common/types.h"
namespace Core::Loader {
class SymbolsResolver;
}
namespace Libraries::DiscMap {
int PS4_SYSV_ABI sceDiscMapGetPackageSize();
int PS4_SYSV_ABI sceDiscMapIsRequestOnHDD();
int PS4_SYSV_ABI Func_7C980FFB0AA27E7A();
int PS4_SYSV_ABI Func_8A828CAEE7EDD5E9();
int PS4_SYSV_ABI Func_E7EBCE96E92F91F8();
void RegisterlibSceDiscMap(Core::Loader::SymbolsResolver* sym);
} // namespace Libraries::DiscMap
| 550
|
C++
|
.h
| 15
| 35.4
| 66
| 0.815443
|
shadps4-emu/shadPS4
| 9,253
| 501
| 185
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
15,797
|
disc_map_codes.h
|
shadps4-emu_shadPS4/src/core/libraries/disc_map/disc_map_codes.h
|
// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
#pragma once
constexpr int ORBIS_DISC_MAP_ERROR_INVALID_ARGUMENT = 0x81100001;
constexpr int ORBIS_DISC_MAP_ERROR_LOCATION_NOT_MAPPED = 0x81100002;
constexpr int ORBIS_DISC_MAP_ERROR_FILE_NOT_FOUND = 0x81100003;
constexpr int ORBIS_DISC_MAP_ERROR_NO_BITMAP_INFO = 0x81100004;
constexpr int ORBIS_DISC_MAP_ERROR_FATAL = 0x811000FF;
| 445
|
C++
|
.h
| 8
| 54.375
| 68
| 0.816092
|
shadps4-emu/shadPS4
| 9,253
| 501
| 185
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
15,798
|
app_content.h
|
shadps4-emu_shadPS4/src/core/libraries/app_content/app_content.h
|
// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
#pragma once
#include "common/types.h"
namespace Core::Loader {
class SymbolsResolver;
}
namespace Libraries::AppContent {
constexpr int ORBIS_APP_CONTENT_APPPARAM_ID_SKU_FLAG = 0;
constexpr int ORBIS_APP_CONTENT_APPPARAM_ID_USER_DEFINED_PARAM_1 = 1;
constexpr int ORBIS_APP_CONTENT_APPPARAM_ID_USER_DEFINED_PARAM_2 = 2;
constexpr int ORBIS_APP_CONTENT_APPPARAM_ID_USER_DEFINED_PARAM_3 = 3;
constexpr int ORBIS_APP_CONTENT_APPPARAM_ID_USER_DEFINED_PARAM_4 = 4;
constexpr int ORBIS_APP_CONTENT_APPPARAM_SKU_FLAG_TRIAL = 1;
constexpr int ORBIS_APP_CONTENT_APPPARAM_SKU_FLAG_FULL = 3;
struct OrbisAppContentInitParam {
char reserved[32];
};
struct OrbisAppContentBootParam {
char reserved1[4];
u32 attr;
char reserved2[32];
};
typedef u32 OrbisAppContentTemporaryDataOption;
constexpr int ORBIS_APP_CONTENT_MOUNTPOINT_DATA_MAXSIZE = 16;
struct OrbisAppContentMountPoint {
char data[ORBIS_APP_CONTENT_MOUNTPOINT_DATA_MAXSIZE];
};
constexpr int ORBIS_APP_CONTENT_TEMPORARY_DATA_OPTION_NONE = 0;
constexpr int ORBIS_APP_CONTENT_TEMPORARY_DATA_OPTION_FORMAT = (1 << 0);
constexpr int ORBIS_NP_UNIFIED_ENTITLEMENT_LABEL_SIZE = 17;
constexpr int ORBIS_APP_CONTENT_ENTITLEMENT_KEY_SIZE = 16;
constexpr int ORBIS_APP_CONTENT_INFO_LIST_MAX_SIZE = 2500;
enum OrbisAppContentAddcontDownloadStatus : u32 {
ORBIS_APP_CONTENT_ADDCONT_DOWNLOAD_STATUS_NO_EXTRA_DATA = 0,
ORBIS_APP_CONTENT_ADDCONT_DOWNLOAD_STATUS_NO_IN_QUEUE = 1,
ORBIS_APP_CONTENT_ADDCONT_DOWNLOAD_STATUS_DOWNLOADING = 2,
ORBIS_APP_CONTENT_ADDCONT_DOWNLOAD_STATUS_DOWNLOAD_SUSPENDED = 3,
ORBIS_APP_CONTENT_ADDCONT_DOWNLOAD_STATUS_INSTALLED = 4
};
struct OrbisNpUnifiedEntitlementLabel {
char data[ORBIS_NP_UNIFIED_ENTITLEMENT_LABEL_SIZE];
char padding[3];
};
typedef u32 OrbisAppContentAppParamId;
struct OrbisAppContentAddcontInfo {
OrbisNpUnifiedEntitlementLabel entitlement_label;
u32 status;
};
struct OrbisAppContentGetEntitlementKey {
char data[ORBIS_APP_CONTENT_ENTITLEMENT_KEY_SIZE];
};
int PS4_SYSV_ABI _Z5dummyv();
int PS4_SYSV_ABI sceAppContentAddcontDelete();
int PS4_SYSV_ABI sceAppContentAddcontEnqueueDownload();
int PS4_SYSV_ABI sceAppContentAddcontEnqueueDownloadSp();
int PS4_SYSV_ABI sceAppContentAddcontMount(u32 service_label,
const OrbisNpUnifiedEntitlementLabel* entitlement_label,
OrbisAppContentMountPoint* mount_point);
int PS4_SYSV_ABI sceAppContentAddcontShrink();
int PS4_SYSV_ABI sceAppContentAddcontUnmount();
int PS4_SYSV_ABI sceAppContentAppParamGetInt(OrbisAppContentAppParamId paramId, s32* value);
int PS4_SYSV_ABI sceAppContentAppParamGetString();
int PS4_SYSV_ABI sceAppContentDownload0Expand();
int PS4_SYSV_ABI sceAppContentDownload0Shrink();
int PS4_SYSV_ABI sceAppContentDownload1Expand();
int PS4_SYSV_ABI sceAppContentDownload1Shrink();
int PS4_SYSV_ABI sceAppContentDownloadDataFormat();
int PS4_SYSV_ABI sceAppContentDownloadDataGetAvailableSpaceKb();
int PS4_SYSV_ABI sceAppContentGetAddcontDownloadProgress();
int PS4_SYSV_ABI sceAppContentGetAddcontInfo(u32 service_label,
const OrbisNpUnifiedEntitlementLabel* entitlementLabel,
OrbisAppContentAddcontInfo* info);
int PS4_SYSV_ABI sceAppContentGetAddcontInfoList(u32 service_label,
OrbisAppContentAddcontInfo* list, u32 list_num,
u32* hit_num);
int PS4_SYSV_ABI sceAppContentGetEntitlementKey(
u32 service_label, const OrbisNpUnifiedEntitlementLabel* entitlement_label,
OrbisAppContentGetEntitlementKey* key);
int PS4_SYSV_ABI sceAppContentGetRegion();
int PS4_SYSV_ABI sceAppContentInitialize(const OrbisAppContentInitParam* initParam,
OrbisAppContentBootParam* bootParam);
int PS4_SYSV_ABI sceAppContentRequestPatchInstall();
int PS4_SYSV_ABI sceAppContentSmallSharedDataFormat();
int PS4_SYSV_ABI sceAppContentSmallSharedDataGetAvailableSpaceKb();
int PS4_SYSV_ABI sceAppContentSmallSharedDataMount();
int PS4_SYSV_ABI sceAppContentSmallSharedDataUnmount();
int PS4_SYSV_ABI sceAppContentTemporaryDataFormat();
int PS4_SYSV_ABI sceAppContentTemporaryDataGetAvailableSpaceKb(
const OrbisAppContentMountPoint* mountPoint, size_t* availableSpaceKb);
int PS4_SYSV_ABI sceAppContentTemporaryDataMount();
int PS4_SYSV_ABI sceAppContentTemporaryDataMount2(OrbisAppContentTemporaryDataOption option,
OrbisAppContentMountPoint* mountPoint);
int PS4_SYSV_ABI sceAppContentTemporaryDataUnmount();
int PS4_SYSV_ABI sceAppContentGetPftFlag();
int PS4_SYSV_ABI Func_C59A36FF8D7C59DA();
int PS4_SYSV_ABI sceAppContentAddcontEnqueueDownloadByEntitlementId();
int PS4_SYSV_ABI sceAppContentAddcontMountByEntitlementId();
int PS4_SYSV_ABI sceAppContentGetAddcontInfoByEntitlementId();
int PS4_SYSV_ABI sceAppContentGetAddcontInfoListByIroTag();
int PS4_SYSV_ABI sceAppContentGetDownloadedStoreCountry();
void RegisterlibSceAppContent(Core::Loader::SymbolsResolver* sym);
} // namespace Libraries::AppContent
| 5,307
|
C++
|
.h
| 103
| 46.106796
| 100
| 0.778828
|
shadps4-emu/shadPS4
| 9,253
| 501
| 185
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
15,799
|
pngdec.h
|
shadps4-emu_shadPS4/src/core/libraries/libpng/pngdec.h
|
// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
#pragma once
#include "common/types.h"
namespace Core::Loader {
class SymbolsResolver;
}
namespace Libraries::PngDec {
constexpr int ORBIS_PNG_DEC_ERROR_INVALID_ADDR = 0x80690001;
constexpr int ORBIS_PNG_DEC_ERROR_INVALID_SIZE = 0x80690002;
constexpr int ORBIS_PNG_DEC_ERROR_INVALID_PARAM = 0x80690003;
constexpr int ORBIS_PNG_DEC_ERROR_INVALID_HANDLE = 0x80690004;
constexpr int ORBIS_PNG_DEC_ERROR_INVALID_WORK_MEMORY = 0x80690005;
constexpr int ORBIS_PNG_DEC_ERROR_INVALID_DATA = 0x80690010;
constexpr int ORBIS_PNG_DEC_ERROR_UNSUPPORT_DATA = 0x80690011;
constexpr int ORBIS_PNG_DEC_ERROR_DECODE_ERROR = 0x80690012;
constexpr int ORBIS_PNG_DEC_ERROR_FATAL = 0x80690020;
typedef struct OrbisPngDecParseParam {
const void* pngMemAddr;
u32 pngMemSize;
u32 reserved;
} OrbisPngDecParseParam;
typedef struct OrbisPngDecImageInfo {
u32 imageWidth;
u32 imageHeight;
u16 colorSpace;
u16 bitDepth;
u32 imageFlag;
} OrbisPngDecImageInfo;
typedef enum OrbisPngDecColorSpace {
ORBIS_PNG_DEC_COLOR_SPACE_GRAYSCALE = 2,
ORBIS_PNG_DEC_COLOR_SPACE_RGB,
ORBIS_PNG_DEC_COLOR_SPACE_CLUT,
ORBIS_PNG_DEC_COLOR_SPACE_GRAYSCALE_ALPHA = 18,
ORBIS_PNG_DEC_COLOR_SPACE_RGBA
} ScePngDecColorSpace;
typedef enum OrbisPngDecImageFlag {
ORBIS_PNG_DEC_IMAGE_FLAG_ADAM7_INTERLACE = 1,
ORBIS_PNG_DEC_IMAGE_FLAG_TRNS_CHUNK_EXIST = 2
} OrbisPngDecImageFlag;
typedef struct OrbisPngDecCreateParam {
u32 thisSize;
u32 attribute;
u32 maxImageWidth;
} OrbisPngDecCreateParam;
typedef void* OrbisPngDecHandle;
typedef struct OrbisPngDecDecodeParam {
const void* pngMemAddr;
void* imageMemAddr;
u32 pngMemSize;
u32 imageMemSize;
u16 pixelFormat;
u16 alphaValue;
u32 imagePitch;
} OrbisPngDecDecodeParam;
s32 PS4_SYSV_ABI scePngDecCreate(const OrbisPngDecCreateParam* param, void* memoryAddress,
u32 memorySize, OrbisPngDecHandle* handle);
s32 PS4_SYSV_ABI scePngDecDecode(OrbisPngDecHandle handle, const OrbisPngDecDecodeParam* param,
OrbisPngDecImageInfo* imageInfo);
s32 PS4_SYSV_ABI scePngDecDecodeWithInputControl();
s32 PS4_SYSV_ABI scePngDecDelete(OrbisPngDecHandle handle);
s32 PS4_SYSV_ABI scePngDecParseHeader(const OrbisPngDecParseParam* param,
OrbisPngDecImageInfo* imageInfo);
s32 PS4_SYSV_ABI scePngDecQueryMemorySize(const OrbisPngDecCreateParam* param);
void RegisterlibScePngDec(Core::Loader::SymbolsResolver* sym);
} // namespace Libraries::PngDec
| 2,655
|
C++
|
.h
| 66
| 35.954545
| 95
| 0.774932
|
shadps4-emu/shadPS4
| 9,253
| 501
| 185
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
15,800
|
save_instance.h
|
shadps4-emu_shadPS4/src/core/libraries/save_data/save_instance.h
|
// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
#pragma once
#include <filesystem>
#include "common/io_file.h"
#include "core/file_format/psf.h"
namespace Core::FileSys {
class MntPoints;
}
namespace Libraries::SaveData {
// Used constexpr to easily use as string
namespace SaveParams {
constexpr std::string_view ACCOUNT_ID = "ACCOUNT_ID";
constexpr std::string_view ATTRIBUTE = "ATTRIBUTE";
constexpr std::string_view CATEGORY = "CATEGORY";
constexpr std::string_view DETAIL = "DETAIL";
constexpr std::string_view FORMAT = "FORMAT";
constexpr std::string_view MAINTITLE = "MAINTITLE";
constexpr std::string_view PARAMS = "PARAMS";
constexpr std::string_view SAVEDATA_BLOCKS = "SAVEDATA_BLOCKS";
constexpr std::string_view SAVEDATA_DIRECTORY = "SAVEDATA_DIRECTORY";
constexpr std::string_view SAVEDATA_LIST_PARAM = "SAVEDATA_LIST_PARAM";
constexpr std::string_view SUBTITLE = "SUBTITLE";
constexpr std::string_view TITLE_ID = "TITLE_ID";
} // namespace SaveParams
using OrbisUserServiceUserId = s32;
class SaveInstance {
int slot_num{};
int user_id{};
std::string game_serial;
std::string dir_name;
std::filesystem::path save_path;
std::filesystem::path param_sfo_path;
std::filesystem::path corrupt_file_path;
Common::FS::IOFile corrupt_file;
PSF param_sfo;
std::string mount_point;
int max_blocks{};
bool exists{};
bool mounted{};
bool read_only{};
public:
// Location of all save data for a title
static std::filesystem::path MakeTitleSavePath(OrbisUserServiceUserId user_id,
std::string_view game_serial);
// Location of a specific save data directory
static std::filesystem::path MakeDirSavePath(OrbisUserServiceUserId user_id,
std::string_view game_serial,
std::string_view dir_name);
static uint64_t GetMaxBlockFromSFO(const PSF& psf);
// Get param.sfo path from a dir_path generated by MakeDirSavePath
static std::filesystem::path GetParamSFOPath(const std::filesystem::path& dir_path);
static void SetupDefaultParamSFO(PSF& param_sfo, std::string dir_name, std::string game_serial);
explicit SaveInstance(int slot_num, OrbisUserServiceUserId user_id, std::string game_serial,
std::string_view dir_name, int max_blocks = 0);
~SaveInstance();
SaveInstance(const SaveInstance& other) = delete;
SaveInstance(SaveInstance&& other) noexcept;
SaveInstance& operator=(const SaveInstance& other) = delete;
SaveInstance& operator=(SaveInstance&& other) noexcept;
void SetupAndMount(bool read_only = false, bool copy_icon = false, bool ignore_corrupt = false);
void Umount();
[[nodiscard]] std::filesystem::path GetIconPath() const noexcept {
return save_path / "sce_sys" / "icon0.png";
}
[[nodiscard]] bool Exists() const noexcept {
return exists;
}
[[nodiscard]] OrbisUserServiceUserId GetUserId() const noexcept {
return user_id;
}
[[nodiscard]] std::string_view GetTitleId() const noexcept {
return game_serial;
}
[[nodiscard]] const std::string& GetDirName() const noexcept {
return dir_name;
}
[[nodiscard]] const std::filesystem::path& GetSavePath() const noexcept {
return save_path;
}
[[nodiscard]] const PSF& GetParamSFO() const noexcept {
return param_sfo;
}
[[nodiscard]] PSF& GetParamSFO() noexcept {
return param_sfo;
}
[[nodiscard]] const std::string& GetMountPoint() const noexcept {
return mount_point;
}
[[nodiscard]] int GetMaxBlocks() const noexcept {
return max_blocks;
}
[[nodiscard]] bool Mounted() const noexcept {
return mounted;
}
[[nodiscard]] bool IsReadOnly() const noexcept {
return read_only;
}
void CreateFiles();
};
} // namespace Libraries::SaveData
| 4,075
|
C++
|
.h
| 101
| 34.118812
| 100
| 0.683007
|
shadps4-emu/shadPS4
| 9,253
| 501
| 185
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
15,801
|
save_backup.h
|
shadps4-emu_shadPS4/src/core/libraries/save_data/save_backup.h
|
// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
#pragma once
#include <filesystem>
#include <optional>
#include "common/types.h"
namespace Libraries::SaveData {
using OrbisUserServiceUserId = s32;
namespace Backup {
enum class WorkerStatus {
NotStarted,
Waiting,
Running,
Stopping,
};
enum class OrbisSaveDataEventType : u32 {
UMOUNT_BACKUP = 1,
BACKUP = 2,
SAVE_DATA_MEMORY_SYNC = 3,
};
struct BackupRequest {
bool done{};
OrbisUserServiceUserId user_id{};
std::string title_id{};
std::string dir_name{};
OrbisSaveDataEventType origin{};
std::filesystem::path save_path{};
};
// No problem calling this function if the backup thread is already running
void StartThread();
void StopThread();
bool NewRequest(OrbisUserServiceUserId user_id, std::string_view title_id,
std::string_view dir_name, OrbisSaveDataEventType origin);
bool Restore(const std::filesystem::path& save_path);
WorkerStatus GetWorkerStatus();
bool IsBackupExecutingFor(const std::filesystem::path& save_path);
std::filesystem::path MakeBackupPath(const std::filesystem::path& save_path);
std::optional<BackupRequest> PopLastEvent();
void PushBackupEvent(BackupRequest&& req);
float GetProgress();
void ClearProgress();
} // namespace Backup
} // namespace Libraries::SaveData
| 1,401
|
C++
|
.h
| 43
| 29.44186
| 77
| 0.76087
|
shadps4-emu/shadPS4
| 9,253
| 501
| 185
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
15,802
|
save_memory.h
|
shadps4-emu_shadPS4/src/core/libraries/save_data/save_memory.h
|
// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
#pragma once
#include <span>
#include "save_backup.h"
class PSF;
namespace Libraries::SaveData {
using OrbisUserServiceUserId = s32;
}
namespace Libraries::SaveData::SaveMemory {
void SetDirectories(OrbisUserServiceUserId user_id, std::string game_serial);
[[nodiscard]] const std::filesystem::path& GetSavePath();
// returns the size of the existed save memory
size_t CreateSaveMemory(size_t memory_size);
// Initialize the icon. Set buf to null to read the standard icon.
void SetIcon(void* buf, size_t buf_size);
// Update the icon
void WriteIcon(void* buf, size_t buf_size);
[[nodiscard]] bool IsSaveMemoryInitialized();
[[nodiscard]] PSF& GetParamSFO();
[[nodiscard]] std::span<u8> GetIcon();
// Save now or wait for the background thread to save
void SaveSFO(bool sync = false);
[[nodiscard]] bool IsSaving();
bool TriggerSaveWithoutEvent();
bool TriggerSave();
void ReadMemory(void* buf, size_t buf_size, int64_t offset);
void WriteMemory(void* buf, size_t buf_size, int64_t offset);
} // namespace Libraries::SaveData::SaveMemory
| 1,169
|
C++
|
.h
| 29
| 38.655172
| 77
| 0.776985
|
shadps4-emu/shadPS4
| 9,253
| 501
| 185
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
15,803
|
savedata.h
|
shadps4-emu_shadPS4/src/core/libraries/save_data/savedata.h
|
// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
#pragma once
#include "common/cstring.h"
#include "common/types.h"
namespace Core::Loader {
class SymbolsResolver;
}
class PSF;
namespace Libraries::SaveData {
constexpr size_t OrbisSaveDataTitleMaxsize = 128; // Maximum title name size
constexpr size_t OrbisSaveDataSubtitleMaxsize = 128; // Maximum subtitle name size
constexpr size_t OrbisSaveDataDetailMaxsize = 1024; // Maximum detail name size
enum class Error : u32;
enum class OrbisSaveDataParamType : u32;
using OrbisUserServiceUserId = s32;
// Maximum size for a title ID (4 uppercase letters + 5 digits)
constexpr int OrbisSaveDataTitleIdDataSize = 10;
// Maximum save directory name size
constexpr int OrbisSaveDataDirnameDataMaxsize = 32;
struct OrbisSaveDataTitleId {
Common::CString<OrbisSaveDataTitleIdDataSize> data;
std::array<char, 6> _pad;
};
struct OrbisSaveDataDirName {
Common::CString<OrbisSaveDataDirnameDataMaxsize> data;
};
struct OrbisSaveDataParam {
Common::CString<OrbisSaveDataTitleMaxsize> title;
Common::CString<OrbisSaveDataSubtitleMaxsize> subTitle;
Common::CString<OrbisSaveDataDetailMaxsize> detail;
u32 userParam;
int : 32;
time_t mtime;
std::array<u8, 32> _reserved;
void FromSFO(const PSF& sfo);
void ToSFO(PSF& sfo) const;
};
struct OrbisSaveDataBackup;
struct OrbisSaveDataCheckBackupData;
struct OrbisSaveDataDelete;
struct OrbisSaveDataDirNameSearchCond;
struct OrbisSaveDataDirNameSearchResult;
struct OrbisSaveDataEvent;
struct OrbisSaveDataEventParam;
struct OrbisSaveDataIcon;
struct OrbisSaveDataMemoryGet2;
struct OrbisSaveDataMemorySet2;
struct OrbisSaveDataMemorySetup2;
struct OrbisSaveDataMemorySetupResult;
struct OrbisSaveDataMemorySync;
struct OrbisSaveDataMount2;
struct OrbisSaveDataMount;
struct OrbisSaveDataMountInfo;
struct OrbisSaveDataMountPoint;
struct OrbisSaveDataMountResult;
struct OrbisSaveDataRestoreBackupData;
struct OrbisSaveDataTransferringMount;
int PS4_SYSV_ABI sceSaveDataAbort();
Error PS4_SYSV_ABI sceSaveDataBackup(const OrbisSaveDataBackup* backup);
int PS4_SYSV_ABI sceSaveDataBindPsnAccount();
int PS4_SYSV_ABI sceSaveDataBindPsnAccountForSystemBackup();
int PS4_SYSV_ABI sceSaveDataChangeDatabase();
int PS4_SYSV_ABI sceSaveDataChangeInternal();
Error PS4_SYSV_ABI sceSaveDataCheckBackupData(const OrbisSaveDataCheckBackupData* check);
int PS4_SYSV_ABI sceSaveDataCheckBackupDataForCdlg();
int PS4_SYSV_ABI sceSaveDataCheckBackupDataInternal();
int PS4_SYSV_ABI sceSaveDataCheckCloudData();
int PS4_SYSV_ABI sceSaveDataCheckIpmiIfSize();
int PS4_SYSV_ABI sceSaveDataCheckSaveDataBroken();
int PS4_SYSV_ABI sceSaveDataCheckSaveDataVersion();
int PS4_SYSV_ABI sceSaveDataCheckSaveDataVersionLatest();
Error PS4_SYSV_ABI sceSaveDataClearProgress();
int PS4_SYSV_ABI sceSaveDataCopy5();
int PS4_SYSV_ABI sceSaveDataCreateUploadData();
int PS4_SYSV_ABI sceSaveDataDebug();
int PS4_SYSV_ABI sceSaveDataDebugCleanMount();
int PS4_SYSV_ABI sceSaveDataDebugCompiledSdkVersion();
int PS4_SYSV_ABI sceSaveDataDebugCreateSaveDataRoot();
int PS4_SYSV_ABI sceSaveDataDebugGetThreadId();
int PS4_SYSV_ABI sceSaveDataDebugRemoveSaveDataRoot();
int PS4_SYSV_ABI sceSaveDataDebugTarget();
Error PS4_SYSV_ABI sceSaveDataDelete(const OrbisSaveDataDelete* del);
int PS4_SYSV_ABI sceSaveDataDelete5();
int PS4_SYSV_ABI sceSaveDataDeleteAllUser();
int PS4_SYSV_ABI sceSaveDataDeleteCloudData();
int PS4_SYSV_ABI sceSaveDataDeleteUser();
Error PS4_SYSV_ABI sceSaveDataDirNameSearch(const OrbisSaveDataDirNameSearchCond* cond,
OrbisSaveDataDirNameSearchResult* result);
int PS4_SYSV_ABI sceSaveDataDirNameSearchInternal();
int PS4_SYSV_ABI sceSaveDataDownload();
int PS4_SYSV_ABI sceSaveDataGetAllSize();
int PS4_SYSV_ABI sceSaveDataGetAppLaunchedUser();
int PS4_SYSV_ABI sceSaveDataGetAutoUploadConditions();
int PS4_SYSV_ABI sceSaveDataGetAutoUploadRequestInfo();
int PS4_SYSV_ABI sceSaveDataGetAutoUploadSetting();
int PS4_SYSV_ABI sceSaveDataGetBoundPsnAccountCount();
int PS4_SYSV_ABI sceSaveDataGetClientThreadPriority();
int PS4_SYSV_ABI sceSaveDataGetCloudQuotaInfo();
int PS4_SYSV_ABI sceSaveDataGetDataBaseFilePath();
int PS4_SYSV_ABI sceSaveDataGetEventInfo();
Error PS4_SYSV_ABI sceSaveDataGetEventResult(const OrbisSaveDataEventParam* eventParam,
OrbisSaveDataEvent* event);
int PS4_SYSV_ABI sceSaveDataGetFormat();
int PS4_SYSV_ABI sceSaveDataGetMountedSaveDataCount();
Error PS4_SYSV_ABI sceSaveDataGetMountInfo(const OrbisSaveDataMountPoint* mountPoint,
OrbisSaveDataMountInfo* info);
Error PS4_SYSV_ABI sceSaveDataGetParam(const OrbisSaveDataMountPoint* mountPoint,
OrbisSaveDataParamType paramType, void* paramBuf,
size_t paramBufSize, size_t* gotSize);
Error PS4_SYSV_ABI sceSaveDataGetProgress(float* progress);
int PS4_SYSV_ABI sceSaveDataGetSaveDataCount();
Error PS4_SYSV_ABI sceSaveDataGetSaveDataMemory(OrbisUserServiceUserId userId, void* buf,
size_t bufSize, int64_t offset);
Error PS4_SYSV_ABI sceSaveDataGetSaveDataMemory2(OrbisSaveDataMemoryGet2* getParam);
int PS4_SYSV_ABI sceSaveDataGetSaveDataRootDir();
int PS4_SYSV_ABI sceSaveDataGetSaveDataRootPath();
int PS4_SYSV_ABI sceSaveDataGetSaveDataRootUsbPath();
int PS4_SYSV_ABI sceSaveDataGetSavePoint();
int PS4_SYSV_ABI sceSaveDataGetUpdatedDataCount();
Error PS4_SYSV_ABI sceSaveDataInitialize(void*);
Error PS4_SYSV_ABI sceSaveDataInitialize2(void*);
Error PS4_SYSV_ABI sceSaveDataInitialize3(void*);
int PS4_SYSV_ABI sceSaveDataInitializeForCdlg();
int PS4_SYSV_ABI sceSaveDataIsDeletingUsbDb();
int PS4_SYSV_ABI sceSaveDataIsMounted();
Error PS4_SYSV_ABI sceSaveDataLoadIcon(const OrbisSaveDataMountPoint* mountPoint,
OrbisSaveDataIcon* icon);
Error PS4_SYSV_ABI sceSaveDataMount(const OrbisSaveDataMount* mount,
OrbisSaveDataMountResult* mount_result);
Error PS4_SYSV_ABI sceSaveDataMount2(const OrbisSaveDataMount2* mount,
OrbisSaveDataMountResult* mount_result);
int PS4_SYSV_ABI sceSaveDataMount5();
int PS4_SYSV_ABI sceSaveDataMountInternal();
int PS4_SYSV_ABI sceSaveDataMountSys();
int PS4_SYSV_ABI sceSaveDataPromote5();
int PS4_SYSV_ABI sceSaveDataRebuildDatabase();
int PS4_SYSV_ABI sceSaveDataRegisterEventCallback();
Error PS4_SYSV_ABI sceSaveDataRestoreBackupData(const OrbisSaveDataRestoreBackupData* restore);
int PS4_SYSV_ABI sceSaveDataRestoreBackupDataForCdlg();
int PS4_SYSV_ABI sceSaveDataRestoreLoadSaveDataMemory();
Error PS4_SYSV_ABI sceSaveDataSaveIcon(const OrbisSaveDataMountPoint* mountPoint,
const OrbisSaveDataIcon* icon);
int PS4_SYSV_ABI sceSaveDataSetAutoUploadSetting();
int PS4_SYSV_ABI sceSaveDataSetEventInfo();
Error PS4_SYSV_ABI sceSaveDataSetParam(const OrbisSaveDataMountPoint* mountPoint,
OrbisSaveDataParamType paramType, const void* paramBuf,
size_t paramBufSize);
int PS4_SYSV_ABI sceSaveDataSetSaveDataLibraryUser();
Error PS4_SYSV_ABI sceSaveDataSetSaveDataMemory(OrbisUserServiceUserId userId, void* buf,
size_t bufSize, int64_t offset);
Error PS4_SYSV_ABI sceSaveDataSetSaveDataMemory2(const OrbisSaveDataMemorySet2* setParam);
Error PS4_SYSV_ABI sceSaveDataSetupSaveDataMemory(OrbisUserServiceUserId userId, size_t memorySize,
OrbisSaveDataParam* param);
Error PS4_SYSV_ABI sceSaveDataSetupSaveDataMemory2(const OrbisSaveDataMemorySetup2* setupParam,
OrbisSaveDataMemorySetupResult* result);
int PS4_SYSV_ABI sceSaveDataShutdownStart();
int PS4_SYSV_ABI sceSaveDataSupportedFakeBrokenStatus();
int PS4_SYSV_ABI sceSaveDataSyncCloudList();
Error PS4_SYSV_ABI sceSaveDataSyncSaveDataMemory(OrbisSaveDataMemorySync* syncParam);
Error PS4_SYSV_ABI sceSaveDataTerminate();
Error PS4_SYSV_ABI sceSaveDataTransferringMount(const OrbisSaveDataTransferringMount* mount,
OrbisSaveDataMountResult* mountResult);
Error PS4_SYSV_ABI sceSaveDataUmount(const OrbisSaveDataMountPoint* mountPoint);
int PS4_SYSV_ABI sceSaveDataUmountSys();
Error PS4_SYSV_ABI sceSaveDataUmountWithBackup(const OrbisSaveDataMountPoint* mountPoint);
int PS4_SYSV_ABI sceSaveDataUnregisterEventCallback();
int PS4_SYSV_ABI sceSaveDataUpload();
int PS4_SYSV_ABI Func_02E4C4D201716422();
void RegisterlibSceSaveData(Core::Loader::SymbolsResolver* sym);
} // namespace Libraries::SaveData
| 8,862
|
C++
|
.h
| 171
| 46.444444
| 99
| 0.787872
|
shadps4-emu/shadPS4
| 9,253
| 501
| 185
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
15,804
|
savedatadialog_ui.h
|
shadps4-emu_shadPS4/src/core/libraries/save_data/dialog/savedatadialog_ui.h
|
// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
#pragma once
#include <mutex>
#include <variant>
#include <vector>
#include "core/file_format/psf.h"
#include "core/libraries/save_data/savedata.h"
#include "core/libraries/system/commondialog.h"
#include "imgui/imgui_layer.h"
#include "imgui/imgui_texture.h"
namespace Libraries::SaveData::Dialog {
using OrbisUserServiceUserId = s32;
enum class SaveDataDialogMode : u32 {
INVALID = 0,
LIST = 1,
USER_MSG = 2,
SYSTEM_MSG = 3,
ERROR_CODE = 4,
PROGRESS_BAR = 5,
};
enum class DialogType : u32 {
SAVE = 1,
LOAD = 2,
DELETE = 3,
};
enum class DialogAnimation : u32 {
ON = 0,
OFF = 1,
};
enum class ButtonId : u32 {
INVALID = 0,
OK = 1,
YES = 1,
NO = 2,
};
enum class ButtonType : u32 {
OK = 0,
YESNO = 1,
NONE = 2,
OKCANCEL = 3,
};
enum class UserMessageType : u32 {
NORMAL = 0,
ERROR = 1,
};
enum class FocusPos : u32 {
LISTHEAD = 0,
LISTTAIL = 1,
DATAHEAD = 2,
DATATAIL = 3,
DATALTATEST = 4,
DATAOLDEST = 5,
DIRNAME = 6,
};
enum class ItemStyle : u32 {
TITLE_DATASIZE_SUBTITLE = 0,
TITLE_SUBTITLE_DATESIZE = 1,
TITLE_DATESIZE = 2,
};
enum class SystemMessageType : u32 {
NODATA = 1,
CONFIRM = 2,
OVERWRITE = 3,
NOSPACE = 4,
PROGRESS = 5,
FILE_CORRUPTED = 6,
FINISHED = 7,
NOSPACE_CONTINUABLE = 8,
CORRUPTED_AND_DELETED = 10,
CORRUPTED_AND_CREATED = 11,
CORRUPTED_AND_RESTORE = 13,
TOTAL_SIZE_EXCEEDED = 14,
};
enum class ProgressBarType : u32 {
PERCENTAGE = 0,
};
enum class ProgressSystemMessageType : u32 {
INVALID = 0,
PROGRESS = 1,
RESTORE = 2,
};
enum class OptionBack : u32 {
ENABLE = 0,
DISABLE = 1,
};
enum class OrbisSaveDataDialogProgressBarTarget : u32 {
DEFAULT = 0,
};
struct AnimationParam {
DialogAnimation userOK;
DialogAnimation userCancel;
std::array<u8, 32> _reserved;
};
struct SaveDialogNewItem {
const char* title;
void* iconBuf;
size_t iconSize;
std::array<u8, 32> _reserved;
};
struct SaveDialogItems {
OrbisUserServiceUserId userId;
s32 : 32;
const OrbisSaveDataTitleId* titleId;
const OrbisSaveDataDirName* dirName;
u32 dirNameNum;
s32 : 32;
const SaveDialogNewItem* newItem;
FocusPos focusPos;
s32 : 32;
const OrbisSaveDataDirName* focusPosDirName;
ItemStyle itemStyle;
std::array<u8, 32> _reserved;
};
struct UserMessageParam {
ButtonType buttonType;
UserMessageType msgType;
const char* msg;
std::array<u8, 32> _reserved;
};
struct SystemMessageParam {
SystemMessageType msgType;
s32 : 32;
u64 value;
std::array<u8, 32> _reserved;
};
struct ErrorCodeParam {
u32 errorCode;
std::array<u8, 32> _reserved;
};
struct ProgressBarParam {
ProgressBarType barType;
s32 : 32;
const char* msg;
ProgressSystemMessageType sysMsgType;
std::array<u8, 28> _reserved;
};
struct OptionParam {
OptionBack back;
std::array<u8, 32> _reserved;
};
struct OrbisSaveDataDialogParam {
CommonDialog::BaseParam baseParam;
s32 size;
SaveDataDialogMode mode;
DialogType dispType;
s32 : 32;
AnimationParam* animParam;
SaveDialogItems* items;
UserMessageParam* userMsgParam;
SystemMessageParam* sysMsgParam;
ErrorCodeParam* errorCodeParam;
ProgressBarParam* progressBarParam;
void* userData;
OptionParam* optionParam;
std::array<u8, 24> _reserved;
};
struct OrbisSaveDataDialogResult {
SaveDataDialogMode mode{};
CommonDialog::Result result{};
ButtonId buttonId{};
s32 : 32;
OrbisSaveDataDirName* dirName;
OrbisSaveDataParam* param;
void* userData;
std::array<u8, 32> _reserved;
};
struct SaveDialogResult {
SaveDataDialogMode mode{};
CommonDialog::Result result{CommonDialog::Result::OK};
ButtonId button_id{ButtonId::INVALID};
std::string dir_name{};
PSF param{};
void* user_data{};
void CopyTo(OrbisSaveDataDialogResult& result) const;
};
class SaveDialogState {
friend class SaveDialogUi;
public:
struct UserState {
ButtonType type{};
UserMessageType msg_type{};
std::string msg{};
UserState(const OrbisSaveDataDialogParam& param);
};
struct SystemState {
std::string msg{};
bool hide_ok{};
bool show_no{}; // Yes instead of OK
bool show_cancel{};
bool return_cancel{};
SystemState(const SaveDialogState& state, const OrbisSaveDataDialogParam& param);
};
struct ErrorCodeState {
std::string error_msg{};
ErrorCodeState(const OrbisSaveDataDialogParam& param);
};
struct ProgressBarState {
std::string msg{};
u32 progress{};
ProgressBarState(const SaveDialogState& state, const OrbisSaveDataDialogParam& param);
};
struct Item {
std::string dir_name{};
ImGui::RefCountedTexture icon{};
std::string title{};
std::string subtitle{};
std::string details{};
std::string date{};
std::string size{};
std::filesystem::file_time_type last_write{};
PSF pfo{};
bool is_corrupted{};
};
private:
SaveDataDialogMode mode{};
DialogType type{};
void* user_data{};
std::optional<bool> enable_back{};
OrbisUserServiceUserId user_id{};
std::string title_id{};
std::vector<Item> save_list{};
std::variant<FocusPos, std::string, std::monostate> focus_pos{std::monostate{}};
ItemStyle style{};
std::optional<Item> new_item{};
std::variant<UserState, SystemState, ErrorCodeState, ProgressBarState, std::monostate> state{
std::monostate{}};
public:
explicit SaveDialogState(const OrbisSaveDataDialogParam& param);
SaveDialogState() = default;
[[nodiscard]] SaveDataDialogMode GetMode() const {
return mode;
}
template <typename T>
[[nodiscard]] T& GetState() {
return std::get<T>(state);
}
};
class SaveDialogUi final : public ImGui::Layer {
bool first_render{false};
SaveDialogState* state{};
CommonDialog::Status* status{};
SaveDialogResult* result{};
std::recursive_mutex draw_mutex{};
public:
explicit SaveDialogUi(SaveDialogState* state = nullptr, CommonDialog::Status* status = nullptr,
SaveDialogResult* result = nullptr);
~SaveDialogUi() override;
SaveDialogUi(const SaveDialogUi& other) = delete;
SaveDialogUi(SaveDialogUi&& other) noexcept;
SaveDialogUi& operator=(SaveDialogUi other);
void Finish(ButtonId buttonId, CommonDialog::Result r = CommonDialog::Result::OK);
void Draw() override;
private:
void DrawItem(int id, const SaveDialogState::Item& item, bool clickable = true);
void DrawList();
void DrawUser();
void DrawSystemMessage();
void DrawErrorCode();
void DrawProgressBar();
};
}; // namespace Libraries::SaveData::Dialog
| 7,086
|
C++
|
.h
| 262
| 22.40458
| 99
| 0.67893
|
shadps4-emu/shadPS4
| 9,253
| 501
| 185
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
15,805
|
savedatadialog.h
|
shadps4-emu_shadPS4/src/core/libraries/save_data/dialog/savedatadialog.h
|
// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
#pragma once
#include "common/types.h"
#include "core/libraries/system/commondialog.h"
namespace Core::Loader {
class SymbolsResolver;
}
namespace Libraries::SaveData::Dialog {
struct OrbisSaveDataDialogParam;
struct OrbisSaveDataDialogResult;
enum class OrbisSaveDataDialogProgressBarTarget : u32;
CommonDialog::Error PS4_SYSV_ABI sceSaveDataDialogClose();
CommonDialog::Error PS4_SYSV_ABI sceSaveDataDialogGetResult(OrbisSaveDataDialogResult* result);
CommonDialog::Status PS4_SYSV_ABI sceSaveDataDialogGetStatus();
CommonDialog::Error PS4_SYSV_ABI sceSaveDataDialogInitialize();
s32 PS4_SYSV_ABI sceSaveDataDialogIsReadyToDisplay();
CommonDialog::Error PS4_SYSV_ABI sceSaveDataDialogOpen(const OrbisSaveDataDialogParam* param);
CommonDialog::Error PS4_SYSV_ABI
sceSaveDataDialogProgressBarInc(OrbisSaveDataDialogProgressBarTarget target, u32 delta);
CommonDialog::Error PS4_SYSV_ABI
sceSaveDataDialogProgressBarSetValue(OrbisSaveDataDialogProgressBarTarget target, u32 rate);
CommonDialog::Error PS4_SYSV_ABI sceSaveDataDialogTerminate();
CommonDialog::Status PS4_SYSV_ABI sceSaveDataDialogUpdateStatus();
void RegisterlibSceSaveDataDialog(Core::Loader::SymbolsResolver* sym);
} // namespace Libraries::SaveData::Dialog
| 1,342
|
C++
|
.h
| 26
| 50.346154
| 95
| 0.861727
|
shadps4-emu/shadPS4
| 9,253
| 501
| 185
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
15,806
|
pad.h
|
shadps4-emu_shadPS4/src/core/libraries/pad/pad.h
|
// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
#pragma once
#include "common/types.h"
namespace Core::Loader {
class SymbolsResolver;
}
namespace Libraries::Pad {
constexpr int ORBIS_PAD_MAX_TOUCH_NUM = 2;
constexpr int ORBIS_PAD_MAX_DEVICE_UNIQUE_DATA_SIZE = 12;
constexpr int ORBIS_PAD_PORT_TYPE_STANDARD = 0;
constexpr int ORBIS_PAD_PORT_TYPE_SPECIAL = 2;
constexpr int ORBIS_PAD_PORT_TYPE_REMOTE_CONTROL = 16;
enum OrbisPadDeviceClass {
ORBIS_PAD_DEVICE_CLASS_INVALID = -1,
ORBIS_PAD_DEVICE_CLASS_STANDARD = 0,
ORBIS_PAD_DEVICE_CLASS_GUITAR = 1,
ORBIS_PAD_DEVICE_CLASS_DRUM = 2,
ORBIS_PAD_DEVICE_CLASS_DJ_TURNTABLE = 3,
ORBIS_PAD_DEVICE_CLASS_DANCEMAT = 4,
ORBIS_PAD_DEVICE_CLASS_NAVIGATION = 5,
ORBIS_PAD_DEVICE_CLASS_STEERING_WHEEL = 6,
ORBIS_PAD_DEVICE_CLASS_STICK = 7,
ORBIS_PAD_DEVICE_CLASS_FLIGHT_STICK = 8,
ORBIS_PAD_DEVICE_CLASS_GUN = 9,
};
struct OrbisPadDeviceClassExtendedInformation {
OrbisPadDeviceClass deviceClass;
u8 reserved[4];
union {
struct {
u8 capability;
u8 reserved1[1];
u16 maxPhysicalWheelAngle;
u8 reserved2[8];
} steeringWheel;
struct {
u8 capability;
u8 quantityOfSelectorSwitch;
u8 reserved[10];
} guitar;
struct {
u8 capability;
u8 reserved[11];
} drum;
struct {
u8 capability;
u8 reserved[11];
} flightStick;
u8 data[12];
} classData;
};
struct OrbisPadDeviceClassData {
OrbisPadDeviceClass deviceClass;
bool bDataValid;
union {
struct {
float steeringWheelAngle;
u16 steeringWheel;
u16 acceleratorPedal;
u16 brakePedal;
u16 clutchPedal;
u16 handBrake;
u8 gear;
u8 reserved[1];
} steeringWheel;
struct {
u8 toneNumber;
u8 whammyBar;
u8 tilt;
u8 fret;
u8 fretSolo;
u8 reserved[11];
} guitar;
struct {
u8 snare;
u8 tom1;
u8 tom2;
u8 floorTom;
u8 hihatCymbal;
u8 rideCymbal;
u8 crashCymbal;
u8 reserved[9];
} drum;
struct {
u16 stickAxisX;
u16 stickAxisY;
u8 stickTwist;
u8 throttle;
u8 trigger;
u8 rudderPedal;
u8 brakePedalLeft;
u8 brakePedalRight;
u8 antennaKnob;
u8 rangeKnob;
u8 reserved[4];
} flightStick;
struct {
u8 dataLen;
u8 reserved[3];
u8 data[ORBIS_PAD_MAX_DEVICE_UNIQUE_DATA_SIZE];
} others;
} classData;
};
struct OrbisPadAnalogButtons {
u8 l2;
u8 r2;
u8 padding[2];
};
struct OrbisPadAnalogStick {
u8 x;
u8 y;
};
enum OrbisPadButtonDataOffset {
ORBIS_PAD_BUTTON_L3 = 0x00000002,
ORBIS_PAD_BUTTON_R3 = 0x00000004,
ORBIS_PAD_BUTTON_OPTIONS = 0x00000008,
ORBIS_PAD_BUTTON_UP = 0x00000010,
ORBIS_PAD_BUTTON_RIGHT = 0x00000020,
ORBIS_PAD_BUTTON_DOWN = 0x00000040,
ORBIS_PAD_BUTTON_LEFT = 0x00000080,
ORBIS_PAD_BUTTON_L2 = 0x00000100,
ORBIS_PAD_BUTTON_R2 = 0x00000200,
ORBIS_PAD_BUTTON_L1 = 0x00000400,
ORBIS_PAD_BUTTON_R1 = 0x00000800,
ORBIS_PAD_BUTTON_TRIANGLE = 0x00001000,
ORBIS_PAD_BUTTON_CIRCLE = 0x00002000,
ORBIS_PAD_BUTTON_CROSS = 0x00004000,
ORBIS_PAD_BUTTON_SQUARE = 0x00008000,
ORBIS_PAD_BUTTON_TOUCH_PAD = 0x00100000,
ORBIS_PAD_BUTTON_INTERCEPTED = 0x80000000,
};
struct OrbisFQuaternion {
float x, y, z, w;
};
struct OrbisFVector3 {
float x, y, z;
};
struct OrbisPadTouch {
u16 x;
u16 y;
u8 id;
u8 reserve[3];
};
struct OrbisPadTouchData {
u8 touchNum;
u8 reserve[3];
u32 reserve1;
OrbisPadTouch touch[ORBIS_PAD_MAX_TOUCH_NUM];
};
struct OrbisPadExtensionUnitData {
u32 extensionUnitId;
u8 reserve[1];
u8 dataLength;
u8 data[10];
};
struct OrbisPadData {
u32 buttons;
OrbisPadAnalogStick leftStick;
OrbisPadAnalogStick rightStick;
OrbisPadAnalogButtons analogButtons;
OrbisFQuaternion orientation;
OrbisFVector3 acceleration;
OrbisFVector3 angularVelocity;
OrbisPadTouchData touchData;
bool connected;
u64 timestamp;
OrbisPadExtensionUnitData extensionUnitData;
u8 connectedCount;
u8 reserve[2];
u8 deviceUniqueDataLen;
u8 deviceUniqueData[ORBIS_PAD_MAX_DEVICE_UNIQUE_DATA_SIZE];
};
struct OrbisPadTouchPadInformation {
float pixelDensity;
struct {
u16 x;
u16 y;
} resolution;
};
struct OrbisPadStickInformation {
u8 deadZoneLeft;
u8 deadZoneRight;
};
struct OrbisPadControllerInformation {
OrbisPadTouchPadInformation touchPadInfo;
OrbisPadStickInformation stickInfo;
u8 connectionType;
u8 connectedCount;
bool connected;
OrbisPadDeviceClass deviceClass;
u8 reserve[8];
};
struct OrbisPadExtendedControllerInformation {
OrbisPadControllerInformation base;
u16 padType1;
u16 padType2;
u8 capability;
union {
u8 quantityOfSelectorSwitch;
int maxPhysicalWheelAngle;
u8 data[8];
};
};
struct OrbisPadOpenParam {
u8 reserve[8];
};
struct OrbisPadOpenExtParam {
u16 vendorId;
u16 productId;
u16 productId_2;
u8 reserve[10];
};
struct OrbisPadLightBarParam {
u8 r;
u8 g;
u8 b;
u8 reserve[1];
};
struct OrbisPadVibrationParam {
u8 largeMotor;
u8 smallMotor;
};
int PS4_SYSV_ABI scePadClose(s32 handle);
int PS4_SYSV_ABI scePadConnectPort();
int PS4_SYSV_ABI scePadDeviceClassGetExtendedInformation(
s32 handle, OrbisPadDeviceClassExtendedInformation* pExtInfo);
int PS4_SYSV_ABI scePadDeviceClassParseData(s32 handle, const OrbisPadData* pData,
OrbisPadDeviceClassData* pDeviceClassData);
int PS4_SYSV_ABI scePadDeviceOpen();
int PS4_SYSV_ABI scePadDisableVibration();
int PS4_SYSV_ABI scePadDisconnectDevice();
int PS4_SYSV_ABI scePadDisconnectPort();
int PS4_SYSV_ABI scePadEnableAutoDetect();
int PS4_SYSV_ABI scePadEnableExtensionPort();
int PS4_SYSV_ABI scePadEnableSpecificDeviceClass();
int PS4_SYSV_ABI scePadEnableUsbConnection();
int PS4_SYSV_ABI scePadGetBluetoothAddress();
int PS4_SYSV_ABI scePadGetCapability();
int PS4_SYSV_ABI scePadGetControllerInformation(s32 handle, OrbisPadControllerInformation* pInfo);
int PS4_SYSV_ABI scePadGetDataInternal();
int PS4_SYSV_ABI scePadGetDeviceId();
int PS4_SYSV_ABI scePadGetDeviceInfo();
int PS4_SYSV_ABI scePadGetExtControllerInformation(s32 handle,
OrbisPadExtendedControllerInformation* pInfo);
int PS4_SYSV_ABI scePadGetExtensionUnitInfo();
int PS4_SYSV_ABI scePadGetFeatureReport();
int PS4_SYSV_ABI scePadGetHandle(s32 userId, s32 type, s32 index);
int PS4_SYSV_ABI scePadGetIdleCount();
int PS4_SYSV_ABI scePadGetInfo();
int PS4_SYSV_ABI scePadGetInfoByPortType();
int PS4_SYSV_ABI scePadGetLicenseControllerInformation();
int PS4_SYSV_ABI scePadGetMotionSensorPosition();
int PS4_SYSV_ABI scePadGetMotionTimerUnit();
int PS4_SYSV_ABI scePadGetSphereRadius();
int PS4_SYSV_ABI scePadGetVersionInfo();
int PS4_SYSV_ABI scePadInit();
int PS4_SYSV_ABI scePadIsBlasterConnected();
int PS4_SYSV_ABI scePadIsDS4Connected();
int PS4_SYSV_ABI scePadIsLightBarBaseBrightnessControllable();
int PS4_SYSV_ABI scePadIsMoveConnected();
int PS4_SYSV_ABI scePadIsMoveReproductionModel();
int PS4_SYSV_ABI scePadIsValidHandle();
int PS4_SYSV_ABI scePadMbusInit();
int PS4_SYSV_ABI scePadMbusTerm();
int PS4_SYSV_ABI scePadOpen(s32 userId, s32 type, s32 index, const OrbisPadOpenParam* pParam);
int PS4_SYSV_ABI scePadOpenExt(s32 userId, s32 type, s32 index, const OrbisPadOpenExtParam* pParam);
int PS4_SYSV_ABI scePadOpenExt2();
int PS4_SYSV_ABI scePadOutputReport();
int PS4_SYSV_ABI scePadRead(s32 handle, OrbisPadData* pData, s32 num);
int PS4_SYSV_ABI scePadReadBlasterForTracker();
int PS4_SYSV_ABI scePadReadExt();
int PS4_SYSV_ABI scePadReadForTracker();
int PS4_SYSV_ABI scePadReadHistory();
int PS4_SYSV_ABI scePadReadState(s32 handle, OrbisPadData* pData);
int PS4_SYSV_ABI scePadReadStateExt();
int PS4_SYSV_ABI scePadResetLightBar(s32 handle);
int PS4_SYSV_ABI scePadResetLightBarAll();
int PS4_SYSV_ABI scePadResetLightBarAllByPortType();
int PS4_SYSV_ABI scePadResetOrientation(s32 handle);
int PS4_SYSV_ABI scePadResetOrientationForTracker();
int PS4_SYSV_ABI scePadSetAngularVelocityDeadbandState(s32 handle, bool bEnable);
int PS4_SYSV_ABI scePadSetAutoPowerOffCount();
int PS4_SYSV_ABI scePadSetButtonRemappingInfo();
int PS4_SYSV_ABI scePadSetConnection();
int PS4_SYSV_ABI scePadSetExtensionReport();
int PS4_SYSV_ABI scePadSetFeatureReport();
int PS4_SYSV_ABI scePadSetForceIntercepted();
int PS4_SYSV_ABI scePadSetLightBar(s32 handle, const OrbisPadLightBarParam* pParam);
int PS4_SYSV_ABI scePadSetLightBarBaseBrightness();
int PS4_SYSV_ABI scePadSetLightBarBlinking();
int PS4_SYSV_ABI scePadSetLightBarForTracker();
int PS4_SYSV_ABI scePadSetLoginUserNumber();
int PS4_SYSV_ABI scePadSetMotionSensorState(s32 handle, bool bEnable);
int PS4_SYSV_ABI scePadSetProcessFocus();
int PS4_SYSV_ABI scePadSetProcessPrivilege();
int PS4_SYSV_ABI scePadSetProcessPrivilegeOfButtonRemapping();
int PS4_SYSV_ABI scePadSetShareButtonMaskForRemotePlay();
int PS4_SYSV_ABI scePadSetTiltCorrectionState(s32 handle, bool bEnable);
int PS4_SYSV_ABI scePadSetUserColor();
int PS4_SYSV_ABI scePadSetVibration(s32 handle, const OrbisPadVibrationParam* pParam);
int PS4_SYSV_ABI scePadSetVibrationForce();
int PS4_SYSV_ABI scePadSetVrTrackingMode();
int PS4_SYSV_ABI scePadShareOutputData();
int PS4_SYSV_ABI scePadStartRecording();
int PS4_SYSV_ABI scePadStopRecording();
int PS4_SYSV_ABI scePadSwitchConnection();
int PS4_SYSV_ABI scePadVertualDeviceAddDevice();
int PS4_SYSV_ABI scePadVirtualDeviceAddDevice();
int PS4_SYSV_ABI scePadVirtualDeviceDeleteDevice();
int PS4_SYSV_ABI scePadVirtualDeviceDisableButtonRemapping();
int PS4_SYSV_ABI scePadVirtualDeviceGetRemoteSetting();
int PS4_SYSV_ABI scePadVirtualDeviceInsertData();
int PS4_SYSV_ABI Func_28B998C7D8A3DA1D();
int PS4_SYSV_ABI Func_298D21481F94C9FA();
int PS4_SYSV_ABI Func_51E514BCD3A05CA5();
int PS4_SYSV_ABI Func_89C9237E393DA243();
int PS4_SYSV_ABI Func_EF103E845B6F0420();
void RegisterlibScePad(Core::Loader::SymbolsResolver* sym);
} // namespace Libraries::Pad
| 10,681
|
C++
|
.h
| 320
| 28.38125
| 100
| 0.729604
|
shadps4-emu/shadPS4
| 9,253
| 501
| 185
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
15,807
|
random_error.h
|
shadps4-emu_shadPS4/src/core/libraries/random/random_error.h
|
// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
#pragma once
constexpr int SCE_RANDOM_ERROR_INVALID = 0x817C0016;
constexpr int SCE_RANDOM_ERROR_OUT_OF_RESOURCES = 0x817C001C;
constexpr int SCE_RANDOM_ERROR_FATAL = 0x817C00FF;
| 292
|
C++
|
.h
| 6
| 47.5
| 66
| 0.817544
|
shadps4-emu/shadPS4
| 9,253
| 501
| 185
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
15,808
|
random.h
|
shadps4-emu_shadPS4/src/core/libraries/random/random.h
|
// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
#pragma once
#include "common/types.h"
namespace Core::Loader {
class SymbolsResolver;
}
namespace Libraries::Random {
constexpr int32_t SCE_RANDOM_MAX_SIZE = 64;
s32 PS4_SYSV_ABI sceRandomGetRandomNumber(u8* buf, std::size_t size);
void RegisterlibSceRandom(Core::Loader::SymbolsResolver* sym);
} // namespace Libraries::Random
| 446
|
C++
|
.h
| 12
| 35.75
| 69
| 0.801865
|
shadps4-emu/shadPS4
| 9,253
| 501
| 185
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
15,809
|
shareplay.h
|
shadps4-emu_shadPS4/src/core/libraries/share_play/shareplay.h
|
// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
#pragma once
#include <core/libraries/np_manager/np_manager.h>
#include "common/types.h"
namespace Core::Loader {
class SymbolsResolver;
}
namespace Libraries::SharePlay {
constexpr int ORBIS_SHARE_PLAY_CONNECTION_STATUS_DORMANT = 0x00;
constexpr int ORBIS_SHARE_PLAY_CONNECTION_STATUS_READY = 0x01;
constexpr int ORBIS_SHARE_PLAY_CONNECTION_STATUS_CONNECTED = 0x02;
struct OrbisSharePlayConnectionInfo {
int status;
int mode;
Libraries::NpManager::OrbisNpOnlineId hostOnlineId;
Libraries::NpManager::OrbisNpOnlineId visitorOnlineId;
s32 hostUserId;
s32 visitorUserId;
};
int PS4_SYSV_ABI sceSharePlayCrashDaemon();
int PS4_SYSV_ABI sceSharePlayGetCurrentConnectionInfo(OrbisSharePlayConnectionInfo* pInfo);
int PS4_SYSV_ABI sceSharePlayGetCurrentConnectionInfoA();
int PS4_SYSV_ABI sceSharePlayGetCurrentInfo();
int PS4_SYSV_ABI sceSharePlayGetEvent();
int PS4_SYSV_ABI sceSharePlayInitialize();
int PS4_SYSV_ABI sceSharePlayNotifyDialogOpen();
int PS4_SYSV_ABI sceSharePlayNotifyForceCloseForCdlg();
int PS4_SYSV_ABI sceSharePlayNotifyOpenQuickMenu();
int PS4_SYSV_ABI sceSharePlayResumeScreenForCdlg();
int PS4_SYSV_ABI sceSharePlayServerLock();
int PS4_SYSV_ABI sceSharePlayServerUnLock();
int PS4_SYSV_ABI sceSharePlaySetMode();
int PS4_SYSV_ABI sceSharePlaySetProhibition();
int PS4_SYSV_ABI sceSharePlaySetProhibitionModeWithAppId();
int PS4_SYSV_ABI sceSharePlayStartStandby();
int PS4_SYSV_ABI sceSharePlayStartStreaming();
int PS4_SYSV_ABI sceSharePlayStopStandby();
int PS4_SYSV_ABI sceSharePlayStopStreaming();
int PS4_SYSV_ABI sceSharePlayTerminate();
int PS4_SYSV_ABI Func_2E93C0EA6A6B67C4();
int PS4_SYSV_ABI Func_C1C236728D88E177();
int PS4_SYSV_ABI Func_E9E80C474781F115();
int PS4_SYSV_ABI Func_F3DD6199DA15ED44();
void RegisterlibSceSharePlay(Core::Loader::SymbolsResolver* sym);
} // namespace Libraries::SharePlay
| 1,978
|
C++
|
.h
| 46
| 41.326087
| 91
| 0.830649
|
shadps4-emu/shadPS4
| 9,253
| 501
| 185
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
15,810
|
gamelivestreaming.h
|
shadps4-emu_shadPS4/src/core/libraries/game_live_streaming/gamelivestreaming.h
|
// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
#pragma once
#include "common/types.h"
namespace Core::Loader {
class SymbolsResolver;
}
namespace Libraries::GameLiveStreaming {
struct OrbisGameLiveStreamingStatus {
bool isOnAir;
u8 align[3];
u32 spectatorCounts;
s32 userId;
u8 reserved[60];
};
struct OrbisGameLiveStreamingStatus2 {
s32 userId;
bool isOnAir;
u8 align[3];
u32 spectatorCounts;
u32 textMessageCounts;
u32 commandMessageCounts;
u32 broadcastVideoResolution;
u8 reserved[48];
};
int PS4_SYSV_ABI sceGameLiveStreamingStartDebugBroadcast();
int PS4_SYSV_ABI sceGameLiveStreamingStopDebugBroadcast();
int PS4_SYSV_ABI sceGameLiveStreamingApplySocialFeedbackMessageFilter();
int PS4_SYSV_ABI sceGameLiveStreamingCheckCallback();
int PS4_SYSV_ABI sceGameLiveStreamingClearPresetSocialFeedbackCommands();
int PS4_SYSV_ABI sceGameLiveStreamingClearSocialFeedbackMessages();
int PS4_SYSV_ABI sceGameLiveStreamingClearSpoilerTag();
int PS4_SYSV_ABI sceGameLiveStreamingEnableLiveStreaming();
int PS4_SYSV_ABI sceGameLiveStreamingEnableSocialFeedback();
int PS4_SYSV_ABI sceGameLiveStreamingGetCurrentBroadcastScreenLayout();
int PS4_SYSV_ABI sceGameLiveStreamingGetCurrentStatus(OrbisGameLiveStreamingStatus* status);
int PS4_SYSV_ABI sceGameLiveStreamingGetCurrentStatus2();
int PS4_SYSV_ABI sceGameLiveStreamingGetProgramInfo();
int PS4_SYSV_ABI sceGameLiveStreamingGetSocialFeedbackMessages();
int PS4_SYSV_ABI sceGameLiveStreamingGetSocialFeedbackMessagesCount();
int PS4_SYSV_ABI sceGameLiveStreamingInitialize();
int PS4_SYSV_ABI sceGameLiveStreamingLaunchLiveViewer();
int PS4_SYSV_ABI sceGameLiveStreamingLaunchLiveViewerA();
int PS4_SYSV_ABI sceGameLiveStreamingPermitLiveStreaming();
int PS4_SYSV_ABI sceGameLiveStreamingPermitServerSideRecording();
int PS4_SYSV_ABI sceGameLiveStreamingPostSocialMessage();
int PS4_SYSV_ABI sceGameLiveStreamingRegisterCallback();
int PS4_SYSV_ABI sceGameLiveStreamingScreenCloseSeparateMode();
int PS4_SYSV_ABI sceGameLiveStreamingScreenConfigureSeparateMode();
int PS4_SYSV_ABI sceGameLiveStreamingScreenInitialize();
int PS4_SYSV_ABI sceGameLiveStreamingScreenInitializeSeparateModeParameter();
int PS4_SYSV_ABI sceGameLiveStreamingScreenOpenSeparateMode();
int PS4_SYSV_ABI sceGameLiveStreamingScreenSetMode();
int PS4_SYSV_ABI sceGameLiveStreamingScreenTerminate();
int PS4_SYSV_ABI sceGameLiveStreamingSetCameraFrameSetting();
int PS4_SYSV_ABI sceGameLiveStreamingSetDefaultServiceProviderPermission();
int PS4_SYSV_ABI sceGameLiveStreamingSetGuardAreas();
int PS4_SYSV_ABI sceGameLiveStreamingSetInvitationSessionId();
int PS4_SYSV_ABI sceGameLiveStreamingSetLinkCommentPreset();
int PS4_SYSV_ABI sceGameLiveStreamingSetMaxBitrate();
int PS4_SYSV_ABI sceGameLiveStreamingSetMetadata();
int PS4_SYSV_ABI sceGameLiveStreamingSetPresetSocialFeedbackCommands();
int PS4_SYSV_ABI sceGameLiveStreamingSetPresetSocialFeedbackCommandsDescription();
int PS4_SYSV_ABI sceGameLiveStreamingSetServiceProviderPermission();
int PS4_SYSV_ABI sceGameLiveStreamingSetSpoilerTag();
int PS4_SYSV_ABI sceGameLiveStreamingSetStandbyScreenResource();
int PS4_SYSV_ABI sceGameLiveStreamingStartGenerateStandbyScreenResource();
int PS4_SYSV_ABI sceGameLiveStreamingStartSocialFeedbackMessageFiltering();
int PS4_SYSV_ABI sceGameLiveStreamingStopGenerateStandbyScreenResource();
int PS4_SYSV_ABI sceGameLiveStreamingStopSocialFeedbackMessageFiltering();
int PS4_SYSV_ABI sceGameLiveStreamingTerminate();
int PS4_SYSV_ABI sceGameLiveStreamingUnregisterCallback();
void RegisterlibSceGameLiveStreaming(Core::Loader::SymbolsResolver* sym);
} // namespace Libraries::GameLiveStreaming
| 3,735
|
C++
|
.h
| 74
| 48.689189
| 92
| 0.866758
|
shadps4-emu/shadPS4
| 9,253
| 501
| 185
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
15,811
|
np_trophy.h
|
shadps4-emu_shadPS4/src/core/libraries/np_trophy/np_trophy.h
|
// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
#pragma once
#include "common/types.h"
#include "core/libraries/rtc/rtc.h"
namespace Core::Loader {
class SymbolsResolver;
}
namespace Libraries::NpTrophy {
extern std::string game_serial;
constexpr int ORBIS_NP_TROPHY_FLAG_SETSIZE = 128;
constexpr int ORBIS_NP_TROPHY_FLAG_BITS_SHIFT = 5;
constexpr int ORBIS_NP_TROPHY_GAME_TITLE_MAX_SIZE = 128;
constexpr int ORBIS_NP_TROPHY_GAME_DESCR_MAX_SIZE = 1024;
constexpr int ORBIS_NP_TROPHY_GROUP_TITLE_MAX_SIZE = 128;
constexpr int ORBIS_NP_TROPHY_GROUP_DESCR_MAX_SIZE = 1024;
constexpr int ORBIS_NP_TROPHY_NAME_MAX_SIZE = 128;
constexpr int ORBIS_NP_TROPHY_DESCR_MAX_SIZE = 1024;
constexpr int ORBIS_NP_TROPHY_NUM_MAX = 128;
constexpr int ORBIS_NP_TROPHY_INVALID_HANDLE = -1;
constexpr int ORBIS_NP_TROPHY_INVALID_CONTEXT = -1;
constexpr int ORBIS_NP_TROPHY_INVALID_TROPHY_ID = -1;
typedef int32_t OrbisNpTrophyHandle;
typedef int32_t OrbisNpTrophyContext;
typedef int32_t OrbisNpTrophyId;
typedef uint32_t OrbisNpTrophyFlagMask;
struct OrbisNpTrophyFlagArray {
OrbisNpTrophyFlagMask
flag_bits[ORBIS_NP_TROPHY_FLAG_SETSIZE >> ORBIS_NP_TROPHY_FLAG_BITS_SHIFT];
};
void ORBIS_NP_TROPHY_FLAG_ZERO(OrbisNpTrophyFlagArray* p);
void ORBIS_NP_TROPHY_FLAG_SET(int32_t trophyId, OrbisNpTrophyFlagArray* p);
void ORBIS_NP_TROPHY_FLAG_SET_ALL(OrbisNpTrophyFlagArray* p);
void ORBIS_NP_TROPHY_FLAG_CLR(int32_t trophyId, OrbisNpTrophyFlagArray* p);
bool ORBIS_NP_TROPHY_FLAG_ISSET(int32_t trophyId, OrbisNpTrophyFlagArray* p);
struct OrbisNpTrophyData {
size_t size;
OrbisNpTrophyId trophy_id;
bool unlocked;
uint8_t reserved[3];
Rtc::OrbisRtcTick timestamp;
};
typedef int32_t OrbisNpTrophyGrade;
constexpr int ORBIS_NP_TROPHY_GRADE_UNKNOWN = 0;
constexpr int ORBIS_NP_TROPHY_GRADE_PLATINUM = 1;
constexpr int ORBIS_NP_TROPHY_GRADE_GOLD = 2;
constexpr int ORBIS_NP_TROPHY_GRADE_SILVER = 3;
constexpr int ORBIS_NP_TROPHY_GRADE_BRONZE = 4;
typedef int32_t OrbisNpTrophyGroupId;
constexpr int ORBIS_NP_TROPHY_BASE_GAME_GROUP_ID = -1;
constexpr int ORBIS_NP_TROPHY_INVALID_GROUP_ID = -2;
struct OrbisNpTrophyDetails {
size_t size;
OrbisNpTrophyId trophy_id;
OrbisNpTrophyGrade trophy_grade;
OrbisNpTrophyGroupId group_id;
bool hidden;
uint8_t reserved[3];
char name[ORBIS_NP_TROPHY_NAME_MAX_SIZE];
char description[ORBIS_NP_TROPHY_DESCR_MAX_SIZE];
};
struct OrbisNpTrophyGameData {
size_t size;
uint32_t unlocked_trophies;
uint32_t unlocked_platinum;
uint32_t unlocked_gold;
uint32_t unlocked_silver;
uint32_t unlocked_bronze;
uint32_t progress_percentage;
};
struct OrbisNpTrophyGameDetails {
size_t size;
uint32_t num_groups;
uint32_t num_trophies;
uint32_t num_platinum;
uint32_t num_gold;
uint32_t num_silver;
uint32_t num_bronze;
char title[ORBIS_NP_TROPHY_GAME_TITLE_MAX_SIZE];
char description[ORBIS_NP_TROPHY_GAME_DESCR_MAX_SIZE];
};
struct OrbisNpTrophyGroupData {
size_t size;
OrbisNpTrophyGroupId group_id;
uint32_t unlocked_trophies;
uint32_t unlocked_platinum;
uint32_t unlocked_gold;
uint32_t unlocked_silver;
uint32_t unlocked_bronze;
uint32_t progress_percentage;
uint8_t reserved[4];
};
struct OrbisNpTrophyGroupDetails {
size_t size;
OrbisNpTrophyGroupId group_id;
uint32_t num_trophies;
uint32_t num_platinum;
uint32_t num_gold;
uint32_t num_silver;
uint32_t num_bronze;
char title[ORBIS_NP_TROPHY_GROUP_TITLE_MAX_SIZE];
char description[ORBIS_NP_TROPHY_GROUP_DESCR_MAX_SIZE];
};
int PS4_SYSV_ABI sceNpTrophyAbortHandle(OrbisNpTrophyHandle handle);
int PS4_SYSV_ABI sceNpTrophyCaptureScreenshot();
int PS4_SYSV_ABI sceNpTrophyConfigGetTrophyDetails();
int PS4_SYSV_ABI sceNpTrophyConfigGetTrophyFlagArray();
int PS4_SYSV_ABI sceNpTrophyConfigGetTrophyGroupArray();
int PS4_SYSV_ABI sceNpTrophyConfigGetTrophyGroupDetails();
int PS4_SYSV_ABI sceNpTrophyConfigGetTrophySetInfo();
int PS4_SYSV_ABI sceNpTrophyConfigGetTrophySetInfoInGroup();
int PS4_SYSV_ABI sceNpTrophyConfigGetTrophySetVersion();
int PS4_SYSV_ABI sceNpTrophyConfigGetTrophyTitleDetails();
int PS4_SYSV_ABI sceNpTrophyConfigHasGroupFeature();
s32 PS4_SYSV_ABI sceNpTrophyCreateContext(OrbisNpTrophyContext* context, int32_t user_id,
uint32_t service_label, uint64_t options);
s32 PS4_SYSV_ABI sceNpTrophyCreateHandle(OrbisNpTrophyHandle* handle);
int PS4_SYSV_ABI sceNpTrophyDestroyContext(OrbisNpTrophyContext context);
s32 PS4_SYSV_ABI sceNpTrophyDestroyHandle(OrbisNpTrophyHandle handle);
int PS4_SYSV_ABI sceNpTrophyGetGameIcon(OrbisNpTrophyContext context, OrbisNpTrophyHandle handle,
void* buffer, size_t* size);
int PS4_SYSV_ABI sceNpTrophyGetGameInfo(OrbisNpTrophyContext context, OrbisNpTrophyHandle handle,
OrbisNpTrophyGameDetails* details,
OrbisNpTrophyGameData* data);
int PS4_SYSV_ABI sceNpTrophyGetGroupIcon(OrbisNpTrophyContext context, OrbisNpTrophyHandle handle,
OrbisNpTrophyGroupId groupId, void* buffer, size_t* size);
int PS4_SYSV_ABI sceNpTrophyGetGroupInfo(OrbisNpTrophyContext context, OrbisNpTrophyHandle handle,
OrbisNpTrophyGroupId groupId,
OrbisNpTrophyGroupDetails* details,
OrbisNpTrophyGroupData* data);
int PS4_SYSV_ABI sceNpTrophyGetTrophyIcon(OrbisNpTrophyContext context, OrbisNpTrophyHandle handle,
OrbisNpTrophyId trophyId, void* buffer, size_t* size);
int PS4_SYSV_ABI sceNpTrophyGetTrophyInfo(OrbisNpTrophyContext context, OrbisNpTrophyHandle handle,
OrbisNpTrophyId trophyId, OrbisNpTrophyDetails* details,
OrbisNpTrophyData* data);
s32 PS4_SYSV_ABI sceNpTrophyGetTrophyUnlockState(OrbisNpTrophyContext context,
OrbisNpTrophyHandle handle,
OrbisNpTrophyFlagArray* flags, u32* count);
int PS4_SYSV_ABI sceNpTrophyGroupArrayGetNum();
int PS4_SYSV_ABI sceNpTrophyIntAbortHandle();
int PS4_SYSV_ABI sceNpTrophyIntCheckNetSyncTitles();
int PS4_SYSV_ABI sceNpTrophyIntCreateHandle();
int PS4_SYSV_ABI sceNpTrophyIntDestroyHandle();
int PS4_SYSV_ABI sceNpTrophyIntGetLocalTrophySummary();
int PS4_SYSV_ABI sceNpTrophyIntGetProgress();
int PS4_SYSV_ABI sceNpTrophyIntGetRunningTitle();
int PS4_SYSV_ABI sceNpTrophyIntGetRunningTitles();
int PS4_SYSV_ABI sceNpTrophyIntGetTrpIconByUri();
int PS4_SYSV_ABI sceNpTrophyIntNetSyncTitle();
int PS4_SYSV_ABI sceNpTrophyIntNetSyncTitles();
int PS4_SYSV_ABI sceNpTrophyNumInfoGetTotal();
int PS4_SYSV_ABI sceNpTrophyRegisterContext(OrbisNpTrophyContext context,
OrbisNpTrophyHandle handle, uint64_t options);
int PS4_SYSV_ABI sceNpTrophySetInfoGetTrophyFlagArray();
int PS4_SYSV_ABI sceNpTrophySetInfoGetTrophyNum();
int PS4_SYSV_ABI sceNpTrophyShowTrophyList(OrbisNpTrophyContext context,
OrbisNpTrophyHandle handle);
int PS4_SYSV_ABI sceNpTrophySystemAbortHandle();
int PS4_SYSV_ABI sceNpTrophySystemBuildGroupIconUri();
int PS4_SYSV_ABI sceNpTrophySystemBuildNetTrophyIconUri();
int PS4_SYSV_ABI sceNpTrophySystemBuildTitleIconUri();
int PS4_SYSV_ABI sceNpTrophySystemBuildTrophyIconUri();
int PS4_SYSV_ABI sceNpTrophySystemCheckNetSyncTitles();
int PS4_SYSV_ABI sceNpTrophySystemCheckRecoveryRequired();
int PS4_SYSV_ABI sceNpTrophySystemCloseStorage();
int PS4_SYSV_ABI sceNpTrophySystemCreateContext();
int PS4_SYSV_ABI sceNpTrophySystemCreateHandle();
int PS4_SYSV_ABI sceNpTrophySystemDbgCtl();
int PS4_SYSV_ABI sceNpTrophySystemDebugLockTrophy();
int PS4_SYSV_ABI sceNpTrophySystemDebugUnlockTrophy();
int PS4_SYSV_ABI sceNpTrophySystemDestroyContext();
int PS4_SYSV_ABI sceNpTrophySystemDestroyHandle();
int PS4_SYSV_ABI sceNpTrophySystemDestroyTrophyConfig();
int PS4_SYSV_ABI sceNpTrophySystemGetDbgParam();
int PS4_SYSV_ABI sceNpTrophySystemGetDbgParamInt();
int PS4_SYSV_ABI sceNpTrophySystemGetGroupIcon();
int PS4_SYSV_ABI sceNpTrophySystemGetLocalTrophySummary();
int PS4_SYSV_ABI sceNpTrophySystemGetNextTitleFileEntryStatus();
int PS4_SYSV_ABI sceNpTrophySystemGetProgress();
int PS4_SYSV_ABI sceNpTrophySystemGetTitleFileStatus();
int PS4_SYSV_ABI sceNpTrophySystemGetTitleIcon();
int PS4_SYSV_ABI sceNpTrophySystemGetTitleSyncStatus();
int PS4_SYSV_ABI sceNpTrophySystemGetTrophyConfig();
int PS4_SYSV_ABI sceNpTrophySystemGetTrophyData();
int PS4_SYSV_ABI sceNpTrophySystemGetTrophyGroupData();
int PS4_SYSV_ABI sceNpTrophySystemGetTrophyIcon();
int PS4_SYSV_ABI sceNpTrophySystemGetTrophyTitleData();
int PS4_SYSV_ABI sceNpTrophySystemGetTrophyTitleIds();
int PS4_SYSV_ABI sceNpTrophySystemGetUserFileInfo();
int PS4_SYSV_ABI sceNpTrophySystemGetUserFileStatus();
int PS4_SYSV_ABI sceNpTrophySystemIsServerAvailable();
int PS4_SYSV_ABI sceNpTrophySystemNetSyncTitle();
int PS4_SYSV_ABI sceNpTrophySystemNetSyncTitles();
int PS4_SYSV_ABI sceNpTrophySystemOpenStorage();
int PS4_SYSV_ABI sceNpTrophySystemPerformRecovery();
int PS4_SYSV_ABI sceNpTrophySystemRemoveAll();
int PS4_SYSV_ABI sceNpTrophySystemRemoveTitleData();
int PS4_SYSV_ABI sceNpTrophySystemRemoveUserData();
int PS4_SYSV_ABI sceNpTrophySystemSetDbgParam();
int PS4_SYSV_ABI sceNpTrophySystemSetDbgParamInt();
int PS4_SYSV_ABI sceNpTrophyUnlockTrophy(OrbisNpTrophyContext context, OrbisNpTrophyHandle handle,
OrbisNpTrophyId trophyId, OrbisNpTrophyId* platinumId);
int PS4_SYSV_ABI Func_149656DA81D41C59();
int PS4_SYSV_ABI Func_9F80071876FFA5F6();
int PS4_SYSV_ABI Func_F8EF6F5350A91990();
int PS4_SYSV_ABI Func_FA7A2DD770447552();
void RegisterlibSceNpTrophy(Core::Loader::SymbolsResolver* sym);
} // namespace Libraries::NpTrophy
| 10,119
|
C++
|
.h
| 208
| 43.331731
| 99
| 0.77252
|
shadps4-emu/shadPS4
| 9,253
| 501
| 185
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
15,812
|
trophy_ui.h
|
shadps4-emu_shadPS4/src/core/libraries/np_trophy/trophy_ui.h
|
// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
#pragma once
#include <string>
#include <variant>
#include <queue>
#include "common/fixed_value.h"
#include "common/types.h"
#include "core/libraries/np_trophy/np_trophy.h"
#include "imgui/imgui_layer.h"
#include "imgui/imgui_texture.h"
namespace Libraries::NpTrophy {
class TrophyUI final : public ImGui::Layer {
public:
TrophyUI(const std::filesystem::path& trophyIconPath, const std::string& trophyName);
~TrophyUI() override;
void Finish();
void Draw() override;
private:
std::string trophy_name;
float trophy_timer = 5.0f;
ImGui::RefCountedTexture trophy_icon;
};
struct TrophyInfo {
std::filesystem::path trophy_icon_path;
std::string trophy_name;
};
void AddTrophyToQueue(const std::filesystem::path& trophyIconPath, const std::string& trophyName);
}; // namespace Libraries::NpTrophy
| 950
|
C++
|
.h
| 29
| 30.172414
| 98
| 0.758507
|
shadps4-emu/shadPS4
| 9,253
| 501
| 185
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
15,813
|
video_out.h
|
shadps4-emu_shadPS4/src/core/libraries/videoout/video_out.h
|
// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
#pragma once
#include "core/libraries/kernel/event_queues.h"
#include "core/libraries/videoout/buffer.h"
namespace Core::Loader {
class SymbolsResolver;
}
namespace Libraries::VideoOut {
using SceUserServiceUserId = s32; // TODO move it to proper place
// SceVideoOutBusType
constexpr int SCE_VIDEO_OUT_BUS_TYPE_MAIN = 0; // Main output
constexpr int SCE_VIDEO_OUT_BUS_TYPE_AUX_SOCIAL_SCREEN = 5; // Aux output for social
constexpr int SCE_VIDEO_OUT_BUS_TYPE_AUX_GAME_LIVE_STREAMING = 6; // Aux output for screaming
// SceVideoOutRefreshRate
constexpr int SCE_VIDEO_OUT_REFRESH_RATE_UNKNOWN = 0;
constexpr int SCE_VIDEO_OUT_REFRESH_RATE_23_98HZ = 1;
constexpr int SCE_VIDEO_OUT_REFRESH_RATE_50HZ = 2;
constexpr int SCE_VIDEO_OUT_REFRESH_RATE_59_94HZ = 3;
constexpr int SCE_VIDEO_OUT_REFRESH_RATE_119_88HZ = 13;
constexpr int SCE_VIDEO_OUT_REFRESH_RATE_89_91HZ = 35;
constexpr s64 SCE_VIDEO_OUT_REFRESH_RATE_ANY = 0xFFFFFFFFFFFFFFFFUL;
constexpr int SCE_VIDEO_OUT_PIXEL_FORMAT_A8R8G8B8_SRGB = 0x80000000;
constexpr int SCE_VIDEO_OUT_PIXEL_FORMAT_A8B8G8R8_SRGB = 0x80002200;
constexpr int SCE_VIDEO_OUT_PIXEL_FORMAT_A2R10G10B10 = 0x88060000;
constexpr int SCE_VIDEO_OUT_PIXEL_FORMAT_A2R10G10B10_SRGB = 0x88000000;
constexpr int SCE_VIDEO_OUT_PIXEL_FORMAT_A2R10G10B10_BT2020_PQ = 0x88740000;
constexpr int SCE_VIDEO_OUT_PIXEL_FORMAT_A16R16G16B16_FLOAT = 0xC1060000;
constexpr int SCE_VIDEO_OUT_PIXEL_FORMAT_YCBCR420_BT709 = 0x08322200;
constexpr int SCE_VIDEO_OUT_BUFFER_ATTRIBUTE_OPTION_NONE = 0;
constexpr int SCE_VIDEO_OUT_BUFFER_ATTRIBUTE_OPTION_VR = 7;
constexpr int SCE_VIDEO_OUT_BUFFER_ATTRIBUTE_OPTION_STRICT_COLORIMETRY = 8;
enum SceVideoOutEventId : s16 {
SCE_VIDEO_OUT_EVENT_FLIP = 0,
SCE_VIDEO_OUT_EVENT_VBLANK = 1,
SCE_VIDEO_OUT_EVENT_PRE_VBLANK_START = 2
};
enum AspectRatioMode : s32 {
SCE_VIDEO_OUT_ASPECT_RATIO_16_9 = 0,
};
struct FlipStatus {
u64 count = 0;
u64 processTime = 0;
u64 tsc = 0;
s64 flipArg = -1;
u64 submitTsc = 0;
u64 reserved0 = 0;
s32 gcQueueNum = 0;
s32 flipPendingNum = 0;
s32 currentBuffer = -1;
u32 reserved1 = 0;
};
struct SceVideoOutResolutionStatus {
s32 fullWidth = 1280;
s32 fullHeight = 720;
s32 paneWidth = 1280;
s32 paneHeight = 720;
u64 refreshRate = SCE_VIDEO_OUT_REFRESH_RATE_59_94HZ;
float screenSizeInInch = 50;
u16 flags = 0;
u16 reserved0 = 0;
u32 reserved1[3] = {0};
};
struct SceVideoOutVblankStatus {
u64 count = 0;
u64 processTime = 0;
u64 tsc = 0;
u64 reserved[1] = {0};
u8 flags = 0;
u8 pad1[7] = {};
};
struct SceVideoOutDeviceCapabilityInfo {
u64 capability;
};
void PS4_SYSV_ABI sceVideoOutSetBufferAttribute(BufferAttribute* attribute, PixelFormat pixelFormat,
u32 tilingMode, u32 aspectRatio, u32 width,
u32 height, u32 pitchInPixel);
s32 PS4_SYSV_ABI sceVideoOutAddFlipEvent(Kernel::SceKernelEqueue eq, s32 handle, void* udata);
s32 PS4_SYSV_ABI sceVideoOutAddVblankEvent(Kernel::SceKernelEqueue eq, s32 handle, void* udata);
s32 PS4_SYSV_ABI sceVideoOutRegisterBuffers(s32 handle, s32 startIndex, void* const* addresses,
s32 bufferNum, const BufferAttribute* attribute);
s32 PS4_SYSV_ABI sceVideoOutSetFlipRate(s32 handle, s32 rate);
s32 PS4_SYSV_ABI sceVideoOutIsFlipPending(s32 handle);
s32 PS4_SYSV_ABI sceVideoOutWaitVblank(s32 handle);
s32 PS4_SYSV_ABI sceVideoOutSubmitFlip(s32 handle, s32 bufferIndex, s32 flipMode, s64 flipArg);
s32 PS4_SYSV_ABI sceVideoOutGetFlipStatus(s32 handle, FlipStatus* status);
s32 PS4_SYSV_ABI sceVideoOutGetResolutionStatus(s32 handle, SceVideoOutResolutionStatus* status);
s32 PS4_SYSV_ABI sceVideoOutOpen(SceUserServiceUserId userId, s32 busType, s32 index,
const void* param);
s32 PS4_SYSV_ABI sceVideoOutClose(s32 handle);
int PS4_SYSV_ABI sceVideoOutGetEventId(const Kernel::SceKernelEvent* ev);
int PS4_SYSV_ABI sceVideoOutGetEventData(const Kernel::SceKernelEvent* ev, int64_t* data);
// Internal system functions
void sceVideoOutGetBufferLabelAddress(s32 handle, uintptr_t* label_addr);
s32 sceVideoOutSubmitEopFlip(s32 handle, u32 buf_id, u32 mode, u32 arg, void** unk);
void RegisterLib(Core::Loader::SymbolsResolver* sym);
} // namespace Libraries::VideoOut
| 4,518
|
C++
|
.h
| 97
| 42.360825
| 100
| 0.743753
|
shadps4-emu/shadPS4
| 9,253
| 501
| 185
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
15,814
|
buffer.h
|
shadps4-emu_shadPS4/src/core/libraries/videoout/buffer.h
|
// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
#pragma once
#include <string_view>
#include "common/assert.h"
#include "common/types.h"
namespace Libraries::VideoOut {
constexpr std::size_t MaxDisplayBuffers = 16;
constexpr std::size_t MaxDisplayBufferGroups = 4;
enum class PixelFormat : u32 {
Unknown,
A8R8G8B8Srgb = 0x80000000,
A8B8G8R8Srgb = 0x80002200,
A2R10G10B10 = 0x88060000,
A2R10G10B10Srgb = 0x88000000,
A2R10G10B10Bt2020Pq = 0x88740000,
A16R16G16B16Float = 0xC1060000,
};
enum class TilingMode : s32 {
Tile = 0,
Linear = 1,
};
constexpr std::string_view GetPixelFormatString(PixelFormat format) {
switch (format) {
case PixelFormat::A8R8G8B8Srgb:
return "A8R8G8B8Srgb";
case PixelFormat::A8B8G8R8Srgb:
return "A8B8G8R8Srgb";
case PixelFormat::A2R10G10B10:
return "A2R10G10B10";
case PixelFormat::A2R10G10B10Srgb:
return "A2R10G10B10Srgb";
case PixelFormat::A2R10G10B10Bt2020Pq:
return "A2R10G10B10Bt2020Pq";
case PixelFormat::A16R16G16B16Float:
return "A16R16G16B16Float";
default:
UNREACHABLE_MSG("Unknown pixel format {}", static_cast<u32>(format));
return "";
}
}
struct BufferAttribute {
PixelFormat pixel_format;
TilingMode tiling_mode;
s32 aspect_ratio;
u32 width;
u32 height;
u32 pitch_in_pixel;
u32 option;
u32 reserved0;
u64 reserved1;
};
struct BufferAttributeGroup {
bool is_occupied;
BufferAttribute attrib;
};
struct VideoOutBuffer {
s32 group_index{-1};
uintptr_t address_left;
uintptr_t address_right;
};
} // namespace Libraries::VideoOut
| 1,735
|
C++
|
.h
| 62
| 23.693548
| 77
| 0.72366
|
shadps4-emu/shadPS4
| 9,253
| 501
| 185
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
15,815
|
driver.h
|
shadps4-emu_shadPS4/src/core/libraries/videoout/driver.h
|
// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
#pragma once
#include "common/debug.h"
#include "common/polyfill_thread.h"
#include "core/libraries/videoout/video_out.h"
#include <condition_variable>
#include <mutex>
#include <queue>
namespace Vulkan {
struct Frame;
}
namespace Libraries::VideoOut {
struct VideoOutPort {
bool is_open = false;
SceVideoOutResolutionStatus resolution;
std::array<VideoOutBuffer, MaxDisplayBuffers> buffer_slots;
std::array<u64, MaxDisplayBuffers> buffer_labels; // should be contiguous in memory
static_assert(sizeof(buffer_labels[0]) == 8u);
std::array<BufferAttributeGroup, MaxDisplayBufferGroups> groups;
FlipStatus flip_status;
SceVideoOutVblankStatus vblank_status;
std::vector<Kernel::SceKernelEqueue> flip_events;
std::vector<Kernel::SceKernelEqueue> vblank_events;
std::mutex vo_mutex;
std::mutex port_mutex;
std::condition_variable vo_cv;
std::condition_variable vblank_cv;
int flip_rate = 0;
s32 FindFreeGroup() const {
s32 index = 0;
while (index < groups.size() && groups[index].is_occupied) {
index++;
}
return index;
}
bool IsVoLabel(const u64* address) const {
const u64* start = &buffer_labels[0];
const u64* end = &buffer_labels[MaxDisplayBuffers - 1];
return address >= start && address <= end;
}
void WaitVoLabel(auto&& pred) {
std::unique_lock lk{vo_mutex};
vo_cv.wait(lk, pred);
}
void SignalVoLabel() {
std::scoped_lock lk{vo_mutex};
vo_cv.notify_one();
}
[[nodiscard]] int NumRegisteredBuffers() const {
return std::count_if(buffer_slots.cbegin(), buffer_slots.cend(),
[](auto& buffer) { return buffer.group_index != -1; });
}
};
struct ServiceThreadParams {
u32 unknown;
bool set_priority;
u32 priority;
bool set_affinity;
u64 affinity;
};
class VideoOutDriver {
public:
explicit VideoOutDriver(u32 width, u32 height);
~VideoOutDriver();
int Open(const ServiceThreadParams* params);
void Close(s32 handle);
VideoOutPort* GetPort(s32 handle);
int RegisterBuffers(VideoOutPort* port, s32 startIndex, void* const* addresses, s32 bufferNum,
const BufferAttribute* attribute);
int UnregisterBuffers(VideoOutPort* port, s32 attributeIndex);
bool SubmitFlip(VideoOutPort* port, s32 index, s64 flip_arg, bool is_eop = false);
private:
struct Request {
Vulkan::Frame* frame;
VideoOutPort* port;
s64 flip_arg;
s32 index;
bool eop;
operator bool() const noexcept {
return frame != nullptr;
}
};
void Flip(const Request& req);
void DrawBlankFrame(); // Used when there is no flip request to keep ImGui up to date
void SubmitFlipInternal(VideoOutPort* port, s32 index, s64 flip_arg, bool is_eop = false);
void PresentThread(std::stop_token token);
std::mutex mutex;
VideoOutPort main_port{};
std::jthread present_thread;
std::queue<Request> requests;
};
} // namespace Libraries::VideoOut
| 3,243
|
C++
|
.h
| 93
| 29.075269
| 98
| 0.67872
|
shadps4-emu/shadPS4
| 9,253
| 501
| 185
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
15,816
|
remoteplay.h
|
shadps4-emu_shadPS4/src/core/libraries/remote_play/remoteplay.h
|
// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
#pragma once
#include "common/types.h"
namespace Core::Loader {
class SymbolsResolver;
}
// returning codes in sceRemoteplayGetConnectionStatus pstatus
constexpr int ORBIS_REMOTEPLAY_CONNECTION_STATUS_DISCONNECT = 0;
constexpr int ORBIS_REMOTEPLAY_CONNECTION_STATUS_CONNECT = 1;
namespace Libraries::Remoteplay {
int PS4_SYSV_ABI sceRemoteplayApprove();
int PS4_SYSV_ABI sceRemoteplayChangeEnterKey();
int PS4_SYSV_ABI sceRemoteplayClearAllRegistData();
int PS4_SYSV_ABI sceRemoteplayClearConnectHistory();
int PS4_SYSV_ABI sceRemoteplayConfirmDeviceRegist();
int PS4_SYSV_ABI sceRemoteplayDisconnect();
int PS4_SYSV_ABI sceRemoteplayGeneratePinCode();
int PS4_SYSV_ABI sceRemoteplayGetApMode();
int PS4_SYSV_ABI sceRemoteplayGetConnectHistory();
int PS4_SYSV_ABI sceRemoteplayGetConnectionStatus(s32 userId, int* pStatus);
int PS4_SYSV_ABI sceRemoteplayGetConnectUserId();
int PS4_SYSV_ABI sceRemoteplayGetMbusDeviceInfo();
int PS4_SYSV_ABI sceRemoteplayGetOperationStatus();
int PS4_SYSV_ABI sceRemoteplayGetRemoteplayStatus();
int PS4_SYSV_ABI sceRemoteplayGetRpMode();
int PS4_SYSV_ABI sceRemoteplayImeClose();
int PS4_SYSV_ABI sceRemoteplayImeFilterResult();
int PS4_SYSV_ABI sceRemoteplayImeGetEvent();
int PS4_SYSV_ABI sceRemoteplayImeNotify();
int PS4_SYSV_ABI sceRemoteplayImeNotifyEventResult();
int PS4_SYSV_ABI sceRemoteplayImeOpen();
int PS4_SYSV_ABI sceRemoteplayImeSetCaret();
int PS4_SYSV_ABI sceRemoteplayImeSetText();
int PS4_SYSV_ABI sceRemoteplayInitialize();
int PS4_SYSV_ABI sceRemoteplayIsRemoteOskReady();
int PS4_SYSV_ABI sceRemoteplayIsRemotePlaying();
int PS4_SYSV_ABI sceRemoteplayNotifyMbusDeviceRegistComplete();
int PS4_SYSV_ABI sceRemoteplayNotifyNpPushWakeup();
int PS4_SYSV_ABI sceRemoteplayNotifyPinCodeError();
int PS4_SYSV_ABI sceRemoteplayNotifyUserDelete();
int PS4_SYSV_ABI sceRemoteplayPrintAllRegistData();
int PS4_SYSV_ABI sceRemoteplayProhibit();
int PS4_SYSV_ABI sceRemoteplayProhibitStreaming();
int PS4_SYSV_ABI sceRemoteplayServerLock();
int PS4_SYSV_ABI sceRemoteplayServerUnLock();
int PS4_SYSV_ABI sceRemoteplaySetApMode();
int PS4_SYSV_ABI sceRemoteplaySetLogLevel();
int PS4_SYSV_ABI sceRemoteplaySetProhibition();
int PS4_SYSV_ABI sceRemoteplaySetProhibitionForVsh();
int PS4_SYSV_ABI sceRemoteplaySetRpMode();
int PS4_SYSV_ABI sceRemoteplayTerminate();
int PS4_SYSV_ABI Func_1D5EE365ED5FADB3();
void RegisterlibSceRemoteplay(Core::Loader::SymbolsResolver* sym);
} // namespace Libraries::Remoteplay
| 2,572
|
C++
|
.h
| 55
| 45.654545
| 76
| 0.845878
|
shadps4-emu/shadPS4
| 9,253
| 501
| 185
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
15,817
|
audio3d_impl.h
|
shadps4-emu_shadPS4/src/core/libraries/audio3d/audio3d_impl.h
|
// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
#pragma once
#include "audio3d.h"
namespace Libraries::Audio3d {
class Audio3d {
public:
private:
typedef unsigned int OrbisAudio3dPluginId;
};
} // namespace Libraries::Audio3d
| 299
|
C++
|
.h
| 11
| 25.363636
| 66
| 0.80212
|
shadps4-emu/shadPS4
| 9,253
| 501
| 185
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
15,818
|
audio3d_error.h
|
shadps4-emu_shadPS4/src/core/libraries/audio3d/audio3d_error.h
|
// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
#pragma once
constexpr int ORBIS_AUDIO3D_ERROR_UNKNOWN = 0x80EA0001;
constexpr int ORBIS_AUDIO3D_ERROR_INVALID_PORT = 0x80EA0002;
constexpr int ORBIS_AUDIO3D_ERROR_INVALID_OBJECT = 0x80EA0003;
constexpr int ORBIS_AUDIO3D_ERROR_INVALID_PARAMETER = 0x80EA0004;
constexpr int ORBIS_AUDIO3D_ERROR_OUT_OF_MEMORY = 0x80EA0005;
constexpr int ORBIS_AUDIO3D_ERROR_OUT_OF_RESOURCES = 0x80EA0006;
constexpr int ORBIS_AUDIO3D_ERROR_NOT_READY = 0x80EA0007;
constexpr int ORBIS_AUDIO3D_ERROR_NOT_SUPPORTED = 0x80EA0008;
| 620
|
C++
|
.h
| 11
| 55.181818
| 66
| 0.828666
|
shadps4-emu/shadPS4
| 9,253
| 501
| 185
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
15,819
|
audio3d.h
|
shadps4-emu_shadPS4/src/core/libraries/audio3d/audio3d.h
|
// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
#pragma once
#include "common/types.h"
#include <stddef.h>
namespace Core::Loader {
class SymbolsResolver;
}
namespace Libraries::Audio3d {
class Audio3d;
typedef int OrbisUserServiceUserId;
typedef unsigned int OrbisAudio3dPortId;
typedef unsigned int OrbisAudio3dObjectId;
typedef unsigned int OrbisAudio3dAttributeId;
enum OrbisAudio3dFormat {
ORBIS_AUDIO3D_FORMAT_S16 = 0, // s16
ORBIS_AUDIO3D_FORMAT_FLOAT = 1 // f32
};
enum OrbisAudio3dRate { ORBIS_AUDIO3D_RATE_48000 = 0 };
enum OrbisAudio3dBufferMode {
ORBIS_AUDIO3D_BUFFER_NO_ADVANCE = 0,
ORBIS_AUDIO3D_BUFFER_ADVANCE_NO_PUSH = 1,
ORBIS_AUDIO3D_BUFFER_ADVANCE_AND_PUSH = 2
};
enum OrbisAudio3dBlocking { ORBIS_AUDIO3D_BLOCKING_ASYNC = 0, ORBIS_AUDIO3D_BLOCKING_SYNC = 1 };
enum OrbisAudio3dPassthrough {
ORBIS_AUDIO3D_PASSTHROUGH_NONE = 0,
ORBIS_AUDIO3D_PASSTHROUGH_LEFT = 1,
ORBIS_AUDIO3D_PASSTHROUGH_RIGHT = 2
};
enum OrbisAudio3dOutputRoute {
ORBIS_AUDIO3D_OUTPUT_BOTH = 0,
ORBIS_AUDIO3D_OUTPUT_HMU_ONLY = 1,
ORBIS_AUDIO3D_OUTPUT_TV_ONLY = 2
};
enum OrbisAudio3dAmbisonics {
ORBIS_AUDIO3D_AMBISONICS_NONE = ~0,
ORBIS_AUDIO3D_AMBISONICS_W = 0,
ORBIS_AUDIO3D_AMBISONICS_X = 1,
ORBIS_AUDIO3D_AMBISONICS_Y = 2,
ORBIS_AUDIO3D_AMBISONICS_Z = 3,
ORBIS_AUDIO3D_AMBISONICS_R = 4,
ORBIS_AUDIO3D_AMBISONICS_S = 5,
ORBIS_AUDIO3D_AMBISONICS_T = 6,
ORBIS_AUDIO3D_AMBISONICS_U = 7,
ORBIS_AUDIO3D_AMBISONICS_V = 8,
ORBIS_AUDIO3D_AMBISONICS_K = 9,
ORBIS_AUDIO3D_AMBISONICS_L = 10,
ORBIS_AUDIO3D_AMBISONICS_M = 11,
ORBIS_AUDIO3D_AMBISONICS_N = 12,
ORBIS_AUDIO3D_AMBISONICS_O = 13,
ORBIS_AUDIO3D_AMBISONICS_P = 14,
ORBIS_AUDIO3D_AMBISONICS_Q = 15
};
static const OrbisAudio3dAttributeId s_sceAudio3dAttributePcm = 0x00000001;
static const OrbisAudio3dAttributeId s_sceAudio3dAttributePriority = 0x00000002;
static const OrbisAudio3dAttributeId s_sceAudio3dAttributePosition = 0x00000003;
static const OrbisAudio3dAttributeId s_sceAudio3dAttributeSpread = 0x00000004;
static const OrbisAudio3dAttributeId s_sceAudio3dAttributeGain = 0x00000005;
static const OrbisAudio3dAttributeId s_sceAudio3dAttributePassthrough = 0x00000006;
static const OrbisAudio3dAttributeId s_sceAudio3dAttributeResetState = 0x00000007;
static const OrbisAudio3dAttributeId s_sceAudio3dAttributeApplicationSpecific = 0x00000008;
static const OrbisAudio3dAttributeId s_sceAudio3dAttributeAmbisonics = 0x00000009;
static const OrbisAudio3dAttributeId s_sceAudio3dAttributeRestricted = 0x0000000A;
static const OrbisAudio3dAttributeId s_sceAudio3dAttributeOutputRoute = 0x0000000B;
static const OrbisAudio3dAttributeId s_sceAudio3dAttributeLateReverbLevel = 0x00010001;
static const OrbisAudio3dAttributeId s_sceAudio3dAttributeDownmixSpreadRadius = 0x00010002;
static const OrbisAudio3dAttributeId s_sceAudio3dAttributeDownmixSpreadHeightAware = 0x00010003;
struct OrbisAudio3dSpeakerArray;
using OrbisAudio3dSpeakerArrayHandle = OrbisAudio3dSpeakerArray*; // head
struct OrbisAudio3dOpenParameters {
size_t szSizeThis;
unsigned int uiGranularity;
OrbisAudio3dRate eRate;
unsigned int uiMaxObjects;
unsigned int uiQueueDepth;
OrbisAudio3dBufferMode eBufferMode;
char padding[32];
unsigned int uiNumBeds;
};
struct OrbisAudio3dAttribute {
OrbisAudio3dAttributeId uiAttributeId;
char padding[32];
const void* pValue;
size_t szValue;
};
struct OrbisAudio3dPosition {
float fX;
float fY;
float fZ;
};
struct OrbisAudio3dPcm {
OrbisAudio3dFormat eFormat;
const void* pSampleBuffer;
unsigned int uiNumSamples;
};
struct OrbisAudio3dSpeakerArrayParameters {
OrbisAudio3dPosition* pSpeakerPosition;
unsigned int uiNumSpeakers;
bool bIs3d;
void* pBuffer;
size_t szSize;
};
struct OrbisAudio3dApplicationSpecific {
size_t szSizeThis;
u8 cApplicationSpecific[32];
};
void PS4_SYSV_ABI sceAudio3dGetDefaultOpenParameters(OrbisAudio3dOpenParameters* sParameters);
void RegisterlibSceAudio3d(Core::Loader::SymbolsResolver* sym);
} // namespace Libraries::Audio3d
| 4,212
|
C++
|
.h
| 110
| 35.154545
| 96
| 0.804854
|
shadps4-emu/shadPS4
| 9,253
| 501
| 185
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
15,820
|
gnm_error.h
|
shadps4-emu_shadPS4/src/core/libraries/gnmdriver/gnm_error.h
|
// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
#pragma once
constexpr int ORBIS_GNM_ERROR_SUBMISSION_FAILED_INVALID_ARGUMENT = 0x80D11000;
constexpr int ORBIS_GNM_ERROR_SUBMISSION_NOT_ENOUGH_RESOURCES = 0x80D11001;
constexpr int ORBIS_GNM_ERROR_SUBMISSION_AND_FLIP_FAILED_INVALID_COMMAND_BUFFER = 0x80D11080;
constexpr int ORBIS_GNM_ERROR_SUBMISSION_AND_FLIP_FAILED_INVALID_QUEUE_FULL = 0x80D11081;
constexpr int ORBIS_GNM_ERROR_SUBMISSION_AND_FLIP_FAILED_REQUEST_FAILED = 0x80D11082;
constexpr int ORBIS_GNM_ERROR_SUBMISSION_FAILED_INTERNAL_ERROR = 0x80D110FF;
constexpr int ORBIS_GNM_ERROR_VALIDATION_WARNING = 0x80D12000;
constexpr int ORBIS_GNM_ERROR_VALIDATION_WARNING_RWBUFFER_ROTYPE = 0x80D12001;
constexpr int ORBIS_GNM_ERROR_VALIDATION_WARNING_BLENDING = 0x80D12002;
constexpr int ORBIS_GNM_ERROR_VALIDATION_WARNING_DRAW_CU_MASK = 0x80D12003;
constexpr int ORBIS_GNM_ERROR_VALIDATION_WARNING_MRT_SETUP = 0x80D12004;
constexpr int ORBIS_GNM_ERROR_VALIDATION_WARNING_DEPTH_RT_SETUP = 0x80D12005;
constexpr int ORBIS_GNM_ERROR_VALIDATION_WARNING_PS_AND_MRT_FORMAT = 0x80D1200F;
constexpr int ORBIS_GNM_ERROR_VALIDATION_ERROR = 0x80D13000;
constexpr int ORBIS_GNM_ERROR_VALIDATION_VSHARP = 0x80D13001;
constexpr int ORBIS_GNM_ERROR_VALIDATION_TSHARP = 0x80D13002;
constexpr int ORBIS_GNM_ERROR_VALIDATION_RESOURCE = 0x80D13003;
constexpr int ORBIS_GNM_ERROR_VALIDATION_TABLE_MEMORY = 0x80D13004;
constexpr int ORBIS_GNM_ERROR_VALIDATION_WRITE_EVENT_OP = 0x80D13005;
constexpr int ORBIS_GNM_ERROR_VALIDATION_INDEX_BUFFER = 0x80D13006;
constexpr int ORBIS_GNM_ERROR_VALIDATION_TESS_FACTOR_BUFFER = 0x80D13007;
constexpr int ORBIS_GNM_ERROR_VALIDATION_SCRATCH_RING = 0x80D13008;
constexpr int ORBIS_GNM_ERROR_VALIDATION_PRIMITIVE_TYPE = 0x80D13009;
constexpr int ORBIS_GNM_ERROR_VALIDATION_INDEX_SIZE = 0x80D1300A;
constexpr int ORBIS_GNM_ERROR_VALIDATION_INLINE_DRAW_SIZE = 0x80D1300B;
constexpr int ORBIS_GNM_ERROR_VALIDATION_NUM_INPUT_PATCHES = 0x80D1300C;
constexpr int ORBIS_GNM_ERROR_VALIDATION_GS_MODE = 0x80D1300D;
constexpr int ORBIS_GNM_ERROR_VALIDATION_SHADER_ADDRESS = 0x80D1300E;
constexpr int ORBIS_GNM_ERROR_VALIDATION_BORDER_COLOR_TABLE = 0x80D1300F;
constexpr int ORBIS_GNM_ERROR_VALIDATION_SSHARP = 0x80D13010;
constexpr int ORBIS_GNM_ERROR_VALIDATION_DISPATCH_DRAW = 0x80D13011;
constexpr int ORBIS_GNM_ERROR_VALIDATION_ACTIVE_SHADER_STAGE = 0x80D13012;
constexpr int ORBIS_GNM_ERROR_VALIDATION_DCB = 0x80D13013;
constexpr int ORBIS_GNM_ERROR_VALIDATION_MISMATCH_SHADER_STAGE = 0x80D13014;
constexpr int ORBIS_GNM_ERROR_VALIDATION_MRT_SETUP = 0x80D13015;
constexpr int ORBIS_GNM_ERROR_VALIDATION_BAD_OP_CODE = 0x80D13016;
constexpr int ORBIS_GNM_ERROR_VALIDATION_DEPTH_RT_SETUP = 0x80D13017;
constexpr int ORBIS_GNM_ERROR_VALIDATION_NUM_INSTANCES = 0x80D13018;
constexpr int ORBIS_GNM_ERROR_VALIDATION_SRT = 0x80D13019;
constexpr int ORBIS_GNM_ERROR_VALIDATION_INVALID_ARGUMENT = 0x80D13FFD;
constexpr int ORBIS_GNM_ERROR_VALIDATION_FAILED_INTERNAL_ERROR = 0x80D13FFE;
constexpr int ORBIS_GNM_ERROR_VALIDATION_NOT_ENABLED = 0x80D13FFF;
constexpr int ORBIS_GNM_ERROR_CAPTURE_FILE_IO = 0x80D15000;
constexpr int ORBIS_GNM_ERROR_CAPTURE_RAZOR_NOT_LOADED = 0x80D15001;
constexpr int ORBIS_GNM_ERROR_CAPTURE_NOTHING_TO_CAPTURE = 0x80D15002;
constexpr int ORBIS_GNM_ERROR_CAPTURE_FAILED_INTERNAL = 0x80D1500F;
constexpr int ORBIS_GNM_ERROR_COMPUTEQUEUE_INVALID_PIPE_ID = 0x80D17000;
constexpr int ORBIS_GNM_ERROR_COMPUTEQUEUE_INVALID_QUEUE_ID = 0x80D17001;
constexpr int ORBIS_GNM_ERROR_COMPUTEQUEUE_INVALID_RING_SIZE = 0x80D17002;
constexpr int ORBIS_GNM_ERROR_COMPUTEQUEUE_INVALID_RING_BASE_ADDR = 0x80D17003;
constexpr int ORBIS_GNM_ERROR_COMPUTEQUEUE_INVALID_READ_PTR_ADDR = 0x80D17004;
constexpr int ORBIS_GNM_ERROR_COMPUTEQUEUE_INVALID_PIPE_PRIORITY = 0x80D17005;
constexpr int ORBIS_GNM_ERROR_COMPUTEQUEUE_INTERNAL = 0x80D170FF;
constexpr int ORBIS_GNM_ERROR_RESOURCE_REGISTRATION_INVALID_ARGUMENT = 0x80D19000;
constexpr int ORBIS_GNM_ERROR_RESOURCE_REGISTRATION_INVALID_SHADER = 0x80D19001;
constexpr int ORBIS_GNM_ERROR_RESOURCE_REGISTRATION_STALE_HANDLE = 0x80D19002;
constexpr int ORBIS_GNM_ERROR_RESOURCE_REGISTRATION_FULL = 0x80D19003;
constexpr int ORBIS_GNM_ERROR_RESOURCE_REGISTRATION_NOT_PERMITTED = 0x80D19004;
constexpr int ORBIS_GNM_ERROR_RESOURCE_REGISTRATION_OUTPUT_ARGUMENT_IS_NULL = 0x80D19005;
constexpr int ORBIS_GNM_ERROR_RESOURCE_REGISTRATION_OWNER_HANDLE_INVALID = 0x80D19006;
constexpr int ORBIS_GNM_ERROR_RESOURCE_REGISTRATION_RESOURCE_HANDLE_INVALID = 0x80D19007;
constexpr int ORBIS_GNM_ERROR_RESOURCE_REGISTRATION_RESOURCE_TYPE_INVALID = 0x80D19008;
constexpr int ORBIS_GNM_ERROR_RESOURCE_REGISTRATION_GDS_RESOURCE_TYPE_INVALID = 0x80D19009;
constexpr int ORBIS_GNM_ERROR_RESOURCE_REGISTRATION_RESOURCE_SIZE_INVALID = 0x80D1900A;
constexpr int ORBIS_GNM_ERROR_RESOURCE_REGISTRATION_RESOURCE_ADDRESS_IS_NULL = 0x80D1900B;
constexpr int ORBIS_GNM_ERROR_RESOURCE_REGISTRATION_GDS_OFFSET_INVALID = 0x80D1900C;
constexpr int ORBIS_GNM_ERROR_RESOURCE_REGISTRATION_RESOURCE_NAME_IS_NULL = 0x80D1900D;
constexpr int ORBIS_GNM_ERROR_RESOURCE_REGISTRATION_OWNER_NAME_IS_NULL = 0x80D1900E;
constexpr int ORBIS_GNM_ERROR_RESOURCE_REGISTRATION_FIND_CALLBACK_IS_NULL = 0x80D1900F;
constexpr int ORBIS_GNM_ERROR_RESOURCE_REGISTRATION_RESOURCE_IS_NOT_SHADER = 0x80D19010;
constexpr int ORBIS_GNM_ERROR_RESOURCE_REGISTRATION_USER_MEMORY_PARAM_IS_NULL = 0x80D19011;
constexpr int ORBIS_GNM_ERROR_RESOURCE_REGISTRATION_USER_MEMORY_PARAM_NOT_ALIGNED = 0x80D19012;
constexpr int ORBIS_GNM_ERROR_RESOURCE_REGISTRATION_INVALID_NAME_LENGTH_PARAM = 0x80D19013;
constexpr int ORBIS_GNM_ERROR_RESOURCE_REGISTRATION_INVALID_SIZE_PARAM = 0x80D19014;
constexpr int ORBIS_GNM_ERROR_RESOURCE_REGISTRATION_INVALID_NUM_RESOURCES_PARAM = 0x80D19015;
constexpr int ORBIS_GNM_ERROR_RESOURCE_REGISTRATION_INTERNAL = 0x80D19FFF;
constexpr int ORBIS_GNM_ERROR_GET_GPU_INFO_PARAMETER_NULL = 0x80D1B000;
constexpr int ORBIS_GNM_ERROR_GET_GPU_INFO_FAILED = 0x80D1B001;
constexpr int ORBIS_GNM_ERROR_GET_GPU_INFO_PARAMETER_INVALID = 0x80D1B002;
constexpr int ORBIS_GNM_ERROR_FAILURE = 0x8EEE00FF;
| 6,170
|
C++
|
.h
| 83
| 73.313253
| 95
| 0.837141
|
shadps4-emu/shadPS4
| 9,253
| 501
| 185
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
15,821
|
gnmdriver.h
|
shadps4-emu_shadPS4/src/core/libraries/gnmdriver/gnmdriver.h
|
// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
#pragma once
#include "common/types.h"
#include "core/libraries/kernel/event_queues.h"
namespace Core::Loader {
class SymbolsResolver;
}
namespace Libraries::GnmDriver {
using namespace Kernel;
s32 PS4_SYSV_ABI sceGnmAddEqEvent(SceKernelEqueue eq, u64 id, void* udata);
int PS4_SYSV_ABI sceGnmAreSubmitsAllowed();
int PS4_SYSV_ABI sceGnmBeginWorkload();
s32 PS4_SYSV_ABI sceGnmComputeWaitOnAddress(u32* cmdbuf, u32 size, uintptr_t addr, u32 mask,
u32 cmp_func, u32 ref);
int PS4_SYSV_ABI sceGnmComputeWaitSemaphore();
int PS4_SYSV_ABI sceGnmCreateWorkloadStream();
int PS4_SYSV_ABI sceGnmDebuggerGetAddressWatch();
int PS4_SYSV_ABI sceGnmDebuggerHaltWavefront();
int PS4_SYSV_ABI sceGnmDebuggerReadGds();
int PS4_SYSV_ABI sceGnmDebuggerReadSqIndirectRegister();
int PS4_SYSV_ABI sceGnmDebuggerResumeWavefront();
int PS4_SYSV_ABI sceGnmDebuggerResumeWavefrontCreation();
int PS4_SYSV_ABI sceGnmDebuggerSetAddressWatch();
int PS4_SYSV_ABI sceGnmDebuggerWriteGds();
int PS4_SYSV_ABI sceGnmDebuggerWriteSqIndirectRegister();
int PS4_SYSV_ABI sceGnmDebugHardwareStatus();
s32 PS4_SYSV_ABI sceGnmDeleteEqEvent(SceKernelEqueue eq, u64 id);
int PS4_SYSV_ABI sceGnmDestroyWorkloadStream();
void PS4_SYSV_ABI sceGnmDingDong(u32 gnm_vqid, u32 next_offs_dw);
int PS4_SYSV_ABI sceGnmDingDongForWorkload();
int PS4_SYSV_ABI sceGnmDisableMipStatsReport();
s32 PS4_SYSV_ABI sceGnmDispatchDirect(u32* cmdbuf, u32 size, u32 threads_x, u32 threads_y,
u32 threads_z, u32 flags);
s32 PS4_SYSV_ABI sceGnmDispatchIndirect(u32* cmdbuf, u32 size, u32 data_offset, u32 flags);
int PS4_SYSV_ABI sceGnmDispatchIndirectOnMec();
u32 PS4_SYSV_ABI sceGnmDispatchInitDefaultHardwareState(u32* cmdbuf, u32 size);
s32 PS4_SYSV_ABI sceGnmDrawIndex(u32* cmdbuf, u32 size, u32 index_count, uintptr_t index_addr,
u32 flags, u32 type);
s32 PS4_SYSV_ABI sceGnmDrawIndexAuto(u32* cmdbuf, u32 size, u32 index_count, u32 flags);
s32 PS4_SYSV_ABI sceGnmDrawIndexIndirect(u32* cmdbuf, u32 size, u32 data_offset, u32 shader_stage,
u32 vertex_sgpr_offset, u32 instance_sgpr_offset,
u32 flags);
int PS4_SYSV_ABI sceGnmDrawIndexIndirectCountMulti();
int PS4_SYSV_ABI sceGnmDrawIndexIndirectMulti();
int PS4_SYSV_ABI sceGnmDrawIndexMultiInstanced();
s32 PS4_SYSV_ABI sceGnmDrawIndexOffset(u32* cmdbuf, u32 size, u32 index_offset, u32 index_count,
u32 flags);
s32 PS4_SYSV_ABI sceGnmDrawIndirect(u32* cmdbuf, u32 size, u32 data_offset, u32 shader_stage,
u32 vertex_sgpr_offset, u32 instance_sgpr_offset, u32 flags);
int PS4_SYSV_ABI sceGnmDrawIndirectCountMulti();
int PS4_SYSV_ABI sceGnmDrawIndirectMulti();
u32 PS4_SYSV_ABI sceGnmDrawInitDefaultHardwareState(u32* cmdbuf, u32 size);
u32 PS4_SYSV_ABI sceGnmDrawInitDefaultHardwareState175(u32* cmdbuf, u32 size);
u32 PS4_SYSV_ABI sceGnmDrawInitDefaultHardwareState200(u32* cmdbuf, u32 size);
u32 PS4_SYSV_ABI sceGnmDrawInitDefaultHardwareState350(u32* cmdbuf, u32 size);
u32 PS4_SYSV_ABI sceGnmDrawInitToDefaultContextState(u32* cmdbuf, u32 size);
u32 PS4_SYSV_ABI sceGnmDrawInitToDefaultContextState400(u32* cmdbuf, u32 size);
int PS4_SYSV_ABI sceGnmDrawOpaqueAuto();
bool PS4_SYSV_ABI sceGnmDriverCaptureInProgress();
int PS4_SYSV_ABI sceGnmDriverInternalRetrieveGnmInterface();
int PS4_SYSV_ABI sceGnmDriverInternalRetrieveGnmInterfaceForGpuDebugger();
int PS4_SYSV_ABI sceGnmDriverInternalRetrieveGnmInterfaceForGpuException();
int PS4_SYSV_ABI sceGnmDriverInternalRetrieveGnmInterfaceForHDRScopes();
int PS4_SYSV_ABI sceGnmDriverInternalRetrieveGnmInterfaceForReplay();
int PS4_SYSV_ABI sceGnmDriverInternalRetrieveGnmInterfaceForResourceRegistration();
int PS4_SYSV_ABI sceGnmDriverInternalRetrieveGnmInterfaceForValidation();
int PS4_SYSV_ABI sceGnmDriverInternalVirtualQuery();
int PS4_SYSV_ABI sceGnmDriverTraceInProgress();
int PS4_SYSV_ABI sceGnmDriverTriggerCapture();
int PS4_SYSV_ABI sceGnmEndWorkload();
s32 PS4_SYSV_ABI sceGnmFindResourcesPublic();
void PS4_SYSV_ABI sceGnmFlushGarlic();
int PS4_SYSV_ABI sceGnmGetCoredumpAddress();
int PS4_SYSV_ABI sceGnmGetCoredumpMode();
int PS4_SYSV_ABI sceGnmGetCoredumpProtectionFaultTimestamp();
int PS4_SYSV_ABI sceGnmGetDbgGcHandle();
int PS4_SYSV_ABI sceGnmGetDebugTimestamp();
int PS4_SYSV_ABI sceGnmGetEqEventType();
int PS4_SYSV_ABI sceGnmGetEqTimeStamp();
int PS4_SYSV_ABI sceGnmGetGpuBlockStatus();
u32 PS4_SYSV_ABI sceGnmGetGpuCoreClockFrequency();
int PS4_SYSV_ABI sceGnmGetGpuInfoStatus();
int PS4_SYSV_ABI sceGnmGetLastWaitedAddress();
int PS4_SYSV_ABI sceGnmGetNumTcaUnits();
int PS4_SYSV_ABI sceGnmGetOffChipTessellationBufferSize();
int PS4_SYSV_ABI sceGnmGetOwnerName();
int PS4_SYSV_ABI sceGnmGetPhysicalCounterFromVirtualized();
int PS4_SYSV_ABI sceGnmGetProtectionFaultTimeStamp();
int PS4_SYSV_ABI sceGnmGetResourceBaseAddressAndSizeInBytes();
int PS4_SYSV_ABI sceGnmGetResourceName();
int PS4_SYSV_ABI sceGnmGetResourceShaderGuid();
int PS4_SYSV_ABI sceGnmGetResourceType();
int PS4_SYSV_ABI sceGnmGetResourceUserData();
int PS4_SYSV_ABI sceGnmGetShaderProgramBaseAddress();
int PS4_SYSV_ABI sceGnmGetShaderStatus();
VAddr PS4_SYSV_ABI sceGnmGetTheTessellationFactorRingBufferBaseAddress();
int PS4_SYSV_ABI sceGnmGpuPaDebugEnter();
int PS4_SYSV_ABI sceGnmGpuPaDebugLeave();
int PS4_SYSV_ABI sceGnmInsertDingDongMarker();
s32 PS4_SYSV_ABI sceGnmInsertPopMarker(u32* cmdbuf, u32 size);
s32 PS4_SYSV_ABI sceGnmInsertPushColorMarker(u32* cmdbuf, u32 size, const char* marker, u32 color);
s32 PS4_SYSV_ABI sceGnmInsertPushMarker(u32* cmdbuf, u32 size, const char* marker);
int PS4_SYSV_ABI sceGnmInsertSetColorMarker();
s32 PS4_SYSV_ABI sceGnmInsertSetMarker(u32* cmdbuf, u32 size, const char* marker);
int PS4_SYSV_ABI sceGnmInsertThreadTraceMarker();
s32 PS4_SYSV_ABI sceGnmInsertWaitFlipDone(u32* cmdbuf, u32 size, s32 vo_handle, u32 buf_idx);
int PS4_SYSV_ABI sceGnmIsCoredumpValid();
int PS4_SYSV_ABI sceGnmIsUserPaEnabled();
int PS4_SYSV_ABI sceGnmLogicalCuIndexToPhysicalCuIndex();
int PS4_SYSV_ABI sceGnmLogicalCuMaskToPhysicalCuMask();
int PS4_SYSV_ABI sceGnmLogicalTcaUnitToPhysical();
int PS4_SYSV_ABI sceGnmMapComputeQueue(u32 pipe_id, u32 queue_id, VAddr ring_base_addr,
u32 ring_size_dw, u32* read_ptr_addr);
int PS4_SYSV_ABI sceGnmMapComputeQueueWithPriority(u32 pipe_id, u32 queue_id, VAddr ring_base_addr,
u32 ring_size_dw, u32* read_ptr_addr,
u32 pipePriority);
int PS4_SYSV_ABI sceGnmPaDisableFlipCallbacks();
int PS4_SYSV_ABI sceGnmPaEnableFlipCallbacks();
int PS4_SYSV_ABI sceGnmPaHeartbeat();
int PS4_SYSV_ABI sceGnmQueryResourceRegistrationUserMemoryRequirements();
int PS4_SYSV_ABI sceGnmRaiseUserExceptionEvent();
int PS4_SYSV_ABI sceGnmRegisterGdsResource();
int PS4_SYSV_ABI sceGnmRegisterGnmLiveCallbackConfig();
s32 PS4_SYSV_ABI sceGnmRegisterOwner(void* handle, const char* name);
s32 PS4_SYSV_ABI sceGnmRegisterResource(void* res_handle, void* owner_handle, const void* addr,
size_t size, const char* name, int res_type, u64 user_data);
int PS4_SYSV_ABI sceGnmRequestFlipAndSubmitDone();
int PS4_SYSV_ABI sceGnmRequestFlipAndSubmitDoneForWorkload();
int PS4_SYSV_ABI sceGnmRequestMipStatsReportAndReset();
s32 PS4_SYSV_ABI sceGnmResetVgtControl(u32* cmdbuf, u32 size);
int PS4_SYSV_ABI sceGnmSdmaClose();
int PS4_SYSV_ABI sceGnmSdmaConstFill();
int PS4_SYSV_ABI sceGnmSdmaCopyLinear();
int PS4_SYSV_ABI sceGnmSdmaCopyTiled();
int PS4_SYSV_ABI sceGnmSdmaCopyWindow();
int PS4_SYSV_ABI sceGnmSdmaFlush();
int PS4_SYSV_ABI sceGnmSdmaGetMinCmdSize();
int PS4_SYSV_ABI sceGnmSdmaOpen();
s32 PS4_SYSV_ABI sceGnmSetCsShader(u32* cmdbuf, u32 size, const u32* cs_regs);
s32 PS4_SYSV_ABI sceGnmSetCsShaderWithModifier(u32* cmdbuf, u32 size, const u32* cs_regs,
u32 modifier);
s32 PS4_SYSV_ABI sceGnmSetEmbeddedPsShader(u32* cmdbuf, u32 size, u32 shader_id,
u32 shader_modifier);
s32 PS4_SYSV_ABI sceGnmSetEmbeddedVsShader(u32* cmdbuf, u32 size, u32 shader_id, u32 modifier);
s32 PS4_SYSV_ABI sceGnmSetEsShader(u32* cmdbuf, u32 size, const u32* es_regs, u32 shader_modifier);
int PS4_SYSV_ABI sceGnmSetGsRingSizes();
s32 PS4_SYSV_ABI sceGnmSetGsShader(u32* cmdbuf, u32 size, const u32* gs_regs);
s32 PS4_SYSV_ABI sceGnmSetHsShader(u32* cmdbuf, u32 size, const u32* hs_regs, u32 param4);
s32 PS4_SYSV_ABI sceGnmSetLsShader(u32* cmdbuf, u32 size, const u32* ls_regs, u32 shader_modifier);
s32 PS4_SYSV_ABI sceGnmSetPsShader(u32* cmdbuf, u32 size, const u32* ps_regs);
s32 PS4_SYSV_ABI sceGnmSetPsShader350(u32* cmdbuf, u32 size, const u32* ps_regs);
int PS4_SYSV_ABI sceGnmSetResourceRegistrationUserMemory();
int PS4_SYSV_ABI sceGnmSetResourceUserData();
int PS4_SYSV_ABI sceGnmSetSpiEnableSqCounters();
int PS4_SYSV_ABI sceGnmSetSpiEnableSqCountersForUnitInstance();
int PS4_SYSV_ABI sceGnmSetupMipStatsReport();
s32 PS4_SYSV_ABI sceGnmSetVgtControl(u32* cmdbuf, u32 size, u32 prim_group_sz_minus_one,
u32 partial_vs_wave_mode, u32 wd_switch_only_on_eop_mode);
s32 PS4_SYSV_ABI sceGnmSetVsShader(u32* cmdbuf, u32 size, const u32* vs_regs, u32 shader_modifier);
int PS4_SYSV_ABI sceGnmSetWaveLimitMultiplier();
int PS4_SYSV_ABI sceGnmSetWaveLimitMultipliers();
int PS4_SYSV_ABI sceGnmSpmEndSpm();
int PS4_SYSV_ABI sceGnmSpmInit();
int PS4_SYSV_ABI sceGnmSpmInit2();
int PS4_SYSV_ABI sceGnmSpmSetDelay();
int PS4_SYSV_ABI sceGnmSpmSetMuxRam();
int PS4_SYSV_ABI sceGnmSpmSetMuxRam2();
int PS4_SYSV_ABI sceGnmSpmSetSelectCounter();
int PS4_SYSV_ABI sceGnmSpmSetSpmSelects();
int PS4_SYSV_ABI sceGnmSpmSetSpmSelects2();
int PS4_SYSV_ABI sceGnmSpmStartSpm();
int PS4_SYSV_ABI sceGnmSqttFini();
int PS4_SYSV_ABI sceGnmSqttFinishTrace();
int PS4_SYSV_ABI sceGnmSqttGetBcInfo();
int PS4_SYSV_ABI sceGnmSqttGetGpuClocks();
int PS4_SYSV_ABI sceGnmSqttGetHiWater();
int PS4_SYSV_ABI sceGnmSqttGetStatus();
int PS4_SYSV_ABI sceGnmSqttGetTraceCounter();
int PS4_SYSV_ABI sceGnmSqttGetTraceWptr();
int PS4_SYSV_ABI sceGnmSqttGetWrapCounts();
int PS4_SYSV_ABI sceGnmSqttGetWrapCounts2();
int PS4_SYSV_ABI sceGnmSqttGetWritebackLabels();
int PS4_SYSV_ABI sceGnmSqttInit();
int PS4_SYSV_ABI sceGnmSqttSelectMode();
int PS4_SYSV_ABI sceGnmSqttSelectTarget();
int PS4_SYSV_ABI sceGnmSqttSelectTokens();
int PS4_SYSV_ABI sceGnmSqttSetCuPerfMask();
int PS4_SYSV_ABI sceGnmSqttSetDceEventWrite();
int PS4_SYSV_ABI sceGnmSqttSetHiWater();
int PS4_SYSV_ABI sceGnmSqttSetTraceBuffer2();
int PS4_SYSV_ABI sceGnmSqttSetTraceBuffers();
int PS4_SYSV_ABI sceGnmSqttSetUserData();
int PS4_SYSV_ABI sceGnmSqttSetUserdataTimer();
int PS4_SYSV_ABI sceGnmSqttStartTrace();
int PS4_SYSV_ABI sceGnmSqttStopTrace();
int PS4_SYSV_ABI sceGnmSqttSwitchTraceBuffer();
int PS4_SYSV_ABI sceGnmSqttSwitchTraceBuffer2();
int PS4_SYSV_ABI sceGnmSqttWaitForEvent();
s32 PS4_SYSV_ABI sceGnmSubmitAndFlipCommandBuffers(u32 count, u32* dcb_gpu_addrs[],
u32* dcb_sizes_in_bytes, u32* ccb_gpu_addrs[],
u32* ccb_sizes_in_bytes, u32 vo_handle,
u32 buf_idx, u32 flip_mode, u32 flip_arg);
int PS4_SYSV_ABI sceGnmSubmitAndFlipCommandBuffersForWorkload();
s32 PS4_SYSV_ABI sceGnmSubmitCommandBuffers(u32 count, const u32* dcb_gpu_addrs[],
u32* dcb_sizes_in_bytes, const u32* ccb_gpu_addrs[],
u32* ccb_sizes_in_bytes);
int PS4_SYSV_ABI sceGnmSubmitCommandBuffersForWorkload();
int PS4_SYSV_ABI sceGnmSubmitDone();
int PS4_SYSV_ABI sceGnmUnmapComputeQueue();
int PS4_SYSV_ABI sceGnmUnregisterAllResourcesForOwner();
int PS4_SYSV_ABI sceGnmUnregisterOwnerAndResources();
int PS4_SYSV_ABI sceGnmUnregisterResource();
s32 PS4_SYSV_ABI sceGnmUpdateGsShader(u32* cmdbuf, u32 size, const u32* gs_regs);
int PS4_SYSV_ABI sceGnmUpdateHsShader();
s32 PS4_SYSV_ABI sceGnmUpdatePsShader(u32* cmdbuf, u32 size, const u32* ps_regs);
s32 PS4_SYSV_ABI sceGnmUpdatePsShader350(u32* cmdbuf, u32 size, const u32* ps_regs);
s32 PS4_SYSV_ABI sceGnmUpdateVsShader(u32* cmdbuf, u32 size, const u32* vs_regs,
u32 shader_modifier);
s32 PS4_SYSV_ABI sceGnmValidateCommandBuffers();
int PS4_SYSV_ABI sceGnmValidateDisableDiagnostics();
int PS4_SYSV_ABI sceGnmValidateDisableDiagnostics2();
int PS4_SYSV_ABI sceGnmValidateDispatchCommandBuffers();
int PS4_SYSV_ABI sceGnmValidateDrawCommandBuffers();
int PS4_SYSV_ABI sceGnmValidateGetDiagnosticInfo();
int PS4_SYSV_ABI sceGnmValidateGetDiagnostics();
int PS4_SYSV_ABI sceGnmValidateGetVersion();
int PS4_SYSV_ABI sceGnmValidateOnSubmitEnabled();
int PS4_SYSV_ABI sceGnmValidateResetState();
int PS4_SYSV_ABI sceGnmValidationRegisterMemoryCheckCallback();
int PS4_SYSV_ABI sceRazorCaptureCommandBuffersOnlyImmediate();
int PS4_SYSV_ABI sceRazorCaptureCommandBuffersOnlySinceLastFlip();
int PS4_SYSV_ABI sceRazorCaptureImmediate();
int PS4_SYSV_ABI sceRazorCaptureSinceLastFlip();
int PS4_SYSV_ABI sceRazorIsLoaded();
int PS4_SYSV_ABI Func_063D065A2D6359C3();
int PS4_SYSV_ABI Func_0CABACAFB258429D();
int PS4_SYSV_ABI Func_150CF336FC2E99A3();
int PS4_SYSV_ABI Func_17CA687F9EE52D49();
int PS4_SYSV_ABI Func_1870B89F759C6B45();
int PS4_SYSV_ABI Func_26F9029EF68A955E();
int PS4_SYSV_ABI Func_301E3DBBAB092DB0();
int PS4_SYSV_ABI Func_30BAFE172AF17FEF();
int PS4_SYSV_ABI Func_3E6A3E8203D95317();
int PS4_SYSV_ABI Func_40FEEF0C6534C434();
int PS4_SYSV_ABI Func_416B9079DE4CBACE();
int PS4_SYSV_ABI Func_4774D83BB4DDBF9A();
int PS4_SYSV_ABI Func_50678F1CCEEB9A00();
int PS4_SYSV_ABI Func_54A2EC5FA4C62413();
int PS4_SYSV_ABI Func_5A9C52C83138AE6B();
int PS4_SYSV_ABI Func_5D22193A31EA1142();
int PS4_SYSV_ABI Func_725A36DEBB60948D();
int PS4_SYSV_ABI Func_8021A502FA61B9BB();
int PS4_SYSV_ABI Func_9D002FE0FA40F0E6();
int PS4_SYSV_ABI Func_9D297F36A7028B71();
int PS4_SYSV_ABI Func_A2D7EC7A7BCF79B3();
int PS4_SYSV_ABI Func_AA12A3CB8990854A();
int PS4_SYSV_ABI Func_ADC8DDC005020BC6();
int PS4_SYSV_ABI Func_B0A8688B679CB42D();
int PS4_SYSV_ABI Func_B489020B5157A5FF();
int PS4_SYSV_ABI Func_BADE7B4C199140DD();
int PS4_SYSV_ABI Func_D1511B9DCFFB3DD9();
int PS4_SYSV_ABI Func_D53446649B02E58E();
int PS4_SYSV_ABI Func_D8B6E8E28E1EF0A3();
int PS4_SYSV_ABI Func_D93D733A19DD7454();
int PS4_SYSV_ABI Func_DE995443BC2A8317();
int PS4_SYSV_ABI Func_DF6E9528150C23FF();
int PS4_SYSV_ABI Func_ECB4C6BA41FE3350();
int PS4_SYSV_ABI sceGnmDebugModuleReset();
int PS4_SYSV_ABI sceGnmDebugReset();
int PS4_SYSV_ABI Func_C4C328B7CF3B4171();
int PS4_SYSV_ABI sceGnmDrawInitToDefaultContextStateInternalCommand();
int PS4_SYSV_ABI sceGnmDrawInitToDefaultContextStateInternalSize();
int PS4_SYSV_ABI sceGnmFindResources();
int PS4_SYSV_ABI sceGnmGetResourceRegistrationBuffers();
int PS4_SYSV_ABI sceGnmRegisterOwnerForSystem();
int PS4_SYSV_ABI Func_1C43886B16EE5530();
int PS4_SYSV_ABI Func_81037019ECCD0E01();
int PS4_SYSV_ABI Func_BFB41C057478F0BF();
int PS4_SYSV_ABI Func_E51D44DB8151238C();
int PS4_SYSV_ABI Func_F916890425496553();
void RegisterlibSceGnmDriver(Core::Loader::SymbolsResolver* sym);
} // namespace Libraries::GnmDriver
| 15,554
|
C++
|
.h
| 283
| 50.90106
| 100
| 0.78066
|
shadps4-emu/shadPS4
| 9,253
| 501
| 185
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
15,822
|
posix.h
|
shadps4-emu_shadPS4/src/core/libraries/system/posix.h
|
// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
#pragma once
namespace Core::Loader {
class SymbolsResolver;
}
namespace Libraries::Posix {
void Registerlibsceposix(Core::Loader::SymbolsResolver* sym);
} // namespace Libraries::Posix
| 301
|
C++
|
.h
| 9
| 32.111111
| 66
| 0.813149
|
shadps4-emu/shadPS4
| 9,253
| 501
| 185
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
15,823
|
userservice.h
|
shadps4-emu_shadPS4/src/core/libraries/system/userservice.h
|
// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
// reference :
// https://github.com/OpenOrbis/OpenOrbis-PS4-Toolchain/blob/master/include/orbis/_types/user.h
#pragma once
#include "common/types.h"
namespace Core::Loader {
class SymbolsResolver;
}
namespace Libraries::UserService {
// Maximum number of users that can be logged in at once
constexpr int ORBIS_USER_SERVICE_MAX_LOGIN_USERS = 4;
// Maximum number of users that can be registered in the system
constexpr int ORBIS_USER_SERVICE_MAX_REGISTER_USERS = 16;
// Maximum user name length
constexpr int ORBIS_USER_SERVICE_MAX_USER_NAME_LENGTH = 16;
constexpr int ORBIS_USER_SERVICE_USER_ID_SYSTEM = 0xFF;
constexpr int ORBIS_USER_SERVICE_USER_ID_INVALID = -1;
using OrbisUserServiceUserId = s32;
constexpr int ORBIS_KERNEL_PRIO_FIFO_LOWEST = 0x2FF;
constexpr int ORBIS_KERNEL_PRIO_FIFO_NORMAL = 0x2BC;
constexpr int ORBIS_KERNEL_PRIO_FIFO_HIGHEST = 0x100;
struct OrbisUserServiceInitializeParams {
s32 priority;
};
struct OrbisUserServiceLoginUserIdList {
int user_id[ORBIS_USER_SERVICE_MAX_LOGIN_USERS];
};
struct OrbisUserServiceRegisteredUserIdList {
OrbisUserServiceUserId userId[ORBIS_USER_SERVICE_MAX_REGISTER_USERS];
};
enum OrbisUserServiceUserColor {
ORBIS_USER_SERVICE_USER_COLOR_BLUE = 0,
ORBIS_USER_SERVICE_USER_COLOR_RED = 1,
ORBIS_USER_SERVICE_USER_COLOR_GREEN = 2,
ORBIS_USER_SERVICE_USER_COLOR_PINK = 3,
};
enum OrbisUserServiceEventType {
SCE_USER_SERVICE_EVENT_TYPE_LOGIN = 0, // Login event
SCE_USER_SERVICE_EVENT_TYPE_LOGOUT = 1, // Logout event
};
struct OrbisUserServiceEvent {
OrbisUserServiceEventType event;
OrbisUserServiceUserId userId;
};
int PS4_SYSV_ABI sceUserServiceInitializeForShellCore();
int PS4_SYSV_ABI sceUserServiceTerminateForShellCore();
int PS4_SYSV_ABI sceUserServiceDestroyUser();
int PS4_SYSV_ABI sceUserServiceGetAccessibilityKeyremapData();
int PS4_SYSV_ABI sceUserServiceGetAccessibilityKeyremapEnable();
int PS4_SYSV_ABI sceUserServiceGetAccessibilityPressAndHoldDelay();
int PS4_SYSV_ABI sceUserServiceGetAccessibilityVibration();
int PS4_SYSV_ABI sceUserServiceGetAccessibilityZoom();
int PS4_SYSV_ABI sceUserServiceGetAccessibilityZoomEnabled();
int PS4_SYSV_ABI sceUserServiceGetAccountRemarks();
int PS4_SYSV_ABI sceUserServiceGetAgeVerified();
int PS4_SYSV_ABI sceUserServiceGetAppearOfflineSetting();
int PS4_SYSV_ABI sceUserServiceGetAppSortOrder();
int PS4_SYSV_ABI sceUserServiceGetAutoLoginEnabled();
int PS4_SYSV_ABI sceUserServiceGetCreatedVersion();
int PS4_SYSV_ABI sceUserServiceGetCurrentUserGroupIndex();
int PS4_SYSV_ABI sceUserServiceGetDefaultNewUserGroupName();
int PS4_SYSV_ABI sceUserServiceGetDeletedUserInfo();
int PS4_SYSV_ABI sceUserServiceGetDiscPlayerFlag();
int PS4_SYSV_ABI sceUserServiceGetEvent(OrbisUserServiceEvent* event);
int PS4_SYSV_ABI sceUserServiceGetEventCalendarType();
int PS4_SYSV_ABI sceUserServiceGetEventFilterTeamEvent();
int PS4_SYSV_ABI sceUserServiceGetEventSortEvent();
int PS4_SYSV_ABI sceUserServiceGetEventSortTitle();
int PS4_SYSV_ABI sceUserServiceGetEventUiFlag();
int PS4_SYSV_ABI sceUserServiceGetEventVsh();
int PS4_SYSV_ABI sceUserServiceGetFaceRecognitionDeleteCount();
int PS4_SYSV_ABI sceUserServiceGetFaceRecognitionRegisterCount();
int PS4_SYSV_ABI sceUserServiceGetFileBrowserFilter();
int PS4_SYSV_ABI sceUserServiceGetFileBrowserSortContent();
int PS4_SYSV_ABI sceUserServiceGetFileBrowserSortTitle();
int PS4_SYSV_ABI sceUserServiceGetFileSelectorFilter();
int PS4_SYSV_ABI sceUserServiceGetFileSelectorSortContent();
int PS4_SYSV_ABI sceUserServiceGetFileSelectorSortTitle();
int PS4_SYSV_ABI sceUserServiceGetForegroundUser();
int PS4_SYSV_ABI sceUserServiceGetFriendCustomListLastFocus();
int PS4_SYSV_ABI sceUserServiceGetFriendFlag();
int PS4_SYSV_ABI sceUserServiceGetGlsAccessTokenNiconicoLive();
int PS4_SYSV_ABI sceUserServiceGetGlsAccessTokenTwitch();
int PS4_SYSV_ABI sceUserServiceGetGlsAccessTokenUstream();
int PS4_SYSV_ABI sceUserServiceGetGlsAnonymousUserId();
int PS4_SYSV_ABI sceUserServiceGetGlsBcTags();
int PS4_SYSV_ABI sceUserServiceGetGlsBcTitle();
int PS4_SYSV_ABI sceUserServiceGetGlsBroadcastChannel();
int PS4_SYSV_ABI sceUserServiceGetGlsBroadcastersComment();
int PS4_SYSV_ABI sceUserServiceGetGlsBroadcastersCommentColor();
int PS4_SYSV_ABI sceUserServiceGetGlsBroadcastService();
int PS4_SYSV_ABI sceUserServiceGetGlsBroadcastUiLayout();
int PS4_SYSV_ABI sceUserServiceGetGlsCamCrop();
int PS4_SYSV_ABI sceUserServiceGetGlsCameraBgFilter();
int PS4_SYSV_ABI sceUserServiceGetGlsCameraBrightness();
int PS4_SYSV_ABI sceUserServiceGetGlsCameraChromaKeyLevel();
int PS4_SYSV_ABI sceUserServiceGetGlsCameraContrast();
int PS4_SYSV_ABI sceUserServiceGetGlsCameraDepthLevel();
int PS4_SYSV_ABI sceUserServiceGetGlsCameraEdgeLevel();
int PS4_SYSV_ABI sceUserServiceGetGlsCameraEffect();
int PS4_SYSV_ABI sceUserServiceGetGlsCameraEliminationLevel();
int PS4_SYSV_ABI sceUserServiceGetGlsCameraPosition();
int PS4_SYSV_ABI sceUserServiceGetGlsCameraReflection();
int PS4_SYSV_ABI sceUserServiceGetGlsCameraSize();
int PS4_SYSV_ABI sceUserServiceGetGlsCameraTransparency();
int PS4_SYSV_ABI sceUserServiceGetGlsCommunityId();
int PS4_SYSV_ABI sceUserServiceGetGlsFloatingMessage();
int PS4_SYSV_ABI sceUserServiceGetGlsHintFlag();
int PS4_SYSV_ABI sceUserServiceGetGlsInitSpectating();
int PS4_SYSV_ABI sceUserServiceGetGlsIsCameraHidden();
int PS4_SYSV_ABI sceUserServiceGetGlsIsFacebookEnabled();
int PS4_SYSV_ABI sceUserServiceGetGlsIsMuteEnabled();
int PS4_SYSV_ABI sceUserServiceGetGlsIsRecDisabled();
int PS4_SYSV_ABI sceUserServiceGetGlsIsRecievedMessageHidden();
int PS4_SYSV_ABI sceUserServiceGetGlsIsTwitterEnabled();
int PS4_SYSV_ABI sceUserServiceGetGlsLanguageFilter();
int PS4_SYSV_ABI sceUserServiceGetGlsLfpsSortOrder();
int PS4_SYSV_ABI sceUserServiceGetGlsLiveQuality();
int PS4_SYSV_ABI sceUserServiceGetGlsLiveQuality2();
int PS4_SYSV_ABI sceUserServiceGetGlsLiveQuality3();
int PS4_SYSV_ABI sceUserServiceGetGlsLiveQuality4();
int PS4_SYSV_ABI sceUserServiceGetGlsLiveQuality5();
int PS4_SYSV_ABI sceUserServiceGetGlsMessageFilterLevel();
int PS4_SYSV_ABI sceUserServiceGetGlsTtsFlags();
int PS4_SYSV_ABI sceUserServiceGetGlsTtsPitch();
int PS4_SYSV_ABI sceUserServiceGetGlsTtsSpeed();
int PS4_SYSV_ABI sceUserServiceGetGlsTtsVolume();
int PS4_SYSV_ABI sceUserServiceGetHmuBrightness();
int PS4_SYSV_ABI sceUserServiceGetHmuZoom();
int PS4_SYSV_ABI sceUserServiceGetHoldAudioOutDevice();
int PS4_SYSV_ABI sceUserServiceGetHomeDirectory();
int PS4_SYSV_ABI sceUserServiceGetImeAutoCapitalEnabled();
int PS4_SYSV_ABI sceUserServiceGetImeInitFlag();
int PS4_SYSV_ABI sceUserServiceGetImeInputType();
int PS4_SYSV_ABI sceUserServiceGetImeLastUnit();
int PS4_SYSV_ABI sceUserServiceGetImePointerMode();
int PS4_SYSV_ABI sceUserServiceGetImePredictiveTextEnabled();
int PS4_SYSV_ABI sceUserServiceGetImeRunCount();
s32 PS4_SYSV_ABI sceUserServiceGetInitialUser(int* user_id);
int PS4_SYSV_ABI sceUserServiceGetIPDLeft();
int PS4_SYSV_ABI sceUserServiceGetIPDRight();
int PS4_SYSV_ABI sceUserServiceGetIsFakePlus();
int PS4_SYSV_ABI sceUserServiceGetIsQuickSignup();
int PS4_SYSV_ABI sceUserServiceGetIsRemotePlayAllowed();
int PS4_SYSV_ABI sceUserServiceGetJapaneseInputType();
int PS4_SYSV_ABI sceUserServiceGetKeyboardType();
int PS4_SYSV_ABI sceUserServiceGetKeyRepeatSpeed();
int PS4_SYSV_ABI sceUserServiceGetKeyRepeatStartingTime();
int PS4_SYSV_ABI sceUserServiceGetKratosPrimaryUser();
int PS4_SYSV_ABI sceUserServiceGetLastLoginOrder();
int PS4_SYSV_ABI sceUserServiceGetLightBarBaseBrightness();
int PS4_SYSV_ABI sceUserServiceGetLoginFlag();
s32 PS4_SYSV_ABI sceUserServiceGetLoginUserIdList(OrbisUserServiceLoginUserIdList* userIdList);
int PS4_SYSV_ABI sceUserServiceGetMicLevel();
int PS4_SYSV_ABI sceUserServiceGetMouseHandType();
int PS4_SYSV_ABI sceUserServiceGetMousePointerSpeed();
int PS4_SYSV_ABI sceUserServiceGetNotificationBehavior();
int PS4_SYSV_ABI sceUserServiceGetNotificationSettings();
int PS4_SYSV_ABI sceUserServiceGetNpAccountId();
int PS4_SYSV_ABI sceUserServiceGetNpAccountUpgradeFlag();
int PS4_SYSV_ABI sceUserServiceGetNpAge();
int PS4_SYSV_ABI sceUserServiceGetNpAuthErrorFlag();
int PS4_SYSV_ABI sceUserServiceGetNpCountryCode();
int PS4_SYSV_ABI sceUserServiceGetNpDateOfBirth();
int PS4_SYSV_ABI sceUserServiceGetNpEnv();
int PS4_SYSV_ABI sceUserServiceGetNpLanguageCode();
int PS4_SYSV_ABI sceUserServiceGetNpLanguageCode2();
int PS4_SYSV_ABI sceUserServiceGetNpLoginId();
int PS4_SYSV_ABI sceUserServiceGetNpMAccountId();
int PS4_SYSV_ABI sceUserServiceGetNpNpId();
int PS4_SYSV_ABI sceUserServiceGetNpOfflineAccountAdult();
int PS4_SYSV_ABI sceUserServiceGetNpOfflineAccountId();
int PS4_SYSV_ABI sceUserServiceGetNpOnlineId();
int PS4_SYSV_ABI sceUserServiceGetNpSubAccount();
int PS4_SYSV_ABI sceUserServiceGetPadSpeakerVolume();
int PS4_SYSV_ABI sceUserServiceGetParentalBdAge();
int PS4_SYSV_ABI sceUserServiceGetParentalBrowser();
int PS4_SYSV_ABI sceUserServiceGetParentalDvd();
int PS4_SYSV_ABI sceUserServiceGetParentalDvdRegion();
int PS4_SYSV_ABI sceUserServiceGetParentalGame();
int PS4_SYSV_ABI sceUserServiceGetParentalGameAgeLevel();
int PS4_SYSV_ABI sceUserServiceGetParentalMorpheus();
int PS4_SYSV_ABI sceUserServiceGetPartyMuteList();
int PS4_SYSV_ABI sceUserServiceGetPartyMuteListA();
int PS4_SYSV_ABI sceUserServiceGetPartySettingFlags();
int PS4_SYSV_ABI sceUserServiceGetPasscode();
int PS4_SYSV_ABI sceUserServiceGetPbtcAdditionalTime();
int PS4_SYSV_ABI sceUserServiceGetPbtcFlag();
int PS4_SYSV_ABI sceUserServiceGetPbtcFridayDuration();
int PS4_SYSV_ABI sceUserServiceGetPbtcFridayHoursEnd();
int PS4_SYSV_ABI sceUserServiceGetPbtcFridayHoursStart();
int PS4_SYSV_ABI sceUserServiceGetPbtcMode();
int PS4_SYSV_ABI sceUserServiceGetPbtcMondayDuration();
int PS4_SYSV_ABI sceUserServiceGetPbtcMondayHoursEnd();
int PS4_SYSV_ABI sceUserServiceGetPbtcMondayHoursStart();
int PS4_SYSV_ABI sceUserServiceGetPbtcPlayTime();
int PS4_SYSV_ABI sceUserServiceGetPbtcPlayTimeLastUpdated();
int PS4_SYSV_ABI sceUserServiceGetPbtcSaturdayDuration();
int PS4_SYSV_ABI sceUserServiceGetPbtcSaturdayHoursEnd();
int PS4_SYSV_ABI sceUserServiceGetPbtcSaturdayHoursStart();
int PS4_SYSV_ABI sceUserServiceGetPbtcSundayDuration();
int PS4_SYSV_ABI sceUserServiceGetPbtcSundayHoursEnd();
int PS4_SYSV_ABI sceUserServiceGetPbtcSundayHoursStart();
int PS4_SYSV_ABI sceUserServiceGetPbtcThursdayDuration();
int PS4_SYSV_ABI sceUserServiceGetPbtcThursdayHoursEnd();
int PS4_SYSV_ABI sceUserServiceGetPbtcThursdayHoursStart();
int PS4_SYSV_ABI sceUserServiceGetPbtcTuesdayDuration();
int PS4_SYSV_ABI sceUserServiceGetPbtcTuesdayHoursEnd();
int PS4_SYSV_ABI sceUserServiceGetPbtcTuesdayHoursStart();
int PS4_SYSV_ABI sceUserServiceGetPbtcTzOffset();
int PS4_SYSV_ABI sceUserServiceGetPbtcWednesdayDuration();
int PS4_SYSV_ABI sceUserServiceGetPbtcWednesdayHoursEnd();
int PS4_SYSV_ABI sceUserServiceGetPbtcWednesdayHoursStart();
int PS4_SYSV_ABI sceUserServiceGetPlayTogetherFlags();
int PS4_SYSV_ABI sceUserServiceGetPsnPasswordForDebug();
int PS4_SYSV_ABI sceUserServiceGetRegisteredHomeUserIdList();
int PS4_SYSV_ABI sceUserServiceGetRegisteredUserIdList();
int PS4_SYSV_ABI sceUserServiceGetSaveDataAutoUpload();
int PS4_SYSV_ABI sceUserServiceGetSaveDataSort();
int PS4_SYSV_ABI sceUserServiceGetSaveDataTutorialFlag();
int PS4_SYSV_ABI sceUserServiceGetSecureHomeDirectory();
int PS4_SYSV_ABI sceUserServiceGetShareButtonAssign();
int PS4_SYSV_ABI sceUserServiceGetShareDailymotionAccessToken();
int PS4_SYSV_ABI sceUserServiceGetShareDailymotionRefreshToken();
int PS4_SYSV_ABI sceUserServiceGetSharePlayFlags();
int PS4_SYSV_ABI sceUserServiceGetSharePlayFramerateHost();
int PS4_SYSV_ABI sceUserServiceGetSharePlayResolutionHost();
int PS4_SYSV_ABI sceUserServiceGetShareStatus();
int PS4_SYSV_ABI sceUserServiceGetShareStatus2();
int PS4_SYSV_ABI sceUserServiceGetSystemLoggerHashedAccountId();
int PS4_SYSV_ABI sceUserServiceGetSystemLoggerHashedAccountIdClockType();
int PS4_SYSV_ABI sceUserServiceGetSystemLoggerHashedAccountIdParam();
int PS4_SYSV_ABI sceUserServiceGetSystemLoggerHashedAccountIdTtl();
int PS4_SYSV_ABI sceUserServiceGetTeamShowAboutTeam();
int PS4_SYSV_ABI sceUserServiceGetThemeBgImageDimmer();
int PS4_SYSV_ABI sceUserServiceGetThemeBgImageWaveColor();
int PS4_SYSV_ABI sceUserServiceGetThemeBgImageZoom();
int PS4_SYSV_ABI sceUserServiceGetThemeEntitlementId();
int PS4_SYSV_ABI sceUserServiceGetThemeHomeShareOwner();
int PS4_SYSV_ABI sceUserServiceGetThemeTextShadow();
int PS4_SYSV_ABI sceUserServiceGetThemeWaveColor();
int PS4_SYSV_ABI sceUserServiceGetTopMenuLimitItem();
int PS4_SYSV_ABI sceUserServiceGetTopMenuNotificationFlag();
int PS4_SYSV_ABI sceUserServiceGetTopMenuTutorialFlag();
int PS4_SYSV_ABI sceUserServiceGetTraditionalChineseInputType();
s32 PS4_SYSV_ABI sceUserServiceGetUserColor(int user_id, int* color);
int PS4_SYSV_ABI sceUserServiceGetUserGroupName();
int PS4_SYSV_ABI sceUserServiceGetUserGroupNameList();
int PS4_SYSV_ABI sceUserServiceGetUserGroupNum();
s32 PS4_SYSV_ABI sceUserServiceGetUserName(int user_id, char* user_name, std::size_t size);
int PS4_SYSV_ABI sceUserServiceGetUserStatus();
int PS4_SYSV_ABI sceUserServiceGetVibrationEnabled();
int PS4_SYSV_ABI sceUserServiceGetVoiceRecognitionLastUsedOsk();
int PS4_SYSV_ABI sceUserServiceGetVoiceRecognitionTutorialState();
int PS4_SYSV_ABI sceUserServiceGetVolumeForController();
int PS4_SYSV_ABI sceUserServiceGetVolumeForGenericUSB();
int PS4_SYSV_ABI sceUserServiceGetVolumeForMorpheusSidetone();
int PS4_SYSV_ABI sceUserServiceGetVolumeForSidetone();
s32 PS4_SYSV_ABI sceUserServiceInitialize(const OrbisUserServiceInitializeParams* initParams);
int PS4_SYSV_ABI sceUserServiceInitialize2();
int PS4_SYSV_ABI sceUserServiceIsGuestUser();
int PS4_SYSV_ABI sceUserServiceIsKratosPrimaryUser();
int PS4_SYSV_ABI sceUserServiceIsKratosUser();
int PS4_SYSV_ABI sceUserServiceIsLoggedIn();
int PS4_SYSV_ABI sceUserServiceIsLoggedInWithoutLock();
int PS4_SYSV_ABI sceUserServiceIsSharePlayClientUser();
int PS4_SYSV_ABI sceUserServiceIsUserStorageAccountBound();
int PS4_SYSV_ABI sceUserServiceLogin();
int PS4_SYSV_ABI sceUserServiceLogout();
int PS4_SYSV_ABI sceUserServiceRegisterEventCallback();
int PS4_SYSV_ABI sceUserServiceSetAccessibilityKeyremapData();
int PS4_SYSV_ABI sceUserServiceSetAccessibilityKeyremapEnable();
int PS4_SYSV_ABI sceUserServiceSetAccessibilityZoom();
int PS4_SYSV_ABI sceUserServiceSetAccountRemarks();
int PS4_SYSV_ABI sceUserServiceSetAgeVerified();
int PS4_SYSV_ABI sceUserServiceSetAppearOfflineSetting();
int PS4_SYSV_ABI sceUserServiceSetAppSortOrder();
int PS4_SYSV_ABI sceUserServiceSetAutoLoginEnabled();
int PS4_SYSV_ABI sceUserServiceSetCreatedVersion();
int PS4_SYSV_ABI sceUserServiceSetDiscPlayerFlag();
int PS4_SYSV_ABI sceUserServiceSetEventCalendarType();
int PS4_SYSV_ABI sceUserServiceSetEventFilterTeamEvent();
int PS4_SYSV_ABI sceUserServiceSetEventSortEvent();
int PS4_SYSV_ABI sceUserServiceSetEventSortTitle();
int PS4_SYSV_ABI sceUserServiceSetEventUiFlag();
int PS4_SYSV_ABI sceUserServiceSetFaceRecognitionDeleteCount();
int PS4_SYSV_ABI sceUserServiceSetFaceRecognitionRegisterCount();
int PS4_SYSV_ABI sceUserServiceSetFileBrowserFilter();
int PS4_SYSV_ABI sceUserServiceSetFileBrowserSortContent();
int PS4_SYSV_ABI sceUserServiceSetFileBrowserSortTitle();
int PS4_SYSV_ABI sceUserServiceSetFileSelectorFilter();
int PS4_SYSV_ABI sceUserServiceSetFileSelectorSortContent();
int PS4_SYSV_ABI sceUserServiceSetFileSelectorSortTitle();
int PS4_SYSV_ABI sceUserServiceSetForegroundUser();
int PS4_SYSV_ABI sceUserServiceSetFriendCustomListLastFocus();
int PS4_SYSV_ABI sceUserServiceSetFriendFlag();
int PS4_SYSV_ABI sceUserServiceSetGlsAccessTokenNiconicoLive();
int PS4_SYSV_ABI sceUserServiceSetGlsAccessTokenTwitch();
int PS4_SYSV_ABI sceUserServiceSetGlsAccessTokenUstream();
int PS4_SYSV_ABI sceUserServiceSetGlsAnonymousUserId();
int PS4_SYSV_ABI sceUserServiceSetGlsBcTags();
int PS4_SYSV_ABI sceUserServiceSetGlsBcTitle();
int PS4_SYSV_ABI sceUserServiceSetGlsBroadcastChannel();
int PS4_SYSV_ABI sceUserServiceSetGlsBroadcastersComment();
int PS4_SYSV_ABI sceUserServiceSetGlsBroadcastersCommentColor();
int PS4_SYSV_ABI sceUserServiceSetGlsBroadcastService();
int PS4_SYSV_ABI sceUserServiceSetGlsBroadcastUiLayout();
int PS4_SYSV_ABI sceUserServiceSetGlsCamCrop();
int PS4_SYSV_ABI sceUserServiceSetGlsCameraBgFilter();
int PS4_SYSV_ABI sceUserServiceSetGlsCameraBrightness();
int PS4_SYSV_ABI sceUserServiceSetGlsCameraChromaKeyLevel();
int PS4_SYSV_ABI sceUserServiceSetGlsCameraContrast();
int PS4_SYSV_ABI sceUserServiceSetGlsCameraDepthLevel();
int PS4_SYSV_ABI sceUserServiceSetGlsCameraEdgeLevel();
int PS4_SYSV_ABI sceUserServiceSetGlsCameraEffect();
int PS4_SYSV_ABI sceUserServiceSetGlsCameraEliminationLevel();
int PS4_SYSV_ABI sceUserServiceSetGlsCameraPosition();
int PS4_SYSV_ABI sceUserServiceSetGlsCameraReflection();
int PS4_SYSV_ABI sceUserServiceSetGlsCameraSize();
int PS4_SYSV_ABI sceUserServiceSetGlsCameraTransparency();
int PS4_SYSV_ABI sceUserServiceSetGlsCommunityId();
int PS4_SYSV_ABI sceUserServiceSetGlsFloatingMessage();
int PS4_SYSV_ABI sceUserServiceSetGlsHintFlag();
int PS4_SYSV_ABI sceUserServiceSetGlsInitSpectating();
int PS4_SYSV_ABI sceUserServiceSetGlsIsCameraHidden();
int PS4_SYSV_ABI sceUserServiceSetGlsIsFacebookEnabled();
int PS4_SYSV_ABI sceUserServiceSetGlsIsMuteEnabled();
int PS4_SYSV_ABI sceUserServiceSetGlsIsRecDisabled();
int PS4_SYSV_ABI sceUserServiceSetGlsIsRecievedMessageHidden();
int PS4_SYSV_ABI sceUserServiceSetGlsIsTwitterEnabled();
int PS4_SYSV_ABI sceUserServiceSetGlsLanguageFilter();
int PS4_SYSV_ABI sceUserServiceSetGlsLfpsSortOrder();
int PS4_SYSV_ABI sceUserServiceSetGlsLiveQuality();
int PS4_SYSV_ABI sceUserServiceSetGlsLiveQuality2();
int PS4_SYSV_ABI sceUserServiceSetGlsLiveQuality3();
int PS4_SYSV_ABI sceUserServiceSetGlsLiveQuality4();
int PS4_SYSV_ABI sceUserServiceSetGlsLiveQuality5();
int PS4_SYSV_ABI sceUserServiceSetGlsMessageFilterLevel();
int PS4_SYSV_ABI sceUserServiceSetGlsTtsFlags();
int PS4_SYSV_ABI sceUserServiceSetGlsTtsPitch();
int PS4_SYSV_ABI sceUserServiceSetGlsTtsSpeed();
int PS4_SYSV_ABI sceUserServiceSetGlsTtsVolume();
int PS4_SYSV_ABI sceUserServiceSetHmuBrightness();
int PS4_SYSV_ABI sceUserServiceSetHmuZoom();
int PS4_SYSV_ABI sceUserServiceSetHoldAudioOutDevice();
int PS4_SYSV_ABI sceUserServiceSetImeAutoCapitalEnabled();
int PS4_SYSV_ABI sceUserServiceSetImeInitFlag();
int PS4_SYSV_ABI sceUserServiceSetImeInputType();
int PS4_SYSV_ABI sceUserServiceSetImeLastUnit();
int PS4_SYSV_ABI sceUserServiceSetImePointerMode();
int PS4_SYSV_ABI sceUserServiceSetImePredictiveTextEnabled();
int PS4_SYSV_ABI sceUserServiceSetImeRunCount();
int PS4_SYSV_ABI sceUserServiceSetIPDLeft();
int PS4_SYSV_ABI sceUserServiceSetIPDRight();
int PS4_SYSV_ABI sceUserServiceSetIsFakePlus();
int PS4_SYSV_ABI sceUserServiceSetIsQuickSignup();
int PS4_SYSV_ABI sceUserServiceSetIsRemotePlayAllowed();
int PS4_SYSV_ABI sceUserServiceSetJapaneseInputType();
int PS4_SYSV_ABI sceUserServiceSetKeyboardType();
int PS4_SYSV_ABI sceUserServiceSetKeyRepeatSpeed();
int PS4_SYSV_ABI sceUserServiceSetKeyRepeatStartingTime();
int PS4_SYSV_ABI sceUserServiceSetLightBarBaseBrightness();
int PS4_SYSV_ABI sceUserServiceSetLoginFlag();
int PS4_SYSV_ABI sceUserServiceSetMicLevel();
int PS4_SYSV_ABI sceUserServiceSetMouseHandType();
int PS4_SYSV_ABI sceUserServiceSetMousePointerSpeed();
int PS4_SYSV_ABI sceUserServiceSetNotificationBehavior();
int PS4_SYSV_ABI sceUserServiceSetNotificationSettings();
int PS4_SYSV_ABI sceUserServiceSetNpAccountUpgradeFlag();
int PS4_SYSV_ABI sceUserServiceSetNpAge();
int PS4_SYSV_ABI sceUserServiceSetNpAuthErrorFlag();
int PS4_SYSV_ABI sceUserServiceSetNpCountryCode();
int PS4_SYSV_ABI sceUserServiceSetNpDateOfBirth();
int PS4_SYSV_ABI sceUserServiceSetNpEnv();
int PS4_SYSV_ABI sceUserServiceSetNpLanguageCode();
int PS4_SYSV_ABI sceUserServiceSetNpLanguageCode2();
int PS4_SYSV_ABI sceUserServiceSetNpLoginId();
int PS4_SYSV_ABI sceUserServiceSetNpMAccountId();
int PS4_SYSV_ABI sceUserServiceSetNpNpId();
int PS4_SYSV_ABI sceUserServiceSetNpOfflineAccountAdult();
int PS4_SYSV_ABI sceUserServiceSetNpOnlineId();
int PS4_SYSV_ABI sceUserServiceSetNpSubAccount();
int PS4_SYSV_ABI sceUserServiceSetPadSpeakerVolume();
int PS4_SYSV_ABI sceUserServiceSetParentalBdAge();
int PS4_SYSV_ABI sceUserServiceSetParentalBrowser();
int PS4_SYSV_ABI sceUserServiceSetParentalDvd();
int PS4_SYSV_ABI sceUserServiceSetParentalDvdRegion();
int PS4_SYSV_ABI sceUserServiceSetParentalGame();
int PS4_SYSV_ABI sceUserServiceSetParentalGameAgeLevel();
int PS4_SYSV_ABI sceUserServiceSetParentalMorpheus();
int PS4_SYSV_ABI sceUserServiceSetPartyMuteList();
int PS4_SYSV_ABI sceUserServiceSetPartyMuteListA();
int PS4_SYSV_ABI sceUserServiceSetPartySettingFlags();
int PS4_SYSV_ABI sceUserServiceSetPasscode();
int PS4_SYSV_ABI sceUserServiceSetPbtcAdditionalTime();
int PS4_SYSV_ABI sceUserServiceSetPbtcFlag();
int PS4_SYSV_ABI sceUserServiceSetPbtcFridayDuration();
int PS4_SYSV_ABI sceUserServiceSetPbtcFridayHoursEnd();
int PS4_SYSV_ABI sceUserServiceSetPbtcFridayHoursStart();
int PS4_SYSV_ABI sceUserServiceSetPbtcMode();
int PS4_SYSV_ABI sceUserServiceSetPbtcMondayDuration();
int PS4_SYSV_ABI sceUserServiceSetPbtcMondayHoursEnd();
int PS4_SYSV_ABI sceUserServiceSetPbtcMondayHoursStart();
int PS4_SYSV_ABI sceUserServiceSetPbtcPlayTime();
int PS4_SYSV_ABI sceUserServiceSetPbtcPlayTimeLastUpdated();
int PS4_SYSV_ABI sceUserServiceSetPbtcSaturdayDuration();
int PS4_SYSV_ABI sceUserServiceSetPbtcSaturdayHoursEnd();
int PS4_SYSV_ABI sceUserServiceSetPbtcSaturdayHoursStart();
int PS4_SYSV_ABI sceUserServiceSetPbtcSundayDuration();
int PS4_SYSV_ABI sceUserServiceSetPbtcSundayHoursEnd();
int PS4_SYSV_ABI sceUserServiceSetPbtcSundayHoursStart();
int PS4_SYSV_ABI sceUserServiceSetPbtcThursdayDuration();
int PS4_SYSV_ABI sceUserServiceSetPbtcThursdayHoursEnd();
int PS4_SYSV_ABI sceUserServiceSetPbtcThursdayHoursStart();
int PS4_SYSV_ABI sceUserServiceSetPbtcTuesdayDuration();
int PS4_SYSV_ABI sceUserServiceSetPbtcTuesdayHoursEnd();
int PS4_SYSV_ABI sceUserServiceSetPbtcTuesdayHoursStart();
int PS4_SYSV_ABI sceUserServiceSetPbtcTzOffset();
int PS4_SYSV_ABI sceUserServiceSetPbtcWednesdayDuration();
int PS4_SYSV_ABI sceUserServiceSetPbtcWednesdayHoursEnd();
int PS4_SYSV_ABI sceUserServiceSetPbtcWednesdayHoursStart();
int PS4_SYSV_ABI sceUserServiceSetPlayTogetherFlags();
int PS4_SYSV_ABI sceUserServiceSetPsnPasswordForDebug();
int PS4_SYSV_ABI sceUserServiceSetSaveDataAutoUpload();
int PS4_SYSV_ABI sceUserServiceSetSaveDataSort();
int PS4_SYSV_ABI sceUserServiceSetSaveDataTutorialFlag();
int PS4_SYSV_ABI sceUserServiceSetShareButtonAssign();
int PS4_SYSV_ABI sceUserServiceSetShareDailymotionAccessToken();
int PS4_SYSV_ABI sceUserServiceSetShareDailymotionRefreshToken();
int PS4_SYSV_ABI sceUserServiceSetSharePlayFlags();
int PS4_SYSV_ABI sceUserServiceSetSharePlayFramerateHost();
int PS4_SYSV_ABI sceUserServiceSetSharePlayResolutionHost();
int PS4_SYSV_ABI sceUserServiceSetShareStatus();
int PS4_SYSV_ABI sceUserServiceSetShareStatus2();
int PS4_SYSV_ABI sceUserServiceSetSystemLoggerHashedAccountId();
int PS4_SYSV_ABI sceUserServiceSetSystemLoggerHashedAccountIdClockType();
int PS4_SYSV_ABI sceUserServiceSetSystemLoggerHashedAccountIdParam();
int PS4_SYSV_ABI sceUserServiceSetSystemLoggerHashedAccountIdTtl();
int PS4_SYSV_ABI sceUserServiceSetTeamShowAboutTeam();
int PS4_SYSV_ABI sceUserServiceSetThemeBgImageDimmer();
int PS4_SYSV_ABI sceUserServiceSetThemeBgImageWaveColor();
int PS4_SYSV_ABI sceUserServiceSetThemeBgImageZoom();
int PS4_SYSV_ABI sceUserServiceSetThemeEntitlementId();
int PS4_SYSV_ABI sceUserServiceSetThemeHomeShareOwner();
int PS4_SYSV_ABI sceUserServiceSetThemeTextShadow();
int PS4_SYSV_ABI sceUserServiceSetThemeWaveColor();
int PS4_SYSV_ABI sceUserServiceSetTopMenuLimitItem();
int PS4_SYSV_ABI sceUserServiceSetTopMenuNotificationFlag();
int PS4_SYSV_ABI sceUserServiceSetTopMenuTutorialFlag();
int PS4_SYSV_ABI sceUserServiceSetTraditionalChineseInputType();
int PS4_SYSV_ABI sceUserServiceSetUserGroupIndex();
int PS4_SYSV_ABI sceUserServiceSetUserGroupName();
int PS4_SYSV_ABI sceUserServiceSetUserName();
int PS4_SYSV_ABI sceUserServiceSetUserStatus();
int PS4_SYSV_ABI sceUserServiceSetVibrationEnabled();
int PS4_SYSV_ABI sceUserServiceSetVoiceRecognitionLastUsedOsk();
int PS4_SYSV_ABI sceUserServiceSetVoiceRecognitionTutorialState();
int PS4_SYSV_ABI sceUserServiceSetVolumeForController();
int PS4_SYSV_ABI sceUserServiceSetVolumeForGenericUSB();
int PS4_SYSV_ABI sceUserServiceSetVolumeForMorpheusSidetone();
int PS4_SYSV_ABI sceUserServiceSetVolumeForSidetone();
int PS4_SYSV_ABI sceUserServiceTerminate();
int PS4_SYSV_ABI sceUserServiceUnregisterEventCallback();
int PS4_SYSV_ABI Func_8AC6DC4168D5FEA5();
int PS4_SYSV_ABI Func_A6BDC9DFDAFD02B4();
int PS4_SYSV_ABI Func_BB9491DFE6B4953C();
int PS4_SYSV_ABI Func_D2B814603E7B4477();
void RegisterlibSceUserService(Core::Loader::SymbolsResolver* sym);
} // namespace Libraries::UserService
| 25,199
|
C++
|
.h
| 470
| 52.489362
| 95
| 0.863802
|
shadps4-emu/shadPS4
| 9,253
| 501
| 185
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
15,824
|
msgdialog_ui.h
|
shadps4-emu_shadPS4/src/core/libraries/system/msgdialog_ui.h
|
// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
#pragma once
#include <string>
#include <variant>
#include "common/fixed_value.h"
#include "common/types.h"
#include "core/libraries/system/commondialog.h"
#include "imgui/imgui_layer.h"
namespace Libraries::MsgDialog {
using OrbisUserServiceUserId = s32;
enum class MsgDialogMode : u32 {
USER_MSG = 1,
PROGRESS_BAR = 2,
SYSTEM_MSG = 3,
};
enum class ButtonId : u32 {
INVALID = 0,
OK = 1,
YES = 1,
NO = 2,
BUTTON1 = 1,
BUTTON2 = 2,
};
enum class ButtonType : u32 {
OK = 0,
YESNO = 1,
NONE = 2,
OK_CANCEL = 3,
WAIT = 5,
WAIT_CANCEL = 6,
YESNO_FOCUS_NO = 7,
OK_CANCEL_FOCUS_CANCEL = 8,
TWO_BUTTONS = 9,
};
enum class ProgressBarType : u32 {
PERCENTAGE = 0,
PERCENTAGE_CANCEL = 1,
};
enum class SystemMessageType : u32 {
TRC_EMPTY_STORE = 0,
TRC_PSN_CHAT_RESTRICTION = 1,
TRC_PSN_UGC_RESTRICTION = 2,
CAMERA_NOT_CONNECTED = 4,
WARNING_PROFILE_PICTURE_AND_NAME_NOT_SHARED = 5,
};
enum class OrbisMsgDialogProgressBarTarget : u32 {
DEFAULT = 0,
};
struct ButtonsParam {
const char* msg1{};
const char* msg2{};
std::array<char, 32> reserved{};
};
struct UserMessageParam {
ButtonType buttonType{};
s32 : 32;
const char* msg{};
ButtonsParam* buttonsParam{};
std::array<char, 24> reserved{};
};
struct ProgressBarParam {
ProgressBarType barType{};
s32 : 32;
const char* msg{};
std::array<char, 64> reserved{};
};
struct SystemMessageParam {
SystemMessageType sysMsgType{};
std::array<char, 32> reserved{};
};
struct OrbisParam {
CommonDialog::BaseParam baseParam;
std::size_t size;
MsgDialogMode mode;
s32 : 32;
UserMessageParam* userMsgParam;
ProgressBarParam* progBarParam;
SystemMessageParam* sysMsgParam;
OrbisUserServiceUserId userId;
std::array<char, 40> reserved;
s32 : 32;
};
struct DialogResult {
FixedValue<u32, 0> mode{};
CommonDialog::Result result{CommonDialog::Result::OK};
ButtonId buttonId{ButtonId::INVALID};
std::array<char, 32> reserved{};
};
// State is used to copy all the data from the param struct
class MsgDialogState {
public:
struct UserState {
ButtonType type{};
std::string msg{};
std::string btn_param1{};
std::string btn_param2{};
};
struct ProgressState {
ProgressBarType type{};
std::string msg{};
u32 progress{};
};
struct SystemState {
SystemMessageType type{};
};
private:
OrbisUserServiceUserId user_id{};
MsgDialogMode mode{};
std::variant<UserState, ProgressState, SystemState, std::monostate> state{std::monostate{}};
public:
explicit MsgDialogState(const OrbisParam& param);
explicit MsgDialogState(UserState mode);
explicit MsgDialogState(ProgressState mode);
explicit MsgDialogState(SystemState mode);
MsgDialogState() = default;
[[nodiscard]] OrbisUserServiceUserId GetUserId() const {
return user_id;
}
[[nodiscard]] MsgDialogMode GetMode() const {
return mode;
}
template <typename T>
[[nodiscard]] T& GetState() {
return std::get<T>(state);
}
};
class MsgDialogUi final : public ImGui::Layer {
bool first_render{false};
MsgDialogState* state{};
CommonDialog::Status* status{};
DialogResult* result{};
void DrawUser();
void DrawProgressBar();
void DrawSystemMessage();
public:
explicit MsgDialogUi(MsgDialogState* state = nullptr, CommonDialog::Status* status = nullptr,
DialogResult* result = nullptr);
~MsgDialogUi() override;
MsgDialogUi(const MsgDialogUi& other) = delete;
MsgDialogUi(MsgDialogUi&& other) noexcept;
MsgDialogUi& operator=(MsgDialogUi other);
void Finish(ButtonId buttonId, CommonDialog::Result r = CommonDialog::Result::OK);
void Draw() override;
};
// Utility function to show a message dialog
// !!! This function can block !!!
DialogResult ShowMsgDialog(MsgDialogState state, bool block = true);
}; // namespace Libraries::MsgDialog
| 4,207
|
C++
|
.h
| 149
| 23.879195
| 97
| 0.685125
|
shadps4-emu/shadPS4
| 9,253
| 501
| 185
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
15,825
|
msgdialog.h
|
shadps4-emu_shadPS4/src/core/libraries/system/msgdialog.h
|
// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
#pragma once
#include "core/libraries/system/commondialog.h"
namespace Core::Loader {
class SymbolsResolver;
}
namespace Libraries::MsgDialog {
struct DialogResult;
struct OrbisParam;
enum class OrbisMsgDialogProgressBarTarget : u32;
CommonDialog::Error PS4_SYSV_ABI sceMsgDialogClose();
CommonDialog::Error PS4_SYSV_ABI sceMsgDialogGetResult(DialogResult* result);
CommonDialog::Status PS4_SYSV_ABI sceMsgDialogGetStatus();
CommonDialog::Error PS4_SYSV_ABI sceMsgDialogInitialize();
CommonDialog::Error PS4_SYSV_ABI sceMsgDialogOpen(const OrbisParam* param);
CommonDialog::Error PS4_SYSV_ABI sceMsgDialogProgressBarInc(OrbisMsgDialogProgressBarTarget,
u32 delta);
CommonDialog::Error PS4_SYSV_ABI sceMsgDialogProgressBarSetMsg(OrbisMsgDialogProgressBarTarget,
const char* msg);
CommonDialog::Error PS4_SYSV_ABI sceMsgDialogProgressBarSetValue(OrbisMsgDialogProgressBarTarget,
u32 value);
CommonDialog::Error PS4_SYSV_ABI sceMsgDialogTerminate();
CommonDialog::Status PS4_SYSV_ABI sceMsgDialogUpdateStatus();
void RegisterlibSceMsgDialog(Core::Loader::SymbolsResolver* sym);
} // namespace Libraries::MsgDialog
| 1,418
|
C++
|
.h
| 26
| 46.038462
| 97
| 0.737906
|
shadps4-emu/shadPS4
| 9,253
| 501
| 185
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
15,826
|
sysmodule.h
|
shadps4-emu_shadPS4/src/core/libraries/system/sysmodule.h
|
// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
#pragma once
#include "common/types.h"
namespace Core::Loader {
class SymbolsResolver;
}
namespace Libraries::SysModule {
enum class OrbisSysModule : u16 {
ORBIS_SYSMODULE_INVALID = 0x0000,
ORBIS_SYSMODULE_FIBER = 0x0006, // libSceFiber.sprx
ORBIS_SYSMODULE_ULT = 0x0007, // libSceUlt.sprx
ORBIS_SYSMODULE_NGS2 = 0x000B, // libSceNgs2.sprx
ORBIS_SYSMODULE_XML = 0x0017, // libSceXml.sprx
ORBIS_SYSMODULE_NP_UTILITY = 0x0019, // libSceNpUtility.sprx
ORBIS_SYSMODULE_VOICE = 0x001A, // libSceVoice.sprx
ORBIS_SYSMODULE_VOICEQOS = 0x001B, // libSceVoiceQos.sprx
ORBIS_SYSMODULE_NP_MATCHING2 = 0x001C, // libSceNpMatching2.sprx
ORBIS_SYSMODULE_NP_SCORE_RANKING = 0x001E, // libSceNpScoreRanking.sprx
ORBIS_SYSMODULE_RUDP = 0x0021, // libSceRudp.sprx
ORBIS_SYSMODULE_NP_TUS = 0x002C, // libSceNpTus.sprx
ORBIS_SYSMODULE_FACE = 0x0038,
ORBIS_SYSMODULE_SMART = 0x0039,
ORBIS_SYSMODULE_JSON = 0x0080,
ORBIS_SYSMODULE_GAME_LIVE_STREAMING = 0x0081, // libSceGameLiveStreaming.sprx
ORBIS_SYSMODULE_COMPANION_UTIL = 0x0082, // libSceCompanionUtil.sprx
ORBIS_SYSMODULE_PLAYGO = 0x0083, // libScePlayGo.sprx
ORBIS_SYSMODULE_FONT = 0x0084, // libSceFont.sprx
ORBIS_SYSMODULE_VIDEO_RECORDING = 0x0085, // libSceVideoRecording.sprx
ORBIS_SYSMODULE_S3DCONVERSION = 0x0086,
ORBIS_SYSMODULE_AUDIODEC = 0x0088, // libSceAudiodec.sprx
ORBIS_SYSMODULE_JPEG_DEC = 0x008A, // libSceJpegDec.sprx
ORBIS_SYSMODULE_JPEG_ENC = 0x008B, // libSceJpegEnc.sprx
ORBIS_SYSMODULE_PNG_DEC = 0x008C, // libScePngDec.sprx
ORBIS_SYSMODULE_PNG_ENC = 0x008D, // libScePngEnc.sprx
ORBIS_SYSMODULE_VIDEODEC = 0x008E, // libSceVideodec.sprx
ORBIS_SYSMODULE_MOVE = 0x008F, // libSceMove.sprx
ORBIS_SYSMODULE_PAD_TRACKER = 0x0091, // libScePadTracker.sprx
ORBIS_SYSMODULE_DEPTH = 0x0092, // libSceDepth.sprx
ORBIS_SYSMODULE_HAND = 0x0093,
ORBIS_SYSMODULE_LIBIME = 0x0095, // libSceIme.sprx
ORBIS_SYSMODULE_IME_DIALOG = 0x0096, // libSceImeDialog.sprx
ORBIS_SYSMODULE_NP_PARTY = 0x0097, // libSceNpParty.sprx
ORBIS_SYSMODULE_FONT_FT = 0x0098, // libSceFontFt.sprx
ORBIS_SYSMODULE_FREETYPE_OT = 0x0099, // libSceFreeTypeOt.sprx
ORBIS_SYSMODULE_FREETYPE_OL = 0x009A, // libSceFreeTypeOl.sprx
ORBIS_SYSMODULE_FREETYPE_OPT_OL = 0x009B, // libSceFreeTypeOptOl.sprx
ORBIS_SYSMODULE_SCREEN_SHOT = 0x009C, // libSceScreenShot.sprx
ORBIS_SYSMODULE_NP_AUTH = 0x009D, // libSceNpAuth.sprx
ORBIS_SYSMODULE_SULPHA = 0x009F,
ORBIS_SYSMODULE_SAVE_DATA_DIALOG = 0x00A0, // libSceSaveDataDialog.sprx
ORBIS_SYSMODULE_INVITATION_DIALOG = 0x00A2, // libSceInvitationDialog.sprx
ORBIS_SYSMODULE_DEBUG_KEYBOARD = 0x00A3,
ORBIS_SYSMODULE_MESSAGE_DIALOG = 0x00A4, // libSceMsgDialog.sprx
ORBIS_SYSMODULE_AV_PLAYER = 0x00A5, // libSceAvPlayer.sprx
ORBIS_SYSMODULE_CONTENT_EXPORT = 0x00A6, // libSceContentExport.sprx
ORBIS_SYSMODULE_AUDIO_3D = 0x00A7, // libSceAudio3d.sprx
ORBIS_SYSMODULE_NP_COMMERCE = 0x00A8, // libSceNpCommerce.sprx
ORBIS_SYSMODULE_MOUSE = 0x00A9, // libSceMouse.sprx
ORBIS_SYSMODULE_COMPANION_HTTPD = 0x00AA, // libSceCompanionHttpd.sprx
ORBIS_SYSMODULE_WEB_BROWSER_DIALOG = 0x00AB, // libSceWebBrowserDialog.sprx
ORBIS_SYSMODULE_ERROR_DIALOG = 0x00AC, // libSceErrorDialog.sprx
ORBIS_SYSMODULE_NP_TROPHY = 0x00AD, // libSceNpTrophy.sprx
ORBIS_SYSMODULE_VIDEO_CORE_IF = 0x00AE, // libSceVideoCoreInterface.sprx
ORBIS_SYSMODULE_VIDEO_CORE_SERVER_IF = 0x00AF, // libSceVideoCoreServerInterface.sprx
ORBIS_SYSMODULE_NP_SNS_FACEBOOK = 0x00B0, // libSceNpSnsFacebookDialog.sprx
ORBIS_SYSMODULE_MOVE_TRACKER = 0x00B1, // libSceMoveTracker.sprx
ORBIS_SYSMODULE_NP_PROFILE_DIALOG = 0x00B2, // libSceNpProfileDialog.sprx
ORBIS_SYSMODULE_NP_FRIEND_LIST_DIALOG = 0x00B3, // libSceNpFriendListDialog.sprx
ORBIS_SYSMODULE_APP_CONTENT = 0x00B4, // libSceAppContent.sprx
ORBIS_SYSMODULE_NP_SIGNALING = 0x00B5, // libSceNpSignaling.sprx
ORBIS_SYSMODULE_REMOTE_PLAY = 0x00B6, // libSceRemoteplay.sprx
ORBIS_SYSMODULE_USBD = 0x00B7, // libSceUsbd.sprx
ORBIS_SYSMODULE_GAME_CUSTOM_DATA_DIALOG = 0x00B8, // libSceGameCustomDataDialog.sprx
ORBIS_SYSMODULE_NP_EULA_DIALOG = 0x00B9, // libSceNpEulaDialog.sprx
ORBIS_SYSMODULE_RANDOM = 0x00BA, // libSceRandom.sprx
ORBIS_SYSMODULE_RESERVED2 = 0x00BB,
ORBIS_SYSMODULE_M4AAC_ENC = 0x00BC, // libSceM4aacEnc.sprx
ORBIS_SYSMODULE_AUDIODEC_CPU = 0x00BD, // libSceAudiodecCpu.sprx
ORBIS_SYSMODULE_AUDIODEC_CPU_DDP = 0x00BE, // libSceAudiodecCpuDdp.sprx
ORBIS_SYSMODULE_AUDIODEC_CPU_M4AAC = 0x00C0, // libSceAudiodecCpuM4aac.sprx
ORBIS_SYSMODULE_BEMP2_SYS = 0x00C1, // libSceBemp2sys.sprx
ORBIS_SYSMODULE_BEISOBMF = 0x00C2, // libSceBeisobmf.sprx
ORBIS_SYSMODULE_PLAY_READY = 0x00C3, // libScePlayReady.sprx
ORBIS_SYSMODULE_VIDEO_NATIVE_EXT_ESSENTIAL = 0x00C4, // libSceVideoNativeExtEssential.sprx
ORBIS_SYSMODULE_ZLIB = 0x00C5, // libSceZlib.sprx
ORBIS_SYSMODULE_DTCP_IP = 0x00C6, // libSceDtcpIp.sprx
ORBIS_SYSMODULE_CONTENT_SEARCH = 0x00C7, // libSceContentSearch.sprx
ORBIS_SYSMODULE_SHARE_UTILITY = 0x00C8, // libSceShareUtility.sprx
ORBIS_SYSMODULE_AUDIODEC_CPU_DTS_HD_LBR = 0x00C9, // libSceAudiodecCpuDtsHdLbr.sprx
ORBIS_SYSMODULE_DECI4H = 0x00CA,
ORBIS_SYSMODULE_HEAD_TRACKER = 0x00CB,
ORBIS_SYSMODULE_GAME_UPDATE = 0x00CC, // libSceGameUpdate.sprx
ORBIS_SYSMODULE_AUTO_MOUNTER_CLIENT = 0x00CD, // libSceAutoMounterClient.sprx
ORBIS_SYSMODULE_SYSTEM_GESTURE = 0x00CE, // libSceSystemGesture.sprx
ORBIS_SYSMODULE_VIDEODEC2 = 0x00CF,
ORBIS_SYSMODULE_VDECWRAP = 0x00D0, // libSceVdecwrap.sprx
ORBIS_SYSMODULE_AT9_ENC = 0x00D1, // libSceAt9Enc.sprx
ORBIS_SYSMODULE_CONVERT_KEYCODE = 0x00D2, // libSceConvertKeycode.sprx
ORBIS_SYSMODULE_SHARE_PLAY = 0x00D3, // libSceSharePlay.sprx
ORBIS_SYSMODULE_HMD = 0x00D4, // libSceHmd.sprx
ORBIS_SYSMODULE_USB_STORAGE = 0x00D5, // libSceUsbStorage.sprx
ORBIS_SYSMODULE_USB_STORAGE_DIALOG = 0x00D6, // libSceUsbStorageDialog.sprx
ORBIS_SYSMODULE_DISC_MAP = 0x00D7, // libSceDiscMap.sprx
ORBIS_SYSMODULE_FACE_TRACKER = 0x00D8,
ORBIS_SYSMODULE_HAND_TRACKER = 0x00D9,
ORBIS_SYSMODULE_NP_SNS_YOUTUBE_DIALOG = 0x00DA, // libSceNpSnsYouTubeDialog.sprx
ORBIS_SYSMODULE_PROFILE_CACHE_EXTERNAL = 0x00DC, // libSceProfileCacheExternal.sprx
ORBIS_SYSMODULE_MUSIC_PLAYER_SERVICE = 0x00DD, // libSceMusicPlayerService.sprx
ORBIS_SYSMODULE_SP_SYS_CALL_WRAPPER = 0x00DE, // libSceSpSysCallWrapper.sprx
ORBIS_SYSMODULE_PS2_EMU_MENU_DIALOG = 0x00DF, // libScePs2EmuMenuDialog.sprx
ORBIS_SYSMODULE_NP_SNS_DIALYMOTION_DIALOG = 0x00E0, // libSceNpSnsDailyMotionDialog.sprx
ORBIS_SYSMODULE_AUDIODEC_CPU_HEVAG = 0x00E1, // libSceAudiodecCpuHevag.sprx
ORBIS_SYSMODULE_LOGIN_DIALOG = 0x00E2, // libSceLoginDialog.sprx
ORBIS_SYSMODULE_LOGIN_SERVICE = 0x00E3, // libSceLoginService.sprx
ORBIS_SYSMODULE_SIGNIN_DIALOG = 0x00E4, // libSceSigninDialog.sprx
ORBIS_SYSMODULE_VDECSW = 0x00E5, // libSceVdecsw.sprx
ORBIS_SYSMODULE_CUSTOM_MUSIC_CORE = 0x00E6, // libSceCustomMusicCore.sprx
ORBIS_SYSMODULE_JSON2 = 0x00E7, // libSceJson2.sprx
ORBIS_SYSMODULE_AUDIO_LATENCY_ESTIMATION = 0x00E8,
ORBIS_SYSMODULE_WK_FONT_CONFIG = 0x00E9, // libSceWkFontConfig.sprx
ORBIS_SYSMODULE_RESERVED27 = 0x00EA,
ORBIS_SYSMODULE_HMD_SETUP_DIALOG = 0x00EB, // libSceHmdSetupDialog.sprx
ORBIS_SYSMODULE_RESERVED28 = 0x00EC,
ORBIS_SYSMODULE_VR_TRACKER = 0x00ED, // libSceVrTracker.sprx
ORBIS_SYSMODULE_CONTENT_DELETE = 0x00EE, // libSceContentDelete.sprx
ORBIS_SYSMODULE_IME_BACKEND = 0x00EF, // libSceImeBackend.sprx
ORBIS_SYSMODULE_NET_CTL_AP_DIALOG = 0x00F0, // libSceNetCtlApDialog.sprx
ORBIS_SYSMODULE_PLAYGO_DIALOG = 0x00F1, // libScePlayGoDialog.sprx
ORBIS_SYSMODULE_SOCIAL_SCREEN = 0x00F2, // libSceSocialScreen.sprx
ORBIS_SYSMODULE_EDIT_MP4 = 0x00F3, // libSceEditMp4.sprx
ORBIS_SYSMODULE_PSM_KIT_SYSTEM = 0x00F5, // libScePsmKitSystem.sprx
ORBIS_SYSMODULE_TEXT_TO_SPEECH = 0x00F6, // libSceTextToSpeech.sprx
ORBIS_SYSMODULE_NP_TOOLKIT = 0x00F7,
ORBIS_SYSMODULE_CUSTOM_MUSIC_SERVICE = 0x00F8, // libSceCustomMusicService.sprx
ORBIS_SYSMODULE_CL_SYS_CALL_WRAPPER = 0x00F9, // libSceClSysCallWrapper.sprx
ORBIS_SYSMODULE_SYSTEM_LOGGER = 0x00FA, // libSceSystemLogger.sprx
ORBIS_SYSMODULE_BLUETOOTH_HID = 0x00FB, // libSceBluetoothHid.sprx
ORBIS_SYSMODULE_VIDEO_DECODER_ARBITRATION = 0x00FC, // libSceVideoDecoderArbitration.sprx
ORBIS_SYSMODULE_VR_SERVICE_DIALOG = 0x00FD, // libSceVrServiceDialog.sprx
ORBIS_SYSMODULE_JOB_MANAGER = 0x00FE,
ORBIS_SYSMODULE_KEYBOARD = 0x0106,
};
int PS4_SYSV_ABI sceSysmoduleGetModuleHandleInternal();
int PS4_SYSV_ABI sceSysmoduleGetModuleInfoForUnwind();
int PS4_SYSV_ABI sceSysmoduleIsCalledFromSysModule();
int PS4_SYSV_ABI sceSysmoduleIsCameraPreloaded();
int PS4_SYSV_ABI sceSysmoduleIsLoaded();
int PS4_SYSV_ABI sceSysmoduleIsLoadedInternal();
int PS4_SYSV_ABI sceSysmoduleLoadModule(OrbisSysModule id);
int PS4_SYSV_ABI sceSysmoduleLoadModuleByNameInternal();
int PS4_SYSV_ABI sceSysmoduleLoadModuleInternal();
int PS4_SYSV_ABI sceSysmoduleLoadModuleInternalWithArg();
int PS4_SYSV_ABI sceSysmoduleMapLibcForLibkernel();
int PS4_SYSV_ABI sceSysmodulePreloadModuleForLibkernel();
int PS4_SYSV_ABI sceSysmoduleUnloadModule();
int PS4_SYSV_ABI sceSysmoduleUnloadModuleByNameInternal();
int PS4_SYSV_ABI sceSysmoduleUnloadModuleInternal();
int PS4_SYSV_ABI sceSysmoduleUnloadModuleInternalWithArg();
void RegisterlibSceSysmodule(Core::Loader::SymbolsResolver* sym);
} // namespace Libraries::SysModule
| 10,754
|
C++
|
.h
| 161
| 62.447205
| 94
| 0.705271
|
shadps4-emu/shadPS4
| 9,253
| 501
| 185
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
15,827
|
systemservice.h
|
shadps4-emu_shadPS4/src/core/libraries/system/systemservice.h
|
// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
// reference
// https://github.com/OpenOrbis/OpenOrbis-PS4-Toolchain/blob/master/include/orbis/_types/sys_service.h
#pragma once
#include "common/types.h"
namespace Core::Loader {
class SymbolsResolver;
}
namespace Libraries::SystemService {
enum OrbisSystemServiceParamId {
ORBIS_SYSTEM_SERVICE_PARAM_ID_LANG = 1,
ORBIS_SYSTEM_SERVICE_PARAM_ID_DATE_FORMAT = 2,
ORBIS_SYSTEM_SERVICE_PARAM_ID_TIME_FORMAT = 3,
ORBIS_SYSTEM_SERVICE_PARAM_ID_TIME_ZONE = 4,
ORBIS_SYSTEM_SERVICE_PARAM_ID_SUMMERTIME = 5,
ORBIS_SYSTEM_SERVICE_PARAM_ID_SYSTEM_NAME = 6,
ORBIS_SYSTEM_SERVICE_PARAM_ID_GAME_PARENTAL_LEVEL = 7,
ORBIS_SYSTEM_SERVICE_PARAM_ID_ENTER_BUTTON_ASSIGN = 1000
};
enum OrbisSystemParamDateFormat {
ORBIS_SYSTEM_PARAM_DATE_FORMAT_YYYYMMDD = 0,
ORBIS_SYSTEM_PARAM_DATE_FORMAT_DDMMYYYY = 1,
ORBIS_SYSTEM_PARAM_DATE_FORMAT_MMDDYYYY = 2
};
enum OrbisSystemParamTimeFormat {
ORBIS_SYSTEM_PARAM_TIME_FORMAT_12HOUR = 0,
ORBIS_SYSTEM_PARAM_TIME_FORMAT_24HOUR = 1
};
enum OrbisSystemParamGameParentalLevel {
ORBIS_SYSTEM_PARAM_GAME_PARENTAL_OFF = 0,
ORBIS_SYSTEM_PARAM_GAME_PARENTAL_LEVEL01 = 1,
ORBIS_SYSTEM_PARAM_GAME_PARENTAL_LEVEL02 = 2,
ORBIS_SYSTEM_PARAM_GAME_PARENTAL_LEVEL03 = 3,
ORBIS_SYSTEM_PARAM_GAME_PARENTAL_LEVEL04 = 4,
ORBIS_SYSTEM_PARAM_GAME_PARENTAL_LEVEL05 = 5,
ORBIS_SYSTEM_PARAM_GAME_PARENTAL_LEVEL06 = 6,
ORBIS_SYSTEM_PARAM_GAME_PARENTAL_LEVEL07 = 7,
ORBIS_SYSTEM_PARAM_GAME_PARENTAL_LEVEL08 = 8,
ORBIS_SYSTEM_PARAM_GAME_PARENTAL_LEVEL09 = 9,
ORBIS_SYSTEM_PARAM_GAME_PARENTAL_LEVEL10 = 10,
ORBIS_SYSTEM_PARAM_GAME_PARENTAL_LEVEL11 = 11
};
enum OrbisSystemParamEnterButtonAssign {
ORBIS_SYSTEM_PARAM_ENTER_BUTTON_ASSIGN_CIRCLE = 0,
ORBIS_SYSTEM_PARAM_ENTER_BUTTON_ASSIGN_CROSS = 1
};
enum OrbisSystemParamLanguage {
ORBIS_SYSTEM_PARAM_LANG_JAPANESE = 0,
ORBIS_SYSTEM_PARAM_LANG_ENGLISH_US = 1,
ORBIS_SYSTEM_PARAM_LANG_FRENCH = 2,
ORBIS_SYSTEM_PARAM_LANG_SPANISH = 3,
ORBIS_SYSTEM_PARAM_LANG_GERMAN = 4,
ORBIS_SYSTEM_PARAM_LANG_ITALIAN = 5,
ORBIS_SYSTEM_PARAM_LANG_DUTCH = 6,
ORBIS_SYSTEM_PARAM_LANG_PORTUGUESE_PT = 7,
ORBIS_SYSTEM_PARAM_LANG_RUSSIAN = 8,
ORBIS_SYSTEM_PARAM_LANG_KOREAN = 9,
ORBIS_SYSTEM_PARAM_LANG_CHINESE_T = 10,
ORBIS_SYSTEM_PARAM_LANG_CHINESE_S = 11,
ORBIS_SYSTEM_PARAM_LANG_FINNISH = 12,
ORBIS_SYSTEM_PARAM_LANG_SWEDISH = 13,
ORBIS_SYSTEM_PARAM_LANG_DANISH = 14,
ORBIS_SYSTEM_PARAM_LANG_NORWEGIAN = 15,
ORBIS_SYSTEM_PARAM_LANG_POLISH = 16,
ORBIS_SYSTEM_PARAM_LANG_PORTUGUESE_BR = 17,
ORBIS_SYSTEM_PARAM_LANG_ENGLISH_GB = 18,
ORBIS_SYSTEM_PARAM_LANG_TURKISH = 19,
ORBIS_SYSTEM_PARAM_LANG_SPANISH_LA = 20,
ORBIS_SYSTEM_PARAM_LANG_ARABIC = 21,
ORBIS_SYSTEM_PARAM_LANG_FRENCH_CA = 22,
ORBIS_SYSTEM_PARAM_LANG_CZECH = 23,
ORBIS_SYSTEM_PARAM_LANG_HUNGARIAN = 24,
ORBIS_SYSTEM_PARAM_LANG_GREEK = 25,
ORBIS_SYSTEM_PARAM_LANG_ROMANIAN = 26,
ORBIS_SYSTEM_PARAM_LANG_THAI = 27,
ORBIS_SYSTEM_PARAM_LANG_VIETNAMESE = 28,
ORBIS_SYSTEM_PARAM_LANG_INDONESIAN = 29
};
enum OrbisSystemServiceEventType {
ORBIS_SYSTEM_SERVICE_EVENT_INVALID = -1,
ORBIS_SYSTEM_SERVICE_EVENT_ON_RESUME = 0x10000000,
ORBIS_SYSTEM_SERVICE_EVENT_GAME_LIVE_STREAMING_STATUS_UPDATE = 0x10000001,
ORBIS_SYSTEM_SERVICE_EVENT_SESSION_INVITATION = 0x10000002,
ORBIS_SYSTEM_SERVICE_EVENT_ENTITLEMENT_UPDATE = 0x10000003,
ORBIS_SYSTEM_SERVICE_EVENT_GAME_CUSTOM_DATA = 0x10000004,
ORBIS_SYSTEM_SERVICE_EVENT_DISPLAY_SAFE_AREA_UPDATE = 0x10000005,
ORBIS_SYSTEM_SERVICE_EVENT_URL_OPEN = 0x10000006,
ORBIS_SYSTEM_SERVICE_EVENT_LAUNCH_APP = 0x10000007,
ORBIS_SYSTEM_SERVICE_EVENT_APP_LAUNCH_LINK = 0x10000008,
ORBIS_SYSTEM_SERVICE_EVENT_ADDCONTENT_INSTALL = 0x10000009,
ORBIS_SYSTEM_SERVICE_EVENT_RESET_VR_POSITION = 0x1000000a,
ORBIS_SYSTEM_SERVICE_EVENT_JOIN_EVENT = 0x1000000b,
ORBIS_SYSTEM_SERVICE_EVENT_PLAYGO_LOCUS_UPDATE = 0x1000000c,
ORBIS_SYSTEM_SERVICE_EVENT_PLAY_TOGETHER_HOST = 0x1000000d,
ORBIS_SYSTEM_SERVICE_EVENT_SERVICE_ENTITLEMENT_UPDATE = 0x1000000e,
ORBIS_SYSTEM_SERVICE_EVENT_EYE_TO_EYE_DISTANCE_UPDATE = 0x1000000f,
ORBIS_SYSTEM_SERVICE_EVENT_JOIN_MATCH_EVENT = 0x10000010,
ORBIS_SYSTEM_SERVICE_EVENT_PLAY_TOGETHER_HOST_A = 0x10000011,
ORBIS_SYSTEM_SERVICE_EVENT_WEBBROWSER_CLOSED = 0x10000012,
ORBIS_SYSTEM_SERVICE_EVENT_CONTROLLER_SETTINGS_CLOSED = 0x10000013,
ORBIS_SYSTEM_SERVICE_EVENT_JOIN_TEAM_ON_TEAM_MATCH_EVENT = 0x10000014,
ORBIS_SYSTEM_SERVICE_EVENT_OPEN_SHARE_MENU = 0x30000000
};
struct OrbisSystemServiceStatus {
s32 eventNum;
bool isSystemUiOverlaid;
bool isInBackgroundExecution;
bool isCpuMode7CpuNormal;
bool isGameLiveStreamingOnAir;
bool isOutOfVrPlayArea;
u8 reserved[];
};
struct OrbisSystemServiceDisplaySafeAreaInfo {
float ratio;
uint8_t reserved[128];
};
struct OrbisSystemServiceEvent {
OrbisSystemServiceEventType eventType;
union {
char param[8192];
struct {
char source[1024];
char url[4096];
} urlOpen;
struct {
u32 size;
u8 arg[8188];
} launchApp;
struct {
u32 size;
u8 arg[2020];
} appLaunchLink;
struct {
s32 userId;
char eventId[37];
char bootArgument[7169];
} joinEvent;
struct {
s32 userId;
u32 npServiceLabel;
u8 reserved[8184];
} serviceEntitlementUpdate;
struct {
s32 userId;
u32 npServiceLabel;
u8 reserved[8184];
} unifiedEntitlementUpdate;
u8 reserved[8192];
};
};
bool IsSplashVisible();
int PS4_SYSV_ABI sceAppMessagingClearEventFlag();
int PS4_SYSV_ABI sceAppMessagingReceiveMsg();
int PS4_SYSV_ABI sceAppMessagingSendMsg();
int PS4_SYSV_ABI sceAppMessagingSendMsgToShellCore();
int PS4_SYSV_ABI sceAppMessagingSendMsgToShellUI();
int PS4_SYSV_ABI sceAppMessagingSetEventFlag();
int PS4_SYSV_ABI sceAppMessagingTryGetEventFlag();
int PS4_SYSV_ABI sceAppMessagingTryReceiveMsg();
int PS4_SYSV_ABI Func_C8E899ABEF7F64C4();
int PS4_SYSV_ABI Func_F74BA759B9C8D2A1();
int PS4_SYSV_ABI sceLncUtilAcquireCpuBudgetOfExtraAudioDevices();
int PS4_SYSV_ABI sceLncUtilAcquireCpuBudgetOfImeForBigApp();
int PS4_SYSV_ABI sceLncUtilAcquireCpuBudgetOfInGameStore();
int PS4_SYSV_ABI sceLncUtilActivateCdlg();
int PS4_SYSV_ABI sceLncUtilAddLocalProcess();
int PS4_SYSV_ABI sceLncUtilBlockAppSuspend();
int PS4_SYSV_ABI sceLncUtilBlockingGetEventForDaemon();
int PS4_SYSV_ABI sceLncUtilContinueApp();
int PS4_SYSV_ABI sceLncUtilCrashSyscore();
int PS4_SYSV_ABI sceLncUtilDeactivateCdlg();
int PS4_SYSV_ABI sceLncUtilDeclareReadyForSuspend();
int PS4_SYSV_ABI sceLncUtilDisableSuspendNotification();
int PS4_SYSV_ABI sceLncUtilEnableSuspendNotification();
int PS4_SYSV_ABI sceLncUtilFinishSpecialResume();
int PS4_SYSV_ABI sceLncUtilForceKillApp();
int PS4_SYSV_ABI sceLncUtilForceKillLocalProcess();
int PS4_SYSV_ABI sceLncUtilGetApp0DirPath();
int PS4_SYSV_ABI sceLncUtilGetAppCategory();
int PS4_SYSV_ABI sceLncUtilGetAppFocusedAppStatus();
int PS4_SYSV_ABI sceLncUtilGetAppId();
int PS4_SYSV_ABI sceLncUtilGetAppIdOfBigApp();
int PS4_SYSV_ABI sceLncUtilGetAppIdOfMiniApp();
int PS4_SYSV_ABI sceLncUtilGetAppLaunchedUser();
int PS4_SYSV_ABI sceLncUtilGetAppStatus();
int PS4_SYSV_ABI sceLncUtilGetAppStatusListForShellUIReboot();
int PS4_SYSV_ABI sceLncUtilGetAppTitleId();
int PS4_SYSV_ABI sceLncUtilGetAppType();
int PS4_SYSV_ABI sceLncUtilGetCdlgExec();
int PS4_SYSV_ABI sceLncUtilGetCoredumpState();
int PS4_SYSV_ABI sceLncUtilGetDbgExecutablePath();
int PS4_SYSV_ABI sceLncUtilGetEventForDaemon();
int PS4_SYSV_ABI sceLncUtilGetEventForShellUI();
int PS4_SYSV_ABI sceLncUtilGetGpuCrashFullDumpAppStatus();
int PS4_SYSV_ABI sceLncUtilGetLocalProcessStatusList();
int PS4_SYSV_ABI sceLncUtilGetParentSocket();
int PS4_SYSV_ABI sceLncUtilGetResultKillApp();
int PS4_SYSV_ABI sceLncUtilGetResultLaunchAppByTitleId();
int PS4_SYSV_ABI sceLncUtilInitialize();
int PS4_SYSV_ABI sceLncUtilIsActiveCdlg();
int PS4_SYSV_ABI sceLncUtilIsAppLaunched();
int PS4_SYSV_ABI sceLncUtilIsAppSuspended();
int PS4_SYSV_ABI sceLncUtilIsCpuBudgetOfExtraAudioDevicesAvailable();
int PS4_SYSV_ABI sceLncUtilIsPs2Emu();
int PS4_SYSV_ABI sceLncUtilIsShellUiFgAndGameBgCpuMode();
int PS4_SYSV_ABI sceLncUtilKickCoredumpOnlyProcMem();
int PS4_SYSV_ABI sceLncUtilKillApp();
int PS4_SYSV_ABI sceLncUtilKillAppWithReason();
int PS4_SYSV_ABI sceLncUtilKillLocalProcess();
int PS4_SYSV_ABI sceLncUtilLaunchApp();
int PS4_SYSV_ABI sceLncUtilLoadExec();
int PS4_SYSV_ABI sceLncUtilNotifyCoredumpRequestEnd();
int PS4_SYSV_ABI sceLncUtilNotifyCoredumpRequestProgress();
int PS4_SYSV_ABI sceLncUtilNotifyVshReady();
int PS4_SYSV_ABI sceLncUtilRaiseException();
int PS4_SYSV_ABI sceLncUtilRaiseExceptionLocalProcess();
int PS4_SYSV_ABI sceLncUtilRegisterCdlgSharedMemoryName();
int PS4_SYSV_ABI sceLncUtilRegisterDaemon();
int PS4_SYSV_ABI sceLncUtilRegisterShellUI();
int PS4_SYSV_ABI sceLncUtilReleaseCpuBudgetOfExtraAudioDevices();
int PS4_SYSV_ABI sceLncUtilReleaseCpuBudgetOfImeForBigApp();
int PS4_SYSV_ABI sceLncUtilReleaseCpuBudgetOfInGameStore();
int PS4_SYSV_ABI sceLncUtilResumeApp();
int PS4_SYSV_ABI sceLncUtilResumeLocalProcess();
int PS4_SYSV_ABI sceLncUtilSetAppFocus();
int PS4_SYSV_ABI sceLncUtilSetCdlgExec();
int PS4_SYSV_ABI sceLncUtilSetControllerFocus();
int PS4_SYSV_ABI sceLncUtilSetControllerFocusPermission();
int PS4_SYSV_ABI sceLncUtilStartKillApp();
int PS4_SYSV_ABI sceLncUtilStartLaunchAppByTitleId();
int PS4_SYSV_ABI sceLncUtilSuspendApp();
int PS4_SYSV_ABI sceLncUtilSuspendBackgroundApp();
int PS4_SYSV_ABI sceLncUtilSuspendLocalProcess();
int PS4_SYSV_ABI sceLncUtilSystemSuspend();
int PS4_SYSV_ABI sceLncUtilTerminate();
int PS4_SYSV_ABI sceLncUtilTryBlockAppSuspend();
int PS4_SYSV_ABI sceLncUtilUnblockAppSuspend();
int PS4_SYSV_ABI sceLncUtilUnregisterCdlgSharedMemoryName();
int PS4_SYSV_ABI sceLncUtilUnregisterDaemon();
int PS4_SYSV_ABI sceLncUtilUnregisterShellUI();
int PS4_SYSV_ABI sceSystemServiceActivateHevcSoft();
int PS4_SYSV_ABI sceSystemServiceActivateHevcSoftAbort();
int PS4_SYSV_ABI sceSystemServiceActivateHevcSoftGetStatus();
int PS4_SYSV_ABI sceSystemServiceActivateHevcSoftInit();
int PS4_SYSV_ABI sceSystemServiceActivateHevcSoftIsActivated();
int PS4_SYSV_ABI sceSystemServiceActivateHevcSoftStart();
int PS4_SYSV_ABI sceSystemServiceActivateHevcSoftTerm();
int PS4_SYSV_ABI sceShellCoreUtilAccessibilityZoomLock();
int PS4_SYSV_ABI sceShellCoreUtilAccessibilityZoomUnlock();
int PS4_SYSV_ABI sceShellCoreUtilAcquireBgmCpuBudget();
int PS4_SYSV_ABI sceShellCoreUtilAcquireRemotePlayCpuBudget();
int PS4_SYSV_ABI sceShellCoreUtilAcquireSharePlayCpuBudget();
int PS4_SYSV_ABI sceShellCoreUtilActivateAbort();
int PS4_SYSV_ABI sceShellCoreUtilActivateGetStatus();
int PS4_SYSV_ABI sceShellCoreUtilActivateInit();
int PS4_SYSV_ABI sceShellCoreUtilActivateIsActivated();
int PS4_SYSV_ABI sceShellCoreUtilActivateRecordActivation();
int PS4_SYSV_ABI sceShellCoreUtilActivateStart();
int PS4_SYSV_ABI sceShellCoreUtilActivateStartAsync();
int PS4_SYSV_ABI sceShellCoreUtilActivateTerm();
int PS4_SYSV_ABI sceShellCoreUtilChangeRunLevel();
int PS4_SYSV_ABI sceShellCoreUtilChangeToStaffModeForIDU();
int PS4_SYSV_ABI sceShellCoreUtilCheckerAbort();
int PS4_SYSV_ABI sceShellCoreUtilCleanupCrashReport();
int PS4_SYSV_ABI sceShellCoreUtilClearAppData();
int PS4_SYSV_ABI sceShellCoreUtilClearPsnAccountInfo();
int PS4_SYSV_ABI sceShellCoreUtilCrashReportRequestCancel();
int PS4_SYSV_ABI sceShellCoreUtilDeclareBeginOfExternalStorageAppMove();
int PS4_SYSV_ABI sceShellCoreUtilDeclareEndOfExternalStorageAppMove();
int PS4_SYSV_ABI sceShellCoreUtilDeleteDiscInstalledTitleWorkaroundFile();
int PS4_SYSV_ABI sceShellCoreUtilDeleteDownloadedHidConfigFile();
int PS4_SYSV_ABI sceShellCoreUtilDeleteDownloadedNetEvConfigFile();
int PS4_SYSV_ABI sceShellCoreUtilDeleteDownloadedTitleWorkaroundFile();
int PS4_SYSV_ABI sceShellCoreUtilDeleteSmrHddDummyData();
int PS4_SYSV_ABI sceShellCoreUtilDoFsck();
int PS4_SYSV_ABI sceShellCoreUtilDownloadHidConfigFileFromServer();
int PS4_SYSV_ABI sceShellCoreUtilDownloadNetEvConfigFileFromServer();
int PS4_SYSV_ABI sceShellCoreUtilDownloadTitleWorkaroundFileFromServer();
int PS4_SYSV_ABI sceShellCoreUtilEnterPowerLockSection();
int PS4_SYSV_ABI sceShellCoreUtilExecuteCrashReport();
int PS4_SYSV_ABI sceShellCoreUtilExfatFormatExternalHdd();
int PS4_SYSV_ABI sceShellCoreUtilExitMiniApp();
int PS4_SYSV_ABI sceShellCoreUtilExitMiniAppWithValue();
int PS4_SYSV_ABI sceShellCoreUtilFillUpSpaceOnSmrHdd();
int PS4_SYSV_ABI sceShellCoreUtilFormatExternalHdd();
int PS4_SYSV_ABI sceShellCoreUtilFormatHddForRestore();
int PS4_SYSV_ABI sceShellCoreUtilFreeUpSpaceOnSmrHdd();
int PS4_SYSV_ABI sceShellCoreUtilGetAppData();
int PS4_SYSV_ABI sceShellCoreUtilGetAppEnableTTS();
int PS4_SYSV_ABI sceShellCoreUtilGetAppEnterButtonAssign();
int PS4_SYSV_ABI sceShellCoreUtilGetAppLaunchedParamInt();
int PS4_SYSV_ABI sceShellCoreUtilGetAppLaunchedParamIntByBudgetType();
int PS4_SYSV_ABI sceShellCoreUtilGetAppLaunchedParamString();
int PS4_SYSV_ABI sceShellCoreUtilGetAppLaunchedParamStringByBudgetType();
int PS4_SYSV_ABI sceShellCoreUtilGetAppLaunchTypeInfo();
int PS4_SYSV_ABI sceShellCoreUtilGetAutoPowerDownRemainingSeconds();
int PS4_SYSV_ABI sceShellCoreUtilGetBasicProductShape();
int PS4_SYSV_ABI sceShellCoreUtilGetCheckerString();
int PS4_SYSV_ABI sceShellCoreUtilGetCheckerStringEx();
int PS4_SYSV_ABI sceShellCoreUtilGetCloudClientStatus();
int PS4_SYSV_ABI sceShellCoreUtilGetCrashReportCoreFileSetSize();
int PS4_SYSV_ABI sceShellCoreUtilGetCrashReportFilterInfoStart();
int PS4_SYSV_ABI sceShellCoreUtilGetCrashReportInfoForBoot();
int PS4_SYSV_ABI sceShellCoreUtilGetCrashReportInfoForBootStart();
int PS4_SYSV_ABI sceShellCoreUtilGetCrashReportInfoStart();
int PS4_SYSV_ABI sceShellCoreutilGetCrashReportProcessInformation();
int PS4_SYSV_ABI sceShellCoreUtilGetCrashReportResult();
int PS4_SYSV_ABI sceShellCoreUtilGetCrashReportStatus();
int PS4_SYSV_ABI sceShellCoreUtilGetCrashReportUploadStatus();
int PS4_SYSV_ABI sceShellCoreUtilGetDeviceIndexBehavior();
int PS4_SYSV_ABI sceShellCoreUtilGetDeviceIndexBehaviorWithTimeout();
int PS4_SYSV_ABI sceShellCoreUtilGetEffectiveTotalSizeOfUserPartition();
int PS4_SYSV_ABI sceShellCoreUtilGetFreeSizeOfAvContentsTmp();
int PS4_SYSV_ABI sceShellCoreUtilGetFreeSizeOfUserPartition();
int PS4_SYSV_ABI sceShellCoreUtilGetFsckProgress();
int PS4_SYSV_ABI sceShellCoreUtilGetGameLiveStreamingStatus();
int PS4_SYSV_ABI sceShellCoreUtilGetGnmCompositorOnScreenProfilerFlag();
int PS4_SYSV_ABI sceShellCoreUtilGetGpuLoadEmulationMode();
int PS4_SYSV_ABI sceShellCoreUtilGetGpuLoadEmulationModeByAppId();
int PS4_SYSV_ABI sceShellCoreUtilGetHidConfigFileInfoString();
int PS4_SYSV_ABI sceShellCoreUtilGetHidConfigFileString();
int PS4_SYSV_ABI sceShellCoreUtilGetHidConfigName();
int PS4_SYSV_ABI sceShellCoreUtilGetHidConfigNum();
int PS4_SYSV_ABI sceShellCoreUtilGetIDUMode();
int PS4_SYSV_ABI sceShellCoreUtilGetImposeMenuFlagForPs2Emu();
int PS4_SYSV_ABI sceShellCoreUtilGetManifestFileStatus();
int PS4_SYSV_ABI sceShellCoreUtilGetNeedSizeOfAppContent();
int PS4_SYSV_ABI sceShellCoreUtilGetNetEvConfigFileInfoString();
int PS4_SYSV_ABI sceShellCoreUtilGetOptimizationStatus();
int PS4_SYSV_ABI sceShellCoreUtilGetOutOfVrPlayZoneWarning();
int PS4_SYSV_ABI sceShellCoreUtilGetPapcGamePcl();
int PS4_SYSV_ABI sceShellCoreUtilGetPbtcUserInfoList();
int PS4_SYSV_ABI sceShellCoreUtilGetPlatformPrivacyDefinitionEventData();
int PS4_SYSV_ABI sceShellCoreUtilGetPlatformPrivacySetting();
int PS4_SYSV_ABI sceShellCoreUtilGetProgressOfFormatExternalHdd();
int PS4_SYSV_ABI sceShellCoreUtilGetProgressOfFsck();
int PS4_SYSV_ABI sceShellCoreUtilGetPsnAccountInfo();
int PS4_SYSV_ABI sceShellCoreUtilGetPsStoreIconLayout();
int PS4_SYSV_ABI sceShellCoreUtilGetPsStoreIconState();
int PS4_SYSV_ABI sceShellCoreUtilGetRegion();
int PS4_SYSV_ABI sceShellCoreUtilGetRemotePlayStatus();
int PS4_SYSV_ABI sceShellCoreUtilGetRunLevel();
int PS4_SYSV_ABI sceShellCoreUtilGetSharePlayStatus();
int PS4_SYSV_ABI sceShellCoreUtilGetShellUIVMStats();
int PS4_SYSV_ABI sceShellCoreUtilGetSmrHddInfoString();
int PS4_SYSV_ABI sceShellCoreUtilGetSocialScreenStatus();
int PS4_SYSV_ABI sceShellCoreUtilGetSplashScreenState();
int PS4_SYSV_ABI sceShellCoreUtilGetSupportSiteURL();
int PS4_SYSV_ABI sceShellCoreUtilGetSuspendConfirmationDialogFlag();
int PS4_SYSV_ABI sceShellCoreUtilGetSystemBGState();
int PS4_SYSV_ABI sceShellCoreUtilGetSystemBGWaveColor();
int PS4_SYSV_ABI sceShellCoreUtilGetSystemBGWaveState();
int PS4_SYSV_ABI sceShellCoreUtilGetTitleWorkaroundFileInfoString();
int PS4_SYSV_ABI sceShellCoreUtilGetTitleWorkaroundFileString();
int PS4_SYSV_ABI sceShellCoreUtilGetUIStatus();
int PS4_SYSV_ABI sceShellCoreUtilGetUserFocus();
int PS4_SYSV_ABI sceShellCoreUtilGetUserIdOfMorpheusUser();
int PS4_SYSV_ABI sceShellCoreUtilGetVersionNumberOfCameraCalibrationData();
int PS4_SYSV_ABI sceShellCoreUtilGoBackToKratosCurrentSessionGame();
int PS4_SYSV_ABI sceShellCoreUtilHideBlocksFromUser();
int PS4_SYSV_ABI sceShellCoreUtilIncrementVersionNumberOfCameraCalibrationData();
int PS4_SYSV_ABI sceShellCoreUtilIsAccessibilityZoomLocked();
int PS4_SYSV_ABI sceShellCoreUtilIsBgmCpuBudgetAcquired();
int PS4_SYSV_ABI sceShellCoreUtilIsBgmCpuBudgetAvailable();
int PS4_SYSV_ABI sceShellCoreUtilIsBgmPlaying();
int PS4_SYSV_ABI sceShellCoreUtilIsExternalStorageAppMoveInProgress();
int PS4_SYSV_ABI sceShellCoreUtilIsEyeToEyeDistanceAdjusted();
int PS4_SYSV_ABI sceShellCoreUtilIsGameLiveStreamingOnAir();
int PS4_SYSV_ABI sceShellCoreUtilIsImposeScreenOverlaid();
int PS4_SYSV_ABI sceShellCoreUtilIsInSystemSuspendBlackList();
int PS4_SYSV_ABI sceShellCoreUtilIsInternalKratosUser();
int PS4_SYSV_ABI sceShellCoreUtilIsKilledOrSuspendedByLogout();
int PS4_SYSV_ABI sceShellCoreUtilIsNeededCrashReport();
int PS4_SYSV_ABI sceShellCoreUtilIsPowerSaveAlertRequested();
int PS4_SYSV_ABI sceShellCoreUtilIsRemotePlayCpuBudgetAcquired();
int PS4_SYSV_ABI sceShellCoreUtilIsScreenSaverOn();
int PS4_SYSV_ABI sceShellCoreUtilIsSharePlayCpuBudgetAcquired();
int PS4_SYSV_ABI sceShellCoreUtilIsShowCrashReport();
int PS4_SYSV_ABI sceShellCoreUtilIsTemperatureDanger();
int PS4_SYSV_ABI sceShellCoreUtilIsTitleWorkaroundEnabled();
int PS4_SYSV_ABI sceShellCoreUtilIsUsbMassStorageMounted();
int PS4_SYSV_ABI sceShellCoreUtilLaunchByUri();
int PS4_SYSV_ABI sceShellCoreUtilLeavePowerLockSection();
int PS4_SYSV_ABI sceShellCoreUtilLog();
int PS4_SYSV_ABI sceShellCoreUtilMakeManifestFile();
int PS4_SYSV_ABI sceShellCoreUtilMountAppRight();
int PS4_SYSV_ABI sceShellCoreUtilMountDownloadDataForShellUI();
int PS4_SYSV_ABI sceShellCoreUtilMountHddForBackup();
int PS4_SYSV_ABI sceShellCoreUtilMountHddForRestore();
int PS4_SYSV_ABI sceShellCoreUtilNavigateToAnotherApp();
int PS4_SYSV_ABI sceShellCoreUtilNavigateToGoHome();
int PS4_SYSV_ABI sceShellCoreUtilNavigateToLaunchedApp();
int PS4_SYSV_ABI sceShellCoreUtilNotificationCancelForIDU();
int PS4_SYSV_ABI sceShellCoreUtilNotificationRequestedForIDU();
int PS4_SYSV_ABI sceShellCoreUtilNotifyBgmCoreTermination();
int PS4_SYSV_ABI sceShellCoreUtilNotifyFarsightUIDone();
int PS4_SYSV_ABI sceShellCoreUtilNotifyFsReadError();
int PS4_SYSV_ABI sceShellCoreUtilNotifyPsnAccountInfoReceived();
int PS4_SYSV_ABI sceShellCoreUtilNotifyYouTubeAccountLinkStatusChanged();
int PS4_SYSV_ABI sceShellCoreUtilPfAuthClientConsoleTokenClearCache();
int PS4_SYSV_ABI sceShellCoreUtilPostActivityForPsNow();
int PS4_SYSV_ABI sceShellCoreUtilPostErrorLog();
int PS4_SYSV_ABI sceShellCoreUtilPostLaunchConfirmResult();
int PS4_SYSV_ABI sceShellCoreUtilPostPsmEventToShellUI();
int PS4_SYSV_ABI sceShellCoreUtilPreNotifyOfGameLiveStreaming();
int PS4_SYSV_ABI sceShellCoreUtilPreNotifyOfRemotePlay();
int PS4_SYSV_ABI sceShellCoreUtilPreNotifyOfSharePlay();
int PS4_SYSV_ABI sceShellCoreUtilReleaseBgmCpuBudget();
int PS4_SYSV_ABI sceShellCoreUtilReleaseRemotePlayCpuBudget();
int PS4_SYSV_ABI sceShellCoreUtilReleaseSharePlayCpuBudget();
int PS4_SYSV_ABI sceShellCoreUtilReportSessionErrorToGaikaiController();
int PS4_SYSV_ABI sceShellCoreUtilReportUnexpectedFatalErrorToSystemTelemetry();
int PS4_SYSV_ABI sceShellCoreUtilRequestCameraCalibration();
int PS4_SYSV_ABI sceShellCoreUtilRequestEjectDevice();
int PS4_SYSV_ABI sceShellCoreUtilRequestRebootApp();
int PS4_SYSV_ABI sceShellCoreUtilRequestShutdown();
int PS4_SYSV_ABI sceShellCoreUtilResetAutoPowerDownTimer();
int PS4_SYSV_ABI sceShellCoreUtilResetBgdcConfig();
int PS4_SYSV_ABI sceShellCoreUtilSetAppData();
int PS4_SYSV_ABI sceShellCoreUtilSetBgmProhibition();
int PS4_SYSV_ABI sceShellCoreUtilSetDeviceIndexBehavior();
int PS4_SYSV_ABI sceShellCoreUtilSetGameLiveStreamingOnAirFlag();
int PS4_SYSV_ABI sceShellCoreUtilSetGameLiveStreamingStatus();
int PS4_SYSV_ABI sceShellCoreUtilSetGnmCompositorOnScreenProfilerFlag();
int PS4_SYSV_ABI sceShellCoreUtilSetGpuLoadEmulationMode();
int PS4_SYSV_ABI sceShellCoreUtilSetGpuLoadEmulationModeByAppId();
int PS4_SYSV_ABI sceShellCoreUtilSetIDUMode();
int PS4_SYSV_ABI sceShellCoreUtilSetImposeStatusFlag();
int PS4_SYSV_ABI sceShellCoreUtilSetPsStoreIconLayout();
int PS4_SYSV_ABI sceShellCoreUtilSetPsStoreIconState();
int PS4_SYSV_ABI sceShellCoreUtilSetRemotePlayStatus();
int PS4_SYSV_ABI sceShellCoreUtilSetSharePlayStatus();
int PS4_SYSV_ABI sceShellCoreUtilSetSkipUpdateCheck();
int PS4_SYSV_ABI sceShellCoreUtilSetSocialScreenStatus();
int PS4_SYSV_ABI sceShellCoreUtilSetSplashScreenState();
int PS4_SYSV_ABI sceShellCoreUtilSetSystemBGState();
int PS4_SYSV_ABI sceShellCoreUtilSetSystemBGWaveColor();
int PS4_SYSV_ABI sceShellCoreUtilSetSystemBGWaveState();
int PS4_SYSV_ABI sceShellCoreUtilSetUIStatus();
int PS4_SYSV_ABI sceShellCoreUtilSetUserFocus();
int PS4_SYSV_ABI sceShellCoreUtilShowCriticalErrorDialog();
int PS4_SYSV_ABI sceShellCoreUtilShowErrorDialog();
int PS4_SYSV_ABI sceShellCoreUtilShowErrorDialogWithFormatArgs();
int PS4_SYSV_ABI sceShellCoreUtilShowErrorDialogWithParam();
int PS4_SYSV_ABI sceShellCoreUtilShowPsUnderLockIndicator();
int PS4_SYSV_ABI sceShellCoreUtilSignalUserInput();
int PS4_SYSV_ABI sceShellCoreUtilStartOptimization();
int PS4_SYSV_ABI sceShellCoreUtilStartPsNowGame();
int PS4_SYSV_ABI sceShellCoreUtilStopOptimization();
int PS4_SYSV_ABI sceShellCoreUtilStopPsNowGame();
int PS4_SYSV_ABI sceShellCoreUtilTestBusTransferSpeed();
int PS4_SYSV_ABI sceShellCoreUtilTickHeartBeat();
int PS4_SYSV_ABI sceShellCoreUtilTriggerPapcRecalculation();
int PS4_SYSV_ABI sceShellCoreUtilTriggerPapcUpdate();
int PS4_SYSV_ABI sceShellCoreUtilTurnOffScreenSaver();
int PS4_SYSV_ABI sceShellCoreUtilUnmountAppRight();
int PS4_SYSV_ABI sceShellCoreUtilUnmountDownloadDataForShellUI();
int PS4_SYSV_ABI sceShellCoreUtilUnmountHddForBackup();
int PS4_SYSV_ABI sceShellCoreUtilUnmountHddForRestore();
int PS4_SYSV_ABI sceShellCoreUtilWriteSmrHddDummyData();
int PS4_SYSV_ABI Func_1E5CA5A71FA7F028();
int PS4_SYSV_ABI Func_6D43644F75C38346();
int PS4_SYSV_ABI Func_739FB849CB28F445();
int PS4_SYSV_ABI Func_B20628FF35C74111();
int PS4_SYSV_ABI sceSystemServiceAddLocalProcessForJvm();
int PS4_SYSV_ABI sceSystemServiceGetParentSocketForJvm();
int PS4_SYSV_ABI sceSystemServiceKillLocalProcessForJvm();
int PS4_SYSV_ABI sceSystemServiceAcquireFb0();
int PS4_SYSV_ABI sceSystemServiceAddLocalProcess();
int PS4_SYSV_ABI sceSystemServiceAddLocalProcessForPsmKit();
int PS4_SYSV_ABI sceSystemServiceChangeAcpClock();
int PS4_SYSV_ABI sceSystemServiceChangeCpuClock();
int PS4_SYSV_ABI sceSystemServiceChangeGpuClock();
int PS4_SYSV_ABI sceSystemServiceChangeMemoryClock();
int PS4_SYSV_ABI sceSystemServiceChangeMemoryClockToBaseMode();
int PS4_SYSV_ABI sceSystemServiceChangeMemoryClockToDefault();
int PS4_SYSV_ABI sceSystemServiceChangeMemoryClockToMultiMediaMode();
int PS4_SYSV_ABI sceSystemServiceChangeNumberOfGpuCu();
int PS4_SYSV_ABI sceSystemServiceChangeSamuClock();
int PS4_SYSV_ABI sceSystemServiceChangeUvdClock();
int PS4_SYSV_ABI sceSystemServiceChangeVceClock();
int PS4_SYSV_ABI sceSystemServiceDisableMusicPlayer();
int PS4_SYSV_ABI sceSystemServiceDisablePersonalEyeToEyeDistanceSetting();
int PS4_SYSV_ABI sceSystemServiceDisableSuspendConfirmationDialog();
int PS4_SYSV_ABI sceSystemServiceEnablePersonalEyeToEyeDistanceSetting();
int PS4_SYSV_ABI sceSystemServiceEnableSuspendConfirmationDialog();
int PS4_SYSV_ABI sceSystemServiceGetAppFocusedAppStatus();
int PS4_SYSV_ABI sceSystemServiceGetAppIdOfBigApp();
int PS4_SYSV_ABI sceSystemServiceGetAppIdOfMiniApp();
int PS4_SYSV_ABI sceSystemServiceGetAppStatus();
int PS4_SYSV_ABI sceSystemServiceGetAppType();
s32 PS4_SYSV_ABI
sceSystemServiceGetDisplaySafeAreaInfo(OrbisSystemServiceDisplaySafeAreaInfo* info);
int PS4_SYSV_ABI sceSystemServiceGetEventForDaemon();
int PS4_SYSV_ABI sceSystemServiceGetGpuLoadEmulationMode();
int PS4_SYSV_ABI sceSystemServiceGetHdrToneMapLuminance();
int PS4_SYSV_ABI sceSystemServiceGetLocalProcessStatusList();
int PS4_SYSV_ABI sceSystemServiceGetParentSocket();
int PS4_SYSV_ABI sceSystemServiceGetParentSocketForPsmKit();
int PS4_SYSV_ABI sceSystemServiceGetPSButtonEvent();
int PS4_SYSV_ABI sceSystemServiceGetRenderingMode();
s32 PS4_SYSV_ABI sceSystemServiceGetStatus(OrbisSystemServiceStatus* status);
int PS4_SYSV_ABI sceSystemServiceGetTitleWorkaroundInfo();
int PS4_SYSV_ABI sceSystemServiceGetVersionNumberOfCameraCalibrationData();
s32 PS4_SYSV_ABI sceSystemServiceHideSplashScreen();
int PS4_SYSV_ABI sceSystemServiceIsAppSuspended();
int PS4_SYSV_ABI sceSystemServiceIsBgmPlaying();
int PS4_SYSV_ABI sceSystemServiceIsEyeToEyeDistanceAdjusted();
int PS4_SYSV_ABI sceSystemServiceIsScreenSaverOn();
int PS4_SYSV_ABI sceSystemServiceIsShellUiFgAndGameBgCpuMode();
int PS4_SYSV_ABI sceSystemServiceKillApp();
int PS4_SYSV_ABI sceSystemServiceKillLocalProcess();
int PS4_SYSV_ABI sceSystemServiceKillLocalProcessForPsmKit();
int PS4_SYSV_ABI sceSystemServiceLaunchApp();
int PS4_SYSV_ABI sceSystemServiceLaunchEventDetails();
int PS4_SYSV_ABI sceSystemServiceLaunchTournamentList();
int PS4_SYSV_ABI sceSystemServiceLaunchTournamentsTeamProfile();
int PS4_SYSV_ABI sceSystemServiceLaunchWebBrowser();
int PS4_SYSV_ABI sceSystemServiceLoadExec();
int PS4_SYSV_ABI sceSystemServiceNavigateToAnotherApp();
int PS4_SYSV_ABI sceSystemServiceNavigateToGoBack();
int PS4_SYSV_ABI sceSystemServiceNavigateToGoBackWithValue();
int PS4_SYSV_ABI sceSystemServiceNavigateToGoHome();
s32 PS4_SYSV_ABI sceSystemServiceParamGetInt(int param_id, int* value);
int PS4_SYSV_ABI sceSystemServiceParamGetString();
int PS4_SYSV_ABI sceSystemServicePowerTick();
int PS4_SYSV_ABI sceSystemServiceRaiseExceptionLocalProcess();
s32 PS4_SYSV_ABI sceSystemServiceReceiveEvent(OrbisSystemServiceEvent* event);
int PS4_SYSV_ABI sceSystemServiceReenableMusicPlayer();
int PS4_SYSV_ABI sceSystemServiceRegisterDaemon();
int PS4_SYSV_ABI sceSystemServiceReleaseFb0();
int PS4_SYSV_ABI sceSystemServiceReportAbnormalTermination();
int PS4_SYSV_ABI sceSystemServiceRequestCameraCalibration();
int PS4_SYSV_ABI sceSystemServiceRequestToChangeRenderingMode();
int PS4_SYSV_ABI sceSystemServiceResumeLocalProcess();
int PS4_SYSV_ABI sceSystemServiceSetControllerFocusPermission();
int PS4_SYSV_ABI sceSystemServiceSetGpuLoadEmulationMode();
int PS4_SYSV_ABI sceSystemServiceSetOutOfVrPlayAreaFlag();
int PS4_SYSV_ABI sceSystemServiceSetOutOfVrPlayZoneWarning();
int PS4_SYSV_ABI sceSystemServiceShowControllerSettings();
int PS4_SYSV_ABI sceSystemServiceShowDisplaySafeAreaSettings();
int PS4_SYSV_ABI sceSystemServiceShowEyeToEyeDistanceSetting();
int PS4_SYSV_ABI sceSystemServiceSuspendBackgroundApp();
int PS4_SYSV_ABI sceSystemServiceSuspendLocalProcess();
int PS4_SYSV_ABI sceSystemServiceTickVideoPlayback();
int PS4_SYSV_ABI sceSystemServiceTurnOffScreenSaver();
int PS4_SYSV_ABI Func_9031A344CB540F1A();
int PS4_SYSV_ABI Func_A9D4CF2568EAB837();
int PS4_SYSV_ABI sceSystemServiceLaunchWebApp();
int PS4_SYSV_ABI Func_B8495C766861FDCF();
int PS4_SYSV_ABI sceSystemServiceGetDbgExecutablePath();
int PS4_SYSV_ABI sceSystemServiceActivateHevc();
int PS4_SYSV_ABI sceSystemServiceActivateHevcAbort();
int PS4_SYSV_ABI sceSystemServiceActivateHevcGetStatus();
int PS4_SYSV_ABI sceSystemServiceActivateHevcInit();
int PS4_SYSV_ABI sceSystemServiceActivateHevcIsActivated();
int PS4_SYSV_ABI sceSystemServiceActivateHevcStart();
int PS4_SYSV_ABI sceSystemServiceActivateHevcTerm();
int PS4_SYSV_ABI sceSystemServiceActivateMpeg2Abort();
int PS4_SYSV_ABI sceSystemServiceActivateMpeg2GetStatus();
int PS4_SYSV_ABI sceSystemServiceActivateMpeg2Init();
int PS4_SYSV_ABI sceSystemServiceActivateMpeg2IsActivated();
int PS4_SYSV_ABI sceSystemServiceActivateMpeg2Start();
int PS4_SYSV_ABI sceSystemServiceActivateMpeg2Term();
int PS4_SYSV_ABI sceSystemStateMgrCancelShutdownTimer();
int PS4_SYSV_ABI sceSystemStateMgrEnterMediaPlaybackMode();
int PS4_SYSV_ABI sceSystemStateMgrEnterStandby();
int PS4_SYSV_ABI sceSystemStateMgrExtendShutdownTimer();
int PS4_SYSV_ABI sceSystemStateMgrExtendShutdownTimerForPostAutoUpdateProcess();
int PS4_SYSV_ABI sceSystemStateMgrGetCurrentState();
int PS4_SYSV_ABI sceSystemStateMgrGetTriggerCode();
int PS4_SYSV_ABI sceSystemStateMgrIsBdDriveReady();
int PS4_SYSV_ABI sceSystemStateMgrIsGpuPerformanceNormal();
int PS4_SYSV_ABI sceSystemStateMgrIsShellUIShutdownInProgress();
int PS4_SYSV_ABI sceSystemStateMgrIsStandbyModeEnabled();
int PS4_SYSV_ABI sceSystemStateMgrLeaveMediaPlaybackMode();
int PS4_SYSV_ABI sceSystemStateMgrNotifySystemSuspendResumeProgress();
int PS4_SYSV_ABI sceSystemStateMgrReboot();
int PS4_SYSV_ABI sceSystemStateMgrSendCecOneTouchPlayCommand();
int PS4_SYSV_ABI sceSystemStateMgrStartRebootTimer();
int PS4_SYSV_ABI sceSystemStateMgrStartShutdownTimer();
int PS4_SYSV_ABI sceSystemStateMgrStartStadbyTimer();
int PS4_SYSV_ABI sceSystemStateMgrStartVshAutoUpdateTimer();
int PS4_SYSV_ABI sceSystemStateMgrTickMusicPlayback();
int PS4_SYSV_ABI sceSystemStateMgrTickPartyChat();
int PS4_SYSV_ABI sceSystemStateMgrTurnOff();
int PS4_SYSV_ABI sceSystemStateMgrVshAutoUpdate();
int PS4_SYSV_ABI sceSystemStateMgrWaitVshAutoUpdateVerifyDone();
int PS4_SYSV_ABI sceSystemStateMgrWakeUp();
int PS4_SYSV_ABI Func_89F262179C22B49E();
int PS4_SYSV_ABI Func_AC8A8FAB4A1696B8();
int PS4_SYSV_ABI sceSystemServiceInvokeAppLaunchLink();
int PS4_SYSV_ABI sceSystemServiceShowClosedCaptionAdvancedSettings();
int PS4_SYSV_ABI sceSystemServiceShowClosedCaptionSettings();
int PS4_SYSV_ABI sceSystemServiceSetPowerSaveLevel();
int PS4_SYSV_ABI sceSystemServiceInitializeForShellCore();
int PS4_SYSV_ABI Func_7C1183FC73629929();
int PS4_SYSV_ABI sceSystemServiceDisablePartyVoice();
int PS4_SYSV_ABI sceSystemServiceReenablePartyVoice();
int PS4_SYSV_ABI sceSystemServiceGetPlatformPrivacyDefinitionData();
int PS4_SYSV_ABI sceSystemServiceGetPlatformPrivacyDefinitionVersion();
int PS4_SYSV_ABI sceSystemServiceGetPlatformPrivacySetting();
int PS4_SYSV_ABI sceSystemServiceDeclareReadyForSuspend();
int PS4_SYSV_ABI sceSystemServiceDisableSuspendNotification();
int PS4_SYSV_ABI sceSystemServiceEnableSuspendNotification();
int PS4_SYSV_ABI sceSystemServiceRequestPowerOff();
int PS4_SYSV_ABI sceSystemServiceRequestReboot();
int PS4_SYSV_ABI sceSystemServiceAddLocalProcessForPs2Emu();
int PS4_SYSV_ABI sceSystemServiceGetParentSocketForPs2Emu();
int PS4_SYSV_ABI sceSystemServiceKillLocalProcessForPs2Emu();
int PS4_SYSV_ABI sceSystemServiceShowImposeMenuForPs2Emu();
int PS4_SYSV_ABI sceSystemServiceSaveVideoToken();
int PS4_SYSV_ABI sceSystemServiceLaunchStore();
int PS4_SYSV_ABI sceSystemServiceTelemetrySetData();
int PS4_SYSV_ABI Func_C67FC780F5B6F71E();
int PS4_SYSV_ABI sceSystemServiceLaunchUdsApp();
int PS4_SYSV_ABI sceSystemServiceLoadExecVideoServiceWebApp();
int PS4_SYSV_ABI sceSystemServiceDisableVoiceRecognition();
int PS4_SYSV_ABI sceSystemServiceReenableVoiceRecognition();
int PS4_SYSV_ABI Func_6B1CDB955F0EBD65();
int PS4_SYSV_ABI Func_CB5E885E225F69F0();
void RegisterlibSceSystemService(Core::Loader::SymbolsResolver* sym);
} // namespace Libraries::SystemService
| 32,385
|
C++
|
.h
| 624
| 49.815705
| 102
| 0.84429
|
shadps4-emu/shadPS4
| 9,253
| 501
| 185
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
15,828
|
commondialog.h
|
shadps4-emu_shadPS4/src/core/libraries/system/commondialog.h
|
// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
#pragma once
#include "common/types.h"
namespace Core::Loader {
class SymbolsResolver;
}
namespace Libraries::CommonDialog {
enum class Status : u32 {
NONE = 0,
INITIALIZED = 1,
RUNNING = 2,
FINISHED = 3,
};
enum class Result : u32 {
OK = 0,
USER_CANCELED = 1,
};
enum class Error : u32 {
OK = 0,
NOT_SYSTEM_INITIALIZED = 0x80B80001,
ALREADY_SYSTEM_INITIALIZED = 0x80B80002,
NOT_INITIALIZED = 0x80B80003,
ALREADY_INITIALIZED = 0x80B80004,
NOT_FINISHED = 0x80B80005,
INVALID_STATE = 0x80B80006,
RESULT_NONE = 0x80B80007,
BUSY = 0x80B80008,
OUT_OF_MEMORY = 0x80B80009,
PARAM_INVALID = 0x80B8000A,
NOT_RUNNING = 0x80B8000B,
ALREADY_CLOSE = 0x80B8000C,
ARG_NULL = 0x80B8000D,
UNEXPECTED_FATAL = 0x80B8000E,
NOT_SUPPORTED = 0x80B8000F,
INHIBIT_SHAREPLAY_CLIENT = 0x80B80010,
};
extern bool g_isInitialized;
extern bool g_isUsed;
struct BaseParam {
std::size_t size;
std::array<u8, 36> reserved;
u32 magic;
};
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();
Error PS4_SYSV_ABI sceCommonDialogInitialize();
bool 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);
} // namespace Libraries::CommonDialog
| 2,775
|
C++
|
.h
| 74
| 34.945946
| 76
| 0.794424
|
shadps4-emu/shadPS4
| 9,253
| 501
| 185
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
15,829
|
ngs2.h
|
shadps4-emu_shadPS4/src/core/libraries/ngs2/ngs2.h
|
// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
#pragma once
#include "common/types.h"
#include <atomic>
#include <memory>
namespace Core::Loader {
class SymbolsResolver;
}
namespace Libraries::Ngs2 {
class Ngs2;
using SceNgs2Handle = Ngs2*;
enum SceNgs2HandleType { SCE_NGS2_HANDLE_TYPE_SYSTEM = 0 };
struct Ngs2Handle {
void* selfPointer;
void* dataPointer;
std::atomic<u32>* atomicPtr;
u32 handleType;
u32 flags_unk;
u32 uid;
u16 maxGrainSamples;
u16 minGrainSamples;
u16 currentGrainSamples;
u16 numGrainSamples;
u16 unknown2;
u32 sampleRate;
u32 unknown3;
void* flushMutex;
u32 flushMutexInitialized;
void* processMutex;
u32 processMutexInitialized;
// Linked list pointers for system list
Ngs2Handle* prev;
Ngs2Handle* next;
};
struct SystemOptions {
char padding[6];
s32 maxGrainSamples;
s32 numGrainSamples;
s32 sampleRate;
};
struct SystemState {
// TODO
};
struct StackBuffer {
void** top;
void* base;
void* curr;
size_t usedSize;
size_t totalSize;
size_t alignment;
char isVerifyEnabled;
char padding[7];
};
void RegisterlibSceNgs2(Core::Loader::SymbolsResolver* sym);
} // namespace Libraries::Ngs2
| 1,322
|
C++
|
.h
| 56
| 19.982143
| 66
| 0.729816
|
shadps4-emu/shadPS4
| 9,253
| 501
| 185
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
15,830
|
ngs2_impl.h
|
shadps4-emu_shadPS4/src/core/libraries/ngs2/ngs2_impl.h
|
// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
#pragma once
#include "ngs2.h"
namespace Libraries::Ngs2 {
class Ngs2 {
public:
s32 ReportInvalid(Ngs2Handle* handle, u32 handle_type) const;
s32 HandleSetup(Ngs2Handle* handle, void* data, std::atomic<u32>* atomic, u32 type, u32 flags);
s32 HandleCleanup(Ngs2Handle* handle, u32 hType, void* dataOut);
s32 HandleEnter(Ngs2Handle* handle, u32 hType, Ngs2Handle* handleOut);
s32 HandleLeave(Ngs2Handle* handle);
s32 StackBufferOpen(StackBuffer* buf, void* base_addr, size_t size, void** stackTop,
bool verify);
s32 StackBufferClose(StackBuffer* buf, size_t* usedSize);
s32 SystemSetupCore(StackBuffer* buf, SystemOptions* options, Ngs2Handle** sysOut);
private:
};
} // namespace Libraries::Ngs2
| 869
|
C++
|
.h
| 19
| 41.473684
| 99
| 0.740521
|
shadps4-emu/shadPS4
| 9,253
| 501
| 185
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
15,831
|
ngs2_error.h
|
shadps4-emu_shadPS4/src/core/libraries/ngs2/ngs2_error.h
|
// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
#pragma once
constexpr int ORBIS_NGS2_ERROR_FAIL = 0x804A0001;
constexpr int ORBIS_NGS2_ERROR_INVALID_MAX_GRAIN_SAMPLES = 0x804A0050;
constexpr int ORBIS_NGS2_ERROR_INVALID_NUM_GRAIN_SAMPLES = 0x804A0051;
constexpr int ORBIS_NGS2_ERROR_INVALID_NUM_CHANNELS = 0x804A0052;
constexpr int ORBIS_NGS2_ERROR_INVALID_OUT_ADDRESS = 0x804A0053;
constexpr int ORBIS_NGS2_ERROR_INVALID_OUT_SIZE = 0x804A0054;
constexpr int ORBIS_NGS2_ERROR_INVALID_OPTION_ADDRESS = 0x804A0080;
constexpr int ORBIS_NGS2_ERROR_INVALID_OPTION_SIZE = 0x804A0081;
constexpr int ORBIS_NGS2_ERROR_INVALID_OPTION_FLAG = 0x804A0082;
constexpr int ORBIS_NGS2_ERROR_INVALID_MAX_MATRICES = 0x804A0100;
constexpr int ORBIS_NGS2_ERROR_INVALID_MAX_PORTS = 0x804A0101;
constexpr int ORBIS_NGS2_ERROR_INVALID_MAX_INPUT_DELAY_BLOCKS = 0x804A0102;
constexpr int ORBIS_NGS2_ERROR_INVALID_MAX_VOICES = 0x804A0103;
constexpr int ORBIS_NGS2_ERROR_INVALID_MAX_CHANNELS = 0x804A0104;
constexpr int ORBIS_NGS2_ERROR_INVALID_MAX_CHANNEL_WORKS = 0x804A0105;
constexpr int ORBIS_NGS2_ERROR_INVALID_MAX_WAVEFORM_BLOCKS = 0x804A0106;
constexpr int ORBIS_NGS2_ERROR_INVALID_MAX_ENVELOPE_POINTS = 0x804A0107;
constexpr int ORBIS_NGS2_ERROR_INVALID_MAX_FILTERS = 0x804A0108;
constexpr int ORBIS_NGS2_ERROR_INVALID_MAX_CODEC_CACHES = 0x804A0109;
constexpr int ORBIS_NGS2_ERROR_INVALID_MAX_ATRAC9_DECODERS = 0x804A010A;
constexpr int ORBIS_NGS2_ERROR_INVALID_MAX_ATRAC9_CHANNEL_WORKS = 0x804A010B;
constexpr int ORBIS_NGS2_ERROR_INVALID_MAX_INPUTS = 0x804A010C;
constexpr int ORBIS_NGS2_ERROR_INVALID_NUM_MATRIX_LEVELS = 0x804A0150;
constexpr int ORBIS_NGS2_ERROR_INVALID_NUM_WAVEFORM_BLOCKS = 0x804A0151;
constexpr int ORBIS_NGS2_ERROR_INVALID_NUM_ENVELOPE_POINTS = 0x804A0152;
constexpr int ORBIS_NGS2_ERROR_INVALID_MATRIX_LEVEL_ADDRESS = 0x804A0153;
constexpr int ORBIS_NGS2_ERROR_INVALID_WAVEFORM_BLOCK_ADDRESS = 0x804A0154;
constexpr int ORBIS_NGS2_ERROR_INVALID_ENVELOPE_POINT_ADDRESS = 0x804A0155;
constexpr int ORBIS_NGS2_ERROR_INVALID_NUM_PEAKMETER_BLOCKS = 0x804A0156;
constexpr int ORBIS_NGS2_ERROR_INVALID_HANDLE = 0x804A0200;
constexpr int ORBIS_NGS2_ERROR_INVALID_SAMPLE_RATE = 0x804A0201;
constexpr int ORBIS_NGS2_ERROR_INVALID_REPORT_TYPE = 0x804A0202;
constexpr int ORBIS_NGS2_ERROR_INVALID_REPORT_HANDLER = 0x804A0203;
constexpr int ORBIS_NGS2_ERROR_INVALID_REPORT_HANDLE = 0x804A0204;
constexpr int ORBIS_NGS2_ERROR_EMPTY_REPORT_HANDLE = 0x804A0205;
constexpr int ORBIS_NGS2_ERROR_INVALID_BUFFER_INFO = 0x804A0206;
constexpr int ORBIS_NGS2_ERROR_INVALID_BUFFER_ADDRESS = 0x804A0207;
constexpr int ORBIS_NGS2_ERROR_INVALID_BUFFER_ALIGN = 0x804A0208;
constexpr int ORBIS_NGS2_ERROR_INVALID_BUFFER_SIZE = 0x804A0209;
constexpr int ORBIS_NGS2_ERROR_INVALID_BUFFER_ALLOCATOR = 0x804A020A;
constexpr int ORBIS_NGS2_ERROR_BUFFER_BROKEN = 0x804A020B;
constexpr int ORBIS_NGS2_ERROR_EMPTY_BUFFER = 0x804A020C;
constexpr int ORBIS_NGS2_ERROR_INVALID_SYSTEM_HANDLE = 0x804A0230;
constexpr int ORBIS_NGS2_ERROR_INVALID_RACK_ID = 0x804A0260;
constexpr int ORBIS_NGS2_ERROR_INVALID_RACK_HANDLE = 0x804A0261;
constexpr int ORBIS_NGS2_ERROR_INVALID_VOICE_HANDLE = 0x804A0300;
constexpr int ORBIS_NGS2_ERROR_UNINIT_VOICE = 0x804A0301;
constexpr int ORBIS_NGS2_ERROR_INVALID_VOICE_INDEX = 0x804A0302;
constexpr int ORBIS_NGS2_ERROR_INVALID_EVENT_TYPE = 0x804A0303;
constexpr int ORBIS_NGS2_ERROR_INVALID_PORT_INDEX = 0x804A0304;
constexpr int ORBIS_NGS2_ERROR_INVALID_PATCH = 0x804A0305;
constexpr int ORBIS_NGS2_ERROR_EMPTY_CHANNEL_WORK = 0x804A0306;
constexpr int ORBIS_NGS2_ERROR_EMPTY_CODEC_DECODER = 0x804A0307;
constexpr int ORBIS_NGS2_ERROR_INVALID_VOICE_CONTROL_ID = 0x804A0308;
constexpr int ORBIS_NGS2_ERROR_INVALID_VOICE_CONTROL_ADDRESS = 0x804A0309;
constexpr int ORBIS_NGS2_ERROR_INVALID_VOICE_CONTROL_SIZE = 0x804A030A;
constexpr int ORBIS_NGS2_ERROR_DETECTED_CIRCULAR_VOICE_CONTROL = 0x804A030B;
constexpr int ORBIS_NGS2_ERROR_UNABLE_CALLBACK = 0x804A030C;
constexpr int ORBIS_NGS2_ERROR_INVALID_CALLBACK_FLAG = 0x804A030D;
constexpr int ORBIS_NGS2_ERROR_INVALID_CALLBACK_HANDLER = 0x804A030E;
constexpr int ORBIS_NGS2_ERROR_INVALID_OPERATION = 0x804A030F;
constexpr int ORBIS_NGS2_ERROR_INVALID_WAVEFORM_FORMAT = 0x804A0400;
constexpr int ORBIS_NGS2_ERROR_UNKNOWN_WAVEFORM_FORMAT = 0x804A0401;
constexpr int ORBIS_NGS2_ERROR_INVALID_WAVEFORM_TYPE = 0x804A0402;
constexpr int ORBIS_NGS2_ERROR_INVALID_WAVEFORM_CONFIG = 0x804A0403;
constexpr int ORBIS_NGS2_ERROR_INVALID_WAVEFORM_SAMPLE_RATE = 0x804A0404;
constexpr int ORBIS_NGS2_ERROR_INVALID_WAVEFORM_FRAME = 0x804A0405;
constexpr int ORBIS_NGS2_ERROR_INVALID_WAVEFORM_ADDRESS = 0x804A0406;
constexpr int ORBIS_NGS2_ERROR_INVALID_WAVEFORM_SIZE = 0x804A0407;
constexpr int ORBIS_NGS2_ERROR_INVALID_WAVEFORM_DATA = 0x804A0408;
constexpr int ORBIS_NGS2_ERROR_INVALID_WAVEFORM_BLOCK_NUM_REPEATS = 0x804A0409;
constexpr int ORBIS_NGS2_ERROR_INVALID_ENVELOPE_CURVE = 0x804A0500;
constexpr int ORBIS_NGS2_ERROR_INVALID_PEAKMETER_FLAG = 0x804A0510;
constexpr int ORBIS_NGS2_ERROR_INVALID_MAX_CHORUS_PHASES = 0x804A0520;
constexpr int ORBIS_NGS2_ERROR_INVALID_NUM_CHORUS_PHASES = 0x804A0521;
constexpr int ORBIS_NGS2_ERROR_INVALID_MAX_DELAY_LENGTH = 0x804A0530;
constexpr int ORBIS_NGS2_ERROR_INVALID_MAX_DELAY_TAPS = 0x804A0531;
constexpr int ORBIS_NGS2_ERROR_INVALID_DELAY_TYPE = 0x804A0532;
constexpr int ORBIS_NGS2_ERROR_INVALID_NUM_DELAY_TAPS = 0x804A0533;
constexpr int ORBIS_NGS2_ERROR_INVALID_DELAY_TAP_INFO = 0x804A0534;
constexpr int ORBIS_NGS2_ERROR_INVALID_PITCH_SHIFT_QUALITY = 0x804A0540;
constexpr int ORBIS_NGS2_ERROR_INVALID_FILTER_INDEX = 0x804A0600;
constexpr int ORBIS_NGS2_ERROR_INVALID_FILTER_TYPE = 0x804A0601;
constexpr int ORBIS_NGS2_ERROR_INVALID_FILTER_LOCATION = 0x804A0602;
constexpr int ORBIS_NGS2_ERROR_INVALID_LFE_FC = 0x804A0603;
constexpr int ORBIS_NGS2_ERROR_INVALID_USER_FX_PARAM_SIZE = 0x804A0650;
constexpr int ORBIS_NGS2_ERROR_INVALID_MATRIX_INDEX = 0x804A0700;
constexpr int ORBIS_NGS2_ERROR_CODEC_UNKNOWN_WAVEFORM = 0x804A0800;
constexpr int ORBIS_NGS2_ERROR_CODEC_EMPTY_INSTANCE = 0x804A0801;
constexpr int ORBIS_NGS2_ERROR_CODEC_EMPTY_CHANNEL = 0x804A0802;
constexpr int ORBIS_NGS2_ERROR_CODEC_SETUP_FAIL = 0x804A0803;
constexpr int ORBIS_NGS2_ERROR_CODEC_RESET_FAIL = 0x804A0804;
constexpr int ORBIS_NGS2_ERROR_CODEC_DECODE_FAIL = 0x804A0805;
constexpr int ORBIS_NGS2_ERROR_INVALID_REVERB_SIZE = 0x804A0900;
constexpr int ORBIS_NGS2_ERROR_INVALID_PAN_UNIT_ANGLE = 0x804A0910;
constexpr int ORBIS_NGS2_ERROR_INVALID_PAN_SPEAKER = 0x804A0911;
constexpr int ORBIS_NGS2_ERROR_INVALID_PAN_MATRIX_FORMAT = 0x804A0912;
constexpr int ORBIS_NGS2_ERROR_INVALID_PAN_WORK = 0x804A0913;
constexpr int ORBIS_NGS2_ERROR_INVALID_PAN_PARAM = 0x804A0914;
constexpr int ORBIS_NGS2_ERROR_INVALID_GEOM_DISTANCE = 0x804A0920;
constexpr int ORBIS_NGS2_ERROR_INVALID_GEOM_LISTENER_ADDRESS = 0x804A0921;
constexpr int ORBIS_NGS2_ERROR_INVALID_GEOM_SOURCE_ADDRESS = 0x804A0922;
constexpr int ORBIS_NGS2_ERROR_INVALID_GEOM_FLAG = 0x804A0923;
constexpr int ORBIS_NGS2_ERROR_INVALID_GEOM_CONE = 0x804A0924;
constexpr int ORBIS_NGS2_ERROR_INVALID_MODULE_ID = 0x804A0A00;
constexpr int ORBIS_NGS2_ERROR_INVALID_NUM_MODULES = 0x804A0A01;
constexpr int ORBIS_NGS2_ERROR_INVALID_NUM_MODULE_BUFFERS = 0x804A0A02;
constexpr int ORBIS_NGS2_ERROR_INVALID_MODULE_BUFFER_ID = 0x804A0A03;
constexpr int ORBIS_NGS2_ERROR_INVALID_MODULE_STATE_OFFSET = 0x804A0A04;
constexpr int ORBIS_NGS2_ERROR_INVALID_MODULE_STATE_SIZE = 0x804A0A05;
constexpr int ORBIS_NGS2_ERROR_INVALID_VOICE_STATE_SIZE = 0x804A0A06;
constexpr int ORBIS_NGS2_ERROR_INVALID_MODULE_INDEX = 0x804A0B00;
constexpr int ORBIS_NGS2_ERROR_INVALID_MODULE_INFO_SIZE = 0x804A0B01;
| 7,750
|
C++
|
.h
| 116
| 65.801724
| 79
| 0.829556
|
shadps4-emu/shadPS4
| 9,253
| 501
| 185
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
15,832
|
playgo.h
|
shadps4-emu_shadPS4/src/core/libraries/playgo/playgo.h
|
// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
#pragma once
#include "common/types.h"
#include "playgo_types.h"
namespace Core::Loader {
class SymbolsResolver;
}
namespace Libraries::PlayGo {
constexpr int shadMagic = 0x53484144;
s32 PS4_SYSV_ABI sceDbgPlayGoRequestNextChunk();
s32 PS4_SYSV_ABI sceDbgPlayGoSnapshot();
s32 PS4_SYSV_ABI scePlayGoClose(OrbisPlayGoHandle handle);
s32 PS4_SYSV_ABI scePlayGoGetChunkId(OrbisPlayGoHandle handle, OrbisPlayGoChunkId* outChunkIdList,
u32 numberOfEntries, u32* outEntries);
s32 PS4_SYSV_ABI scePlayGoGetEta(OrbisPlayGoHandle handle, const OrbisPlayGoChunkId* chunkIds,
u32 numberOfEntries, OrbisPlayGoEta* outEta);
s32 PS4_SYSV_ABI scePlayGoGetInstallSpeed(OrbisPlayGoHandle handle,
OrbisPlayGoInstallSpeed* outSpeed);
s32 PS4_SYSV_ABI scePlayGoGetLanguageMask(OrbisPlayGoHandle handle,
OrbisPlayGoLanguageMask* outLanguageMask);
s32 PS4_SYSV_ABI scePlayGoGetLocus(OrbisPlayGoHandle handle, const OrbisPlayGoChunkId* chunkIds,
uint32_t numberOfEntries, OrbisPlayGoLocus* outLoci);
s32 PS4_SYSV_ABI scePlayGoGetProgress(OrbisPlayGoHandle handle, const OrbisPlayGoChunkId* chunkIds,
uint32_t numberOfEntries, OrbisPlayGoProgress* outProgress);
s32 PS4_SYSV_ABI scePlayGoGetToDoList(OrbisPlayGoHandle handle, OrbisPlayGoToDo* outTodoList,
u32 numberOfEntries, u32* outEntries);
s32 PS4_SYSV_ABI scePlayGoInitialize(OrbisPlayGoInitParams* param);
s32 PS4_SYSV_ABI scePlayGoOpen(OrbisPlayGoHandle* outHandle, const void* param);
s32 PS4_SYSV_ABI scePlayGoPrefetch(OrbisPlayGoHandle handle, const OrbisPlayGoChunkId* chunkIds,
u32 numberOfEntries, OrbisPlayGoLocus minimumLocus);
s32 PS4_SYSV_ABI scePlayGoSetInstallSpeed(OrbisPlayGoHandle handle, OrbisPlayGoInstallSpeed speed);
s32 PS4_SYSV_ABI scePlayGoSetLanguageMask(OrbisPlayGoHandle handle,
OrbisPlayGoLanguageMask languageMask);
s32 PS4_SYSV_ABI scePlayGoSetToDoList(OrbisPlayGoHandle handle, const OrbisPlayGoToDo* todoList,
uint32_t numberOfEntries);
s32 PS4_SYSV_ABI scePlayGoTerminate();
void RegisterlibScePlayGo(Core::Loader::SymbolsResolver* sym);
} // namespace Libraries::PlayGo
| 2,533
|
C++
|
.h
| 39
| 54.076923
| 99
| 0.728405
|
shadps4-emu/shadPS4
| 9,253
| 501
| 185
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
15,833
|
playgo_types.h
|
shadps4-emu_shadPS4/src/core/libraries/playgo/playgo_types.h
|
// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
#pragma once
#include "common/types.h"
typedef u32 OrbisPlayGoHandle;
typedef u16 OrbisPlayGoChunkId;
typedef s8 OrbisPlayGoLocus;
typedef s32 OrbisPlayGoInstallSpeed;
typedef s64 OrbisPlayGoEta;
typedef u64 OrbisPlayGoLanguageMask;
typedef struct OrbisPlayGoInitParams {
const void* bufAddr;
u32 bufSize;
u32 reserved;
} OrbisPlayGoInitParams;
typedef struct OrbisPlayGoToDo {
OrbisPlayGoChunkId chunkId;
OrbisPlayGoLocus locus;
s8 reserved;
} OrbisPlayGoToDo;
typedef struct OrbisPlayGoProgress {
uint64_t progressSize;
uint64_t totalSize;
} OrbisPlayGoProgress;
typedef enum OrbisPlayGoLocusValue {
ORBIS_PLAYGO_LOCUS_NOT_DOWNLOADED = 0,
ORBIS_PLAYGO_LOCUS_LOCAL_SLOW = 2,
ORBIS_PLAYGO_LOCUS_LOCAL_FAST = 3
} OrbisPlayGoLocusValue;
typedef enum OrbisPlayGoInstallSpeedValue {
ORBIS_PLAYGO_INSTALL_SPEED_SUSPENDED = 0,
ORBIS_PLAYGO_INSTALL_SPEED_TRICKLE = 1,
ORBIS_PLAYGO_INSTALL_SPEED_FULL = 2
} OrbisPlayGoInstallSpeedValue;
constexpr int ORBIS_PLAYGO_ERROR_UNKNOWN = -2135818239; /* 0x80B20001 */
constexpr int ORBIS_PLAYGO_ERROR_FATAL = -2135818238; /* 0x80B20002 */
constexpr int ORBIS_PLAYGO_ERROR_NO_MEMORY = -2135818237; /* 0x80B20003 */
constexpr int ORBIS_PLAYGO_ERROR_INVALID_ARGUMENT = -2135818236; /* 0x80B20004 */
constexpr int ORBIS_PLAYGO_ERROR_NOT_INITIALIZED = -2135818235; /* 0x80B20005 */
constexpr int ORBIS_PLAYGO_ERROR_ALREADY_INITIALIZED = -2135818234; /* 0x80B20006 */
constexpr int ORBIS_PLAYGO_ERROR_ALREADY_STARTED = -2135818233; /* 0x80B20007 */
constexpr int ORBIS_PLAYGO_ERROR_NOT_STARTED = -2135818232; /* 0x80B20008 */
constexpr int ORBIS_PLAYGO_ERROR_BAD_HANDLE = -2135818231; /* 0x80B20009 */
constexpr int ORBIS_PLAYGO_ERROR_BAD_POINTER = -2135818230; /* 0x80B2000A */
constexpr int ORBIS_PLAYGO_ERROR_BAD_SIZE = -2135818229; /* 0x80B2000B */
constexpr int ORBIS_PLAYGO_ERROR_BAD_CHUNK_ID = -2135818228; /* 0x80B2000C */
constexpr int ORBIS_PLAYGO_ERROR_BAD_SPEED = -2135818227; /* 0x80B2000D */
constexpr int ORBIS_PLAYGO_ERROR_NOT_SUPPORT_PLAYGO = -2135818226; /* 0x80B2000E */
constexpr int ORBIS_PLAYGO_ERROR_EPERM = -2135818225; /* 0x80B2000F */
constexpr int ORBIS_PLAYGO_ERROR_BAD_LOCUS = -2135818224; /* 0x80B20010 */
constexpr int ORBIS_PLAYGO_ERROR_NEED_DATA_DISC = -2135818223; /* 0x80B20011 */
| 2,551
|
C++
|
.h
| 51
| 47.745098
| 84
| 0.743075
|
shadps4-emu/shadPS4
| 9,253
| 501
| 185
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
15,834
|
audioin.h
|
shadps4-emu_shadPS4/src/core/libraries/audio/audioin.h
|
// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
#pragma once
#include "common/types.h"
namespace Core::Loader {
class SymbolsResolver;
}
namespace Libraries::AudioIn {
int PS4_SYSV_ABI sceAudioInChangeAppModuleState();
int PS4_SYSV_ABI sceAudioInClose();
int PS4_SYSV_ABI sceAudioInCountPorts();
int PS4_SYSV_ABI sceAudioInDeviceHqOpen();
int PS4_SYSV_ABI sceAudioInDeviceIdHqOpen();
int PS4_SYSV_ABI sceAudioInDeviceIdOpen();
int PS4_SYSV_ABI sceAudioInDeviceOpen();
int PS4_SYSV_ABI sceAudioInDeviceOpenEx();
int PS4_SYSV_ABI sceAudioInExtClose();
int PS4_SYSV_ABI sceAudioInExtCtrl();
int PS4_SYSV_ABI sceAudioInExtInput();
int PS4_SYSV_ABI sceAudioInExtOpen();
int PS4_SYSV_ABI sceAudioInExtSetAecMode();
int PS4_SYSV_ABI sceAudioInGetGain();
int PS4_SYSV_ABI sceAudioInGetHandleStatusInfo();
int PS4_SYSV_ABI sceAudioInGetRerouteCount();
int PS4_SYSV_ABI sceAudioInGetSilentState();
int PS4_SYSV_ABI sceAudioInHqOpen();
int PS4_SYSV_ABI sceAudioInHqOpenEx();
int PS4_SYSV_ABI sceAudioInInit();
int PS4_SYSV_ABI sceAudioInInput();
int PS4_SYSV_ABI sceAudioInInputs();
int PS4_SYSV_ABI sceAudioInIsSharedDevice();
int PS4_SYSV_ABI sceAudioInOpen();
int PS4_SYSV_ABI sceAudioInOpenEx();
int PS4_SYSV_ABI sceAudioInSetAllMute();
int PS4_SYSV_ABI sceAudioInSetCompressorPreGain();
int PS4_SYSV_ABI sceAudioInSetConnections();
int PS4_SYSV_ABI sceAudioInSetConnectionsForUser();
int PS4_SYSV_ABI sceAudioInSetDevConnection();
int PS4_SYSV_ABI sceAudioInSetFocusForUser();
int PS4_SYSV_ABI sceAudioInSetMode();
int PS4_SYSV_ABI sceAudioInSetMode2();
int PS4_SYSV_ABI sceAudioInSetPortConnections();
int PS4_SYSV_ABI sceAudioInSetPortStatuses();
int PS4_SYSV_ABI sceAudioInSetSparkParam();
int PS4_SYSV_ABI sceAudioInSetSparkSideTone();
int PS4_SYSV_ABI sceAudioInSetUsbGain();
int PS4_SYSV_ABI sceAudioInSetUserMute();
int PS4_SYSV_ABI sceAudioInVmicCreate();
int PS4_SYSV_ABI sceAudioInVmicDestroy();
int PS4_SYSV_ABI sceAudioInVmicWrite();
void RegisterlibSceAudioIn(Core::Loader::SymbolsResolver* sym);
} // namespace Libraries::AudioIn
| 2,108
|
C++
|
.h
| 52
| 39.423077
| 66
| 0.827317
|
shadps4-emu/shadPS4
| 9,253
| 501
| 185
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
15,835
|
audioout.h
|
shadps4-emu_shadPS4/src/core/libraries/audio/audioout.h
|
// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
#pragma once
#include "common/bit_field.h"
#include "core/libraries/system/userservice.h"
namespace Libraries::AudioOut {
constexpr int SCE_AUDIO_OUT_VOLUME_0DB = 32768; // max volume value
// 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
constexpr int SCE_AUDIO_OUT_NUM_PORTS = 22;
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 OrbisAudioOutParamFormat {
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
};
enum OrbisAudioOutParamAttr {
ORBIS_AUDIO_OUT_PARAM_ATTR_NONE = 0,
ORBIS_AUDIO_OUT_PARAM_ATTR_RESTRICTED = 1,
ORBIS_AUDIO_OUT_PARAM_ATTR_MIX_TO_MAIN = 2,
};
struct OrbisAudioOutParamExtendedInformation {
union {
BitField<0, 8, OrbisAudioOutParamFormat> data_format;
BitField<8, 8, u32> reserve0;
BitField<16, 4, OrbisAudioOutParamAttr> attributes;
BitField<20, 10, u32> reserve1;
BitField<31, 1, u32> unused;
};
};
struct OrbisAudioOutOutputParam {
s32 handle;
const void* ptr;
};
struct OrbisAudioOutPortState {
u16 output;
u8 channel;
u8 reserved8_1[1];
s16 volume;
u16 rerouteCounter;
u64 flag;
u64 reserved64[2];
};
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(s32 handle, OrbisAudioOutPortState* state);
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, OrbisAudioOutParamExtendedInformation param_type);
int PS4_SYSV_ABI sceAudioOutOpenEx();
s32 PS4_SYSV_ABI sceAudioOutOutput(s32 handle, const void* ptr);
s32 PS4_SYSV_ABI sceAudioOutOutputs(OrbisAudioOutOutputParam* param, u32 num);
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();
s32 PS4_SYSV_ABI sceAudioOutSetVolume(s32 handle, s32 flag, s32* vol);
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
| 5,733
|
C++
|
.h
| 130
| 41.315385
| 100
| 0.795312
|
shadps4-emu/shadPS4
| 9,253
| 501
| 185
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
15,836
|
rtc_error.h
|
shadps4-emu_shadPS4/src/core/libraries/rtc/rtc_error.h
|
// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
#pragma once
constexpr int ORBIS_RTC_ERROR_DATETIME_UNINITIALIZED = 0x7FFEF9FE;
constexpr int ORBIS_RTC_ERROR_INVALID_PARAMETER = 0x80010602;
constexpr int ORBIS_RTC_ERROR_INVALID_TICK_PARAMETER = 0x80010603;
constexpr int ORBIS_RTC_ERROR_INVALID_DATE_PARAMETER = 0x80010604;
constexpr int ORBIS_RTC_ERROR_NOT_IMPLEMENTED = 0x80010605;
constexpr int ORBIS_RTC_ERROR_INVALID_TIMEZONE_FORMAT = 0x80010607;
constexpr int ORBIS_RTC_ERROR_INVALID_YEARS_PARAMETER = 0x80010621;
constexpr int ORBIS_RTC_ERROR_INVALID_MONTHS_PARAMETER = 0x80010622;
constexpr int ORBIS_RTC_ERROR_INVALID_DAYS_PARAMETER = 0x80010623;
constexpr int ORBIS_RTC_ERROR_INVALID_HOURS_PARAMETER = 0x80010624;
constexpr int ORBIS_RTC_ERROR_INVALID_MINUTES_PARAMETER = 0x80010625;
constexpr int ORBIS_RTC_ERROR_INVALID_SECONDS_PARAMETER = 0x80010626;
constexpr int ORBIS_RTC_ERROR_INVALID_MILLISECONDS_PARAMETER = 0x80010627;
constexpr int ORBIS_RTC_ERROR_NOT_INITIALIZED = 0x80B50001;
constexpr int ORBIS_RTC_ERROR_INVALID_POINTER = 0x80B50002;
constexpr int ORBIS_RTC_ERROR_INVALID_VALUE = 0x80B50003;
constexpr int ORBIS_RTC_ERROR_INVALID_ARG = 0x80B50004;
constexpr int ORBIS_RTC_ERROR_NOT_SUPPORTED = 0x80B50005;
constexpr int ORBIS_RTC_ERROR_NO_CLOCK = 0x80B50006;
constexpr int ORBIS_RTC_ERROR_BAD_PARSE = 0x80B50007;
constexpr int ORBIS_RTC_ERROR_INVALID_YEAR = 0x80B50008;
constexpr int ORBIS_RTC_ERROR_INVALID_MONTH = 0x80B50009;
constexpr int ORBIS_RTC_ERROR_INVALID_DAY = 0x80B5000A;
constexpr int ORBIS_RTC_ERROR_INVALID_HOUR = 0x80B5000B;
constexpr int ORBIS_RTC_ERROR_INVALID_MINUTE = 0x80B5000C;
constexpr int ORBIS_RTC_ERROR_INVALID_SECOND = 0x80B5000D;
constexpr int ORBIS_RTC_ERROR_INVALID_MICROSECOND = 0x80B5000E;
| 1,813
|
C++
|
.h
| 30
| 59.4
| 74
| 0.829966
|
shadps4-emu/shadPS4
| 9,253
| 501
| 185
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
15,837
|
rtc.h
|
shadps4-emu_shadPS4/src/core/libraries/rtc/rtc.h
|
// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
#pragma once
#include "common/types.h"
namespace Core::Loader {
class SymbolsResolver;
}
namespace Libraries::Rtc {
constexpr int ORBIS_RTC_DAYOFWEEK_SUNDAY = 0;
constexpr int ORBIS_RTC_DAYOFWEEK_MONDAY = 1;
constexpr int ORBIS_RTC_DAYOFWEEK_TUESDAY = 2;
constexpr int ORBIS_RTC_DAYOFWEEK_WEDNESDAY = 3;
constexpr int ORBIS_RTC_DAYOFWEEK_THURSDAY = 4;
constexpr int ORBIS_RTC_DAYOFWEEK_FRIDAY = 5;
constexpr int ORBIS_RTC_DAYOFWEEK_SATURDAY = 6;
constexpr int64_t UNIX_EPOCH_TICKS = 0xdcbffeff2bc000;
constexpr int64_t WIN32_FILETIME_EPOCH_TICKS = 0xb36168b6a58000;
struct OrbisRtcTick {
uint64_t tick;
};
struct OrbisRtcDateTime {
uint16_t year;
uint16_t month;
uint16_t day;
uint16_t hour;
uint16_t minute;
uint16_t second;
uint32_t microsecond;
};
int PS4_SYSV_ABI sceRtcCheckValid(OrbisRtcDateTime* pTime);
int PS4_SYSV_ABI sceRtcCompareTick(OrbisRtcTick* pTick1, OrbisRtcTick* pTick2);
int PS4_SYSV_ABI sceRtcConvertLocalTimeToUtc(OrbisRtcTick* pTickLocal, OrbisRtcTick* pTickUtc);
int PS4_SYSV_ABI sceRtcConvertUtcToLocalTime(OrbisRtcTick* pTickUtc, OrbisRtcTick* pTickLocal);
int PS4_SYSV_ABI sceRtcEnd();
int PS4_SYSV_ABI sceRtcFormatRFC2822(char* pszDateTime, const OrbisRtcTick* pTickUtc, int minutes);
int PS4_SYSV_ABI sceRtcFormatRFC2822LocalTime(char* pszDateTime, const OrbisRtcTick* pTickUtc);
int PS4_SYSV_ABI sceRtcFormatRFC3339(char* pszDateTime, const OrbisRtcTick* pTickUtc, int minutes);
int PS4_SYSV_ABI sceRtcFormatRFC3339LocalTime(char* pszDateTime, const OrbisRtcTick* pTickUtc);
int PS4_SYSV_ABI sceRtcFormatRFC3339Precise(char* pszDateTime, const OrbisRtcTick* pTickUtc,
int minutes);
int PS4_SYSV_ABI sceRtcFormatRFC3339PreciseLocalTime(char* pszDateTime,
const OrbisRtcTick* pTickUtc);
int PS4_SYSV_ABI sceRtcGetCurrentAdNetworkTick(OrbisRtcTick* pTick);
int PS4_SYSV_ABI sceRtcGetCurrentClock(OrbisRtcDateTime* pTime, int timeZone);
int PS4_SYSV_ABI sceRtcGetCurrentClockLocalTime(OrbisRtcDateTime* pTime);
int PS4_SYSV_ABI sceRtcGetCurrentDebugNetworkTick(OrbisRtcTick* pTick);
int PS4_SYSV_ABI sceRtcGetCurrentNetworkTick(OrbisRtcTick* pTick);
int PS4_SYSV_ABI sceRtcGetCurrentRawNetworkTick(OrbisRtcTick* pTick);
int PS4_SYSV_ABI sceRtcGetCurrentTick(OrbisRtcTick* pTick);
int PS4_SYSV_ABI sceRtcGetDayOfWeek(int year, int month, int day);
int PS4_SYSV_ABI sceRtcGetDaysInMonth(int year, int month);
int PS4_SYSV_ABI sceRtcGetDosTime(OrbisRtcDateTime* pTime, unsigned int* dosTime);
int PS4_SYSV_ABI sceRtcGetTick(OrbisRtcDateTime* pTime, OrbisRtcTick* pTick);
unsigned int PS4_SYSV_ABI sceRtcGetTickResolution();
int PS4_SYSV_ABI sceRtcGetTime_t(OrbisRtcDateTime* pTime, time_t* llTime);
int PS4_SYSV_ABI sceRtcGetWin32FileTime(OrbisRtcDateTime* pTime, uint64_t* ulWin32Time);
int PS4_SYSV_ABI sceRtcInit();
int PS4_SYSV_ABI sceRtcIsLeapYear(int yearInt);
int PS4_SYSV_ABI sceRtcParseDateTime(OrbisRtcTick* pTickUtc, const char* pszDateTime);
int PS4_SYSV_ABI sceRtcParseRFC3339(OrbisRtcTick* pTickUtc, const char* pszDateTime);
int PS4_SYSV_ABI sceRtcSetConf();
int PS4_SYSV_ABI sceRtcSetCurrentAdNetworkTick(OrbisRtcTick* pTick);
int PS4_SYSV_ABI sceRtcSetCurrentDebugNetworkTick(OrbisRtcTick* pTick);
int PS4_SYSV_ABI sceRtcSetCurrentNetworkTick(OrbisRtcTick* pTick);
int PS4_SYSV_ABI sceRtcSetCurrentTick(OrbisRtcTick* pTick);
int PS4_SYSV_ABI sceRtcSetDosTime(OrbisRtcDateTime* pTime, u32 dosTime);
int PS4_SYSV_ABI sceRtcSetTick(OrbisRtcDateTime* pTime, OrbisRtcTick* pTick);
int PS4_SYSV_ABI sceRtcSetTime_t(OrbisRtcDateTime* pTime, time_t llTime);
int PS4_SYSV_ABI sceRtcSetWin32FileTime(OrbisRtcDateTime* pTime, int64_t ulWin32Time);
int PS4_SYSV_ABI sceRtcTickAddDays(OrbisRtcTick* pTick1, OrbisRtcTick* pTick2, int32_t lAdd);
int PS4_SYSV_ABI sceRtcTickAddHours(OrbisRtcTick* pTick1, OrbisRtcTick* pTick2, int32_t lAdd);
int PS4_SYSV_ABI sceRtcTickAddMicroseconds(OrbisRtcTick* pTick1, OrbisRtcTick* pTick2,
int64_t lAdd);
int PS4_SYSV_ABI sceRtcTickAddMinutes(OrbisRtcTick* pTick1, OrbisRtcTick* pTick2, int64_t lAdd);
int PS4_SYSV_ABI sceRtcTickAddMonths(OrbisRtcTick* pTick1, OrbisRtcTick* pTick2, int32_t lAdd);
int PS4_SYSV_ABI sceRtcTickAddSeconds(OrbisRtcTick* pTick1, OrbisRtcTick* pTick2, int64_t lAdd);
int PS4_SYSV_ABI sceRtcTickAddTicks(OrbisRtcTick* pTick1, OrbisRtcTick* pTick2, int64_t lAdd);
int PS4_SYSV_ABI sceRtcTickAddWeeks(OrbisRtcTick* pTick1, OrbisRtcTick* pTick2, int32_t lAdd);
int PS4_SYSV_ABI sceRtcTickAddYears(OrbisRtcTick* pTick1, OrbisRtcTick* pTick2, int32_t lAdd);
void RegisterlibSceRtc(Core::Loader::SymbolsResolver* sym);
} // namespace Libraries::Rtc
| 4,826
|
C++
|
.h
| 81
| 56.345679
| 99
| 0.801731
|
shadps4-emu/shadPS4
| 9,253
| 501
| 185
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
15,838
|
videodec2_impl.h
|
shadps4-emu_shadPS4/src/core/libraries/videodec/videodec2_impl.h
|
// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
#pragma once
#include <vector>
#include "videodec2.h"
extern "C" {
#include <libavcodec/avcodec.h>
#include <libavutil/imgutils.h>
#include <libswscale/swscale.h>
}
namespace Libraries::Vdec2 {
extern std::vector<OrbisVideodec2AvcPictureInfo> gPictureInfos;
class VdecDecoder {
public:
VdecDecoder(const OrbisVideodec2DecoderConfigInfo& configInfo,
const OrbisVideodec2DecoderMemoryInfo& memoryInfo);
~VdecDecoder();
s32 Decode(const OrbisVideodec2InputData& inputData, OrbisVideodec2FrameBuffer& frameBuffer,
OrbisVideodec2OutputInfo& outputInfo);
s32 Flush(OrbisVideodec2FrameBuffer& frameBuffer, OrbisVideodec2OutputInfo& outputInfo);
s32 Reset();
private:
AVFrame* ConvertNV12Frame(AVFrame& frame);
private:
AVCodecContext* mCodecContext = nullptr;
SwsContext* mSwsContext = nullptr;
};
} // namespace Libraries::Vdec2
| 1,046
|
C++
|
.h
| 28
| 32.392857
| 97
| 0.764293
|
shadps4-emu/shadPS4
| 9,253
| 501
| 185
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
15,839
|
videodec_impl.h
|
shadps4-emu_shadPS4/src/core/libraries/videodec/videodec_impl.h
|
// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
#pragma once
#include <vector>
#include "videodec.h"
extern "C" {
#include <libavcodec/avcodec.h>
#include <libavutil/imgutils.h>
#include <libswscale/swscale.h>
}
namespace Libraries::Videodec {
class VdecDecoder {
public:
VdecDecoder(const OrbisVideodecConfigInfo& pCfgInfoIn,
const OrbisVideodecResourceInfo& pRsrcInfoIn);
~VdecDecoder();
s32 Decode(const OrbisVideodecInputData& pInputDataIn,
OrbisVideodecFrameBuffer& pFrameBufferInOut,
OrbisVideodecPictureInfo& pPictureInfoOut);
s32 Flush(OrbisVideodecFrameBuffer& pFrameBufferInOut,
OrbisVideodecPictureInfo& pPictureInfoOut);
s32 Reset();
private:
AVFrame* ConvertNV12Frame(AVFrame& frame);
private:
AVCodecContext* mCodecContext = nullptr;
SwsContext* mSwsContext = nullptr;
};
} // namespace Libraries::Videodec
| 985
|
C++
|
.h
| 29
| 29.517241
| 66
| 0.759494
|
shadps4-emu/shadPS4
| 9,253
| 501
| 185
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
15,840
|
videodec.h
|
shadps4-emu_shadPS4/src/core/libraries/videodec/videodec.h
|
// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
#pragma once
#include "common/types.h"
namespace Core::Loader {
class SymbolsResolver;
}
namespace Libraries::Videodec {
struct OrbisVideodecConfigInfo {
u64 thisSize;
u32 codecType;
u32 profile;
u32 maxLevel;
s32 maxFrameWidth;
s32 maxFrameHeight;
s32 maxDpbFrameCount;
u64 videodecFlags;
};
struct OrbisVideodecResourceInfo {
u64 thisSize;
u64 cpuMemorySize;
void* pCpuMemory;
u64 cpuGpuMemorySize;
void* pCpuGpuMemory;
u64 maxFrameBufferSize;
u32 frameBufferAlignment;
};
struct OrbisVideodecCtrl {
u64 thisSize;
void* handle;
u64 version;
};
struct OrbisVideodecFrameBuffer {
u64 thisSize;
void* pFrameBuffer;
u64 frameBufferSize;
};
struct OrbisVideodecAvcInfo {
u32 numUnitsInTick;
u32 timeScale;
u8 fixedFrameRateFlag;
u8 aspectRatioIdc;
u16 sarWidth;
u16 sarHeight;
u8 colourPrimaries;
u8 transferCharacteristics;
u8 matrixCoefficients;
u8 videoFullRangeFlag;
u32 frameCropLeftOffset;
u32 frameCropRightOffset;
u32 frameCropTopOffset;
u32 frameCropBottomOffset;
};
union OrbisVideodecCodecInfo {
u8 reserved[64];
OrbisVideodecAvcInfo avc;
};
struct OrbisVideodecPictureInfo {
u64 thisSize;
u32 isValid;
u32 codecType;
u32 frameWidth;
u32 framePitch;
u32 frameHeight;
u32 isErrorPic;
u64 ptsData;
u64 attachedData;
OrbisVideodecCodecInfo codec;
};
struct OrbisVideodecInputData {
u64 thisSize;
void* pAuData;
u64 auSize;
u64 ptsData;
u64 dtsData;
u64 attachedData;
};
int PS4_SYSV_ABI sceVideodecCreateDecoder(const OrbisVideodecConfigInfo* pCfgInfoIn,
const OrbisVideodecResourceInfo* pRsrcInfoIn,
OrbisVideodecCtrl* pCtrlOut);
int PS4_SYSV_ABI sceVideodecDecode(OrbisVideodecCtrl* pCtrlIn,
const OrbisVideodecInputData* pInputDataIn,
OrbisVideodecFrameBuffer* pFrameBufferInOut,
OrbisVideodecPictureInfo* pPictureInfoOut);
int PS4_SYSV_ABI sceVideodecDeleteDecoder(OrbisVideodecCtrl* pCtrlIn);
int PS4_SYSV_ABI sceVideodecFlush(OrbisVideodecCtrl* pCtrlIn,
OrbisVideodecFrameBuffer* pFrameBufferInOut,
OrbisVideodecPictureInfo* pPictureInfoOut);
int PS4_SYSV_ABI sceVideodecMapMemory();
int PS4_SYSV_ABI sceVideodecQueryResourceInfo(const OrbisVideodecConfigInfo* pCfgInfoIn,
OrbisVideodecResourceInfo* pRsrcInfoOut);
int PS4_SYSV_ABI sceVideodecReset(OrbisVideodecCtrl* pCtrlIn);
void RegisterlibSceVideodec(Core::Loader::SymbolsResolver* sym);
} // namespace Libraries::Videodec
| 2,929
|
C++
|
.h
| 94
| 24.542553
| 88
| 0.710489
|
shadps4-emu/shadPS4
| 9,253
| 501
| 185
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
15,841
|
videodec2.h
|
shadps4-emu_shadPS4/src/core/libraries/videodec/videodec2.h
|
// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
#pragma once
#include "common/types.h"
#include "videodec2_avc.h"
namespace Core::Loader {
class SymbolsResolver;
}
namespace Libraries::Vdec2 {
class VdecDecoder;
using OrbisVideodec2Decoder = VdecDecoder*;
typedef void* OrbisVideodec2ComputeQueue;
struct OrbisVideodec2DecoderConfigInfo {
u64 thisSize;
u32 resourceType;
u32 codecType;
u32 profile;
u32 maxLevel;
s32 maxFrameWidth;
s32 maxFrameHeight;
s32 maxDpbFrameCount;
u32 decodePipelineDepth;
OrbisVideodec2ComputeQueue computeQueue;
u64 cpuAffinityMask;
s32 cpuThreadPriority;
bool optimizeProgressiveVideo;
bool checkMemoryType;
u8 reserved0;
u8 reserved1;
void* extraConfigInfo;
};
static_assert(sizeof(OrbisVideodec2DecoderConfigInfo) == 0x48);
struct OrbisVideodec2DecoderMemoryInfo {
u64 thisSize;
u64 cpuMemorySize;
void* cpuMemory;
u64 gpuMemorySize;
void* gpuMemory;
u64 cpuGpuMemorySize;
void* cpuGpuMemory;
u64 maxFrameBufferSize;
u32 frameBufferAlignment;
u32 reserved0;
};
static_assert(sizeof(OrbisVideodec2DecoderMemoryInfo) == 0x48);
struct OrbisVideodec2InputData {
u64 thisSize;
void* auData;
u64 auSize;
u64 ptsData;
u64 dtsData;
u64 attachedData;
};
static_assert(sizeof(OrbisVideodec2InputData) == 0x30);
struct OrbisVideodec2OutputInfo {
u64 thisSize;
bool isValid;
bool isErrorFrame;
u8 pictureCount;
u32 codecType;
u32 frameWidth;
u32 framePitch;
u32 frameHeight;
void* frameBuffer;
u64 frameBufferSize;
};
static_assert(sizeof(OrbisVideodec2OutputInfo) == 0x30);
struct OrbisVideodec2FrameBuffer {
u64 thisSize;
void* frameBuffer;
u64 frameBufferSize;
bool isAccepted;
};
static_assert(sizeof(OrbisVideodec2FrameBuffer) == 0x20);
struct OrbisVideodec2ComputeMemoryInfo {
u64 thisSize;
u64 cpuGpuMemorySize;
void* cpuGpuMemory;
};
static_assert(sizeof(OrbisVideodec2ComputeMemoryInfo) == 0x18);
struct OrbisVideodec2ComputeConfigInfo {
u64 thisSize;
u16 computePipeId;
u16 computeQueueId;
bool checkMemoryType;
u8 reserved0;
u16 reserved1;
};
static_assert(sizeof(OrbisVideodec2ComputeConfigInfo) == 0x10);
s32 PS4_SYSV_ABI
sceVideodec2QueryComputeMemoryInfo(OrbisVideodec2ComputeMemoryInfo* computeMemInfo);
s32 PS4_SYSV_ABI
sceVideodec2AllocateComputeQueue(const OrbisVideodec2ComputeConfigInfo* computeCfgInfo,
const OrbisVideodec2ComputeMemoryInfo* computeMemInfo,
OrbisVideodec2ComputeQueue* computeQueue);
s32 PS4_SYSV_ABI sceVideodec2ReleaseComputeQueue(OrbisVideodec2ComputeQueue computeQueue);
s32 PS4_SYSV_ABI
sceVideodec2QueryDecoderMemoryInfo(const OrbisVideodec2DecoderConfigInfo* decoderCfgInfo,
OrbisVideodec2DecoderMemoryInfo* decoderMemInfo);
s32 PS4_SYSV_ABI sceVideodec2CreateDecoder(const OrbisVideodec2DecoderConfigInfo* decoderCfgInfo,
const OrbisVideodec2DecoderMemoryInfo* decoderMemInfo,
OrbisVideodec2Decoder* decoder);
s32 PS4_SYSV_ABI sceVideodec2DeleteDecoder(OrbisVideodec2Decoder decoder);
s32 PS4_SYSV_ABI sceVideodec2Decode(OrbisVideodec2Decoder decoder,
const OrbisVideodec2InputData* inputData,
OrbisVideodec2FrameBuffer* frameBuffer,
OrbisVideodec2OutputInfo* outputInfo);
s32 PS4_SYSV_ABI sceVideodec2Flush(OrbisVideodec2Decoder decoder,
OrbisVideodec2FrameBuffer* frameBuffer,
OrbisVideodec2OutputInfo* outputInfo);
s32 PS4_SYSV_ABI sceVideodec2Reset(OrbisVideodec2Decoder decoder);
s32 PS4_SYSV_ABI sceVideodec2GetPictureInfo(const OrbisVideodec2OutputInfo* outputInfo,
void* p1stPictureInfo, void* p2ndPictureInfo);
void RegisterlibSceVdec2(Core::Loader::SymbolsResolver* sym);
} // namespace Libraries::Vdec2
| 4,338
|
C++
|
.h
| 115
| 29.817391
| 98
| 0.718391
|
shadps4-emu/shadPS4
| 9,253
| 501
| 185
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
15,842
|
videodec2_avc.h
|
shadps4-emu_shadPS4/src/core/libraries/videodec/videodec2_avc.h
|
// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
#pragma once
#include "common/types.h"
namespace Libraries::Vdec2 {
struct OrbisVideodec2AvcPictureInfo {
u64 thisSize;
bool isValid;
u64 ptsData;
u64 dtsData;
u64 attachedData;
u8 idrPictureflag;
u8 profile_idc;
u8 level_idc;
u32 pic_width_in_mbs_minus1;
u32 pic_height_in_map_units_minus1;
u8 frame_mbs_only_flag;
u8 frame_cropping_flag;
u32 frameCropLeftOffset;
u32 frameCropRightOffset;
u32 frameCropTopOffset;
u32 frameCropBottomOffset;
u8 aspect_ratio_info_present_flag;
u8 aspect_ratio_idc;
u16 sar_width;
u16 sar_height;
u8 video_signal_type_present_flag;
u8 video_format;
u8 video_full_range_flag;
u8 colour_description_present_flag;
u8 colour_primaries;
u8 transfer_characteristics;
u8 matrix_coefficients;
u8 timing_info_present_flag;
u32 num_units_in_tick;
u32 time_scale;
u8 fixed_frame_rate_flag;
u8 bitstream_restriction_flag;
u8 max_dec_frame_buffering;
u8 pic_struct_present_flag;
u8 pic_struct;
u8 field_pic_flag;
u8 bottom_field_flag;
};
} // namespace Libraries::Vdec2
| 1,322
|
C++
|
.h
| 45
| 23.466667
| 67
| 0.700321
|
shadps4-emu/shadPS4
| 9,253
| 501
| 185
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
15,843
|
avplayer_state.h
|
shadps4-emu_shadPS4/src/core/libraries/avplayer/avplayer_state.h
|
// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
#pragma once
#include "avplayer.h"
#include "avplayer_data_streamer.h"
#include "avplayer_source.h"
#include "common/polyfill_thread.h"
#include "core/libraries/kernel/thread_management.h"
#include <memory>
#include <mutex>
#include <shared_mutex>
namespace Libraries::AvPlayer {
class Stream;
class AvDecoder;
class AvPlayerState : public AvPlayerStateCallback {
public:
AvPlayerState(const SceAvPlayerInitData& init_data);
~AvPlayerState();
void PostInit(const SceAvPlayerPostInitData& post_init_data);
bool AddSource(std::string_view filename, SceAvPlayerSourceType source_type);
s32 GetStreamCount();
bool GetStreamInfo(u32 stream_index, SceAvPlayerStreamInfo& info);
bool EnableStream(u32 stream_index);
bool Start();
bool Stop();
bool GetAudioData(SceAvPlayerFrameInfo& audio_info);
bool GetVideoData(SceAvPlayerFrameInfo& video_info);
bool GetVideoData(SceAvPlayerFrameInfoEx& video_info);
bool IsActive();
u64 CurrentTime();
bool SetLooping(bool is_looping);
private:
// Event Replacement
static void PS4_SYSV_ABI AutoPlayEventCallback(void* handle, SceAvPlayerEvents event_id,
s32 source_id, void* event_data);
static void PS4_SYSV_ABI DefaultEventCallback(void* handle, SceAvPlayerEvents event_id,
s32 source_id, void* event_data);
void OnWarning(u32 id) override;
void OnError() override;
void OnEOF() override;
void OnPlaybackStateChanged(AvState state);
std::optional<bool> OnBufferingCheckEvent(u32 num_frames);
void EmitEvent(SceAvPlayerEvents event_id, void* event_data = nullptr);
bool SetState(AvState state);
void AvControllerThread(std::stop_token stop);
void AddSourceEvent();
void WarningEvent(s32 id);
void StartControllerThread();
void ProcessEvent();
void UpdateBufferingState();
bool IsStateTransitionValid(AvState state);
std::unique_ptr<AvPlayerSource> m_up_source;
SceAvPlayerInitData m_init_data{};
SceAvPlayerPostInitData m_post_init_data{};
SceAvPlayerEventReplacement m_event_replacement{};
bool m_auto_start{};
u8 m_default_language[4]{};
std::atomic<AvState> m_current_state;
std::atomic<AvState> m_previous_state;
u32 m_thread_priority;
u32 m_thread_affinity;
std::atomic_uint32_t m_some_event_result{};
std::shared_mutex m_source_mutex{};
std::mutex m_state_machine_mutex{};
std::mutex m_event_handler_mutex{};
std::jthread m_controller_thread{};
AvPlayerQueue<AvPlayerEvent> m_event_queue{};
};
} // namespace Libraries::AvPlayer
| 2,794
|
C++
|
.h
| 69
| 34.942029
| 92
| 0.727071
|
shadps4-emu/shadPS4
| 9,253
| 501
| 185
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
15,844
|
avplayer_file_streamer.h
|
shadps4-emu_shadPS4/src/core/libraries/avplayer/avplayer_file_streamer.h
|
// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
#pragma once
#include "avplayer.h"
#include "avplayer_data_streamer.h"
#include <string_view>
#include <vector>
struct AVIOContext;
namespace Libraries::AvPlayer {
class AvPlayerFileStreamer : public IDataStreamer {
public:
AvPlayerFileStreamer(const SceAvPlayerFileReplacement& file_replacement);
~AvPlayerFileStreamer();
bool Init(std::string_view path) override;
AVIOContext* GetContext() override {
return m_avio_context;
}
private:
static s32 ReadPacket(void* opaque, u8* buffer, s32 size);
static s64 Seek(void* opaque, s64 buffer, int whence);
SceAvPlayerFileReplacement m_file_replacement;
int m_fd = -1;
u64 m_position{};
u64 m_file_size{};
AVIOContext* m_avio_context{};
};
} // namespace Libraries::AvPlayer
| 899
|
C++
|
.h
| 27
| 29.777778
| 77
| 0.751163
|
shadps4-emu/shadPS4
| 9,253
| 501
| 185
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
15,845
|
avplayer.h
|
shadps4-emu_shadPS4/src/core/libraries/avplayer/avplayer.h
|
// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
#pragma once
#include "common/types.h"
#include <stdarg.h> // va_list
#include <stddef.h> // size_t
namespace Core::Loader {
class SymbolsResolver;
}
namespace Libraries::AvPlayer {
class AvPlayer;
using SceAvPlayerHandle = AvPlayer*;
enum SceAvPlayerUriType { SCE_AVPLAYER_URI_TYPE_SOURCE = 0 };
struct SceAvPlayerUri {
const char* name;
u32 length;
};
enum SceAvPlayerSourceType {
SCE_AVPLAYER_SOURCE_TYPE_UNKNOWN = 0,
SCE_AVPLAYER_SOURCE_TYPE_FILE_MP4 = 1,
SCE_AVPLAYER_SOURCE_TYPE_HLS = 8
};
struct SceAvPlayerSourceDetails {
SceAvPlayerUri uri;
u8 reserved1[64];
SceAvPlayerSourceType source_type;
u8 reserved2[44];
};
struct SceAvPlayerAudio {
u16 channel_count;
u8 reserved1[2];
u32 sample_rate;
u32 size;
u8 language_code[4];
};
struct SceAvPlayerVideo {
u32 width;
u32 height;
f32 aspect_ratio;
u8 language_code[4];
};
struct SceAvPlayerTextPosition {
u16 top;
u16 left;
u16 bottom;
u16 right;
};
struct SceAvPlayerTimedText {
u8 language_code[4];
u16 text_size;
u16 font_size;
SceAvPlayerTextPosition position;
};
union SceAvPlayerStreamDetails {
u8 reserved[16];
SceAvPlayerAudio audio;
SceAvPlayerVideo video;
SceAvPlayerTimedText subs;
};
struct SceAvPlayerFrameInfo {
u8* pData;
u8 reserved[4];
u64 timestamp;
SceAvPlayerStreamDetails details;
};
struct SceAvPlayerStreamInfo {
u32 type;
u8 reserved[4];
SceAvPlayerStreamDetails details;
u64 duration;
u64 start_time;
};
struct SceAvPlayerAudioEx {
u16 channel_count;
u8 reserved[2];
u32 sample_rate;
u32 size;
u8 language_code[4];
u8 reserved1[64];
};
struct SceAvPlayerVideoEx {
u32 width;
u32 height;
f32 aspect_ratio;
u8 language_code[4];
u32 framerate;
u32 crop_left_offset;
u32 crop_right_offset;
u32 crop_top_offset;
u32 crop_bottom_offset;
u32 pitch;
u8 luma_bit_depth;
u8 chroma_bit_depth;
bool video_full_range_flag;
u8 reserved1[37];
};
struct SceAvPlayerTimedTextEx {
u8 language_code[4];
u8 reserved[12];
u8 reserved1[64];
};
union SceAvPlayerStreamDetailsEx {
SceAvPlayerAudioEx audio;
SceAvPlayerVideoEx video;
SceAvPlayerTimedTextEx subs;
u8 reserved1[80];
};
struct SceAvPlayerFrameInfoEx {
void* pData;
u8 reserved[4];
u64 timestamp;
SceAvPlayerStreamDetailsEx details;
};
typedef void* PS4_SYSV_ABI (*SceAvPlayerAllocate)(void* p, u32 align, u32 size);
typedef void PS4_SYSV_ABI (*SceAvPlayerDeallocate)(void* p, void* mem);
typedef void* PS4_SYSV_ABI (*SceAvPlayerAllocateTexture)(void* p, u32 align, u32 size);
typedef void PS4_SYSV_ABI (*SceAvPlayerDeallocateTexture)(void* p, void* mem);
struct SceAvPlayerMemAllocator {
void* object_ptr;
SceAvPlayerAllocate allocate;
SceAvPlayerDeallocate deallocate;
SceAvPlayerAllocateTexture allocate_texture;
SceAvPlayerDeallocateTexture deallocate_texture;
};
typedef s32 PS4_SYSV_ABI (*SceAvPlayerOpenFile)(void* p, const char* name);
typedef s32 PS4_SYSV_ABI (*SceAvPlayerCloseFile)(void* p);
typedef s32 PS4_SYSV_ABI (*SceAvPlayerReadOffsetFile)(void* p, u8* buf, u64 pos, u32 len);
typedef u64 PS4_SYSV_ABI (*SceAvPlayerSizeFile)(void* p);
struct SceAvPlayerFileReplacement {
void* object_ptr;
SceAvPlayerOpenFile open;
SceAvPlayerCloseFile close;
SceAvPlayerReadOffsetFile readOffset;
SceAvPlayerSizeFile size;
};
enum SceAvPlayerEvents {
SCE_AVPLAYER_STATE_STOP = 0x01,
SCE_AVPLAYER_STATE_READY = 0x02,
SCE_AVPLAYER_STATE_PLAY = 0x03,
SCE_AVPLAYER_STATE_PAUSE = 0x04,
SCE_AVPLAYER_STATE_BUFFERING = 0x05,
SCE_AVPLAYER_TIMED_TEXT_DELIVERY = 0x10,
SCE_AVPLAYER_WARNING_ID = 0x20,
SCE_AVPLAYER_ENCRYPTION = 0x30,
SCE_AVPLAYER_DRM_ERROR = 0x40
};
typedef void PS4_SYSV_ABI (*SceAvPlayerEventCallback)(void* p, SceAvPlayerEvents event, s32 src_id,
void* data);
struct SceAvPlayerEventReplacement {
void* object_ptr;
SceAvPlayerEventCallback event_callback;
};
enum SceAvPlayerDebuglevels {
SCE_AVPLAYER_DBG_NONE,
SCE_AVPLAYER_DBG_INFO,
SCE_AVPLAYER_DBG_WARNINGS,
SCE_AVPLAYER_DBG_ALL
};
struct SceAvPlayerInitData {
SceAvPlayerMemAllocator memory_replacement;
SceAvPlayerFileReplacement file_replacement;
SceAvPlayerEventReplacement event_replacement;
SceAvPlayerDebuglevels debug_level;
u32 base_priority;
s32 num_output_video_framebuffers;
bool auto_start;
u8 reserved[3];
const char* default_language;
};
struct SceAvPlayerInitDataEx {
size_t this_size;
SceAvPlayerMemAllocator memory_replacement;
SceAvPlayerFileReplacement file_replacement;
SceAvPlayerEventReplacement event_replacement;
const char* default_language;
SceAvPlayerDebuglevels debug_level;
u32 audio_decoder_priority;
u32 audio_decoder_affinity;
u32 video_decoder_priority;
u32 video_decoder_affinity;
u32 demuxer_priority;
u32 demuxer_affinity;
u32 controller_priority;
u32 controller_affinity;
u32 http_streaming_priority;
u32 http_streaming_affinity;
u32 file_streaming_priority;
u32 file_streaming_affinity;
s32 num_output_video_framebuffers;
bool auto_start;
u8 reserved[3];
};
enum SceAvPlayerStreamType {
SCE_AVPLAYER_VIDEO,
SCE_AVPLAYER_AUDIO,
SCE_AVPLAYER_TIMEDTEXT,
SCE_AVPLAYER_UNKNOWN
};
enum SceAvPlayerVideoDecoderType {
SCE_AVPLAYER_VIDEO_DECODER_TYPE_DEFAULT = 0,
SCE_AVPLAYER_VIDEO_DECODER_TYPE_RESERVED1,
SCE_AVPLAYER_VIDEO_DECODER_TYPE_SOFTWARE,
SCE_AVPLAYER_VIDEO_DECODER_TYPE_SOFTWARE2
};
enum SceAvPlayerAudioDecoderType {
SCE_AVPLAYER_AUDIO_DECODER_TYPE_DEFAULT = 0,
SCE_AVPLAYER_AUDIO_DECODER_TYPE_RESERVED1,
SCE_AVPLAYER_AUDIO_DECODER_TYPE_RESERVED2
};
struct SceAvPlayerDecoderInit {
union {
SceAvPlayerVideoDecoderType video_type;
SceAvPlayerAudioDecoderType audio_type;
u8 reserved[4];
} decoderType;
union {
struct {
s32 cpu_affinity_mask;
s32 cpu_thread_priority;
u8 decode_pipeline_depth;
u8 compute_pipe_id;
u8 compute_queue_id;
u8 enable_interlaced;
u8 reserved[16];
} avcSw2;
struct {
u8 audio_channel_order;
u8 reserved[27];
} aac;
u8 reserved[28];
} decoderParams;
};
struct SceAvPlayerHTTPCtx {
u32 http_context_id;
u32 ssl_context_id;
};
struct SceAvPlayerPostInitData {
u32 demux_video_buffer_size;
SceAvPlayerDecoderInit video_decoder_init;
SceAvPlayerDecoderInit audio_decoder_init;
SceAvPlayerHTTPCtx http_context;
u8 reserved[56];
};
enum SceAvPlayerAvSyncMode {
SCE_AVPLAYER_AV_SYNC_MODE_DEFAULT = 0,
SCE_AVPLAYER_AV_SYNC_MODE_NONE
};
typedef int PS4_SYSV_ABI (*SceAvPlayerLogCallback)(void* p, const char* format, va_list args);
void RegisterlibSceAvPlayer(Core::Loader::SymbolsResolver* sym);
} // namespace Libraries::AvPlayer
| 7,248
|
C++
|
.h
| 250
| 24.532
| 99
| 0.730697
|
shadps4-emu/shadPS4
| 9,253
| 501
| 185
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
15,846
|
avplayer_common.h
|
shadps4-emu_shadPS4/src/core/libraries/avplayer/avplayer_common.h
|
// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
#pragma once
#include "avplayer.h"
#include "common/assert.h"
#include "common/logging/log.h"
#include "core/libraries/kernel/thread_management.h"
#include <optional>
#include <utility>
#include <queue>
#define AVPLAYER_IS_ERROR(x) ((x) < 0)
namespace Libraries::AvPlayer {
enum class AvState {
Initial,
AddingSource,
Ready,
Play,
Stop,
EndOfFile,
Pause,
C0x08,
Jump,
TrickMode,
C0x0B,
Buffering,
Starting,
Error,
};
enum class AvEventType {
ChangeFlowState = 21,
WarningId = 22,
RevertState = 30,
AddSource = 40,
Error = 255,
};
union AvPlayerEventData {
u32 num_frames; // 20
AvState state; // AvEventType::ChangeFlowState
s32 error; // AvEventType::WarningId
u32 attempt; // AvEventType::AddSource
};
struct AvPlayerEvent {
AvEventType event;
AvPlayerEventData payload;
};
template <class T>
class AvPlayerQueue {
public:
size_t Size() {
return m_queue.size();
}
void Push(T&& value) {
std::lock_guard guard(m_mutex);
m_queue.emplace(std::forward<T>(value));
}
std::optional<T> Pop() {
if (Size() == 0) {
return std::nullopt;
}
std::lock_guard guard(m_mutex);
auto result = std::move(m_queue.front());
m_queue.pop();
return result;
}
void Clear() {
std::lock_guard guard(m_mutex);
m_queue = {};
}
private:
std::mutex m_mutex{};
std::queue<T> m_queue{};
};
SceAvPlayerSourceType GetSourceType(std::string_view path);
} // namespace Libraries::AvPlayer
| 1,732
|
C++
|
.h
| 74
| 18.932432
| 66
| 0.646557
|
shadps4-emu/shadPS4
| 9,253
| 501
| 185
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
15,847
|
avplayer_impl.h
|
shadps4-emu_shadPS4/src/core/libraries/avplayer/avplayer_impl.h
|
// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
#pragma once
#include "avplayer.h"
#include "avplayer_data_streamer.h"
#include "avplayer_state.h"
#include "core/libraries/kernel/thread_management.h"
#include <mutex>
extern "C" {
#include <libavcodec/avcodec.h>
#include <libavformat/avformat.h>
}
#include <memory>
#include <vector>
namespace Libraries::AvPlayer {
class AvPlayer {
public:
AvPlayer(const SceAvPlayerInitData& data);
s32 PostInit(const SceAvPlayerPostInitData& data);
s32 AddSource(std::string_view filename);
s32 GetStreamCount();
s32 GetStreamInfo(u32 stream_index, SceAvPlayerStreamInfo& info);
s32 EnableStream(u32 stream_index);
s32 Start();
bool GetAudioData(SceAvPlayerFrameInfo& audio_info);
bool GetVideoData(SceAvPlayerFrameInfo& video_info);
bool GetVideoData(SceAvPlayerFrameInfoEx& video_info);
bool IsActive();
u64 CurrentTime();
s32 Stop();
bool SetLooping(bool is_looping);
private:
// Memory Replacement
static void* PS4_SYSV_ABI Allocate(void* handle, u32 alignment, u32 size);
static void PS4_SYSV_ABI Deallocate(void* handle, void* memory);
static void* PS4_SYSV_ABI AllocateTexture(void* handle, u32 alignment, u32 size);
static void PS4_SYSV_ABI DeallocateTexture(void* handle, void* memory);
// File Replacement
static int PS4_SYSV_ABI OpenFile(void* handle, const char* filename);
static int PS4_SYSV_ABI CloseFile(void* handle);
static int PS4_SYSV_ABI ReadOffsetFile(void* handle, u8* buffer, u64 position, u32 length);
static u64 PS4_SYSV_ABI SizeFile(void* handle);
SceAvPlayerInitData StubInitData(const SceAvPlayerInitData& data);
SceAvPlayerInitData m_init_data{};
SceAvPlayerInitData m_init_data_original{};
std::mutex m_file_io_mutex{};
std::atomic_bool m_has_source{};
std::unique_ptr<AvPlayerState> m_state{};
};
} // namespace Libraries::AvPlayer
| 1,999
|
C++
|
.h
| 50
| 36.28
| 95
| 0.753361
|
shadps4-emu/shadPS4
| 9,253
| 501
| 185
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
15,848
|
avplayer_source.h
|
shadps4-emu_shadPS4/src/core/libraries/avplayer/avplayer_source.h
|
// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
#pragma once
#include "avplayer.h"
#include "avplayer_common.h"
#include "avplayer_data_streamer.h"
#include "common/polyfill_thread.h"
#include "common/types.h"
#include "core/libraries/kernel/thread_management.h"
#include <atomic>
#include <chrono>
#include <condition_variable>
#include <mutex>
#include <optional>
#include <string>
struct AVCodecContext;
struct AVFormatContext;
struct AVFrame;
struct AVIOContext;
struct AVPacket;
struct SwrContext;
struct SwsContext;
namespace Libraries::AvPlayer {
class AvPlayerStateCallback {
public:
virtual ~AvPlayerStateCallback() = default;
virtual void OnWarning(u32 id) = 0;
virtual void OnError() = 0;
virtual void OnEOF() = 0;
};
class FrameBuffer {
public:
FrameBuffer(const SceAvPlayerMemAllocator& memory_replacement, u32 align, u32 size) noexcept
: m_memory_replacement(memory_replacement),
m_data(Allocate(memory_replacement, align, size)) {
ASSERT_MSG(m_data, "Could not allocated frame buffer.");
}
~FrameBuffer() {
if (m_data != nullptr) {
Deallocate(m_memory_replacement, m_data);
m_data = {};
}
}
FrameBuffer(const FrameBuffer&) noexcept = delete;
FrameBuffer& operator=(const FrameBuffer&) noexcept = delete;
FrameBuffer(FrameBuffer&& r) noexcept
: m_memory_replacement(r.m_memory_replacement), m_data(r.m_data) {
r.m_data = nullptr;
};
FrameBuffer& operator=(FrameBuffer&& r) noexcept {
std::swap(m_data, r.m_data);
return *this;
}
u8* GetBuffer() const noexcept {
return m_data;
}
private:
static u8* Allocate(const SceAvPlayerMemAllocator& memory_replacement, u32 align, u32 size) {
return reinterpret_cast<u8*>(
memory_replacement.allocate(memory_replacement.object_ptr, align, size));
}
static void Deallocate(const SceAvPlayerMemAllocator& memory_replacement, void* ptr) {
memory_replacement.deallocate(memory_replacement.object_ptr, ptr);
}
const SceAvPlayerMemAllocator& m_memory_replacement;
u8* m_data = nullptr;
};
struct Frame {
FrameBuffer buffer;
SceAvPlayerFrameInfoEx info;
};
class EventCV {
public:
template <class Pred>
void Wait(Pred pred) {
std::unique_lock lock(m_mutex);
m_cv.wait(lock, std::move(pred));
}
template <class Pred>
bool Wait(std::stop_token stop, Pred pred) {
std::unique_lock lock(m_mutex);
return m_cv.wait(lock, std::move(stop), std::move(pred));
}
template <class Pred, class Rep, class Period>
bool WaitFor(std::chrono::duration<Rep, Period> timeout, Pred pred) {
std::unique_lock lock(m_mutex);
return m_cv.wait_for(lock, timeout, std::move(pred));
}
void Notify() {
std::unique_lock lock(m_mutex);
m_cv.notify_all();
}
private:
std::mutex m_mutex{};
std::condition_variable_any m_cv{};
};
class AvPlayerSource {
public:
AvPlayerSource(AvPlayerStateCallback& state, bool use_vdec2);
~AvPlayerSource();
bool Init(const SceAvPlayerInitData& init_data, std::string_view path);
bool FindStreamInfo();
s32 GetStreamCount();
bool GetStreamInfo(u32 stream_index, SceAvPlayerStreamInfo& info);
bool EnableStream(u32 stream_index);
void SetLooping(bool is_looping);
std::optional<bool> HasFrames(u32 num_frames);
bool Start();
bool Stop();
bool GetAudioData(SceAvPlayerFrameInfo& audio_info);
bool GetVideoData(SceAvPlayerFrameInfo& video_info);
bool GetVideoData(SceAvPlayerFrameInfoEx& video_info);
u64 CurrentTime();
bool IsActive();
private:
using ScePthread = Kernel::ScePthread;
static void ReleaseAVPacket(AVPacket* packet);
static void ReleaseAVFrame(AVFrame* frame);
static void ReleaseAVCodecContext(AVCodecContext* context);
static void ReleaseSWRContext(SwrContext* context);
static void ReleaseSWSContext(SwsContext* context);
static void ReleaseAVFormatContext(AVFormatContext* context);
using AVPacketPtr = std::unique_ptr<AVPacket, decltype(&ReleaseAVPacket)>;
using AVFramePtr = std::unique_ptr<AVFrame, decltype(&ReleaseAVFrame)>;
using AVCodecContextPtr = std::unique_ptr<AVCodecContext, decltype(&ReleaseAVCodecContext)>;
using SWRContextPtr = std::unique_ptr<SwrContext, decltype(&ReleaseSWRContext)>;
using SWSContextPtr = std::unique_ptr<SwsContext, decltype(&ReleaseSWSContext)>;
using AVFormatContextPtr = std::unique_ptr<AVFormatContext, decltype(&ReleaseAVFormatContext)>;
void DemuxerThread(std::stop_token stop);
void VideoDecoderThread(std::stop_token stop);
void AudioDecoderThread(std::stop_token stop);
bool HasRunningThreads() const;
AVFramePtr ConvertAudioFrame(const AVFrame& frame);
AVFramePtr ConvertVideoFrame(const AVFrame& frame);
Frame PrepareAudioFrame(FrameBuffer buffer, const AVFrame& frame);
Frame PrepareVideoFrame(FrameBuffer buffer, const AVFrame& frame);
AvPlayerStateCallback& m_state;
bool m_use_vdec2 = false;
SceAvPlayerMemAllocator m_memory_replacement{};
u32 m_num_output_video_framebuffers{};
std::atomic_bool m_is_looping = false;
std::atomic_bool m_is_eof = false;
std::unique_ptr<IDataStreamer> m_up_data_streamer;
AvPlayerQueue<FrameBuffer> m_audio_buffers;
AvPlayerQueue<FrameBuffer> m_video_buffers;
AvPlayerQueue<AVPacketPtr> m_audio_packets;
AvPlayerQueue<AVPacketPtr> m_video_packets;
AvPlayerQueue<Frame> m_audio_frames;
AvPlayerQueue<Frame> m_video_frames;
std::optional<FrameBuffer> m_current_video_frame;
std::optional<FrameBuffer> m_current_audio_frame;
std::optional<s32> m_video_stream_index{};
std::optional<s32> m_audio_stream_index{};
EventCV m_audio_packets_cv{};
EventCV m_audio_frames_cv{};
EventCV m_audio_buffers_cv{};
EventCV m_video_packets_cv{};
EventCV m_video_frames_cv{};
EventCV m_video_buffers_cv{};
EventCV m_stop_cv{};
std::mutex m_state_mutex{};
std::jthread m_demuxer_thread{};
std::jthread m_video_decoder_thread{};
std::jthread m_audio_decoder_thread{};
AVFormatContextPtr m_avformat_context{nullptr, &ReleaseAVFormatContext};
AVCodecContextPtr m_video_codec_context{nullptr, &ReleaseAVCodecContext};
AVCodecContextPtr m_audio_codec_context{nullptr, &ReleaseAVCodecContext};
SWRContextPtr m_swr_context{nullptr, &ReleaseSWRContext};
SWSContextPtr m_sws_context{nullptr, &ReleaseSWSContext};
std::chrono::high_resolution_clock::time_point m_start_time{};
};
} // namespace Libraries::AvPlayer
| 6,774
|
C++
|
.h
| 172
| 34.44186
| 99
| 0.725359
|
shadps4-emu/shadPS4
| 9,253
| 501
| 185
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
15,849
|
avplayer_data_streamer.h
|
shadps4-emu_shadPS4/src/core/libraries/avplayer/avplayer_data_streamer.h
|
// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
#pragma once
#include "avplayer.h"
#include "common/types.h"
#include <string_view>
struct AVIOContext;
namespace Libraries::AvPlayer {
class IDataStreamer {
public:
virtual ~IDataStreamer() = default;
virtual bool Init(std::string_view path) = 0;
virtual AVIOContext* GetContext() = 0;
};
} // namespace Libraries::AvPlayer
| 457
|
C++
|
.h
| 15
| 28.133333
| 66
| 0.767281
|
shadps4-emu/shadPS4
| 9,253
| 501
| 185
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
15,850
|
event_queue.h
|
shadps4-emu_shadPS4/src/core/libraries/kernel/event_queue.h
|
// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
#pragma once
#include <condition_variable>
#include <mutex>
#include <string>
#include <vector>
#include <boost/asio/steady_timer.hpp>
#include "common/types.h"
namespace Libraries::Kernel {
class EqueueInternal;
struct EqueueEvent;
struct SceKernelEvent {
enum Filter : s16 {
None = 0,
Read = -1,
Write = -2,
Aio = -3,
Vnode = -4,
Proc = -5,
Signal = -6,
Timer = -7,
Fs = -9,
Lio = -10,
User = -11,
Polling = -12,
VideoOut = -13,
GraphicsCore = -14,
HrTimer = -15,
};
enum Flags : u16 {
Add = 1u,
Delete = 2u,
Enable = 4u,
Disable = 8u,
OneShot = 0x10u,
Clear = 0x20u,
Receipt = 0x40u,
Dispatch = 0x80u,
Flag1 = 0x2000u,
System = 0xf000u,
};
u64 ident = 0; /* identifier for this event */
Filter filter = Filter::None; /* filter for event */
u16 flags = 0;
u32 fflags = 0;
u64 data = 0;
void* udata = nullptr; /* opaque user data identifier */
};
struct EqueueEvent {
SceKernelEvent event;
void* data = nullptr;
std::chrono::steady_clock::time_point time_added;
std::unique_ptr<boost::asio::steady_timer> timer;
void Reset() {
is_triggered = false;
event.fflags = 0;
event.data = 0;
}
void Trigger(void* data) {
is_triggered = true;
event.fflags++;
event.data = reinterpret_cast<uintptr_t>(data);
}
bool IsTriggered() const {
return is_triggered;
}
bool operator==(const EqueueEvent& ev) const {
return ev.event.ident == event.ident;
}
private:
bool is_triggered = false;
};
class EqueueInternal {
public:
EqueueInternal() = default;
virtual ~EqueueInternal();
void setName(const std::string& m_name) {
this->m_name = m_name;
}
const auto& GetName() const {
return m_name;
}
bool AddEvent(EqueueEvent& event);
bool RemoveEvent(u64 id);
int WaitForEvents(SceKernelEvent* ev, int num, u32 micros);
bool TriggerEvent(u64 ident, s16 filter, void* trigger_data);
int GetTriggeredEvents(SceKernelEvent* ev, int num);
bool AddSmallTimer(EqueueEvent& event);
bool HasSmallTimer() const {
return small_timer_event.event.data != 0;
}
int WaitForSmallTimer(SceKernelEvent* ev, int num, u32 micros);
private:
std::string m_name;
std::mutex m_mutex;
std::vector<EqueueEvent> m_events;
EqueueEvent small_timer_event{};
std::condition_variable m_cond;
};
} // namespace Libraries::Kernel
| 2,780
|
C++
|
.h
| 101
| 21.782178
| 67
| 0.614662
|
shadps4-emu/shadPS4
| 9,253
| 501
| 185
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
15,851
|
event_queues.h
|
shadps4-emu_shadPS4/src/core/libraries/kernel/event_queues.h
|
// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
#pragma once
#include "core/libraries/kernel/event_queue.h"
namespace Libraries::Kernel {
using SceKernelUseconds = u32;
using SceKernelEqueue = EqueueInternal*;
int PS4_SYSV_ABI sceKernelCreateEqueue(SceKernelEqueue* eq, const char* name);
int PS4_SYSV_ABI sceKernelDeleteEqueue(SceKernelEqueue eq);
int PS4_SYSV_ABI sceKernelWaitEqueue(SceKernelEqueue eq, SceKernelEvent* ev, int num, int* out,
SceKernelUseconds* timo);
void* PS4_SYSV_ABI sceKernelGetEventUserData(const SceKernelEvent* ev);
u64 PS4_SYSV_ABI sceKernelGetEventId(const SceKernelEvent* ev);
int PS4_SYSV_ABI sceKernelTriggerUserEvent(SceKernelEqueue eq, int id, void* udata);
int PS4_SYSV_ABI sceKernelDeleteUserEvent(SceKernelEqueue eq, int id);
int PS4_SYSV_ABI sceKernelAddUserEvent(SceKernelEqueue eq, int id);
int PS4_SYSV_ABI sceKernelAddUserEventEdge(SceKernelEqueue eq, int id);
s32 PS4_SYSV_ABI sceKernelAddHRTimerEvent(SceKernelEqueue eq, int id, timespec* ts, void* udata);
s16 PS4_SYSV_ABI sceKernelGetEventFilter(const SceKernelEvent* ev);
} // namespace Libraries::Kernel
| 1,209
|
C++
|
.h
| 20
| 57.3
| 97
| 0.801352
|
shadps4-emu/shadPS4
| 9,253
| 501
| 185
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
15,852
|
time_management.h
|
shadps4-emu_shadPS4/src/core/libraries/kernel/time_management.h
|
// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
#pragma once
#include <sys/types.h>
#include "common/types.h"
namespace Common {
class NativeClock;
}
namespace Core::Loader {
class SymbolsResolver;
}
namespace Libraries::Kernel {
struct OrbisKernelTimeval {
s64 tv_sec;
s64 tv_usec;
};
struct OrbisKernelTimezone {
s32 tz_minuteswest;
s32 tz_dsttime;
};
struct OrbisKernelTimespec {
s64 tv_sec;
s64 tv_nsec;
};
constexpr int ORBIS_CLOCK_REALTIME = 0;
constexpr int ORBIS_CLOCK_VIRTUAL = 1;
constexpr int ORBIS_CLOCK_PROF = 2;
constexpr int ORBIS_CLOCK_MONOTONIC = 4;
constexpr int ORBIS_CLOCK_UPTIME = 5;
constexpr int ORBIS_CLOCK_UPTIME_PRECISE = 7;
constexpr int ORBIS_CLOCK_UPTIME_FAST = 8;
constexpr int ORBIS_CLOCK_REALTIME_PRECISE = 9;
constexpr int ORBIS_CLOCK_REALTIME_FAST = 10;
constexpr int ORBIS_CLOCK_MONOTONIC_PRECISE = 11;
constexpr int ORBIS_CLOCK_MONOTONIC_FAST = 12;
constexpr int ORBIS_CLOCK_SECOND = 13;
constexpr int ORBIS_CLOCK_THREAD_CPUTIME_ID = 14;
constexpr int ORBIS_CLOCK_PROCTIME = 15;
constexpr int ORBIS_CLOCK_EXT_NETWORK = 16;
constexpr int ORBIS_CLOCK_EXT_DEBUG_NETWORK = 17;
constexpr int ORBIS_CLOCK_EXT_AD_NETWORK = 18;
constexpr int ORBIS_CLOCK_EXT_RAW_NETWORK = 19;
namespace Dev {
u64& GetInitialPtc();
Common::NativeClock* GetClock();
} // namespace Dev
u64 PS4_SYSV_ABI sceKernelGetTscFrequency();
u64 PS4_SYSV_ABI sceKernelGetProcessTime();
u64 PS4_SYSV_ABI sceKernelGetProcessTimeCounter();
u64 PS4_SYSV_ABI sceKernelGetProcessTimeCounterFrequency();
u64 PS4_SYSV_ABI sceKernelReadTsc();
int PS4_SYSV_ABI sceKernelClockGettime(s32 clock_id, OrbisKernelTimespec* tp);
s32 PS4_SYSV_ABI sceKernelGettimezone(OrbisKernelTimezone* tz);
int PS4_SYSV_ABI sceKernelConvertLocaltimeToUtc(time_t param_1, int64_t param_2, time_t* seconds,
OrbisKernelTimezone* timezone, int* dst_seconds);
void timeSymbolsRegister(Core::Loader::SymbolsResolver* sym);
} // namespace Libraries::Kernel
| 2,067
|
C++
|
.h
| 57
| 33.754386
| 97
| 0.778557
|
shadps4-emu/shadPS4
| 9,253
| 501
| 185
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
15,853
|
file_system.h
|
shadps4-emu_shadPS4/src/core/libraries/kernel/file_system.h
|
// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
#pragma once
#include "common/types.h"
#include "core/libraries/kernel/time_management.h"
namespace Core::Loader {
class SymbolsResolver;
}
namespace Libraries::Kernel {
constexpr int ORBIS_MAX_PATH = 255;
struct SceKernelIovec {
void* iov_base;
std::size_t iov_len;
};
struct OrbisKernelStat {
u32 st_dev;
u32 st_ino;
u16 st_mode;
u16 st_nlink;
u32 st_uid;
u32 st_gid;
u32 st_rdev;
OrbisKernelTimespec st_atim;
OrbisKernelTimespec st_mtim;
OrbisKernelTimespec st_ctim;
s64 st_size;
s64 st_blocks;
u32 st_blksize;
u32 st_flags;
u32 st_gen;
s32 st_lspare;
OrbisKernelTimespec st_birthtim;
unsigned int : (8 / 2) * (16 - static_cast<int>(sizeof(OrbisKernelTimespec)));
unsigned int : (8 / 2) * (16 - static_cast<int>(sizeof(OrbisKernelTimespec)));
};
struct OrbisKernelDirent {
u32 d_fileno; /* file number of entry */
u16 d_reclen; /* length of this record */
u8 d_type; /* file type, see below */
u8 d_namlen; /* length of string in d_name */
char d_name[ORBIS_MAX_PATH + 1]; /* name must be no longer than this */
};
// flags for Open
constexpr int ORBIS_KERNEL_O_RDONLY = 0x0000;
constexpr int ORBIS_KERNEL_O_WRONLY = 0x0001;
constexpr int ORBIS_KERNEL_O_RDWR = 0x0002;
constexpr int ORBIS_KERNEL_O_NONBLOCK = 0x0004;
constexpr int ORBIS_KERNEL_O_APPEND = 0x0008;
constexpr int ORBIS_KERNEL_O_FSYNC = 0x0080;
constexpr int ORBIS_KERNEL_O_SYNC = 0x0080;
constexpr int ORBIS_KERNEL_O_CREAT = 0x0200;
constexpr int ORBIS_KERNEL_O_TRUNC = 0x0400;
constexpr int ORBIS_KERNEL_O_EXCL = 0x0800;
constexpr int ORBIS_KERNEL_O_DSYNC = 0x1000;
constexpr int ORBIS_KERNEL_O_DIRECT = 0x00010000;
constexpr int ORBIS_KERNEL_O_DIRECTORY = 0x00020000;
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(Core::Loader::SymbolsResolver* sym);
} // namespace Libraries::Kernel
| 2,280
|
C++
|
.h
| 61
| 34.442623
| 89
| 0.707029
|
shadps4-emu/shadPS4
| 9,253
| 501
| 185
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
15,854
|
libkernel.h
|
shadps4-emu_shadPS4/src/core/libraries/kernel/libkernel.h
|
// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
#pragma once
#include <sys/types.h>
#include "common/types.h"
namespace Core::Loader {
class SymbolsResolver;
}
namespace Libraries::Kernel {
void ErrSceToPosix(int result);
int ErrnoToSceKernelError(int e);
void SetPosixErrno(int e);
struct OrbisTimesec {
time_t t;
u32 west_sec;
u32 dst_sec;
};
typedef struct {
uint32_t timeLow;
uint16_t timeMid;
uint16_t timeHiAndVersion;
uint8_t clockSeqHiAndReserved;
uint8_t clockSeqLow;
uint8_t node[6];
} OrbisKernelUuid;
int* PS4_SYSV_ABI __Error();
int PS4_SYSV_ABI sceKernelConvertUtcToLocaltime(time_t time, time_t* local_time,
struct OrbisTimesec* st, unsigned long* dst_sec);
int PS4_SYSV_ABI sceKernelGetCompiledSdkVersion(int* ver);
void LibKernel_Register(Core::Loader::SymbolsResolver* sym);
} // namespace Libraries::Kernel
| 985
|
C++
|
.h
| 31
| 27.709677
| 97
| 0.734889
|
shadps4-emu/shadPS4
| 9,253
| 501
| 185
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
15,855
|
memory_management.h
|
shadps4-emu_shadPS4/src/core/libraries/kernel/memory_management.h
|
// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
#pragma once
#include "common/bit_field.h"
#include "common/types.h"
constexpr u64 SCE_KERNEL_MAIN_DMEM_SIZE = 5056_MB; // ~ 5GB
// TODO: Confirm this value on hardware.
constexpr u64 SCE_KERNEL_MAIN_DMEM_SIZE_PRO = 5568_MB; // ~ 5.5GB
namespace Libraries::Kernel {
enum MemoryTypes : u32 {
SCE_KERNEL_WB_ONION = 0, // write - back mode (Onion bus)
SCE_KERNEL_WC_GARLIC = 3, // write - combining mode (Garlic bus)
SCE_KERNEL_WB_GARLIC = 10 // write - back mode (Garlic bus)
};
enum MemoryFlags : u32 {
SCE_KERNEL_MAP_FIXED = 0x0010, // Fixed
SCE_KERNEL_MAP_NO_OVERWRITE = 0x0080,
SCE_KERNEL_MAP_NO_COALESCE = 0x400000
};
enum MemoryProtection : u32 {
SCE_KERNEL_PROT_CPU_READ = 0x01, // Permit reads from the CPU
SCE_KERNEL_PROT_CPU_RW = 0x02, // Permit reads/writes from the CPU
SCE_KERNEL_PROT_CPU_WRITE = 0x02, // Permit reads/writes from the CPU (same)
SCE_KERNEL_PROT_GPU_READ = 0x10, // Permit reads from the GPU
SCE_KERNEL_PROT_GPU_WRITE = 0x20, // Permit writes from the GPU
SCE_KERNEL_PROT_GPU_RW = 0x30 // Permit reads/writes from the GPU
};
enum MemoryOpTypes : u32 {
ORBIS_KERNEL_MAP_OP_MAP_DIRECT = 0,
ORBIS_KERNEL_MAP_OP_UNMAP = 1,
ORBIS_KERNEL_MAP_OP_PROTECT = 2,
ORBIS_KERNEL_MAP_OP_MAP_FLEXIBLE = 3,
ORBIS_KERNEL_MAP_OP_TYPE_PROTECT = 4
};
struct OrbisQueryInfo {
uintptr_t start;
uintptr_t end;
int memoryType;
};
struct OrbisVirtualQueryInfo {
uintptr_t start;
uintptr_t end;
size_t offset;
s32 protection;
s32 memory_type;
union {
BitField<0, 1, u32> is_flexible;
BitField<1, 1, u32> is_direct;
BitField<2, 1, u32> is_stack;
BitField<3, 1, u32> is_pooled;
BitField<4, 1, u32> is_committed;
};
std::array<char, 32> name;
};
struct OrbisKernelBatchMapEntry {
void* start;
size_t offset;
size_t length;
char protection;
char type;
short reserved;
int operation;
};
u64 PS4_SYSV_ABI sceKernelGetDirectMemorySize();
int PS4_SYSV_ABI sceKernelAllocateDirectMemory(s64 searchStart, s64 searchEnd, u64 len,
u64 alignment, int memoryType, s64* physAddrOut);
int PS4_SYSV_ABI sceKernelMapNamedDirectMemory(void** addr, u64 len, int prot, int flags,
s64 directMemoryStart, u64 alignment,
const char* name);
int PS4_SYSV_ABI sceKernelMapDirectMemory(void** addr, u64 len, int prot, int flags,
s64 directMemoryStart, u64 alignment);
s32 PS4_SYSV_ABI sceKernelAllocateMainDirectMemory(size_t len, size_t alignment, int memoryType,
s64* physAddrOut);
s32 PS4_SYSV_ABI sceKernelReleaseDirectMemory(u64 start, size_t len);
s32 PS4_SYSV_ABI sceKernelCheckedReleaseDirectMemory(u64 start, size_t len);
s32 PS4_SYSV_ABI sceKernelAvailableDirectMemorySize(u64 searchStart, u64 searchEnd,
size_t alignment, u64* physAddrOut,
size_t* sizeOut);
s32 PS4_SYSV_ABI sceKernelVirtualQuery(const void* addr, int flags, OrbisVirtualQueryInfo* info,
size_t infoSize);
s32 PS4_SYSV_ABI sceKernelReserveVirtualRange(void** addr, u64 len, int flags, u64 alignment);
s32 PS4_SYSV_ABI sceKernelMapNamedFlexibleMemory(void** addrInOut, std::size_t len, int prot,
int flags, const char* name);
s32 PS4_SYSV_ABI sceKernelMapFlexibleMemory(void** addr_in_out, std::size_t len, int prot,
int flags);
int PS4_SYSV_ABI sceKernelQueryMemoryProtection(void* addr, void** start, void** end, u32* prot);
int PS4_SYSV_ABI sceKernelMProtect(const void* addr, size_t size, int prot);
int PS4_SYSV_ABI sceKernelMTypeProtect(const void* addr, size_t size, int mtype, int prot);
int PS4_SYSV_ABI sceKernelDirectMemoryQuery(u64 offset, int flags, OrbisQueryInfo* query_info,
size_t infoSize);
s32 PS4_SYSV_ABI sceKernelAvailableFlexibleMemorySize(size_t* sizeOut);
void PS4_SYSV_ABI _sceKernelRtldSetApplicationHeapAPI(void* func[]);
int PS4_SYSV_ABI sceKernelGetDirectMemoryType(u64 addr, int* directMemoryTypeOut,
void** directMemoryStartOut,
void** directMemoryEndOut);
s32 PS4_SYSV_ABI sceKernelBatchMap(OrbisKernelBatchMapEntry* entries, int numEntries,
int* numEntriesOut);
s32 PS4_SYSV_ABI sceKernelBatchMap2(OrbisKernelBatchMapEntry* entries, int numEntries,
int* numEntriesOut, int flags);
s32 PS4_SYSV_ABI sceKernelSetVirtualRangeName(const void* addr, size_t len, const char* name);
s32 PS4_SYSV_ABI sceKernelMemoryPoolExpand(u64 searchStart, u64 searchEnd, size_t len,
size_t alignment, u64* physAddrOut);
s32 PS4_SYSV_ABI sceKernelMemoryPoolReserve(void* addrIn, size_t len, size_t alignment, int flags,
void** addrOut);
s32 PS4_SYSV_ABI sceKernelMemoryPoolCommit(void* addr, size_t len, int type, int prot, int flags);
s32 PS4_SYSV_ABI sceKernelMemoryPoolDecommit(void* addr, size_t len, int flags);
} // namespace Libraries::Kernel
| 5,597
|
C++
|
.h
| 107
| 42.308411
| 98
| 0.651069
|
shadps4-emu/shadPS4
| 9,253
| 501
| 185
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
15,856
|
thread_management.h
|
shadps4-emu_shadPS4/src/core/libraries/kernel/thread_management.h
|
// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
#pragma once
#include <atomic>
#include <mutex>
#include <semaphore>
#include <string>
#include <vector>
#include <pthread.h>
#include <sched.h>
#include "common/types.h"
#define ORBIS_PTHREAD_MUTEX_ADAPTIVE_INITIALIZER (reinterpret_cast<ScePthreadMutex>(1))
namespace Core::Loader {
class SymbolsResolver;
}
namespace Libraries::Kernel {
constexpr int ORBIS_KERNEL_PRIO_FIFO_DEFAULT = 700;
constexpr int ORBIS_KERNEL_PRIO_FIFO_HIGHEST = 256;
constexpr int ORBIS_KERNEL_PRIO_FIFO_LOWEST = 767;
constexpr int ORBIS_KERNEL_SEM_VALUE_MAX = 0x7FFFFFFF;
constexpr int ORBIS_PTHREAD_MUTEX_ERRORCHECK = 1;
constexpr int ORBIS_PTHREAD_MUTEX_RECURSIVE = 2;
constexpr int ORBIS_PTHREAD_MUTEX_NORMAL = 3;
constexpr int ORBIS_PTHREAD_MUTEX_ADAPTIVE = 4;
struct PthreadInternal;
struct PthreadAttrInternal;
struct PthreadMutexInternal;
struct PthreadMutexattrInternal;
struct PthreadCondInternal;
struct PthreadCondAttrInternal;
struct PthreadRwInternal;
struct PthreadRwLockAttrInternal;
class PthreadKeys;
using SceKernelSchedParam = ::sched_param;
using ScePthread = PthreadInternal*;
using ScePthreadAttr = PthreadAttrInternal*;
using ScePthreadMutex = PthreadMutexInternal*;
using ScePthreadMutexattr = PthreadMutexattrInternal*;
using ScePthreadCond = PthreadCondInternal*;
using ScePthreadCondattr = PthreadCondAttrInternal*;
using OrbisPthreadRwlock = PthreadRwInternal*;
using OrbisPthreadRwlockattr = PthreadRwLockAttrInternal*;
using OrbisPthreadKey = u32;
using PthreadKeyDestructor = PS4_SYSV_ABI void (*)(void*);
using PthreadEntryFunc = PS4_SYSV_ABI void* (*)(void*);
struct PthreadInternal {
u8 reserved[4096];
std::string name;
pthread_t pth;
ScePthreadAttr attr;
PthreadEntryFunc entry;
void* arg;
std::atomic_bool is_started;
std::atomic_bool is_detached;
std::atomic_bool is_almost_done;
std::atomic_bool is_free;
using Destructor = std::pair<OrbisPthreadKey, PthreadKeyDestructor>;
std::vector<Destructor> key_destructors;
int prio;
};
struct PthreadAttrInternal {
u8 reserved[64];
u64 affinity;
size_t guard_size;
int policy;
bool detached;
pthread_attr_t pth_attr;
};
struct PthreadMutexInternal {
u8 reserved[256];
std::string name;
pthread_mutex_t pth_mutex;
};
struct PthreadMutexattrInternal {
u8 reserved[64];
pthread_mutexattr_t pth_mutex_attr;
int pprotocol;
};
struct PthreadCondInternal {
u8 reserved[256];
std::string name;
pthread_cond_t cond;
};
struct PthreadCondAttrInternal {
u8 reserved[64];
pthread_condattr_t cond_attr;
clockid_t clock;
};
struct PthreadRwLockAttrInternal {
u8 reserved[64];
pthread_rwlockattr_t attr_rwlock;
int type;
};
struct PthreadRwInternal {
pthread_rwlock_t pth_rwlock;
std::string name;
};
struct PthreadSemInternal {
std::counting_semaphore<ORBIS_KERNEL_SEM_VALUE_MAX> semaphore;
std::atomic<s32> value;
};
class PThreadPool {
public:
ScePthread Create(const char* name);
private:
std::vector<ScePthread> m_threads;
std::mutex m_mutex;
};
class PThreadCxt {
public:
ScePthreadMutexattr* getDefaultMutexattr() {
return &m_default_mutexattr;
}
void setDefaultMutexattr(ScePthreadMutexattr attr) {
m_default_mutexattr = attr;
}
ScePthreadMutexattr* getAdaptiveMutexattr() {
return &m_adaptive_mutexattr;
}
void setAdaptiveMutexattr(ScePthreadMutexattr attr) {
m_adaptive_mutexattr = attr;
}
ScePthreadCondattr* getDefaultCondattr() {
return &m_default_condattr;
}
void setDefaultCondattr(ScePthreadCondattr attr) {
m_default_condattr = attr;
}
ScePthreadAttr* GetDefaultAttr() {
return &m_default_attr;
}
void SetDefaultAttr(ScePthreadAttr attr) {
m_default_attr = attr;
}
PThreadPool* GetPthreadPool() {
return m_pthread_pool;
}
void SetPthreadPool(PThreadPool* pool) {
m_pthread_pool = pool;
}
OrbisPthreadRwlockattr* getDefaultRwattr() {
return &m_default_Rwattr;
}
void setDefaultRwattr(OrbisPthreadRwlockattr attr) {
m_default_Rwattr = attr;
}
private:
ScePthreadMutexattr m_default_mutexattr = nullptr;
ScePthreadMutexattr m_adaptive_mutexattr = nullptr;
ScePthreadCondattr m_default_condattr = nullptr;
ScePthreadAttr m_default_attr = nullptr;
PThreadPool* m_pthread_pool = nullptr;
OrbisPthreadRwlockattr m_default_Rwattr = nullptr;
};
void init_pthreads();
void pthreadInitSelfMainThread();
int PS4_SYSV_ABI scePthreadAttrInit(ScePthreadAttr* attr);
int PS4_SYSV_ABI scePthreadAttrSetdetachstate(ScePthreadAttr* attr, int detachstate);
int PS4_SYSV_ABI scePthreadAttrSetinheritsched(ScePthreadAttr* attr, int inheritSched);
int PS4_SYSV_ABI scePthreadAttrSetschedparam(ScePthreadAttr* attr,
const SceKernelSchedParam* param);
int PS4_SYSV_ABI scePthreadAttrSetschedpolicy(ScePthreadAttr* attr, int policy);
ScePthread PS4_SYSV_ABI scePthreadSelf();
int PS4_SYSV_ABI scePthreadAttrSetaffinity(ScePthreadAttr* pattr,
const /*SceKernelCpumask*/ u64 mask);
int PS4_SYSV_ABI scePthreadSetaffinity(ScePthread thread, const /*SceKernelCpumask*/ u64 mask);
int PS4_SYSV_ABI scePthreadGetaffinity(ScePthread thread, /*SceKernelCpumask*/ u64* mask);
int PS4_SYSV_ABI scePthreadCreate(ScePthread* thread, const ScePthreadAttr* attr,
PthreadEntryFunc start_routine, void* arg, const char* name);
int PS4_SYSV_ABI scePthreadSetprio(ScePthread thread, int prio);
/***
* Mutex calls
*/
int PS4_SYSV_ABI scePthreadMutexInit(ScePthreadMutex* mutex, const ScePthreadMutexattr* attr,
const char* name);
int PS4_SYSV_ABI scePthreadMutexattrInit(ScePthreadMutexattr* attr);
int PS4_SYSV_ABI scePthreadMutexattrSettype(ScePthreadMutexattr* attr, int type);
int PS4_SYSV_ABI scePthreadMutexattrSetprotocol(ScePthreadMutexattr* attr, int protocol);
int PS4_SYSV_ABI scePthreadMutexLock(ScePthreadMutex* mutex);
int PS4_SYSV_ABI scePthreadMutexUnlock(ScePthreadMutex* mutex);
/****
* Cond calls
*/
int PS4_SYSV_ABI scePthreadCondInit(ScePthreadCond* cond, const ScePthreadCondattr* attr,
const char* name);
int PS4_SYSV_ABI scePthreadCondattrInit(ScePthreadCondattr* attr);
int PS4_SYSV_ABI scePthreadCondBroadcast(ScePthreadCond* cond);
int PS4_SYSV_ABI scePthreadCondWait(ScePthreadCond* cond, ScePthreadMutex* mutex);
/****
* Posix calls
*/
int PS4_SYSV_ABI posix_pthread_mutex_init(ScePthreadMutex* mutex, const ScePthreadMutexattr* attr);
int PS4_SYSV_ABI posix_pthread_mutex_lock(ScePthreadMutex* mutex);
int PS4_SYSV_ABI posix_pthread_mutex_unlock(ScePthreadMutex* mutex);
int PS4_SYSV_ABI posix_pthread_cond_broadcast(ScePthreadCond* cond);
void pthreadSymbolsRegister(Core::Loader::SymbolsResolver* sym);
} // namespace Libraries::Kernel
| 7,104
|
C++
|
.h
| 197
| 31.969543
| 99
| 0.756941
|
shadps4-emu/shadPS4
| 9,253
| 501
| 185
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
15,857
|
cpu_management.h
|
shadps4-emu_shadPS4/src/core/libraries/kernel/cpu_management.h
|
// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
#pragma once
#include "common/types.h"
namespace Libraries::Kernel {
int PS4_SYSV_ABI sceKernelIsNeoMode();
} // namespace Libraries::Kernel
| 258
|
C++
|
.h
| 7
| 35.142857
| 66
| 0.800813
|
shadps4-emu/shadPS4
| 9,253
| 501
| 185
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
15,858
|
event_flag_obj.h
|
shadps4-emu_shadPS4/src/core/libraries/kernel/event_flag/event_flag_obj.h
|
// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
#pragma once
#include <condition_variable>
#include <mutex>
#include "common/types.h"
namespace Libraries::Kernel {
class EventFlagInternal {
public:
enum class ClearMode { None, All, Bits };
enum class WaitMode { And, Or };
enum class ThreadMode { Single, Multi };
enum class QueueMode { Fifo, ThreadPrio };
EventFlagInternal(const std::string& name, ThreadMode thread_mode, QueueMode queue_mode,
uint64_t bits)
: m_name(name), m_thread_mode(thread_mode), m_queue_mode(queue_mode), m_bits(bits){};
int Wait(u64 bits, WaitMode wait_mode, ClearMode clear_mode, u64* result, u32* ptr_micros);
int Poll(u64 bits, WaitMode wait_mode, ClearMode clear_mode, u64* result);
void Set(u64 bits);
void Clear(u64 bits);
private:
enum class Status { Set, Canceled, Deleted };
std::mutex m_mutex;
std::condition_variable m_cond_var;
Status m_status = Status::Set;
int m_waiting_threads = 0;
std::string m_name;
ThreadMode m_thread_mode = ThreadMode::Single;
QueueMode m_queue_mode = QueueMode::Fifo;
u64 m_bits = 0;
};
} // namespace Libraries::Kernel
| 1,264
|
C++
|
.h
| 32
| 34.9375
| 95
| 0.701639
|
shadps4-emu/shadPS4
| 9,253
| 501
| 185
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
15,859
|
event_flag_codes.h
|
shadps4-emu_shadPS4/src/core/libraries/kernel/event_flag/event_flag_codes.h
|
// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
#pragma once
constexpr int ORBIS_KERNEL_EVF_ATTR_TH_FIFO = 0x01;
constexpr int ORBIS_KERNEL_EVF_ATTR_TH_PRIO = 0x02;
constexpr int ORBIS_KERNEL_EVF_ATTR_SINGLE = 0x10;
constexpr int ORBIS_KERNEL_EVF_ATTR_MULTI = 0x20;
constexpr int ORBIS_KERNEL_EVF_WAITMODE_AND = 0x01;
constexpr int ORBIS_KERNEL_EVF_WAITMODE_OR = 0x02;
constexpr int ORBIS_KERNEL_EVF_WAITMODE_CLEAR_ALL = 0x10;
constexpr int ORBIS_KERNEL_EVF_WAITMODE_CLEAR_PAT = 0x20;
| 551
|
C++
|
.h
| 11
| 48.909091
| 66
| 0.801115
|
shadps4-emu/shadPS4
| 9,253
| 501
| 185
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
15,860
|
event_flag.h
|
shadps4-emu_shadPS4/src/core/libraries/kernel/event_flag/event_flag.h
|
// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
#pragma once
#include "common/types.h"
#include "event_flag_codes.h"
#include "event_flag_obj.h"
namespace Core::Loader {
class SymbolsResolver;
}
namespace Libraries::Kernel {
using OrbisKernelUseconds = u32;
using OrbisKernelEventFlag = EventFlagInternal*;
struct OrbisKernelEventFlagOptParam {
size_t size;
};
int PS4_SYSV_ABI sceKernelCreateEventFlag(OrbisKernelEventFlag* ef, const char* pName, u32 attr,
u64 initPattern,
const OrbisKernelEventFlagOptParam* pOptParam);
int PS4_SYSV_ABI sceKernelDeleteEventFlag(OrbisKernelEventFlag ef);
int PS4_SYSV_ABI sceKernelOpenEventFlag();
int PS4_SYSV_ABI sceKernelCloseEventFlag();
int PS4_SYSV_ABI sceKernelClearEventFlag(OrbisKernelEventFlag ef, u64 bitPattern);
int PS4_SYSV_ABI sceKernelCancelEventFlag(OrbisKernelEventFlag ef, u64 setPattern,
int* pNumWaitThreads);
int PS4_SYSV_ABI sceKernelSetEventFlag(OrbisKernelEventFlag ef, u64 bitPattern);
int PS4_SYSV_ABI sceKernelPollEventFlag(OrbisKernelEventFlag ef, u64 bitPattern, u32 waitMode,
u64* pResultPat);
int PS4_SYSV_ABI sceKernelWaitEventFlag(OrbisKernelEventFlag ef, u64 bitPattern, u32 waitMode,
u64* pResultPat, OrbisKernelUseconds* pTimeout);
void RegisterKernelEventFlag(Core::Loader::SymbolsResolver* sym);
} // namespace Libraries::Kernel
| 1,586
|
C++
|
.h
| 31
| 43.129032
| 96
| 0.727214
|
shadps4-emu/shadPS4
| 9,253
| 501
| 185
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
15,861
|
threads.h
|
shadps4-emu_shadPS4/src/core/libraries/kernel/threads/threads.h
|
// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
#pragma once
#include "core/libraries/kernel/thread_management.h"
namespace Core::Loader {
class SymbolsResolver;
}
namespace Libraries::Kernel {
int PS4_SYSV_ABI scePthreadRwlockattrInit(OrbisPthreadRwlockattr* attr);
void SemaphoreSymbolsRegister(Core::Loader::SymbolsResolver* sym);
void RwlockSymbolsRegister(Core::Loader::SymbolsResolver* sym);
void KeySymbolsRegister(Core::Loader::SymbolsResolver* sym);
} // namespace Libraries::Kernel
| 563
|
C++
|
.h
| 13
| 41.769231
| 72
| 0.830571
|
shadps4-emu/shadPS4
| 9,253
| 501
| 185
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
15,862
|
net_ctl_codes.h
|
shadps4-emu_shadPS4/src/core/libraries/network/net_ctl_codes.h
|
// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
#pragma once
// error codes
constexpr int ORBIS_NET_CTL_ERROR_CALLBACK_MAX = 0x80412103;
constexpr int ORBIS_NET_CTL_ERROR_ID_NOT_FOUND = 0x80412104;
constexpr int ORBIS_NET_CTL_ERROR_INVALID_ID = 0x80412105;
constexpr int ORBIS_NET_CTL_ERROR_INVALID_ADDR = 0x80412107;
constexpr int ORBIS_NET_CTL_ERROR_NOT_CONNECTED = 0x80412108;
constexpr int ORBIS_NET_CTL_ERROR_NOT_AVAIL = 0x80412109;
constexpr int ORBIS_NET_CTL_ERROR_NETWORK_DISABLED = 0x8041210D;
constexpr int ORBIS_NET_CTL_ERROR_DISCONNECT_REQ = 0x8041210E;
constexpr int ORBIS_NET_CTL_ERROR_ETHERNET_PLUGOUT = 0x80412115;
constexpr int ORBIS_NET_CTL_ERROR_WIFI_DEAUTHED = 0x80412116;
constexpr int ORBIS_NET_CTL_ERROR_WIFI_BEACON_LOST = 0x80412117;
// state codes
constexpr int ORBIS_NET_CTL_STATE_DISCONNECTED = 0;
constexpr int ORBIS_NET_CTL_STATE_CONNECTING = 1;
constexpr int ORBIS_NET_CTL_STATE_IPOBTAINING = 2;
constexpr int ORBIS_NET_CTL_STATE_IPOBTAINED = 3;
// event type
constexpr int ORBIS_NET_CTL_EVENT_TYPE_DISCONNECTED = 1;
constexpr int ORBIS_SCE_NET_CTL_EVENT_TYPE_DISCONNECT_REQ_FINISHED = 2;
constexpr int ORBIS_NET_CTL_EVENT_TYPE_IPOBTAINED = 3;
// get info codes
// device
constexpr int ORBIS_NET_CTL_DEVICE_WIRED = 0;
constexpr int ORBIS_NET_CTL_DEVICE_WIRELESS = 1;
// link
constexpr int ORBIS_NET_CTL_LINK_DISCONNECTED = 0;
constexpr int ORBIS_NET_CTL_LINK_CONNECTED = 1;
| 1,473
|
C++
|
.h
| 31
| 46.354839
| 71
| 0.80167
|
shadps4-emu/shadPS4
| 9,253
| 501
| 185
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
15,863
|
http.h
|
shadps4-emu_shadPS4/src/core/libraries/network/http.h
|
// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
#pragma once
#include "common/types.h"
namespace Core::Loader {
class SymbolsResolver;
}
namespace Libraries::Http {
int PS4_SYSV_ABI sceHttpAbortRequest();
int PS4_SYSV_ABI sceHttpAbortRequestForce();
int PS4_SYSV_ABI sceHttpAbortWaitRequest();
int PS4_SYSV_ABI sceHttpAddCookie();
int PS4_SYSV_ABI sceHttpAddQuery();
int PS4_SYSV_ABI sceHttpAddRequestHeader();
int PS4_SYSV_ABI sceHttpAddRequestHeaderRaw();
int PS4_SYSV_ABI sceHttpAuthCacheExport();
int PS4_SYSV_ABI sceHttpAuthCacheFlush();
int PS4_SYSV_ABI sceHttpAuthCacheImport();
int PS4_SYSV_ABI sceHttpCacheRedirectedConnectionEnabled();
int PS4_SYSV_ABI sceHttpCookieExport();
int PS4_SYSV_ABI sceHttpCookieFlush();
int PS4_SYSV_ABI sceHttpCookieImport();
int PS4_SYSV_ABI sceHttpCreateConnection();
int PS4_SYSV_ABI sceHttpCreateConnectionWithURL();
int PS4_SYSV_ABI sceHttpCreateEpoll();
int PS4_SYSV_ABI sceHttpCreateRequest();
int PS4_SYSV_ABI sceHttpCreateRequest2();
int PS4_SYSV_ABI sceHttpCreateRequestWithURL();
int PS4_SYSV_ABI sceHttpCreateRequestWithURL2();
int PS4_SYSV_ABI sceHttpCreateTemplate();
int PS4_SYSV_ABI sceHttpDbgEnableProfile();
int PS4_SYSV_ABI sceHttpDbgGetConnectionStat();
int PS4_SYSV_ABI sceHttpDbgGetRequestStat();
int PS4_SYSV_ABI sceHttpDbgSetPrintf();
int PS4_SYSV_ABI sceHttpDbgShowConnectionStat();
int PS4_SYSV_ABI sceHttpDbgShowMemoryPoolStat();
int PS4_SYSV_ABI sceHttpDbgShowRequestStat();
int PS4_SYSV_ABI sceHttpDbgShowStat();
int PS4_SYSV_ABI sceHttpDeleteConnection();
int PS4_SYSV_ABI sceHttpDeleteRequest();
int PS4_SYSV_ABI sceHttpDeleteTemplate();
int PS4_SYSV_ABI sceHttpDestroyEpoll();
int PS4_SYSV_ABI sceHttpGetAcceptEncodingGZIPEnabled();
int PS4_SYSV_ABI sceHttpGetAllResponseHeaders();
int PS4_SYSV_ABI sceHttpGetAuthEnabled();
int PS4_SYSV_ABI sceHttpGetAutoRedirect();
int PS4_SYSV_ABI sceHttpGetConnectionStat();
int PS4_SYSV_ABI sceHttpGetCookie();
int PS4_SYSV_ABI sceHttpGetCookieEnabled();
int PS4_SYSV_ABI sceHttpGetCookieStats();
int PS4_SYSV_ABI sceHttpGetEpoll();
int PS4_SYSV_ABI sceHttpGetEpollId();
int PS4_SYSV_ABI sceHttpGetLastErrno();
int PS4_SYSV_ABI sceHttpGetMemoryPoolStats();
int PS4_SYSV_ABI sceHttpGetNonblock();
int PS4_SYSV_ABI sceHttpGetRegisteredCtxIds();
int PS4_SYSV_ABI sceHttpGetResponseContentLength();
int PS4_SYSV_ABI sceHttpGetStatusCode();
int PS4_SYSV_ABI sceHttpInit(int libnetMemId, int libsslCtxId, std::size_t poolSize);
int PS4_SYSV_ABI sceHttpParseResponseHeader();
int PS4_SYSV_ABI sceHttpParseStatusLine();
int PS4_SYSV_ABI sceHttpReadData();
int PS4_SYSV_ABI sceHttpRedirectCacheFlush();
int PS4_SYSV_ABI sceHttpRemoveRequestHeader();
int PS4_SYSV_ABI sceHttpRequestGetAllHeaders();
int PS4_SYSV_ABI sceHttpsDisableOption();
int PS4_SYSV_ABI sceHttpsDisableOptionPrivate();
int PS4_SYSV_ABI sceHttpsEnableOption();
int PS4_SYSV_ABI sceHttpsEnableOptionPrivate();
int PS4_SYSV_ABI sceHttpSendRequest();
int PS4_SYSV_ABI sceHttpSetAcceptEncodingGZIPEnabled();
int PS4_SYSV_ABI sceHttpSetAuthEnabled();
int PS4_SYSV_ABI sceHttpSetAuthInfoCallback();
int PS4_SYSV_ABI sceHttpSetAutoRedirect();
int PS4_SYSV_ABI sceHttpSetChunkedTransferEnabled();
int PS4_SYSV_ABI sceHttpSetConnectTimeOut();
int PS4_SYSV_ABI sceHttpSetCookieEnabled();
int PS4_SYSV_ABI sceHttpSetCookieMaxNum();
int PS4_SYSV_ABI sceHttpSetCookieMaxNumPerDomain();
int PS4_SYSV_ABI sceHttpSetCookieMaxSize();
int PS4_SYSV_ABI sceHttpSetCookieRecvCallback();
int PS4_SYSV_ABI sceHttpSetCookieSendCallback();
int PS4_SYSV_ABI sceHttpSetCookieTotalMaxSize();
int PS4_SYSV_ABI sceHttpSetDefaultAcceptEncodingGZIPEnabled();
int PS4_SYSV_ABI sceHttpSetDelayBuildRequestEnabled();
int PS4_SYSV_ABI sceHttpSetEpoll();
int PS4_SYSV_ABI sceHttpSetEpollId();
int PS4_SYSV_ABI sceHttpSetHttp09Enabled();
int PS4_SYSV_ABI sceHttpSetInflateGZIPEnabled();
int PS4_SYSV_ABI sceHttpSetNonblock();
int PS4_SYSV_ABI sceHttpSetPolicyOption();
int PS4_SYSV_ABI sceHttpSetPriorityOption();
int PS4_SYSV_ABI sceHttpSetProxy();
int PS4_SYSV_ABI sceHttpSetRecvBlockSize();
int PS4_SYSV_ABI sceHttpSetRecvTimeOut();
int PS4_SYSV_ABI sceHttpSetRedirectCallback();
int PS4_SYSV_ABI sceHttpSetRequestContentLength();
int PS4_SYSV_ABI sceHttpSetRequestStatusCallback();
int PS4_SYSV_ABI sceHttpSetResolveRetry();
int PS4_SYSV_ABI sceHttpSetResolveTimeOut();
int PS4_SYSV_ABI sceHttpSetResponseHeaderMaxSize();
int PS4_SYSV_ABI sceHttpSetSendTimeOut();
int PS4_SYSV_ABI sceHttpSetSocketCreationCallback();
int PS4_SYSV_ABI sceHttpsFreeCaList();
int PS4_SYSV_ABI sceHttpsGetCaList();
int PS4_SYSV_ABI sceHttpsGetSslError();
int PS4_SYSV_ABI sceHttpsLoadCert();
int PS4_SYSV_ABI sceHttpsSetMinSslVersion();
int PS4_SYSV_ABI sceHttpsSetSslCallback();
int PS4_SYSV_ABI sceHttpsSetSslVersion();
int PS4_SYSV_ABI sceHttpsUnloadCert();
int PS4_SYSV_ABI sceHttpTerm();
int PS4_SYSV_ABI sceHttpTryGetNonblock();
int PS4_SYSV_ABI sceHttpTrySetNonblock();
int PS4_SYSV_ABI sceHttpUnsetEpoll();
int PS4_SYSV_ABI sceHttpUriBuild();
int PS4_SYSV_ABI sceHttpUriCopy();
int PS4_SYSV_ABI sceHttpUriEscape();
int PS4_SYSV_ABI sceHttpUriMerge();
int PS4_SYSV_ABI sceHttpUriParse();
int PS4_SYSV_ABI sceHttpUriSweepPath();
int PS4_SYSV_ABI sceHttpUriUnescape();
int PS4_SYSV_ABI sceHttpWaitRequest();
void RegisterlibSceHttp(Core::Loader::SymbolsResolver* sym);
} // namespace Libraries::Http
| 5,389
|
C++
|
.h
| 125
| 42.064
| 85
| 0.833587
|
shadps4-emu/shadPS4
| 9,253
| 501
| 185
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
15,864
|
net_ctl_obj.h
|
shadps4-emu_shadPS4/src/core/libraries/network/net_ctl_obj.h
|
// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
#pragma once
#include <condition_variable>
#include <mutex>
#include "common/types.h"
namespace Libraries::NetCtl {
using OrbisNetCtlCallback = PS4_SYSV_ABI void (*)(int eventType, void* arg);
using OrbisNetCtlCallbackForNpToolkit = PS4_SYSV_ABI void (*)(int eventType, void* arg);
struct NetCtlCallback {
OrbisNetCtlCallback func;
void* arg;
};
struct NetCtlCallbackForNpToolkit {
OrbisNetCtlCallbackForNpToolkit func;
void* arg;
};
class NetCtlInternal {
public:
NetCtlInternal();
~NetCtlInternal();
s32 registerCallback(OrbisNetCtlCallback func, void* arg);
s32 registerNpToolkitCallback(OrbisNetCtlCallbackForNpToolkit func, void* arg);
void checkCallback();
void checkNpToolkitCallback();
public:
std::array<NetCtlCallback, 8> nptoolCallbacks;
std::array<NetCtlCallbackForNpToolkit, 8> callbacks;
std::mutex m_mutex;
};
} // namespace Libraries::NetCtl
| 1,031
|
C++
|
.h
| 31
| 30.290323
| 88
| 0.775984
|
shadps4-emu/shadPS4
| 9,253
| 501
| 185
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
15,865
|
netctl.h
|
shadps4-emu_shadPS4/src/core/libraries/network/netctl.h
|
// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
#pragma once
#include "common/types.h"
#include "net_ctl_obj.h"
namespace Core::Loader {
class SymbolsResolver;
}
namespace Libraries::NetCtl {
constexpr int ORBIS_NET_ETHER_ADDR_LEN = 6;
struct OrbisNetEtherAddr {
u8 data[ORBIS_NET_ETHER_ADDR_LEN];
};
constexpr int ORBIS_NET_CTL_SSID_LEN = 32 + 1;
constexpr int ORBIS_NET_CTL_HOSTNAME_LEN = 255 + 1;
constexpr int ORBIS_NET_CTL_AUTH_NAME_LEN = 127 + 1;
constexpr int ORBIS_NET_CTL_IPV4_ADDR_STR_LEN = 16;
typedef union OrbisNetCtlInfo {
u32 device;
OrbisNetEtherAddr ether_addr;
u32 mtu;
u32 link;
OrbisNetEtherAddr bssid;
char ssid[ORBIS_NET_CTL_SSID_LEN];
u32 wifi_security;
u8 rssi_dbm;
uint8_t rssi_percentage;
u8 channel;
u32 ip_config;
char dhcp_hostname[ORBIS_NET_CTL_HOSTNAME_LEN];
char pppoe_auth_name[ORBIS_NET_CTL_AUTH_NAME_LEN];
char ip_address[ORBIS_NET_CTL_IPV4_ADDR_STR_LEN];
char netmask[ORBIS_NET_CTL_IPV4_ADDR_STR_LEN];
char default_route[ORBIS_NET_CTL_IPV4_ADDR_STR_LEN];
char primary_dns[ORBIS_NET_CTL_IPV4_ADDR_STR_LEN];
char secondary_dns[ORBIS_NET_CTL_IPV4_ADDR_STR_LEN];
u32 http_proxy_config;
char http_proxy_server[ORBIS_NET_CTL_HOSTNAME_LEN];
u16 http_proxy_port;
} SceNetCtlInfo;
// GetInfo codes
constexpr int ORBIS_NET_CTL_INFO_DEVICE = 1;
constexpr int ORBIS_NET_CTL_INFO_LINK = 4;
constexpr int ORBIS_NET_CTL_INFO_IP_ADDRESS = 14;
int PS4_SYSV_ABI sceNetBweCheckCallbackIpcInt();
int PS4_SYSV_ABI sceNetBweClearEventIpcInt();
int PS4_SYSV_ABI sceNetBweFinishInternetConnectionTestIpcInt();
int PS4_SYSV_ABI sceNetBweGetInfoIpcInt();
int PS4_SYSV_ABI sceNetBweRegisterCallbackIpcInt();
int PS4_SYSV_ABI sceNetBweSetInternetConnectionTestResultIpcInt();
int PS4_SYSV_ABI sceNetBweStartInternetConnectionTestBandwidthTestIpcInt();
int PS4_SYSV_ABI sceNetBweStartInternetConnectionTestIpcInt();
int PS4_SYSV_ABI sceNetBweUnregisterCallbackIpcInt();
int PS4_SYSV_ABI sceNetCtlGetInfoV6();
int PS4_SYSV_ABI sceNetCtlGetResultV6();
int PS4_SYSV_ABI sceNetCtlGetStateV6();
int PS4_SYSV_ABI sceNetCtlRegisterCallbackV6();
int PS4_SYSV_ABI sceNetCtlUnregisterCallbackV6();
int PS4_SYSV_ABI sceNetCtlCheckCallback();
int PS4_SYSV_ABI sceNetCtlCheckCallbackForLibIpcInt();
int PS4_SYSV_ABI sceNetCtlClearEventForLibIpcInt();
int PS4_SYSV_ABI sceNetCtlClearEventIpcInt();
int PS4_SYSV_ABI sceNetCtlConnectConfIpcInt();
int PS4_SYSV_ABI sceNetCtlConnectIpcInt();
int PS4_SYSV_ABI sceNetCtlConnectWithRetryIpcInt();
int PS4_SYSV_ABI sceNetCtlDisableBandwidthManagementIpcInt();
int PS4_SYSV_ABI sceNetCtlDisconnectIpcInt();
int PS4_SYSV_ABI sceNetCtlEnableBandwidthManagementIpcInt();
int PS4_SYSV_ABI sceNetCtlGetBandwidthInfoIpcInt();
int PS4_SYSV_ABI sceNetCtlGetEtherLinkMode();
int PS4_SYSV_ABI sceNetCtlGetIfStat();
int PS4_SYSV_ABI sceNetCtlGetInfo(int code, OrbisNetCtlInfo* info);
int PS4_SYSV_ABI sceNetCtlGetInfoIpcInt();
int PS4_SYSV_ABI sceNetCtlGetInfoV6IpcInt();
int PS4_SYSV_ABI sceNetCtlGetNatInfo();
int PS4_SYSV_ABI sceNetCtlGetNatInfoIpcInt();
int PS4_SYSV_ABI sceNetCtlGetNetEvConfigInfoIpcInt();
int PS4_SYSV_ABI sceNetCtlGetResult(int eventType, int* errorCode);
int PS4_SYSV_ABI sceNetCtlGetResultIpcInt();
int PS4_SYSV_ABI sceNetCtlGetResultV6IpcInt();
int PS4_SYSV_ABI sceNetCtlGetScanInfoBssidForSsidListScanIpcInt();
int PS4_SYSV_ABI sceNetCtlGetScanInfoBssidIpcInt();
int PS4_SYSV_ABI sceNetCtlGetScanInfoByBssidIpcInt();
int PS4_SYSV_ABI sceNetCtlGetScanInfoForSsidListScanIpcInt();
int PS4_SYSV_ABI sceNetCtlGetScanInfoForSsidScanIpcInt();
int PS4_SYSV_ABI sceNetCtlGetState(int* state);
int PS4_SYSV_ABI sceNetCtlGetState2IpcInt();
int PS4_SYSV_ABI sceNetCtlGetStateIpcInt();
int PS4_SYSV_ABI sceNetCtlGetStateV6IpcInt();
int PS4_SYSV_ABI sceNetCtlGetWifiType();
int PS4_SYSV_ABI sceNetCtlInit();
int PS4_SYSV_ABI sceNetCtlIsBandwidthManagementEnabledIpcInt();
int PS4_SYSV_ABI sceNetCtlRegisterCallback(OrbisNetCtlCallback func, void* arg, int* cid);
int PS4_SYSV_ABI sceNetCtlRegisterCallbackForLibIpcInt();
int PS4_SYSV_ABI sceNetCtlRegisterCallbackIpcInt();
int PS4_SYSV_ABI sceNetCtlRegisterCallbackV6IpcInt();
int PS4_SYSV_ABI sceNetCtlScanIpcInt();
int PS4_SYSV_ABI sceNetCtlSetErrorNotificationEnabledIpcInt();
int PS4_SYSV_ABI sceNetCtlSetStunWithPaddingFlagIpcInt();
int PS4_SYSV_ABI sceNetCtlTerm();
int PS4_SYSV_ABI sceNetCtlUnregisterCallback();
int PS4_SYSV_ABI sceNetCtlUnregisterCallbackForLibIpcInt();
int PS4_SYSV_ABI sceNetCtlUnregisterCallbackIpcInt();
int PS4_SYSV_ABI sceNetCtlUnregisterCallbackV6IpcInt();
int PS4_SYSV_ABI sceNetCtlUnsetStunWithPaddingFlagIpcInt();
int PS4_SYSV_ABI Func_D8DCB6973537A3DC();
int PS4_SYSV_ABI sceNetCtlCheckCallbackForNpToolkit();
int PS4_SYSV_ABI sceNetCtlClearEventForNpToolkit();
int PS4_SYSV_ABI sceNetCtlRegisterCallbackForNpToolkit(OrbisNetCtlCallbackForNpToolkit func,
void* arg, int* cid);
int PS4_SYSV_ABI sceNetCtlUnregisterCallbackForNpToolkit();
int PS4_SYSV_ABI sceNetCtlApCheckCallback();
int PS4_SYSV_ABI sceNetCtlApClearEvent();
int PS4_SYSV_ABI sceNetCtlApGetConnectInfo();
int PS4_SYSV_ABI sceNetCtlApGetInfo();
int PS4_SYSV_ABI sceNetCtlApGetResult();
int PS4_SYSV_ABI sceNetCtlApGetState();
int PS4_SYSV_ABI sceNetCtlApInit();
int PS4_SYSV_ABI sceNetCtlApRegisterCallback();
int PS4_SYSV_ABI sceNetCtlApStop();
int PS4_SYSV_ABI sceNetCtlApTerm();
int PS4_SYSV_ABI sceNetCtlApUnregisterCallback();
int PS4_SYSV_ABI sceNetCtlApAppInitWpaKey();
int PS4_SYSV_ABI sceNetCtlApAppInitWpaKeyForQa();
int PS4_SYSV_ABI sceNetCtlApAppStartWithRetry();
int PS4_SYSV_ABI sceNetCtlApAppStartWithRetryPid();
int PS4_SYSV_ABI sceNetCtlApRestart();
int PS4_SYSV_ABI sceNetCtlApRpCheckCallback();
int PS4_SYSV_ABI sceNetCtlApRpClearEvent();
int PS4_SYSV_ABI sceNetCtlApRpGetInfo();
int PS4_SYSV_ABI sceNetCtlApRpGetResult();
int PS4_SYSV_ABI sceNetCtlApRpGetState();
int PS4_SYSV_ABI sceNetCtlApRpRegisterCallback();
int PS4_SYSV_ABI sceNetCtlApRpStart();
int PS4_SYSV_ABI sceNetCtlApRpStartConf();
int PS4_SYSV_ABI sceNetCtlApRpStartWithRetry();
int PS4_SYSV_ABI sceNetCtlApRpStop();
int PS4_SYSV_ABI sceNetCtlApRpUnregisterCallback();
void RegisterlibSceNetCtl(Core::Loader::SymbolsResolver* sym);
} // namespace Libraries::NetCtl
| 6,357
|
C++
|
.h
| 140
| 43.307143
| 92
| 0.817274
|
shadps4-emu/shadPS4
| 9,253
| 501
| 185
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
15,866
|
ssl.h
|
shadps4-emu_shadPS4/src/core/libraries/network/ssl.h
|
// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
#pragma once
#include "common/types.h"
namespace Core::Loader {
class SymbolsResolver;
}
namespace Libraries::Ssl {
int PS4_SYSV_ABI CA_MGMT_allocCertDistinguishedName();
int PS4_SYSV_ABI CA_MGMT_certDistinguishedNameCompare();
int PS4_SYSV_ABI CA_MGMT_convertKeyBlobToPKCS8Key();
int PS4_SYSV_ABI CA_MGMT_convertKeyDER();
int PS4_SYSV_ABI CA_MGMT_convertKeyPEM();
int PS4_SYSV_ABI CA_MGMT_convertPKCS8KeyToKeyBlob();
int PS4_SYSV_ABI CA_MGMT_convertProtectedPKCS8KeyToKeyBlob();
int PS4_SYSV_ABI CA_MGMT_decodeCertificate();
int PS4_SYSV_ABI CA_MGMT_enumAltName();
int PS4_SYSV_ABI CA_MGMT_enumCrl();
int PS4_SYSV_ABI CA_MGMT_extractAllCertDistinguishedName();
int PS4_SYSV_ABI CA_MGMT_extractBasicConstraint();
int PS4_SYSV_ABI CA_MGMT_extractCertASN1Name();
int PS4_SYSV_ABI CA_MGMT_extractCertTimes();
int PS4_SYSV_ABI CA_MGMT_extractKeyBlobEx();
int PS4_SYSV_ABI CA_MGMT_extractKeyBlobTypeEx();
int PS4_SYSV_ABI CA_MGMT_extractPublicKeyInfo();
int PS4_SYSV_ABI CA_MGMT_extractSerialNum();
int PS4_SYSV_ABI CA_MGMT_extractSignature();
int PS4_SYSV_ABI CA_MGMT_free();
int PS4_SYSV_ABI CA_MGMT_freeCertDistinguishedName();
int PS4_SYSV_ABI CA_MGMT_freeCertDistinguishedNameOnStack();
int PS4_SYSV_ABI CA_MGMT_freeCertificate();
int PS4_SYSV_ABI CA_MGMT_freeKeyBlob();
int PS4_SYSV_ABI CA_MGMT_freeSearchDetails();
int PS4_SYSV_ABI CA_MGMT_getCertSignAlgoType();
int PS4_SYSV_ABI CA_MGMT_keyBlobToDER();
int PS4_SYSV_ABI CA_MGMT_keyBlobToPEM();
int PS4_SYSV_ABI CA_MGMT_makeKeyBlobEx();
int PS4_SYSV_ABI CA_MGMT_rawVerifyOID();
int PS4_SYSV_ABI CA_MGMT_reorderChain();
int PS4_SYSV_ABI CA_MGMT_returnCertificatePrints();
int PS4_SYSV_ABI CA_MGMT_verifyCertWithKeyBlob();
int PS4_SYSV_ABI CA_MGMT_verifySignature();
int PS4_SYSV_ABI CERT_checkCertificateIssuer();
int PS4_SYSV_ABI CERT_checkCertificateIssuer2();
int PS4_SYSV_ABI CERT_checkCertificateIssuerSerialNumber();
int PS4_SYSV_ABI CERT_CompSubjectAltNames();
int PS4_SYSV_ABI CERT_CompSubjectAltNames2();
int PS4_SYSV_ABI CERT_CompSubjectAltNamesExact();
int PS4_SYSV_ABI CERT_CompSubjectCommonName();
int PS4_SYSV_ABI CERT_CompSubjectCommonName2();
int PS4_SYSV_ABI CERT_ComputeBufferHash();
int PS4_SYSV_ABI CERT_decryptRSASignature();
int PS4_SYSV_ABI CERT_decryptRSASignatureBuffer();
int PS4_SYSV_ABI CERT_enumerateAltName();
int PS4_SYSV_ABI CERT_enumerateAltName2();
int PS4_SYSV_ABI CERT_enumerateCRL();
int PS4_SYSV_ABI CERT_enumerateCRL2();
int PS4_SYSV_ABI CERT_enumerateCRLAux();
int PS4_SYSV_ABI CERT_extractAllDistinguishedNames();
int PS4_SYSV_ABI CERT_extractDistinguishedNames();
int PS4_SYSV_ABI CERT_extractDistinguishedNames2();
int PS4_SYSV_ABI CERT_extractDistinguishedNamesFromName();
int PS4_SYSV_ABI CERT_extractRSAKey();
int PS4_SYSV_ABI CERT_extractSerialNum();
int PS4_SYSV_ABI CERT_extractSerialNum2();
int PS4_SYSV_ABI CERT_extractValidityTime();
int PS4_SYSV_ABI CERT_extractValidityTime2();
int PS4_SYSV_ABI CERT_getCertExtension();
int PS4_SYSV_ABI CERT_getCertificateExtensions();
int PS4_SYSV_ABI CERT_getCertificateExtensions2();
int PS4_SYSV_ABI CERT_getCertificateIssuerSerialNumber();
int PS4_SYSV_ABI CERT_getCertificateIssuerSerialNumber2();
int PS4_SYSV_ABI CERT_getCertificateKeyUsage();
int PS4_SYSV_ABI CERT_getCertificateKeyUsage2();
int PS4_SYSV_ABI CERT_getCertificateSubject();
int PS4_SYSV_ABI CERT_getCertificateSubject2();
int PS4_SYSV_ABI CERT_getCertSignAlgoType();
int PS4_SYSV_ABI CERT_GetCertTime();
int PS4_SYSV_ABI CERT_getNumberOfChild();
int PS4_SYSV_ABI CERT_getRSASignatureAlgo();
int PS4_SYSV_ABI CERT_getSignatureItem();
int PS4_SYSV_ABI CERT_getSubjectCommonName();
int PS4_SYSV_ABI CERT_getSubjectCommonName2();
int PS4_SYSV_ABI CERT_isRootCertificate();
int PS4_SYSV_ABI CERT_isRootCertificate2();
int PS4_SYSV_ABI CERT_rawVerifyOID();
int PS4_SYSV_ABI CERT_rawVerifyOID2();
int PS4_SYSV_ABI CERT_setKeyFromSubjectPublicKeyInfo();
int PS4_SYSV_ABI CERT_setKeyFromSubjectPublicKeyInfoCert();
int PS4_SYSV_ABI CERT_STORE_addCertAuthority();
int PS4_SYSV_ABI CERT_STORE_addIdentity();
int PS4_SYSV_ABI CERT_STORE_addIdentityNakedKey();
int PS4_SYSV_ABI CERT_STORE_addIdentityPSK();
int PS4_SYSV_ABI CERT_STORE_addIdentityWithCertificateChain();
int PS4_SYSV_ABI CERT_STORE_addTrustPoint();
int PS4_SYSV_ABI CERT_STORE_createStore();
int PS4_SYSV_ABI CERT_STORE_findCertBySubject();
int PS4_SYSV_ABI CERT_STORE_findIdentityByTypeFirst();
int PS4_SYSV_ABI CERT_STORE_findIdentityByTypeNext();
int PS4_SYSV_ABI CERT_STORE_findIdentityCertChainFirst();
int PS4_SYSV_ABI CERT_STORE_findIdentityCertChainNext();
int PS4_SYSV_ABI CERT_STORE_findPskByIdentity();
int PS4_SYSV_ABI CERT_STORE_releaseStore();
int PS4_SYSV_ABI CERT_STORE_traversePskListHead();
int PS4_SYSV_ABI CERT_STORE_traversePskListNext();
int PS4_SYSV_ABI CERT_validateCertificate();
int PS4_SYSV_ABI CERT_validateCertificateWithConf();
int PS4_SYSV_ABI CERT_VerifyCertificatePolicies();
int PS4_SYSV_ABI CERT_VerifyCertificatePolicies2();
int PS4_SYSV_ABI CERT_verifySignature();
int PS4_SYSV_ABI CERT_VerifyValidityTime();
int PS4_SYSV_ABI CERT_VerifyValidityTime2();
int PS4_SYSV_ABI CERT_VerifyValidityTimeWithConf();
int PS4_SYSV_ABI CRYPTO_initAsymmetricKey();
int PS4_SYSV_ABI CRYPTO_uninitAsymmetricKey();
int PS4_SYSV_ABI GC_createInstanceIDs();
int PS4_SYSV_ABI getCertSigAlgo();
int PS4_SYSV_ABI MOCANA_freeMocana();
int PS4_SYSV_ABI MOCANA_initMocana();
int PS4_SYSV_ABI RSA_verifySignature();
int PS4_SYSV_ABI sceSslCheckRecvPending();
int PS4_SYSV_ABI sceSslClose();
int PS4_SYSV_ABI sceSslConnect();
int PS4_SYSV_ABI sceSslCreateSslConnection();
int PS4_SYSV_ABI sceSslDeleteSslConnection();
int PS4_SYSV_ABI sceSslDisableOption();
int PS4_SYSV_ABI sceSslDisableOptionInternal();
int PS4_SYSV_ABI sceSslDisableOptionInternalInsecure();
int PS4_SYSV_ABI sceSslEnableOption();
int PS4_SYSV_ABI sceSslEnableOptionInternal();
int PS4_SYSV_ABI sceSslFreeCaCerts();
int PS4_SYSV_ABI sceSslFreeCaList();
int PS4_SYSV_ABI sceSslFreeSslCertName();
int PS4_SYSV_ABI sceSslGetCaCerts();
int PS4_SYSV_ABI sceSslGetCaList();
int PS4_SYSV_ABI sceSslGetIssuerName();
int PS4_SYSV_ABI sceSslGetMemoryPoolStats();
int PS4_SYSV_ABI sceSslGetNameEntryCount();
int PS4_SYSV_ABI sceSslGetNameEntryInfo();
int PS4_SYSV_ABI sceSslGetNanoSSLModuleId();
int PS4_SYSV_ABI sceSslGetNotAfter();
int PS4_SYSV_ABI sceSslGetNotBefore();
int PS4_SYSV_ABI sceSslGetSerialNumber();
int PS4_SYSV_ABI sceSslGetSslError();
int PS4_SYSV_ABI sceSslGetSubjectName();
int PS4_SYSV_ABI sceSslInit(std::size_t poolSize);
int PS4_SYSV_ABI sceSslLoadCert();
int PS4_SYSV_ABI sceSslLoadRootCACert();
int PS4_SYSV_ABI sceSslRecv();
int PS4_SYSV_ABI sceSslReuseConnection();
int PS4_SYSV_ABI sceSslSend();
int PS4_SYSV_ABI sceSslSetMinSslVersion();
int PS4_SYSV_ABI sceSslSetSslVersion();
int PS4_SYSV_ABI sceSslSetVerifyCallback();
int PS4_SYSV_ABI sceSslShowMemoryStat();
int PS4_SYSV_ABI sceSslTerm();
int PS4_SYSV_ABI sceSslUnloadCert();
int PS4_SYSV_ABI SSL_acceptConnection();
int PS4_SYSV_ABI SSL_acceptConnectionCommon();
int PS4_SYSV_ABI SSL_assignCertificateStore();
int PS4_SYSV_ABI SSL_ASYNC_acceptConnection();
int PS4_SYSV_ABI SSL_ASYNC_closeConnection();
int PS4_SYSV_ABI SSL_ASYNC_connect();
int PS4_SYSV_ABI SSL_ASYNC_connectCommon();
int PS4_SYSV_ABI SSL_ASYNC_getRecvBuffer();
int PS4_SYSV_ABI SSL_ASYNC_getSendBuffer();
int PS4_SYSV_ABI SSL_ASYNC_init();
int PS4_SYSV_ABI SSL_ASYNC_initServer();
int PS4_SYSV_ABI SSL_ASYNC_recvMessage();
int PS4_SYSV_ABI SSL_ASYNC_recvMessage2();
int PS4_SYSV_ABI SSL_ASYNC_sendMessage();
int PS4_SYSV_ABI SSL_ASYNC_sendMessagePending();
int PS4_SYSV_ABI SSL_ASYNC_start();
int PS4_SYSV_ABI SSL_closeConnection();
int PS4_SYSV_ABI SSL_connect();
int PS4_SYSV_ABI SSL_connectWithCfgParam();
int PS4_SYSV_ABI SSL_enableCiphers();
int PS4_SYSV_ABI SSL_findConnectionInstance();
int PS4_SYSV_ABI SSL_getCipherInfo();
int PS4_SYSV_ABI SSL_getClientRandom();
int PS4_SYSV_ABI SSL_getClientSessionInfo();
int PS4_SYSV_ABI SSL_getCookie();
int PS4_SYSV_ABI SSL_getNextSessionId();
int PS4_SYSV_ABI SSL_getServerRandom();
int PS4_SYSV_ABI SSL_getSessionCache();
int PS4_SYSV_ABI SSL_getSessionFlags();
int PS4_SYSV_ABI SSL_getSessionInfo();
int PS4_SYSV_ABI SSL_getSessionStatus();
int PS4_SYSV_ABI SSL_getSocketId();
int PS4_SYSV_ABI SSL_getSSLTLSVersion();
int PS4_SYSV_ABI SSL_init();
int PS4_SYSV_ABI SSL_initiateRehandshake();
int PS4_SYSV_ABI SSL_initServerCert();
int PS4_SYSV_ABI SSL_ioctl();
int PS4_SYSV_ABI SSL_isSessionSSL();
int PS4_SYSV_ABI SSL_lockSessionCacheMutex();
int PS4_SYSV_ABI SSL_lookupAlert();
int PS4_SYSV_ABI SSL_negotiateConnection();
int PS4_SYSV_ABI SSL_recv();
int PS4_SYSV_ABI SSL_recvPending();
int PS4_SYSV_ABI SSL_releaseTables();
int PS4_SYSV_ABI SSL_retrieveServerNameList();
int PS4_SYSV_ABI SSL_rngFun();
int PS4_SYSV_ABI SSL_send();
int PS4_SYSV_ABI SSL_sendAlert();
int PS4_SYSV_ABI SSL_sendPending();
int PS4_SYSV_ABI SSL_setCookie();
int PS4_SYSV_ABI SSL_setServerCert();
int PS4_SYSV_ABI SSL_setServerNameList();
int PS4_SYSV_ABI SSL_setSessionFlags();
int PS4_SYSV_ABI SSL_shutdown();
int PS4_SYSV_ABI SSL_sslSettings();
int PS4_SYSV_ABI SSL_validateCertParam();
int PS4_SYSV_ABI VLONG_freeVlongQueue();
int PS4_SYSV_ABI Func_22E76E60BC0587D7();
int PS4_SYSV_ABI Func_28F8791A771D39C7();
void RegisterlibSceSsl(Core::Loader::SymbolsResolver* sym);
} // namespace Libraries::Ssl
| 9,441
|
C++
|
.h
| 218
| 42.279817
| 66
| 0.809808
|
shadps4-emu/shadPS4
| 9,253
| 501
| 185
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
15,867
|
net.h
|
shadps4-emu_shadPS4/src/core/libraries/network/net.h
|
// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
#pragma once
#include "common/types.h"
namespace Core::Loader {
class SymbolsResolver;
}
// Define our own htonll and ntohll because its not available in some systems/platforms
#ifndef HTONLL
#define HTONLL(x) (((uint64_t)htonl((x) & 0xFFFFFFFFUL)) << 32) | htonl((uint32_t)((x) >> 32))
#endif
#ifndef NTOHLL
#define NTOHLL(x) (((uint64_t)ntohl((x) & 0xFFFFFFFFUL)) << 32) | ntohl((uint32_t)((x) >> 32))
#endif
namespace Libraries::Net {
using OrbisNetId = s32;
struct OrbisNetSockaddr {
u8 sa_len;
u8 sa_family;
char sa_data[14];
};
int PS4_SYSV_ABI in6addr_any();
int PS4_SYSV_ABI in6addr_loopback();
int PS4_SYSV_ABI sce_net_dummy();
int PS4_SYSV_ABI sce_net_in6addr_any();
int PS4_SYSV_ABI sce_net_in6addr_linklocal_allnodes();
int PS4_SYSV_ABI sce_net_in6addr_linklocal_allrouters();
int PS4_SYSV_ABI sce_net_in6addr_loopback();
int PS4_SYSV_ABI sce_net_in6addr_nodelocal_allnodes();
OrbisNetId PS4_SYSV_ABI sceNetAccept(OrbisNetId s, OrbisNetSockaddr* addr, u32* paddrlen);
int PS4_SYSV_ABI sceNetAddrConfig6GetInfo();
int PS4_SYSV_ABI sceNetAddrConfig6Start();
int PS4_SYSV_ABI sceNetAddrConfig6Stop();
int PS4_SYSV_ABI sceNetAllocateAllRouteInfo();
int PS4_SYSV_ABI sceNetBandwidthControlGetDataTraffic();
int PS4_SYSV_ABI sceNetBandwidthControlGetDefaultParam();
int PS4_SYSV_ABI sceNetBandwidthControlGetIfParam();
int PS4_SYSV_ABI sceNetBandwidthControlGetPolicy();
int PS4_SYSV_ABI sceNetBandwidthControlSetDefaultParam();
int PS4_SYSV_ABI sceNetBandwidthControlSetIfParam();
int PS4_SYSV_ABI sceNetBandwidthControlSetPolicy();
int PS4_SYSV_ABI sceNetBind(OrbisNetId s, const OrbisNetSockaddr* addr, u32 addrlen);
int PS4_SYSV_ABI sceNetClearDnsCache();
int PS4_SYSV_ABI sceNetConfigAddArp();
int PS4_SYSV_ABI sceNetConfigAddArpWithInterface();
int PS4_SYSV_ABI sceNetConfigAddIfaddr();
int PS4_SYSV_ABI sceNetConfigAddMRoute();
int PS4_SYSV_ABI sceNetConfigAddRoute();
int PS4_SYSV_ABI sceNetConfigAddRoute6();
int PS4_SYSV_ABI sceNetConfigAddRouteWithInterface();
int PS4_SYSV_ABI sceNetConfigCleanUpAllInterfaces();
int PS4_SYSV_ABI sceNetConfigDelArp();
int PS4_SYSV_ABI sceNetConfigDelArpWithInterface();
int PS4_SYSV_ABI sceNetConfigDelDefaultRoute();
int PS4_SYSV_ABI sceNetConfigDelDefaultRoute6();
int PS4_SYSV_ABI sceNetConfigDelIfaddr();
int PS4_SYSV_ABI sceNetConfigDelIfaddr6();
int PS4_SYSV_ABI sceNetConfigDelMRoute();
int PS4_SYSV_ABI sceNetConfigDelRoute();
int PS4_SYSV_ABI sceNetConfigDelRoute6();
int PS4_SYSV_ABI sceNetConfigDownInterface();
int PS4_SYSV_ABI sceNetConfigEtherGetLinkMode();
int PS4_SYSV_ABI sceNetConfigEtherPostPlugInOutEvent();
int PS4_SYSV_ABI sceNetConfigEtherSetLinkMode();
int PS4_SYSV_ABI sceNetConfigFlushRoute();
int PS4_SYSV_ABI sceNetConfigGetDefaultRoute();
int PS4_SYSV_ABI sceNetConfigGetDefaultRoute6();
int PS4_SYSV_ABI sceNetConfigGetIfaddr();
int PS4_SYSV_ABI sceNetConfigGetIfaddr6();
int PS4_SYSV_ABI sceNetConfigRoutingShowRoutingConfig();
int PS4_SYSV_ABI sceNetConfigRoutingShowtCtlVar();
int PS4_SYSV_ABI sceNetConfigRoutingStart();
int PS4_SYSV_ABI sceNetConfigRoutingStop();
int PS4_SYSV_ABI sceNetConfigSetDefaultRoute();
int PS4_SYSV_ABI sceNetConfigSetDefaultRoute6();
int PS4_SYSV_ABI sceNetConfigSetDefaultScope();
int PS4_SYSV_ABI sceNetConfigSetIfaddr();
int PS4_SYSV_ABI sceNetConfigSetIfaddr6();
int PS4_SYSV_ABI sceNetConfigSetIfaddr6WithFlags();
int PS4_SYSV_ABI sceNetConfigSetIfFlags();
int PS4_SYSV_ABI sceNetConfigSetIfLinkLocalAddr6();
int PS4_SYSV_ABI sceNetConfigSetIfmtu();
int PS4_SYSV_ABI sceNetConfigUnsetIfFlags();
int PS4_SYSV_ABI sceNetConfigUpInterface();
int PS4_SYSV_ABI sceNetConfigUpInterfaceWithFlags();
int PS4_SYSV_ABI sceNetConfigWlanAdhocClearWakeOnWlan();
int PS4_SYSV_ABI sceNetConfigWlanAdhocCreate();
int PS4_SYSV_ABI sceNetConfigWlanAdhocGetWakeOnWlanInfo();
int PS4_SYSV_ABI sceNetConfigWlanAdhocJoin();
int PS4_SYSV_ABI sceNetConfigWlanAdhocLeave();
int PS4_SYSV_ABI sceNetConfigWlanAdhocPspEmuClearWakeOnWlan();
int PS4_SYSV_ABI sceNetConfigWlanAdhocPspEmuGetWakeOnWlanInfo();
int PS4_SYSV_ABI sceNetConfigWlanAdhocPspEmuSetWakeOnWlan();
int PS4_SYSV_ABI sceNetConfigWlanAdhocScanJoin();
int PS4_SYSV_ABI sceNetConfigWlanAdhocSetExtInfoElement();
int PS4_SYSV_ABI sceNetConfigWlanAdhocSetWakeOnWlan();
int PS4_SYSV_ABI sceNetConfigWlanApStart();
int PS4_SYSV_ABI sceNetConfigWlanApStop();
int PS4_SYSV_ABI sceNetConfigWlanBackgroundScanQuery();
int PS4_SYSV_ABI sceNetConfigWlanBackgroundScanStart();
int PS4_SYSV_ABI sceNetConfigWlanBackgroundScanStop();
int PS4_SYSV_ABI sceNetConfigWlanDiagGetDeviceInfo();
int PS4_SYSV_ABI sceNetConfigWlanDiagSetAntenna();
int PS4_SYSV_ABI sceNetConfigWlanDiagSetTxFixedRate();
int PS4_SYSV_ABI sceNetConfigWlanGetDeviceConfig();
int PS4_SYSV_ABI sceNetConfigWlanInfraGetRssiInfo();
int PS4_SYSV_ABI sceNetConfigWlanInfraLeave();
int PS4_SYSV_ABI sceNetConfigWlanInfraScanJoin();
int PS4_SYSV_ABI sceNetConfigWlanScan();
int PS4_SYSV_ABI sceNetConfigWlanSetDeviceConfig();
int PS4_SYSV_ABI sceNetConnect();
int PS4_SYSV_ABI sceNetControl();
int PS4_SYSV_ABI sceNetDhcpdStart();
int PS4_SYSV_ABI sceNetDhcpdStop();
int PS4_SYSV_ABI sceNetDhcpGetAutoipInfo();
int PS4_SYSV_ABI sceNetDhcpGetInfo();
int PS4_SYSV_ABI sceNetDhcpGetInfoEx();
int PS4_SYSV_ABI sceNetDhcpStart();
int PS4_SYSV_ABI sceNetDhcpStop();
int PS4_SYSV_ABI sceNetDumpAbort();
int PS4_SYSV_ABI sceNetDumpCreate();
int PS4_SYSV_ABI sceNetDumpDestroy();
int PS4_SYSV_ABI sceNetDumpRead();
int PS4_SYSV_ABI sceNetDuplicateIpStart();
int PS4_SYSV_ABI sceNetDuplicateIpStop();
int PS4_SYSV_ABI sceNetEpollAbort();
int PS4_SYSV_ABI sceNetEpollControl();
int PS4_SYSV_ABI sceNetEpollCreate();
int PS4_SYSV_ABI sceNetEpollDestroy();
int PS4_SYSV_ABI sceNetEpollWait();
int* PS4_SYSV_ABI sceNetErrnoLoc();
int PS4_SYSV_ABI sceNetEtherNtostr();
int PS4_SYSV_ABI sceNetEtherStrton();
int PS4_SYSV_ABI sceNetEventCallbackCreate();
int PS4_SYSV_ABI sceNetEventCallbackDestroy();
int PS4_SYSV_ABI sceNetEventCallbackGetError();
int PS4_SYSV_ABI sceNetEventCallbackWaitCB();
int PS4_SYSV_ABI sceNetFreeAllRouteInfo();
int PS4_SYSV_ABI sceNetGetArpInfo();
int PS4_SYSV_ABI sceNetGetDns6Info();
int PS4_SYSV_ABI sceNetGetDnsInfo();
int PS4_SYSV_ABI sceNetGetIfList();
int PS4_SYSV_ABI sceNetGetIfListOnce();
int PS4_SYSV_ABI sceNetGetIfName();
int PS4_SYSV_ABI sceNetGetIfnameNumList();
int PS4_SYSV_ABI sceNetGetMacAddress();
int PS4_SYSV_ABI sceNetGetMemoryPoolStats();
int PS4_SYSV_ABI sceNetGetNameToIndex();
int PS4_SYSV_ABI sceNetGetpeername();
int PS4_SYSV_ABI sceNetGetRandom();
int PS4_SYSV_ABI sceNetGetRouteInfo();
int PS4_SYSV_ABI sceNetGetSockInfo();
int PS4_SYSV_ABI sceNetGetSockInfo6();
int PS4_SYSV_ABI sceNetGetsockname(OrbisNetId s, OrbisNetSockaddr* addr, u32* paddrlen);
int PS4_SYSV_ABI sceNetGetsockopt(OrbisNetId s, int level, int optname, void* optval, u32* optlen);
int PS4_SYSV_ABI sceNetGetStatisticsInfo();
int PS4_SYSV_ABI sceNetGetStatisticsInfoInternal();
int PS4_SYSV_ABI sceNetGetSystemTime();
u32 PS4_SYSV_ABI sceNetHtonl(u32 host32);
u64 PS4_SYSV_ABI sceNetHtonll(u64 host64);
u16 PS4_SYSV_ABI sceNetHtons(u16 host16);
const char* PS4_SYSV_ABI sceNetInetNtop(int af, const void* src, char* dst, u32 size);
int PS4_SYSV_ABI sceNetInetNtopWithScopeId();
int PS4_SYSV_ABI sceNetInetPton(int af, const char* src, void* dst);
int PS4_SYSV_ABI sceNetInetPtonEx();
int PS4_SYSV_ABI sceNetInetPtonWithScopeId();
int PS4_SYSV_ABI sceNetInfoDumpStart();
int PS4_SYSV_ABI sceNetInfoDumpStop();
int PS4_SYSV_ABI sceNetInit();
int PS4_SYSV_ABI sceNetInitParam();
int PS4_SYSV_ABI sceNetIoctl();
int PS4_SYSV_ABI sceNetListen();
int PS4_SYSV_ABI sceNetMemoryAllocate();
int PS4_SYSV_ABI sceNetMemoryFree();
u32 PS4_SYSV_ABI sceNetNtohl(u32 net32);
int PS4_SYSV_ABI sceNetNtohll();
u16 PS4_SYSV_ABI sceNetNtohs(u16 net16);
int PS4_SYSV_ABI sceNetPoolCreate(const char* name, int size, int flags);
int PS4_SYSV_ABI sceNetPoolDestroy();
int PS4_SYSV_ABI sceNetPppoeStart();
int PS4_SYSV_ABI sceNetPppoeStop();
int PS4_SYSV_ABI sceNetRecv();
int PS4_SYSV_ABI sceNetRecvfrom(OrbisNetId s, void* buf, size_t len, int flags,
OrbisNetSockaddr* addr, u32* paddrlen);
int PS4_SYSV_ABI sceNetRecvmsg();
int PS4_SYSV_ABI sceNetResolverAbort();
int PS4_SYSV_ABI sceNetResolverConnect();
int PS4_SYSV_ABI sceNetResolverConnectAbort();
int PS4_SYSV_ABI sceNetResolverConnectCreate();
int PS4_SYSV_ABI sceNetResolverConnectDestroy();
int PS4_SYSV_ABI sceNetResolverCreate();
int PS4_SYSV_ABI sceNetResolverDestroy();
int PS4_SYSV_ABI sceNetResolverGetError();
int PS4_SYSV_ABI sceNetResolverStartAton();
int PS4_SYSV_ABI sceNetResolverStartAton6();
int PS4_SYSV_ABI sceNetResolverStartNtoa();
int PS4_SYSV_ABI sceNetResolverStartNtoa6();
int PS4_SYSV_ABI sceNetResolverStartNtoaMultipleRecords();
int PS4_SYSV_ABI sceNetResolverStartNtoaMultipleRecordsEx();
int PS4_SYSV_ABI sceNetSend();
int PS4_SYSV_ABI sceNetSendmsg();
int PS4_SYSV_ABI sceNetSendto();
int PS4_SYSV_ABI sceNetSetDns6Info();
int PS4_SYSV_ABI sceNetSetDns6InfoToKernel();
int PS4_SYSV_ABI sceNetSetDnsInfo();
int PS4_SYSV_ABI sceNetSetDnsInfoToKernel();
int PS4_SYSV_ABI sceNetSetsockopt();
int PS4_SYSV_ABI sceNetShowIfconfig();
int PS4_SYSV_ABI sceNetShowIfconfigForBuffer();
int PS4_SYSV_ABI sceNetShowIfconfigWithMemory();
int PS4_SYSV_ABI sceNetShowNetstat();
int PS4_SYSV_ABI sceNetShowNetstatEx();
int PS4_SYSV_ABI sceNetShowNetstatExForBuffer();
int PS4_SYSV_ABI sceNetShowNetstatForBuffer();
int PS4_SYSV_ABI sceNetShowNetstatWithMemory();
int PS4_SYSV_ABI sceNetShowPolicy();
int PS4_SYSV_ABI sceNetShowPolicyWithMemory();
int PS4_SYSV_ABI sceNetShowRoute();
int PS4_SYSV_ABI sceNetShowRoute6();
int PS4_SYSV_ABI sceNetShowRoute6ForBuffer();
int PS4_SYSV_ABI sceNetShowRoute6WithMemory();
int PS4_SYSV_ABI sceNetShowRouteForBuffer();
int PS4_SYSV_ABI sceNetShowRouteWithMemory();
int PS4_SYSV_ABI sceNetShutdown();
int PS4_SYSV_ABI sceNetSocket(const char* name, int family, int type, int protocol);
int PS4_SYSV_ABI sceNetSocketAbort();
int PS4_SYSV_ABI sceNetSocketClose();
int PS4_SYSV_ABI sceNetSyncCreate();
int PS4_SYSV_ABI sceNetSyncDestroy();
int PS4_SYSV_ABI sceNetSyncGet();
int PS4_SYSV_ABI sceNetSyncSignal();
int PS4_SYSV_ABI sceNetSyncWait();
int PS4_SYSV_ABI sceNetSysctl();
int PS4_SYSV_ABI sceNetTerm();
int PS4_SYSV_ABI sceNetThreadCreate();
int PS4_SYSV_ABI sceNetThreadExit();
int PS4_SYSV_ABI sceNetThreadJoin();
int PS4_SYSV_ABI sceNetUsleep();
int PS4_SYSV_ABI Func_0E707A589F751C68();
int PS4_SYSV_ABI sceNetEmulationGet();
int PS4_SYSV_ABI sceNetEmulationSet();
void RegisterlibSceNet(Core::Loader::SymbolsResolver* sym);
} // namespace Libraries::Net
| 10,732
|
C++
|
.h
| 243
| 42.946502
| 99
| 0.819275
|
shadps4-emu/shadPS4
| 9,253
| 501
| 185
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
15,868
|
np_manager.h
|
shadps4-emu_shadPS4/src/core/libraries/np_manager/np_manager.h
|
// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
#pragma once
#include "common/types.h"
namespace Core::Loader {
class SymbolsResolver;
}
namespace Libraries::NpManager {
constexpr int ORBIS_NP_ERROR_SIGNED_OUT = 0x80550006;
enum OrbisNpState {
ORBIS_NP_STATE_UNKNOWN = 0,
ORBIS_NP_STATE_SIGNED_OUT,
ORBIS_NP_STATE_SIGNED_IN
};
using OrbisNpStateCallbackForNpToolkit = PS4_SYSV_ABI void (*)(s32 userId, OrbisNpState state,
void* userdata);
constexpr int ORBIS_NP_ONLINEID_MAX_LENGTH = 16;
typedef int OrbisUserServiceUserId;
struct OrbisNpOnlineId {
char data[ORBIS_NP_ONLINEID_MAX_LENGTH];
char term;
char dummy[3];
};
struct OrbisNpId {
OrbisNpOnlineId handle;
u8 opt[8];
u8 reserved[8];
};
int PS4_SYSV_ABI Func_EF4378573542A508();
int PS4_SYSV_ABI _sceNpIpcCreateMemoryFromKernel();
int PS4_SYSV_ABI _sceNpIpcCreateMemoryFromPool();
int PS4_SYSV_ABI _sceNpIpcDestroyMemory();
int PS4_SYSV_ABI _sceNpIpcFreeImpl();
int PS4_SYSV_ABI _sceNpIpcGetNpMemAllocator();
int PS4_SYSV_ABI _sceNpIpcMallocImpl();
int PS4_SYSV_ABI _sceNpIpcReallocImpl();
int PS4_SYSV_ABI _sceNpManagerCreateMemoryFromKernel();
int PS4_SYSV_ABI _sceNpManagerCreateMemoryFromPool();
int PS4_SYSV_ABI _sceNpManagerDestroyMemory();
int PS4_SYSV_ABI _sceNpManagerFreeImpl();
int PS4_SYSV_ABI _sceNpManagerGetNpMemAllocator();
int PS4_SYSV_ABI _sceNpManagerMallocImpl();
int PS4_SYSV_ABI _sceNpManagerReallocImpl();
int PS4_SYSV_ABI _ZN3sce2np10NpOnlineId13GetNpOnlineIdERKNS0_4UserEP13SceNpOnlineId();
int PS4_SYSV_ABI _ZN3sce2np10NpOnlineId13GetNpOnlineIdERKNS0_4UserEPS1_();
int PS4_SYSV_ABI _ZN3sce2np10NpOnlineId16SetNpOnlineIdStrEPKc();
int PS4_SYSV_ABI _ZN3sce2np10NpOnlineId5ClearEv();
int PS4_SYSV_ABI _ZN3sce2np10NpOnlineIdC1ERK13SceNpOnlineId();
int PS4_SYSV_ABI _ZN3sce2np10NpOnlineIdC1ERKS1_();
int PS4_SYSV_ABI _ZN3sce2np10NpOnlineIdC1Ev();
int PS4_SYSV_ABI _ZN3sce2np10NpOnlineIdC2ERK13SceNpOnlineId();
int PS4_SYSV_ABI _ZN3sce2np10NpOnlineIdC2ERKS1_();
int PS4_SYSV_ABI _ZN3sce2np10NpOnlineIdC2Ev();
int PS4_SYSV_ABI _ZN3sce2np10NpOnlineIdD0Ev();
int PS4_SYSV_ABI _ZN3sce2np10NpOnlineIdD1Ev();
int PS4_SYSV_ABI _ZN3sce2np10NpOnlineIdD2Ev();
int PS4_SYSV_ABI _ZN3sce2np11NpHttpTrans13GetResultCodeEPNS0_6HandleE();
int PS4_SYSV_ABI _ZN3sce2np11NpHttpTrans21SetRequestAccessTokenEPNS0_6HandleE();
int PS4_SYSV_ABI _ZN3sce2np11NpHttpTrans24BuildAuthorizationHeaderERKNS0_13NpAccessTokenEPcm();
int PS4_SYSV_ABI _ZN3sce2np11NpHttpTransC2EP16SceNpAllocatorEx();
int PS4_SYSV_ABI _ZN3sce2np11NpHttpTransD0Ev();
int PS4_SYSV_ABI _ZN3sce2np11NpHttpTransD1Ev();
int PS4_SYSV_ABI _ZN3sce2np11NpHttpTransD2Ev();
int PS4_SYSV_ABI _ZN3sce2np12NpHttpClient4InitEii();
int PS4_SYSV_ABI _ZN3sce2np12NpHttpClientC1EP16SceNpAllocatorEx();
int PS4_SYSV_ABI _ZN3sce2np12NpHttpClientC2EP16SceNpAllocatorEx();
int PS4_SYSV_ABI _ZN3sce2np12NpHttpClientD0Ev();
int PS4_SYSV_ABI _ZN3sce2np12NpHttpClientD1Ev();
int PS4_SYSV_ABI _ZN3sce2np12NpHttpClientD2Ev();
int PS4_SYSV_ABI _ZN3sce2np12NpTitleToken5ClearEv();
int PS4_SYSV_ABI _ZN3sce2np12NpTitleTokenC1ERKS1_();
int PS4_SYSV_ABI _ZN3sce2np12NpTitleTokenC1Ev();
int PS4_SYSV_ABI _ZN3sce2np12NpTitleTokenC2ERKS1_();
int PS4_SYSV_ABI _ZN3sce2np12NpTitleTokenC2Ev();
int PS4_SYSV_ABI _ZN3sce2np12NpTitleTokenD0Ev();
int PS4_SYSV_ABI _ZN3sce2np12NpTitleTokenD1Ev();
int PS4_SYSV_ABI _ZN3sce2np12NpTitleTokenD2Ev();
int PS4_SYSV_ABI _ZN3sce2np13NpAccessToken14GetAccessTokenEPNS0_6HandleERKNS0_4UserEPS1_();
int PS4_SYSV_ABI _ZN3sce2np13NpAccessToken5ClearEv();
int PS4_SYSV_ABI _ZN3sce2np13NpAccessTokenC1ERK16SceNpAccessToken();
int PS4_SYSV_ABI _ZN3sce2np13NpAccessTokenC1ERKS1_();
int PS4_SYSV_ABI _ZN3sce2np13NpAccessTokenC1Ev();
int PS4_SYSV_ABI _ZN3sce2np13NpAccessTokenC2ERK16SceNpAccessToken();
int PS4_SYSV_ABI _ZN3sce2np13NpAccessTokenC2ERKS1_();
int PS4_SYSV_ABI _ZN3sce2np13NpAccessTokenC2Ev();
int PS4_SYSV_ABI _ZN3sce2np13NpAccessTokenD0Ev();
int PS4_SYSV_ABI _ZN3sce2np13NpAccessTokenD1Ev();
int PS4_SYSV_ABI _ZN3sce2np13NpAccessTokenD2Ev();
int PS4_SYSV_ABI _ZN3sce2np3ipc14service_client10EndRequestEii();
int PS4_SYSV_ABI _ZN3sce2np3ipc14service_client11InitServiceEi();
int PS4_SYSV_ABI _ZN3sce2np3ipc14service_client11TermServiceEi();
int PS4_SYSV_ABI _ZN3sce2np3ipc14service_client11WaitRequestEiij();
int PS4_SYSV_ABI _ZN3sce2np3ipc14service_client12AbortRequestEii();
int PS4_SYSV_ABI _ZN3sce2np3ipc14service_client12BeginRequestEii();
int PS4_SYSV_ABI _ZN3sce2np3ipc14service_client13CreateRequestEimPKvPi();
int PS4_SYSV_ABI _ZN3sce2np3ipc14service_client13DeleteRequestEii();
int PS4_SYSV_ABI _ZN3sce2np3ipc14service_client13GetIpmiClientEv();
int PS4_SYSV_ABI _ZN3sce2np3ipc14service_client13PollEventFlagEijmjPm();
int PS4_SYSV_ABI _ZN3sce2np3ipc14service_client14PollEventQueueEiPvm();
int PS4_SYSV_ABI _ZN3sce2np4NpId5ClearEv();
int PS4_SYSV_ABI _ZN3sce2np4NpIdC1ERK7SceNpId();
int PS4_SYSV_ABI _ZN3sce2np4NpIdC1ERKS1_();
int PS4_SYSV_ABI _ZN3sce2np4NpIdC1Ev();
int PS4_SYSV_ABI _ZN3sce2np4NpIdC2ERK7SceNpId();
int PS4_SYSV_ABI _ZN3sce2np4NpIdC2ERKS1_();
int PS4_SYSV_ABI _ZN3sce2np4NpIdC2Ev();
int PS4_SYSV_ABI _ZN3sce2np4NpIdD0Ev();
int PS4_SYSV_ABI _ZN3sce2np4NpIdD1Ev();
int PS4_SYSV_ABI _ZN3sce2np4NpIdD2Ev();
int PS4_SYSV_ABI _ZN3sce2np4User5ClearEv();
int PS4_SYSV_ABI _ZN3sce2np4User7GetUserEiPS1_();
int PS4_SYSV_ABI _ZN3sce2np4UserC1Ei();
int PS4_SYSV_ABI _ZN3sce2np4UserC1ERKS1_();
int PS4_SYSV_ABI _ZN3sce2np4UserC1Ev();
int PS4_SYSV_ABI _ZN3sce2np4UserC2Ei();
int PS4_SYSV_ABI _ZN3sce2np4UserC2ERKS1_();
int PS4_SYSV_ABI _ZN3sce2np4UserC2Ev();
int PS4_SYSV_ABI _ZN3sce2np4UserD0Ev();
int PS4_SYSV_ABI _ZN3sce2np4UserD1Ev();
int PS4_SYSV_ABI _ZN3sce2np4UserD2Ev();
int PS4_SYSV_ABI _ZN3sce2np8NpTicket5ClearEv();
int PS4_SYSV_ABI _ZN3sce2np8NpTicketD0Ev();
int PS4_SYSV_ABI _ZN3sce2np8NpTicketD1Ev();
int PS4_SYSV_ABI _ZN3sce2np8NpTicketD2Ev();
int PS4_SYSV_ABI _ZN3sce2npeqERK13SceNpOnlineIdRKNS0_10NpOnlineIdE();
int PS4_SYSV_ABI _ZN3sce2npeqERKNS0_10NpOnlineIdERK13SceNpOnlineId();
int PS4_SYSV_ABI _ZN3sce2npeqERKNS0_10NpOnlineIdES3_();
int PS4_SYSV_ABI _ZN3sce2npeqERKNS0_4UserERKi();
int PS4_SYSV_ABI _ZN3sce2npeqERKNS0_4UserES3_();
int PS4_SYSV_ABI _ZN3sce2npneERK13SceNpOnlineIdRKNS0_10NpOnlineIdE();
int PS4_SYSV_ABI _ZN3sce2npneERKNS0_10NpOnlineIdERK13SceNpOnlineId();
int PS4_SYSV_ABI _ZN3sce2npneERKNS0_10NpOnlineIdES3_();
int PS4_SYSV_ABI _ZN3sce2npneERKNS0_4UserERKi();
int PS4_SYSV_ABI _ZN3sce2npneERKNS0_4UserES3_();
int PS4_SYSV_ABI _ZNK3sce2np10NpOnlineId7IsEmptyEv();
int PS4_SYSV_ABI _ZNK3sce2np12NpTitleToken6GetStrEv();
int PS4_SYSV_ABI _ZNK3sce2np13NpAccessToken7IsEmptyEv();
int PS4_SYSV_ABI _ZNK3sce2np4User10IsLoggedInEv();
int PS4_SYSV_ABI _ZNK3sce2np4User12GetAccountIdEPm();
int PS4_SYSV_ABI _ZNK3sce2np4User12HasAccountIdEPb();
int PS4_SYSV_ABI _ZNK3sce2np4User25GetAccountIdFromRegistoryEPm();
int PS4_SYSV_ABI _ZNK3sce2np4User7IsEmptyEv();
int PS4_SYSV_ABI _ZNK3sce2np4User7IsGuestEv();
int PS4_SYSV_ABI _ZNK3sce2np4User9GetUserIdEv();
int PS4_SYSV_ABI _ZNK3sce2np8NpTicket13GetTicketDataEv();
int PS4_SYSV_ABI _ZNK3sce2np8NpTicket13GetTicketSizeEv();
int PS4_SYSV_ABI _ZThn16_N3sce2np11NpHttpTransD0Ev();
int PS4_SYSV_ABI _ZThn16_N3sce2np11NpHttpTransD1Ev();
int PS4_SYSV_ABI _ZThn8_N3sce2np11NpHttpTransD0Ev();
int PS4_SYSV_ABI _ZThn8_N3sce2np11NpHttpTransD1Ev();
int PS4_SYSV_ABI sceNpAbortRequest();
int PS4_SYSV_ABI sceNpAsmAbort();
int PS4_SYSV_ABI sceNpAsmClientAbortRequest();
int PS4_SYSV_ABI sceNpAsmClientClearNpTitleToken();
int PS4_SYSV_ABI sceNpAsmClientClearNpTitleTokenA();
int PS4_SYSV_ABI sceNpAsmClientCreateRequest2();
int PS4_SYSV_ABI sceNpAsmClientCreateResourceContext();
int PS4_SYSV_ABI sceNpAsmClientCreateResourceContext2();
int PS4_SYSV_ABI sceNpAsmClientDeleteRequest();
int PS4_SYSV_ABI sceNpAsmClientDeleteResourceContext();
int PS4_SYSV_ABI sceNpAsmClientDeleteResourceContext2();
int PS4_SYSV_ABI sceNpAsmClientGetAppId();
int PS4_SYSV_ABI sceNpAsmClientGetCacheControlMaxAge();
int PS4_SYSV_ABI sceNpAsmClientGetGameNpTitleInfo();
int PS4_SYSV_ABI sceNpAsmClientGetGameNpTitleToken();
int PS4_SYSV_ABI sceNpAsmClientGetGameTitleBanInfo();
int PS4_SYSV_ABI sceNpAsmClientGetNpComInfo2();
int PS4_SYSV_ABI sceNpAsmClientGetNpComInfo2A();
int PS4_SYSV_ABI sceNpAsmClientGetNpComInfo2WithHmac();
int PS4_SYSV_ABI sceNpAsmClientGetNpComInfo3();
int PS4_SYSV_ABI sceNpAsmClientGetNpComInfo4();
int PS4_SYSV_ABI sceNpAsmClientGetNpTitleId();
int PS4_SYSV_ABI sceNpAsmClientGetNpTitleToken();
int PS4_SYSV_ABI sceNpAsmClientGetNpTitleToken2();
int PS4_SYSV_ABI sceNpAsmClientGetNpTitleTokenA();
int PS4_SYSV_ABI sceNpAsmClientGetRelatedGameNpTitleIds();
int PS4_SYSV_ABI sceNpAsmClientGetRelatedGameNpTitleIdsA();
int PS4_SYSV_ABI sceNpAsmClientGetRelatedGameNpTitleIdsResult();
int PS4_SYSV_ABI sceNpAsmClientGetServiceBaseUrl();
int PS4_SYSV_ABI sceNpAsmClientGetServiceBaseUrlA();
int PS4_SYSV_ABI sceNpAsmClientGetServiceBaseUrlWithNpTitleId();
int PS4_SYSV_ABI sceNpAsmClientGetServiceBaseUrlWithNpTitleIdA();
int PS4_SYSV_ABI sceNpAsmClientGetServiceIdInfo();
int PS4_SYSV_ABI sceNpAsmClientGetServiceIdInfoA();
int PS4_SYSV_ABI sceNpAsmClientInitialize();
int PS4_SYSV_ABI sceNpAsmClientSetNpTitleId();
int PS4_SYSV_ABI sceNpAsmClientTerminate();
int PS4_SYSV_ABI sceNpAsmCreateConnection();
int PS4_SYSV_ABI sceNpAsmCreateRequest();
int PS4_SYSV_ABI sceNpAsmDeleteConnection();
int PS4_SYSV_ABI sceNpAsmDeleteRequest();
int PS4_SYSV_ABI sceNpAsmGenerateNpTitleToken();
int PS4_SYSV_ABI sceNpAsmGenerateNpTitleToken2();
int PS4_SYSV_ABI sceNpAsmGetNpCommInfo();
int PS4_SYSV_ABI sceNpAsmGetNpCommInfo2();
int PS4_SYSV_ABI sceNpAsmGetRelatedGameNpTitleIds();
int PS4_SYSV_ABI sceNpAsmGetServiceBaseUrl();
int PS4_SYSV_ABI sceNpAsmGetServiceIdInfo();
int PS4_SYSV_ABI sceNpAsmInitialize();
int PS4_SYSV_ABI sceNpAsmTerminate();
int PS4_SYSV_ABI sceNpCheckCallback();
int PS4_SYSV_ABI sceNpCheckCallbackForLib();
int PS4_SYSV_ABI sceNpCheckNpAvailability();
int PS4_SYSV_ABI sceNpCheckNpAvailabilityA();
int PS4_SYSV_ABI sceNpCheckNpReachability();
int PS4_SYSV_ABI sceNpCheckPlus();
int PS4_SYSV_ABI sceNpCreateAsyncRequest();
int PS4_SYSV_ABI sceNpCreateRequest();
int PS4_SYSV_ABI sceNpDeleteRequest(int reqId);
int PS4_SYSV_ABI sceNpGetAccountAge();
int PS4_SYSV_ABI sceNpGetAccountCountry();
int PS4_SYSV_ABI sceNpGetAccountCountryA();
int PS4_SYSV_ABI sceNpGetAccountDateOfBirth();
int PS4_SYSV_ABI sceNpGetAccountDateOfBirthA();
int PS4_SYSV_ABI sceNpGetAccountId();
int PS4_SYSV_ABI sceNpGetAccountIdA();
int PS4_SYSV_ABI sceNpGetAccountLanguage();
int PS4_SYSV_ABI sceNpGetAccountLanguage2();
int PS4_SYSV_ABI sceNpGetAccountLanguageA();
int PS4_SYSV_ABI sceNpGetGamePresenceStatus();
int PS4_SYSV_ABI sceNpGetGamePresenceStatusA();
int PS4_SYSV_ABI sceNpGetNpId(OrbisUserServiceUserId userId, OrbisNpId* npId);
int PS4_SYSV_ABI sceNpGetNpReachabilityState();
int PS4_SYSV_ABI sceNpGetOnlineId(s32 userId, OrbisNpOnlineId* onlineId);
int PS4_SYSV_ABI sceNpGetParentalControlInfo();
int PS4_SYSV_ABI sceNpGetParentalControlInfoA();
int PS4_SYSV_ABI sceNpGetState(s32 userId, OrbisNpState* state);
int PS4_SYSV_ABI sceNpGetUserIdByAccountId();
int PS4_SYSV_ABI sceNpGetUserIdByOnlineId();
int PS4_SYSV_ABI sceNpHasSignedUp();
int PS4_SYSV_ABI sceNpIdMapperAbortRequest();
int PS4_SYSV_ABI sceNpIdMapperAccountIdToNpId();
int PS4_SYSV_ABI sceNpIdMapperAccountIdToOnlineId();
int PS4_SYSV_ABI sceNpIdMapperCreateRequest();
int PS4_SYSV_ABI sceNpIdMapperDeleteRequest();
int PS4_SYSV_ABI sceNpIdMapperNpIdToAccountId();
int PS4_SYSV_ABI sceNpIdMapperOnlineIdToAccountId();
int PS4_SYSV_ABI sceNpInGameMessageAbortHandle();
int PS4_SYSV_ABI sceNpInGameMessageCheckCallback();
int PS4_SYSV_ABI sceNpInGameMessageCreateHandle();
int PS4_SYSV_ABI sceNpInGameMessageDeleteHandle();
int PS4_SYSV_ABI sceNpInGameMessageGetMemoryPoolStatistics();
int PS4_SYSV_ABI sceNpInGameMessageInitialize();
int PS4_SYSV_ABI sceNpInGameMessagePrepare();
int PS4_SYSV_ABI sceNpInGameMessagePrepareA();
int PS4_SYSV_ABI sceNpInGameMessageSendData();
int PS4_SYSV_ABI sceNpInGameMessageSendDataA();
int PS4_SYSV_ABI sceNpInGameMessageTerminate();
int PS4_SYSV_ABI sceNpIntCheckPlus();
int PS4_SYSV_ABI sceNpIntGetAppType();
int PS4_SYSV_ABI sceNpIntGetGamePresenceStatus();
int PS4_SYSV_ABI sceNpIntGetNpTitleId();
int PS4_SYSV_ABI sceNpIntGetNpTitleIdSecret();
int PS4_SYSV_ABI sceNpIntRegisterGamePresenceCallback();
int PS4_SYSV_ABI sceNpIsPlusMember();
int PS4_SYSV_ABI sceNpManagerIntAbortRequest();
int PS4_SYSV_ABI sceNpManagerIntAddActiveSigninStateCallback();
int PS4_SYSV_ABI sceNpManagerIntAddOnlineIdChangeCallback();
int PS4_SYSV_ABI sceNpManagerIntAddPlusMemberTypeCallback();
int PS4_SYSV_ABI sceNpManagerIntAddSigninStateCallback();
int PS4_SYSV_ABI sceNpManagerIntAuthGetAuthorizationCode();
int PS4_SYSV_ABI sceNpManagerIntAuthGetIdToken();
int PS4_SYSV_ABI sceNpManagerIntBindOfflineAccountId();
int PS4_SYSV_ABI sceNpManagerIntCheckGameNpAvailability();
int PS4_SYSV_ABI sceNpManagerIntCheckNpAvailability();
int PS4_SYSV_ABI sceNpManagerIntCheckNpAvailabilityByPid();
int PS4_SYSV_ABI sceNpManagerIntCheckNpState();
int PS4_SYSV_ABI sceNpManagerIntCheckNpStateA();
int PS4_SYSV_ABI sceNpManagerIntClearGameAccessToken();
int PS4_SYSV_ABI sceNpManagerIntClearOnlineIdChangeFlag();
int PS4_SYSV_ABI sceNpManagerIntClearTicket();
int PS4_SYSV_ABI sceNpManagerIntClearUsedFlag();
int PS4_SYSV_ABI sceNpManagerIntClearVshAccessToken();
int PS4_SYSV_ABI sceNpManagerIntCreateLoginContext();
int PS4_SYSV_ABI sceNpManagerIntCreateLoginRequest();
int PS4_SYSV_ABI sceNpManagerIntCreateRequest();
int PS4_SYSV_ABI sceNpManagerIntDeleteLoginContext();
int PS4_SYSV_ABI sceNpManagerIntDeleteRequest();
int PS4_SYSV_ABI sceNpManagerIntGetAccountCountry();
int PS4_SYSV_ABI sceNpManagerIntGetAccountCountryA();
int PS4_SYSV_ABI sceNpManagerIntGetAccountCountrySdk();
int PS4_SYSV_ABI sceNpManagerIntGetAccountDateOfBirthA();
int PS4_SYSV_ABI sceNpManagerIntGetAccountDateOfBirthSdk();
int PS4_SYSV_ABI sceNpManagerIntGetAccountId();
int PS4_SYSV_ABI sceNpManagerIntGetAccountIdSdk();
int PS4_SYSV_ABI sceNpManagerIntGetAccountLanguage();
int PS4_SYSV_ABI sceNpManagerIntGetAccountLanguageA();
int PS4_SYSV_ABI sceNpManagerIntGetAccountNpEnv();
int PS4_SYSV_ABI sceNpManagerIntGetAccountType();
int PS4_SYSV_ABI sceNpManagerIntGetActiveSigninState();
int PS4_SYSV_ABI sceNpManagerIntGetAuthorizationCodeA();
int PS4_SYSV_ABI sceNpManagerIntGetAuthorizationCodeWithPsnoUri();
int PS4_SYSV_ABI sceNpManagerIntGetAuthServerErrorFlag();
int PS4_SYSV_ABI sceNpManagerIntGetClientCredentialAccessToken();
int PS4_SYSV_ABI sceNpManagerIntGetCommunicationRestrictionStatus();
int PS4_SYSV_ABI sceNpManagerIntGetGameAccessToken();
int PS4_SYSV_ABI sceNpManagerIntGetIssuerId();
int PS4_SYSV_ABI sceNpManagerIntGetLastAccountLanguage();
int PS4_SYSV_ABI sceNpManagerIntGetMAccountId();
int PS4_SYSV_ABI sceNpManagerIntGetNpEnv();
int PS4_SYSV_ABI sceNpManagerIntGetNpId();
int PS4_SYSV_ABI sceNpManagerIntGetNpIdByOnlineId();
int PS4_SYSV_ABI sceNpManagerIntGetNpIdSdk();
int PS4_SYSV_ABI sceNpManagerIntGetOfflineAccountId();
int PS4_SYSV_ABI sceNpManagerIntGetOnlineIdByAccountId();
int PS4_SYSV_ABI sceNpManagerIntGetOnlineIdChangeFlag();
int PS4_SYSV_ABI sceNpManagerIntGetOnlineIdInternal();
int PS4_SYSV_ABI sceNpManagerIntGetOnlineIdSdk();
int PS4_SYSV_ABI sceNpManagerIntGetParentalControlFlag();
int PS4_SYSV_ABI sceNpManagerIntGetParentalControlInfo();
int PS4_SYSV_ABI sceNpManagerIntGetParentalControlInfoA();
int PS4_SYSV_ABI sceNpManagerIntGetPlusMemberType();
int PS4_SYSV_ABI sceNpManagerIntGetPlusMemberTypeNB();
int PS4_SYSV_ABI sceNpManagerIntGetServerError();
int PS4_SYSV_ABI sceNpManagerIntGetSigninState();
int PS4_SYSV_ABI sceNpManagerIntGetTicket();
int PS4_SYSV_ABI sceNpManagerIntGetTicketA();
int PS4_SYSV_ABI sceNpManagerIntGetTitleTokenWithCheck();
int PS4_SYSV_ABI sceNpManagerIntGetUserIdByAccountId();
int PS4_SYSV_ABI sceNpManagerIntGetUserIdByMAccountId();
int PS4_SYSV_ABI sceNpManagerIntGetUserIdByNpId();
int PS4_SYSV_ABI sceNpManagerIntGetUserIdByOfflineAccountId();
int PS4_SYSV_ABI sceNpManagerIntGetUserIdByOnlineId();
int PS4_SYSV_ABI sceNpManagerIntGetUserIdByOnlineIdSdk();
int PS4_SYSV_ABI sceNpManagerIntGetUserList();
int PS4_SYSV_ABI sceNpManagerIntGetUserNum();
int PS4_SYSV_ABI sceNpManagerIntGetVshAccessToken();
int PS4_SYSV_ABI sceNpManagerIntGetVshAccessTokenWithCheck();
int PS4_SYSV_ABI sceNpManagerIntGetVshClientId();
int PS4_SYSV_ABI sceNpManagerIntIsSubAccount();
int PS4_SYSV_ABI sceNpManagerIntIsTemporarySignout();
int PS4_SYSV_ABI sceNpManagerIntIsUnregisteredClientError();
int PS4_SYSV_ABI sceNpManagerIntLoginAddJsonInfo();
int PS4_SYSV_ABI sceNpManagerIntLoginAuthenticate();
int PS4_SYSV_ABI sceNpManagerIntLoginBind();
int PS4_SYSV_ABI sceNpManagerIntLoginGet2svInfo();
int PS4_SYSV_ABI sceNpManagerIntLoginGetAccessToken();
int PS4_SYSV_ABI sceNpManagerIntLoginGetAccessTokenViaImplicitFlow();
int PS4_SYSV_ABI sceNpManagerIntLoginGetAccountId();
int PS4_SYSV_ABI sceNpManagerIntLoginGetAuthenticateResponse();
int PS4_SYSV_ABI sceNpManagerIntLoginGetAuthorizationCode();
int PS4_SYSV_ABI sceNpManagerIntLoginGetDeviceCodeInfo();
int PS4_SYSV_ABI sceNpManagerIntLoginGetEmail();
int PS4_SYSV_ABI sceNpManagerIntLoginGetOnlineId();
int PS4_SYSV_ABI sceNpManagerIntLoginGetUserId();
int PS4_SYSV_ABI sceNpManagerIntLoginParseJsonUserInfo();
int PS4_SYSV_ABI sceNpManagerIntLoginResetSsoToken();
int PS4_SYSV_ABI sceNpManagerIntLoginRevalidatePassword();
int PS4_SYSV_ABI sceNpManagerIntLoginSetAccountInfo();
int PS4_SYSV_ABI sceNpManagerIntLoginSetSsoToken();
int PS4_SYSV_ABI sceNpManagerIntLoginSignin();
int PS4_SYSV_ABI sceNpManagerIntLoginValidateCredential();
int PS4_SYSV_ABI sceNpManagerIntLoginValidateKratosAuthCode();
int PS4_SYSV_ABI sceNpManagerIntLoginVerifyDeviceCode();
int PS4_SYSV_ABI sceNpManagerIntPfAuth();
int PS4_SYSV_ABI sceNpManagerIntRemoveActiveSigninStateCallback();
int PS4_SYSV_ABI sceNpManagerIntRemoveOnlineIdChangeCallback();
int PS4_SYSV_ABI sceNpManagerIntRemovePlusMemberTypeCallback();
int PS4_SYSV_ABI sceNpManagerIntRemoveSigninStateCallback();
int PS4_SYSV_ABI sceNpManagerIntRevalidatePassword();
int PS4_SYSV_ABI sceNpManagerIntSetPlusMemberTypeNB();
int PS4_SYSV_ABI sceNpManagerIntSetTimeout();
int PS4_SYSV_ABI sceNpManagerIntSignout();
int PS4_SYSV_ABI sceNpManagerIntSubmitUserCode();
int PS4_SYSV_ABI sceNpManagerIntTemporarySignout();
int PS4_SYSV_ABI sceNpManagerIntUnbindOfflineAccountId();
int PS4_SYSV_ABI sceNpManagerIntUpdateVshAccessToken();
int PS4_SYSV_ABI sceNpManagerIntWebLoginRequired();
int PS4_SYSV_ABI sceNpManagerPrxStartVsh();
int PS4_SYSV_ABI sceNpManagerPrxStopVsh();
int PS4_SYSV_ABI sceNpNotifyPlusFeature();
int PS4_SYSV_ABI sceNpPollAsync();
int PS4_SYSV_ABI sceNpPush2CreateUserContext();
int PS4_SYSV_ABI sceNpPush2DeleteUserContext();
int PS4_SYSV_ABI sceNpPush2Init();
int PS4_SYSV_ABI sceNpPush2IsInit();
int PS4_SYSV_ABI sceNpPush2OptionalCheckCallback();
int PS4_SYSV_ABI sceNpPush2RegisterDataType();
int PS4_SYSV_ABI sceNpPush2RegisterExtendedDataFilter();
int PS4_SYSV_ABI sceNpPush2RegisterNotificationExCallback();
int PS4_SYSV_ABI sceNpPush2SendPushStatisticsDataSystemTelemetry();
int PS4_SYSV_ABI sceNpPush2SetGlobalMutex();
int PS4_SYSV_ABI sceNpPush2SetNpCommunicationId();
int PS4_SYSV_ABI sceNpPush2Term();
int PS4_SYSV_ABI sceNpPush2TriggerEmptyUserEvent();
int PS4_SYSV_ABI sceNpPush2UnregisterDataType();
int PS4_SYSV_ABI sceNpPush2UnregisterExtendedDataFilter();
int PS4_SYSV_ABI sceNpPush2UnregisterNotificationExCallback();
int PS4_SYSV_ABI sceNpPush2UnsetNpCommunicationId();
int PS4_SYSV_ABI sceNpPush2WaitCallback();
int PS4_SYSV_ABI sceNpPushCheckCallback();
int PS4_SYSV_ABI sceNpPushInit();
int PS4_SYSV_ABI sceNpPushIntBeginInactive();
int PS4_SYSV_ABI sceNpPushIntEndInactive();
int PS4_SYSV_ABI sceNpPushIntGetBindUserState();
int PS4_SYSV_ABI sceNpPushIntGetConnectionState();
int PS4_SYSV_ABI sceNpPushIntRegisterNotificationPacketCallback();
int PS4_SYSV_ABI sceNpPushIntUnregisterNotificationPacketCallback();
int PS4_SYSV_ABI sceNpPushRegisterExtendedDataFilter();
int PS4_SYSV_ABI sceNpPushRegisterNotificationExCallback();
int PS4_SYSV_ABI sceNpPushSetNpCommunicationId();
int PS4_SYSV_ABI sceNpPushStartNotification();
int PS4_SYSV_ABI sceNpPushStartNotificationA();
int PS4_SYSV_ABI sceNpPushStopNotification();
int PS4_SYSV_ABI sceNpPushStopNotificationA();
int PS4_SYSV_ABI sceNpPushTerm();
int PS4_SYSV_ABI sceNpPushUnregisterExtendedDataFilter();
int PS4_SYSV_ABI sceNpPushUnregisterNotificationCallback();
int PS4_SYSV_ABI sceNpPushUnsetNpCommunicationId();
int PS4_SYSV_ABI sceNpRegisterGamePresenceCallback();
int PS4_SYSV_ABI sceNpRegisterGamePresenceCallbackA();
int PS4_SYSV_ABI sceNpRegisterNpReachabilityStateCallback();
int PS4_SYSV_ABI sceNpRegisterPlusEventCallback();
int PS4_SYSV_ABI sceNpRegisterStateCallback();
int PS4_SYSV_ABI sceNpRegisterStateCallbackA();
int PS4_SYSV_ABI sceNpServiceClientInit();
int PS4_SYSV_ABI sceNpServiceClientTerm();
int PS4_SYSV_ABI sceNpSetAdditionalScope();
int PS4_SYSV_ABI sceNpSetContentRestriction();
int PS4_SYSV_ABI sceNpSetGamePresenceOnline();
int PS4_SYSV_ABI sceNpSetGamePresenceOnlineA();
int PS4_SYSV_ABI sceNpSetNpTitleId();
int PS4_SYSV_ABI sceNpSetNpTitleIdVsh();
int PS4_SYSV_ABI sceNpSetTimeout();
int PS4_SYSV_ABI sceNpUnregisterGamePresenceCallbackA();
int PS4_SYSV_ABI sceNpUnregisterNpReachabilityStateCallback();
int PS4_SYSV_ABI sceNpUnregisterPlusEventCallback();
int PS4_SYSV_ABI sceNpUnregisterStateCallback();
int PS4_SYSV_ABI sceNpUnregisterStateCallbackA();
int PS4_SYSV_ABI sceNpWaitAsync();
int PS4_SYSV_ABI Func_05003628D66BD87D();
int PS4_SYSV_ABI Func_0C388A4F21C98AF9();
int PS4_SYSV_ABI Func_0CECC7A08A3E50AF();
int PS4_SYSV_ABI Func_0D17030A1DA18EEB();
int PS4_SYSV_ABI Func_0F0F320B6AD8A53D();
int PS4_SYSV_ABI Func_113C477090F9A174();
int PS4_SYSV_ABI Func_12D367D5C727F008();
int PS4_SYSV_ABI Func_1640120BD475931E();
int PS4_SYSV_ABI Func_1AFE1C07C95E65A5();
int PS4_SYSV_ABI Func_1D983C7E0C28AC72();
int PS4_SYSV_ABI Func_208943695A3B58FE();
int PS4_SYSV_ABI Func_258A3D10C99A43BB();
int PS4_SYSV_ABI Func_263E325794B412AC();
int PS4_SYSV_ABI Func_2B6A4BF35C5E240D();
int PS4_SYSV_ABI Func_2B707FFE05ACB009();
int PS4_SYSV_ABI Func_2CE5AB230EBAF8B4();
int PS4_SYSV_ABI Func_3237EE3C3AFC187B();
int PS4_SYSV_ABI Func_33D4DFB2A1603BFF();
int PS4_SYSV_ABI Func_3821D79C1ED86F33();
int PS4_SYSV_ABI Func_3F431997C7105BBF();
int PS4_SYSV_ABI Func_4192797C2D2D3FC3();
int PS4_SYSV_ABI Func_41C7E3D88BBB7F75();
int PS4_SYSV_ABI Func_438F60858A883FCF();
int PS4_SYSV_ABI Func_4C4A062E5660FABD();
int PS4_SYSV_ABI Func_4C808F7A4EFA36A7();
int PS4_SYSV_ABI Func_4E1CED7E62F68F46();
int PS4_SYSV_ABI Func_5161A48C6A61C4BF();
int PS4_SYSV_ABI Func_542603999CA0AEE9();
int PS4_SYSV_ABI Func_54690B41C1128799();
int PS4_SYSV_ABI Func_55A76C7C29521FAD();
int PS4_SYSV_ABI Func_562B234AAE25F80C();
int PS4_SYSV_ABI Func_58D1975026DD864A();
int PS4_SYSV_ABI Func_5A60395F8C3FE128();
int PS4_SYSV_ABI Func_5B382777E9B5F294();
int PS4_SYSV_ABI Func_5DB301F9CD649671();
int PS4_SYSV_ABI Func_6441D55869D8D6F2();
int PS4_SYSV_ABI Func_69068E18854284DE();
int PS4_SYSV_ABI Func_6F59C3B00B03E05A();
int PS4_SYSV_ABI Func_724CCE7F78A1356B();
int PS4_SYSV_ABI Func_750F1B053C243308();
int PS4_SYSV_ABI Func_760F079BB91DE258();
int PS4_SYSV_ABI Func_78657523221556EF();
int PS4_SYSV_ABI Func_8089888BD363EDA6();
int PS4_SYSV_ABI Func_810CA029B6F7C3A1();
int PS4_SYSV_ABI Func_8253B94686A8D3FD();
int PS4_SYSV_ABI Func_8665138A709E1654();
int PS4_SYSV_ABI Func_882F48FAE6097C0C();
int PS4_SYSV_ABI Func_89DBE4B3303FF888();
int PS4_SYSV_ABI Func_8BD3E57620BDDC38();
int PS4_SYSV_ABI Func_8F0A74013AD633EC();
int PS4_SYSV_ABI Func_8FA6264BF3F6CC00();
int PS4_SYSV_ABI Func_9292E87C2C0971E4();
int PS4_SYSV_ABI Func_92CA292318CA03A8();
int PS4_SYSV_ABI Func_9348596C2B17F662();
int PS4_SYSV_ABI Func_9507E9B321A5E0D7();
int PS4_SYSV_ABI Func_98CA95E231980731();
int PS4_SYSV_ABI Func_9E66CC4BBF2C1990();
int PS4_SYSV_ABI Func_9E6CEF7064891F84();
int PS4_SYSV_ABI Func_A7BC2C792E9522C5();
int PS4_SYSV_ABI Func_ABBA0F809548CB02();
int PS4_SYSV_ABI Func_B14A27A4CEDE020F();
int PS4_SYSV_ABI Func_B323EE1C23AB97F3();
int PS4_SYSV_ABI Func_B429819DAEF40BAC();
int PS4_SYSV_ABI Func_B54B9571BEAD82C5();
int PS4_SYSV_ABI Func_B5ACB5CF4A4114A6();
int PS4_SYSV_ABI Func_BA41BE0F44157EE4();
int PS4_SYSV_ABI Func_BAA1DEC848D99690();
int PS4_SYSV_ABI Func_BB8CCCD6C9480EB2();
int PS4_SYSV_ABI Func_BEC25DAAE8B8B81F();
int PS4_SYSV_ABI Func_BFEE936391AB0C70();
int PS4_SYSV_ABI Func_C0DD2DBE2EA66F7A();
int PS4_SYSV_ABI Func_C1F858BF5B86C2A1();
int PS4_SYSV_ABI Func_C240618E6FC39206();
int PS4_SYSV_ABI Func_C338A34450310E79();
int PS4_SYSV_ABI Func_C91EE3603D966909();
int PS4_SYSV_ABI Func_CB67035ED668CF6B();
int PS4_SYSV_ABI Func_D5A5A28B7351A9BE();
int PS4_SYSV_ABI Func_DA8426059F1D5A2D();
int PS4_SYSV_ABI Func_DA8E15DD00AF9DF8();
int PS4_SYSV_ABI Func_DB86987643BB5DD7();
int PS4_SYSV_ABI Func_DEC53D7165C137DF();
int PS4_SYSV_ABI Func_DFDEEE26F2EB96B3();
int PS4_SYSV_ABI Func_E2056A6F01642866();
int PS4_SYSV_ABI Func_E240E9B8597EE56E();
int PS4_SYSV_ABI Func_E32CE33B706F05F7();
int PS4_SYSV_ABI Func_E4F67EFC91C84F87();
int PS4_SYSV_ABI Func_E6F041A2660F83EB();
int PS4_SYSV_ABI Func_E979BA413BD84D38();
int PS4_SYSV_ABI Func_EDDDF2D305DB7866();
int PS4_SYSV_ABI Func_F08EC7725B42E2F9();
int PS4_SYSV_ABI Func_F3595D8EFFF26EC0();
int PS4_SYSV_ABI Func_F3DF5271142F155D();
int PS4_SYSV_ABI Func_F89997168DC987A8();
int PS4_SYSV_ABI Func_F91B5B25CC9B30D9();
int PS4_SYSV_ABI Func_FC335B7102A585B3();
int PS4_SYSV_ABI Func_FCEAC354CA8B206E();
int PS4_SYSV_ABI Func_FF966E4351E564D6();
int PS4_SYSV_ABI sceNpRegisterStateCallbackForToolkit(OrbisNpStateCallbackForNpToolkit callback,
void* userdata);
int PS4_SYSV_ABI sceNpUnregisterStateCallbackForToolkit();
void RegisterlibSceNpManager(Core::Loader::SymbolsResolver* sym);
} // namespace Libraries::NpManager
| 26,128
|
C++
|
.h
| 532
| 47.802632
| 96
| 0.83947
|
shadps4-emu/shadPS4
| 9,253
| 501
| 185
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
15,869
|
np_score.h
|
shadps4-emu_shadPS4/src/core/libraries/np_score/np_score.h
|
// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
#pragma once
#include "common/types.h"
namespace Core::Loader {
class SymbolsResolver;
}
namespace Libraries::NpScore {
int PS4_SYSV_ABI sceNpScoreAbortRequest();
int PS4_SYSV_ABI sceNpScoreCensorComment();
int PS4_SYSV_ABI sceNpScoreCensorCommentAsync();
int PS4_SYSV_ABI sceNpScoreChangeModeForOtherSaveDataOwners();
int PS4_SYSV_ABI sceNpScoreCreateNpTitleCtx();
int PS4_SYSV_ABI sceNpScoreCreateNpTitleCtxA();
int PS4_SYSV_ABI sceNpScoreCreateRequest();
int PS4_SYSV_ABI sceNpScoreCreateTitleCtx();
int PS4_SYSV_ABI sceNpScoreDeleteNpTitleCtx();
int PS4_SYSV_ABI sceNpScoreDeleteRequest();
int PS4_SYSV_ABI sceNpScoreGetBoardInfo();
int PS4_SYSV_ABI sceNpScoreGetBoardInfoAsync();
int PS4_SYSV_ABI sceNpScoreGetFriendsRanking();
int PS4_SYSV_ABI sceNpScoreGetFriendsRankingA();
int PS4_SYSV_ABI sceNpScoreGetFriendsRankingAAsync();
int PS4_SYSV_ABI sceNpScoreGetFriendsRankingAsync();
int PS4_SYSV_ABI sceNpScoreGetFriendsRankingForCrossSave();
int PS4_SYSV_ABI sceNpScoreGetFriendsRankingForCrossSaveAsync();
int PS4_SYSV_ABI sceNpScoreGetGameData();
int PS4_SYSV_ABI sceNpScoreGetGameDataAsync();
int PS4_SYSV_ABI sceNpScoreGetGameDataByAccountId();
int PS4_SYSV_ABI sceNpScoreGetGameDataByAccountIdAsync();
int PS4_SYSV_ABI sceNpScoreGetRankingByAccountId();
int PS4_SYSV_ABI sceNpScoreGetRankingByAccountIdAsync();
int PS4_SYSV_ABI sceNpScoreGetRankingByAccountIdForCrossSave();
int PS4_SYSV_ABI sceNpScoreGetRankingByAccountIdForCrossSaveAsync();
int PS4_SYSV_ABI sceNpScoreGetRankingByAccountIdPcId();
int PS4_SYSV_ABI sceNpScoreGetRankingByAccountIdPcIdAsync();
int PS4_SYSV_ABI sceNpScoreGetRankingByAccountIdPcIdForCrossSave();
int PS4_SYSV_ABI sceNpScoreGetRankingByAccountIdPcIdForCrossSaveAsync();
int PS4_SYSV_ABI sceNpScoreGetRankingByNpId();
int PS4_SYSV_ABI sceNpScoreGetRankingByNpIdAsync();
int PS4_SYSV_ABI sceNpScoreGetRankingByNpIdPcId();
int PS4_SYSV_ABI sceNpScoreGetRankingByNpIdPcIdAsync();
int PS4_SYSV_ABI sceNpScoreGetRankingByRange();
int PS4_SYSV_ABI sceNpScoreGetRankingByRangeA();
int PS4_SYSV_ABI sceNpScoreGetRankingByRangeAAsync();
int PS4_SYSV_ABI sceNpScoreGetRankingByRangeAsync();
int PS4_SYSV_ABI sceNpScoreGetRankingByRangeForCrossSave();
int PS4_SYSV_ABI sceNpScoreGetRankingByRangeForCrossSaveAsync();
int PS4_SYSV_ABI sceNpScorePollAsync();
int PS4_SYSV_ABI sceNpScoreRecordGameData();
int PS4_SYSV_ABI sceNpScoreRecordGameDataAsync();
int PS4_SYSV_ABI sceNpScoreRecordScore();
int PS4_SYSV_ABI sceNpScoreRecordScoreAsync();
int PS4_SYSV_ABI sceNpScoreSanitizeComment();
int PS4_SYSV_ABI sceNpScoreSanitizeCommentAsync();
int PS4_SYSV_ABI sceNpScoreSetPlayerCharacterId();
int PS4_SYSV_ABI sceNpScoreSetThreadParam();
int PS4_SYSV_ABI sceNpScoreSetTimeout();
int PS4_SYSV_ABI sceNpScoreWaitAsync();
void RegisterlibSceNpScore(Core::Loader::SymbolsResolver* sym);
} // namespace Libraries::NpScore
| 2,962
|
C++
|
.h
| 61
| 47.47541
| 72
| 0.856008
|
shadps4-emu/shadPS4
| 9,253
| 501
| 185
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
15,870
|
usbd.h
|
shadps4-emu_shadPS4/src/core/libraries/usbd/usbd.h
|
// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
#pragma once
#include "common/types.h"
namespace Core::Loader {
class SymbolsResolver;
}
namespace Libraries::Usbd {
int PS4_SYSV_ABI sceUsbdAllocTransfer();
int PS4_SYSV_ABI sceUsbdAttachKernelDriver();
int PS4_SYSV_ABI sceUsbdBulkTransfer();
int PS4_SYSV_ABI sceUsbdCancelTransfer();
int PS4_SYSV_ABI sceUsbdCheckConnected();
int PS4_SYSV_ABI sceUsbdClaimInterface();
int PS4_SYSV_ABI sceUsbdClearHalt();
int PS4_SYSV_ABI sceUsbdClose();
int PS4_SYSV_ABI sceUsbdControlTransfer();
int PS4_SYSV_ABI sceUsbdControlTransferGetData();
int PS4_SYSV_ABI sceUsbdControlTransferGetSetup();
int PS4_SYSV_ABI sceUsbdDetachKernelDriver();
int PS4_SYSV_ABI sceUsbdEventHandlerActive();
int PS4_SYSV_ABI sceUsbdEventHandlingOk();
int PS4_SYSV_ABI sceUsbdExit();
int PS4_SYSV_ABI sceUsbdFillBulkTransfer();
int PS4_SYSV_ABI sceUsbdFillControlSetup();
int PS4_SYSV_ABI sceUsbdFillControlTransfer();
int PS4_SYSV_ABI sceUsbdFillInterruptTransfer();
int PS4_SYSV_ABI sceUsbdFillIsoTransfer();
int PS4_SYSV_ABI sceUsbdFreeConfigDescriptor();
int PS4_SYSV_ABI sceUsbdFreeDeviceList();
int PS4_SYSV_ABI sceUsbdFreeTransfer();
int PS4_SYSV_ABI sceUsbdGetActiveConfigDescriptor();
int PS4_SYSV_ABI sceUsbdGetBusNumber();
int PS4_SYSV_ABI sceUsbdGetConfigDescriptor();
int PS4_SYSV_ABI sceUsbdGetConfigDescriptorByValue();
int PS4_SYSV_ABI sceUsbdGetConfiguration();
int PS4_SYSV_ABI sceUsbdGetDescriptor();
int PS4_SYSV_ABI sceUsbdGetDevice();
int PS4_SYSV_ABI sceUsbdGetDeviceAddress();
int PS4_SYSV_ABI sceUsbdGetDeviceDescriptor();
int PS4_SYSV_ABI sceUsbdGetDeviceList();
int PS4_SYSV_ABI sceUsbdGetDeviceSpeed();
int PS4_SYSV_ABI sceUsbdGetIsoPacketBuffer();
int PS4_SYSV_ABI sceUsbdGetMaxIsoPacketSize();
int PS4_SYSV_ABI sceUsbdGetMaxPacketSize();
int PS4_SYSV_ABI sceUsbdGetStringDescriptor();
int PS4_SYSV_ABI sceUsbdGetStringDescriptorAscii();
int PS4_SYSV_ABI sceUsbdHandleEvents();
int PS4_SYSV_ABI sceUsbdHandleEventsLocked();
int PS4_SYSV_ABI sceUsbdHandleEventsTimeout();
int PS4_SYSV_ABI sceUsbdInit();
int PS4_SYSV_ABI sceUsbdInterruptTransfer();
int PS4_SYSV_ABI sceUsbdKernelDriverActive();
int PS4_SYSV_ABI sceUsbdLockEvents();
int PS4_SYSV_ABI sceUsbdLockEventWaiters();
int PS4_SYSV_ABI sceUsbdOpen();
int PS4_SYSV_ABI sceUsbdOpenDeviceWithVidPid();
int PS4_SYSV_ABI sceUsbdRefDevice();
int PS4_SYSV_ABI sceUsbdReleaseInterface();
int PS4_SYSV_ABI sceUsbdResetDevice();
int PS4_SYSV_ABI sceUsbdSetConfiguration();
int PS4_SYSV_ABI sceUsbdSetInterfaceAltSetting();
int PS4_SYSV_ABI sceUsbdSetIsoPacketLengths();
int PS4_SYSV_ABI sceUsbdSubmitTransfer();
int PS4_SYSV_ABI sceUsbdTryLockEvents();
int PS4_SYSV_ABI sceUsbdUnlockEvents();
int PS4_SYSV_ABI sceUsbdUnlockEventWaiters();
int PS4_SYSV_ABI sceUsbdUnrefDevice();
int PS4_SYSV_ABI sceUsbdWaitForEvent();
int PS4_SYSV_ABI Func_65F6EF33E38FFF50();
int PS4_SYSV_ABI Func_97F056BAD90AADE7();
int PS4_SYSV_ABI Func_C55104A33B35B264();
int PS4_SYSV_ABI Func_D56B43060720B1E0();
void RegisterlibSceUsbd(Core::Loader::SymbolsResolver* sym);
} // namespace Libraries::Usbd
| 3,137
|
C++
|
.h
| 75
| 40.773333
| 66
| 0.830281
|
shadps4-emu/shadPS4
| 9,253
| 501
| 185
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
15,871
|
ajm.h
|
shadps4-emu_shadPS4/src/core/libraries/ajm/ajm.h
|
// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
#pragma once
#include "common/bit_field.h"
#include "common/enum.h"
#include "common/types.h"
namespace Core::Loader {
class SymbolsResolver;
}
namespace Libraries::Ajm {
constexpr u32 ORBIS_AT9_CONFIG_DATA_SIZE = 4;
constexpr u32 AJM_INSTANCE_STATISTICS = 0x80000;
enum class AjmCodecType : u32 {
Mp3Dec = 0,
At9Dec = 1,
M4aacDec = 2,
Max = 23,
};
DECLARE_ENUM_FLAG_OPERATORS(AjmCodecType);
struct AjmBatchInfo {
void* pBuffer;
u64 offset;
u64 size;
};
struct AjmBatchError {
int error_code;
const void* job_addr;
u32 cmd_offset;
const void* job_ra;
};
struct AjmBuffer {
u8* p_address;
u64 size;
};
enum class AjmJobControlFlags : u64 {
Reset = 1 << 0,
Initialize = 1 << 1,
Resample = 1 << 2,
};
DECLARE_ENUM_FLAG_OPERATORS(AjmJobControlFlags)
enum class AjmJobRunFlags : u64 {
GetCodecInfo = 1 << 0,
MultipleFrames = 1 << 1,
};
DECLARE_ENUM_FLAG_OPERATORS(AjmJobRunFlags)
enum class AjmJobSidebandFlags : u64 {
GaplessDecode = 1 << 0,
Format = 1 << 1,
Stream = 1 << 2,
};
DECLARE_ENUM_FLAG_OPERATORS(AjmJobSidebandFlags)
union AjmJobFlags {
u64 raw;
struct {
u64 version : 3;
u64 codec : 8;
AjmJobRunFlags run_flags : 2;
AjmJobControlFlags control_flags : 3;
u64 reserved : 29;
AjmJobSidebandFlags sideband_flags : 3;
};
};
struct AjmSidebandResult {
s32 result;
s32 internal_result;
};
struct AjmSidebandMFrame {
u32 num_frames;
u32 reserved;
};
struct AjmSidebandStream {
s32 input_consumed;
s32 output_written;
u64 total_decoded_samples;
};
enum class AjmFormatEncoding : u32 {
S16 = 0,
S32 = 1,
Float = 2,
};
struct AjmSidebandFormat {
u32 num_channels;
u32 channel_mask;
u32 sampl_freq;
AjmFormatEncoding sample_encoding;
u32 bitrate;
u32 reserved;
};
struct AjmSidebandGaplessDecode {
u32 total_samples;
u16 skip_samples;
u16 skipped_samples;
};
struct AjmSidebandResampleParameters {
float ratio;
uint32_t flags;
};
struct AjmDecAt9InitializeParameters {
u8 config_data[ORBIS_AT9_CONFIG_DATA_SIZE];
u32 reserved;
};
union AjmSidebandInitParameters {
AjmDecAt9InitializeParameters at9;
u8 reserved[8];
};
union AjmInstanceFlags {
u64 raw;
struct {
u64 version : 3;
u64 channels : 4;
u64 format : 3;
u64 gapless_loop : 1;
u64 : 21;
u64 codec : 28;
};
};
static_assert(sizeof(AjmInstanceFlags) == 8);
struct AjmDecMp3ParseFrame;
u32 GetChannelMask(u32 num_channels);
int PS4_SYSV_ABI sceAjmBatchCancel(const u32 context_id, const u32 batch_id);
int PS4_SYSV_ABI sceAjmBatchErrorDump();
void* PS4_SYSV_ABI sceAjmBatchJobControlBufferRa(void* p_buffer, u32 instance_id, u64 flags,
void* p_sideband_input, size_t sideband_input_size,
void* p_sideband_output,
size_t sideband_output_size,
void* p_return_address);
void* PS4_SYSV_ABI sceAjmBatchJobInlineBuffer(void* p_buffer, const void* p_data_input,
size_t data_input_size,
const void** pp_batch_address);
void* PS4_SYSV_ABI sceAjmBatchJobRunBufferRa(void* p_buffer, u32 instance_id, u64 flags,
void* p_data_input, size_t data_input_size,
void* p_data_output, size_t data_output_size,
void* p_sideband_output, size_t sideband_output_size,
void* p_return_address);
void* PS4_SYSV_ABI sceAjmBatchJobRunSplitBufferRa(
void* p_buffer, u32 instance_id, u64 flags, const AjmBuffer* p_data_input_buffers,
size_t num_data_input_buffers, const AjmBuffer* p_data_output_buffers,
size_t num_data_output_buffers, void* p_sideband_output, size_t sideband_output_size,
void* p_return_address);
int PS4_SYSV_ABI sceAjmBatchStartBuffer(u32 context, u8* batch, u32 batch_size, const int priority,
AjmBatchError* batch_error, u32* out_batch_id);
int PS4_SYSV_ABI sceAjmBatchWait(const u32 context, const u32 batch_id, const u32 timeout,
AjmBatchError* const batch_error);
int PS4_SYSV_ABI sceAjmDecAt9ParseConfigData();
int PS4_SYSV_ABI sceAjmDecMp3ParseFrame(const u8* stream, u32 stream_size, int parse_ofl,
AjmDecMp3ParseFrame* frame);
int PS4_SYSV_ABI sceAjmFinalize();
int PS4_SYSV_ABI sceAjmInitialize(s64 reserved, u32* out_context);
int PS4_SYSV_ABI sceAjmInstanceCodecType();
int PS4_SYSV_ABI sceAjmInstanceCreate(u32 context, AjmCodecType codec_type, AjmInstanceFlags flags,
u32* instance);
int PS4_SYSV_ABI sceAjmInstanceDestroy(u32 context, u32 instance);
int PS4_SYSV_ABI sceAjmInstanceExtend();
int PS4_SYSV_ABI sceAjmInstanceSwitch();
int PS4_SYSV_ABI sceAjmMemoryRegister();
int PS4_SYSV_ABI sceAjmMemoryUnregister();
int PS4_SYSV_ABI sceAjmModuleRegister(u32 context, AjmCodecType codec_type, s64 reserved);
int PS4_SYSV_ABI sceAjmModuleUnregister();
int PS4_SYSV_ABI sceAjmStrError();
void RegisterlibSceAjm(Core::Loader::SymbolsResolver* sym);
} // namespace Libraries::Ajm
| 5,608
|
C++
|
.h
| 161
| 27.832298
| 100
| 0.658487
|
shadps4-emu/shadPS4
| 9,253
| 501
| 185
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
15,872
|
ajm_batch.h
|
shadps4-emu_shadPS4/src/core/libraries/ajm/ajm_batch.h
|
// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
#pragma once
#include "common/assert.h"
#include "common/types.h"
#include "core/libraries/ajm/ajm.h"
#include <boost/container/small_vector.hpp>
#include <atomic>
#include <limits>
#include <memory>
#include <semaphore>
#include <span>
#include <vector>
namespace Libraries::Ajm {
struct AjmJob {
struct Input {
std::optional<AjmDecAt9InitializeParameters> init_params;
std::optional<AjmSidebandResampleParameters> resample_parameters;
std::optional<AjmSidebandFormat> format;
std::optional<AjmSidebandGaplessDecode> gapless_decode;
std::vector<u8> buffer;
};
struct Output {
boost::container::small_vector<std::span<u8>, 8> buffers;
AjmSidebandResult* p_result = nullptr;
AjmSidebandStream* p_stream = nullptr;
AjmSidebandFormat* p_format = nullptr;
AjmSidebandGaplessDecode* p_gapless_decode = nullptr;
AjmSidebandMFrame* p_mframe = nullptr;
u8* p_codec_info = nullptr;
};
u32 instance_id{};
AjmJobFlags flags{};
Input input;
Output output;
};
struct AjmBatch {
u32 id{};
std::atomic_bool waiting{};
std::atomic_bool canceled{};
std::binary_semaphore finished{0};
boost::container::small_vector<AjmJob, 16> jobs;
static std::shared_ptr<AjmBatch> FromBatchBuffer(std::span<u8> buffer);
};
void* BatchJobControlBufferRa(void* p_buffer, u32 instance_id, u64 flags, void* p_sideband_input,
size_t sideband_input_size, void* p_sideband_output,
size_t sideband_output_size, void* p_return_address);
void* BatchJobInlineBuffer(void* p_buffer, const void* p_data_input, size_t data_input_size,
const void** pp_batch_address);
void* BatchJobRunBufferRa(void* p_buffer, u32 instance_id, u64 flags, void* p_data_input,
size_t data_input_size, void* p_data_output, size_t data_output_size,
void* p_sideband_output, size_t sideband_output_size,
void* p_return_address);
void* BatchJobRunSplitBufferRa(void* p_buffer, u32 instance_id, u64 flags,
const AjmBuffer* p_data_input_buffers, size_t num_data_input_buffers,
const AjmBuffer* p_data_output_buffers,
size_t num_data_output_buffers, void* p_sideband_output,
size_t sideband_output_size, void* p_return_address);
} // namespace Libraries::Ajm
| 2,654
|
C++
|
.h
| 59
| 36.254237
| 100
| 0.655426
|
shadps4-emu/shadPS4
| 9,253
| 501
| 185
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
15,873
|
ajm_mp3.h
|
shadps4-emu_shadPS4/src/core/libraries/ajm/ajm_mp3.h
|
// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
#pragma once
#include "common/types.h"
#include "core/libraries/ajm/ajm_instance.h"
extern "C" {
#include <libavcodec/avcodec.h>
struct SwrContext;
}
namespace Libraries::Ajm {
enum class AjmDecMp3OflType : u32 {
None = 0,
Lame = 1,
Vbri = 2,
Fgh = 3,
VbriAndFgh = 4,
};
enum AjmMp3CodecFlags : u32 {
IgnoreOfl = 1 << 0,
VlcRewind = 1 << 8,
};
DECLARE_ENUM_FLAG_OPERATORS(AjmMp3CodecFlags)
// 11-bit syncword if MPEG 2.5 extensions are enabled
static constexpr u8 SYNCWORDH = 0xff;
static constexpr u8 SYNCWORDL = 0xe0;
struct AjmDecMp3ParseFrame {
u64 frame_size;
u32 num_channels;
u32 samples_per_channel;
u32 bitrate;
u32 sample_rate;
u32 encoder_delay;
u32 num_frames;
u32 total_samples;
AjmDecMp3OflType ofl_type;
};
enum class ChannelMode : u8 {
Stereo = 0,
JointStero = 1,
Dual = 2,
Mono = 3,
};
struct AjmSidebandDecMp3CodecInfo {
u32 header;
bool has_crc;
ChannelMode channel_mode;
u8 mode_extension;
u8 copyright;
u8 original;
u8 emphasis;
u16 reserved[3];
};
class AjmMp3Decoder : public AjmCodec {
public:
explicit AjmMp3Decoder(AjmFormatEncoding format, AjmMp3CodecFlags flags);
~AjmMp3Decoder() override;
void Reset() override;
void Initialize(const void* buffer, u32 buffer_size) override {}
void GetInfo(void* out_info) const override;
AjmSidebandFormat GetFormat() const override;
u32 GetNextFrameSize(const AjmInstanceGapless& gapless) const override;
std::tuple<u32, u32> ProcessData(std::span<u8>& input, SparseOutputBuffer& output,
AjmInstanceGapless& gapless) override;
static int ParseMp3Header(const u8* buf, u32 stream_size, int parse_ofl,
AjmDecMp3ParseFrame* frame);
private:
template <class T>
size_t WriteOutputPCM(AVFrame* frame, SparseOutputBuffer& output, u32 skipped_samples,
u32 max_pcm) {
std::span<T> pcm_data(reinterpret_cast<T*>(frame->data[0]),
frame->nb_samples * frame->ch_layout.nb_channels);
pcm_data = pcm_data.subspan(skipped_samples * frame->ch_layout.nb_channels);
return output.Write(pcm_data.subspan(0, std::min(u32(pcm_data.size()), max_pcm)));
}
AVFrame* ConvertAudioFrame(AVFrame* frame);
const AjmFormatEncoding m_format;
const AjmMp3CodecFlags m_flags;
const AVCodec* m_codec = nullptr;
AVCodecContext* m_codec_context = nullptr;
AVCodecParserContext* m_parser = nullptr;
SwrContext* m_swr_context = nullptr;
std::optional<u32> m_header;
u32 m_frame_samples = 0;
};
} // namespace Libraries::Ajm
| 2,822
|
C++
|
.h
| 85
| 27.964706
| 90
| 0.690441
|
shadps4-emu/shadPS4
| 9,253
| 501
| 185
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
15,874
|
ajm_instance.h
|
shadps4-emu_shadPS4/src/core/libraries/ajm/ajm_instance.h
|
// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
#pragma once
#include "common/enum.h"
#include "common/types.h"
#include "core/libraries/ajm/ajm.h"
#include "core/libraries/ajm/ajm_batch.h"
#include <memory>
#include <optional>
#include <tuple>
namespace Libraries::Ajm {
u8 GetPCMSize(AjmFormatEncoding format);
class SparseOutputBuffer {
public:
SparseOutputBuffer(std::span<std::span<u8>> chunks)
: m_chunks(chunks), m_current(m_chunks.begin()) {}
template <class T>
size_t Write(std::span<T> pcm) {
size_t samples_written = 0;
while (!pcm.empty() && !IsEmpty()) {
auto size = std::min(pcm.size() * sizeof(T), m_current->size());
std::memcpy(m_current->data(), pcm.data(), size);
const auto nsamples = size / sizeof(T);
samples_written += nsamples;
pcm = pcm.subspan(nsamples);
*m_current = m_current->subspan(size);
if (m_current->empty()) {
++m_current;
}
}
if (!pcm.empty()) {
LOG_ERROR(Lib_Ajm, "Could not write {} samples", pcm.size());
}
return samples_written;
}
bool IsEmpty() const {
return m_current == m_chunks.end();
}
size_t Size() const {
size_t result = 0;
for (auto it = m_current; it != m_chunks.end(); ++it) {
result += it->size();
}
return result;
}
private:
std::span<std::span<u8>> m_chunks;
std::span<std::span<u8>>::iterator m_current;
};
struct AjmInstanceGapless {
AjmSidebandGaplessDecode init{};
AjmSidebandGaplessDecode current{};
bool IsEnd() const {
return init.total_samples != 0 && current.total_samples == 0;
}
};
class AjmCodec {
public:
virtual ~AjmCodec() = default;
virtual void Initialize(const void* buffer, u32 buffer_size) = 0;
virtual void Reset() = 0;
virtual void GetInfo(void* out_info) const = 0;
virtual AjmSidebandFormat GetFormat() const = 0;
virtual u32 GetNextFrameSize(const AjmInstanceGapless& gapless) const = 0;
virtual std::tuple<u32, u32> ProcessData(std::span<u8>& input, SparseOutputBuffer& output,
AjmInstanceGapless& gapless) = 0;
};
class AjmInstance {
public:
AjmInstance(AjmCodecType codec_type, AjmInstanceFlags flags);
void ExecuteJob(AjmJob& job);
private:
bool HasEnoughSpace(const SparseOutputBuffer& output) const;
std::optional<u32> GetNumRemainingSamples() const;
AjmInstanceFlags m_flags{};
AjmSidebandFormat m_format{};
AjmInstanceGapless m_gapless{};
AjmSidebandResampleParameters m_resample_parameters{};
u32 m_total_samples{};
std::unique_ptr<AjmCodec> m_codec;
};
} // namespace Libraries::Ajm
| 2,867
|
C++
|
.h
| 82
| 28.743902
| 94
| 0.642082
|
shadps4-emu/shadPS4
| 9,253
| 501
| 185
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
15,875
|
ajm_context.h
|
shadps4-emu_shadPS4/src/core/libraries/ajm/ajm_context.h
|
// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
#pragma once
#include "common/bounded_threadsafe_queue.h"
#include "common/slot_array.h"
#include "common/types.h"
#include "core/libraries/ajm/ajm.h"
#include "core/libraries/ajm/ajm_batch.h"
#include "core/libraries/ajm/ajm_instance.h"
#include <array>
#include <memory>
#include <shared_mutex>
#include <span>
#include <thread>
#include <utility>
namespace Libraries::Ajm {
class AjmContext {
public:
AjmContext();
s32 InstanceCreate(AjmCodecType codec_type, AjmInstanceFlags flags, u32* out_instance_id);
s32 InstanceDestroy(u32 instance_id);
s32 BatchCancel(const u32 batch_id);
s32 ModuleRegister(AjmCodecType type);
s32 BatchWait(const u32 batch_id, const u32 timeout, AjmBatchError* const p_batch_error);
s32 BatchStartBuffer(u8* p_batch, u32 batch_size, const int priority,
AjmBatchError* p_batch_error, u32* p_batch_id);
void WorkerThread(std::stop_token stop);
void ProcessBatch(u32 id, std::span<AjmJob> jobs);
private:
static constexpr u32 MaxInstances = 0x2fff;
static constexpr u32 MaxBatches = 0x0400;
static constexpr u32 NumAjmCodecs = std::to_underlying(AjmCodecType::Max);
[[nodiscard]] bool IsRegistered(AjmCodecType type) const;
std::array<bool, NumAjmCodecs> registered_codecs{};
std::shared_mutex instances_mutex;
Common::SlotArray<u32, std::shared_ptr<AjmInstance>, MaxInstances, 1> instances;
std::shared_mutex batches_mutex;
Common::SlotArray<u32, std::shared_ptr<AjmBatch>, MaxBatches, 1> batches;
std::jthread worker_thread{};
Common::MPSCQueue<std::shared_ptr<AjmBatch>> batch_queue;
};
} // namespace Libraries::Ajm
| 1,779
|
C++
|
.h
| 42
| 38.5
| 94
| 0.747387
|
shadps4-emu/shadPS4
| 9,253
| 501
| 185
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.