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 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
5,818
|
ErrorCodes.h
|
RPCS3_rpcs3/rpcs3/Emu/Cell/ErrorCodes.h
|
#pragma once
#include "util/types.hpp"
#include "Utilities/StrFmt.h"
namespace logs
{
struct message;
}
// Error code type (return type), implements error reporting.
class error_code
{
s32 value;
// Common constructor
template <typename ET> requires requires (ET v) { static_cast<s32>(v); }
error_code(const logs::message* ch, const ET& value) noexcept
: value(error_report(static_cast<s32>(value), ch, " : %s", fmt::type_info_v<ET>, fmt_args_t<ET>{fmt_unveil<ET>::get(value)}))
{
}
// Error constructor (2 args)
template <typename ET, typename T> requires requires (ET v) { static_cast<s32>(v); }
error_code(const logs::message* ch, const ET& value, const T& arg) noexcept
: value(error_report(static_cast<s32>(value), ch, " : %s, %s", fmt::type_info_v<ET, T>, fmt_args_t<ET, T>{fmt_unveil<ET>::get(value), fmt_unveil<T>::get(arg)}))
{
}
// Formatting constructor (error, format string, variadic list)
template <typename ET, typename... Args> requires requires (ET v) { static_cast<s32>(v); }
error_code(const logs::message* ch, const ET& value, const const_str& fmt, const Args&... args) noexcept
: value(error_report(static_cast<s32>(value), ch, fmt, fmt::type_info_v<Args...>, fmt_args_t<Args...>{fmt_unveil<Args>::get(args)...}))
{
}
public:
// Implementation must be provided independently
static s32 error_report(s32 result, const logs::message* channel, const char* fmt, const fmt_type_info* sup, const u64* args);
error_code() = default;
// Constructor without channel
template <typename... Args> requires (sizeof...(Args) > 0 && !(std::is_same_v<std::decay_t<std::remove_pointer_t<Args>>, logs::message> || ...))
error_code(const Args&... args) noexcept
: error_code(std::add_pointer_t<const logs::message>{}, args...)
{
}
// Constructor with channel
template <typename... Args>
error_code(const logs::message& ch, const Args&... args) noexcept
: error_code(std::addressof(ch), args...)
{
}
operator s32() const
{
return value;
}
ENABLE_BITWISE_SERIALIZATION;
};
enum CellNotAnError : s32
{
CELL_OK = 0,
CELL_CANCEL = 1,
};
// Constructor specialization that doesn't trigger reporting
template <>
constexpr FORCE_INLINE error_code::error_code(const CellNotAnError& value) noexcept
: value(value)
{
}
// Helper function for error_code
template <typename T>
constexpr FORCE_INLINE CellNotAnError not_an_error(const T& value)
{
return static_cast<CellNotAnError>(static_cast<s32>(value));
}
template <typename T, typename>
struct ppu_gpr_cast_impl;
template <>
struct ppu_gpr_cast_impl<error_code, void>
{
static inline u64 to(const error_code& code)
{
return code;
}
static inline error_code from(const u64 reg)
{
return not_an_error(reg);
}
};
enum CellError : u32
{
CELL_EAGAIN = 0x80010001, // The resource is temporarily unavailable
CELL_EINVAL = 0x80010002, // An invalid argument value is specified
CELL_ENOSYS = 0x80010003, // The feature is not yet implemented
CELL_ENOMEM = 0x80010004, // Memory allocation failure
CELL_ESRCH = 0x80010005, // The resource with the specified identifier does not exist
CELL_ENOENT = 0x80010006, // The file does not exist
CELL_ENOEXEC = 0x80010007, // The file is in unrecognized format
CELL_EDEADLK = 0x80010008, // Resource deadlock is avoided
CELL_EPERM = 0x80010009, // The operation is not permitted
CELL_EBUSY = 0x8001000A, // The device or resource is busy
CELL_ETIMEDOUT = 0x8001000B, // The operation is timed out
CELL_EABORT = 0x8001000C, // The operation is aborted
CELL_EFAULT = 0x8001000D, // Invalid memory access
CELL_ENOCHILD = 0x8001000E, // Process has no child(s)
CELL_ESTAT = 0x8001000F, // State of the target thread is invalid
CELL_EALIGN = 0x80010010, // Alignment is invalid.
CELL_EKRESOURCE = 0x80010011, // Shortage of the kernel resources
CELL_EISDIR = 0x80010012, // The file is a directory
CELL_ECANCELED = 0x80010013, // Operation canceled
CELL_EEXIST = 0x80010014, // Entry already exists
CELL_EISCONN = 0x80010015, // Port is already connected
CELL_ENOTCONN = 0x80010016, // Port is not connected
CELL_EAUTHFAIL = 0x80010017, // Program authentication fail
CELL_ENOTMSELF = 0x80010018, // The file is not a MSELF
CELL_ESYSVER = 0x80010019, // System version error
CELL_EAUTHFATAL = 0x8001001A, // Fatal system error
CELL_EDOM = 0x8001001B, // Math domain violation
CELL_ERANGE = 0x8001001C, // Math range violation
CELL_EILSEQ = 0x8001001D, // Illegal multi-byte sequence in input
CELL_EFPOS = 0x8001001E, // File position error
CELL_EINTR = 0x8001001F, // Syscall was interrupted
CELL_EFBIG = 0x80010020, // File too large
CELL_EMLINK = 0x80010021, // Too many links
CELL_ENFILE = 0x80010022, // File table overflow
CELL_ENOSPC = 0x80010023, // No space left on device
CELL_ENOTTY = 0x80010024, // Not a TTY
CELL_EPIPE = 0x80010025, // Broken pipe
CELL_EROFS = 0x80010026, // Read-only filesystem (write fail)
CELL_ESPIPE = 0x80010027, // Illegal seek (e.g. seek on pipe)
CELL_E2BIG = 0x80010028, // Arg list too long
CELL_EACCES = 0x80010029, // Access violation
CELL_EBADF = 0x8001002A, // Invalid file descriptor
CELL_EIO = 0x8001002B, // Filesystem mounting failed (actually IO error...EIO)
CELL_EMFILE = 0x8001002C, // Too many files open
CELL_ENODEV = 0x8001002D, // No device
CELL_ENOTDIR = 0x8001002E, // Not a directory
CELL_ENXIO = 0x8001002F, // No such device or IO
CELL_EXDEV = 0x80010030, // Cross-device link error
CELL_EBADMSG = 0x80010031, // Bad Message
CELL_EINPROGRESS = 0x80010032, // In progress
CELL_EMSGSIZE = 0x80010033, // Message size error
CELL_ENAMETOOLONG = 0x80010034, // Name too long
CELL_ENOLCK = 0x80010035, // No lock
CELL_ENOTEMPTY = 0x80010036, // Not empty
CELL_ENOTSUP = 0x80010037, // Not supported
CELL_EFSSPECIFIC = 0x80010038, // File-system specific error
CELL_EOVERFLOW = 0x80010039, // Overflow occured
CELL_ENOTMOUNTED = 0x8001003A, // Filesystem not mounted
CELL_ENOTSDATA = 0x8001003B, // Not SData
CELL_ESDKVER = 0x8001003C, // Incorrect version in sys_load_param
CELL_ENOLICDISC = 0x8001003D, // Pointer is null. Similar than 0x8001003E but with some PARAM.SFO parameter (TITLE_ID?) embedded.
CELL_ENOLICENT = 0x8001003E, // Pointer is null
};
| 6,604
|
C++
|
.h
| 147
| 42.965986
| 162
| 0.693849
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,819
|
SPUDisAsm.h
|
RPCS3_rpcs3/rpcs3/Emu/Cell/SPUDisAsm.h
|
#pragma once
#include "PPCDisAsm.h"
#include "SPUOpcodes.h"
#include "util/v128.hpp"
enum spu_stop_syscall : u32;
static constexpr const char* spu_reg_name[128] =
{
"lr", "sp", "r2", "r3", "r4", "r5", "r6", "r7",
"r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
"r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
"r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",
"r32", "r33", "r34", "r35", "r36", "r37", "r38", "r39",
"r40", "r41", "r42", "r43", "r44", "r45", "r46", "r47",
"r48", "r49", "r50", "r51", "r52", "r53", "r54", "r55",
"r56", "r57", "r58", "r59", "r60", "r61", "r62", "r63",
"r64", "r65", "r66", "r67", "r68", "r69", "r70", "r71",
"r72", "r73", "r74", "r75", "r76", "r77", "r78", "r79",
"r80", "r81", "r82", "r83", "r84", "r85", "r86", "r87",
"r88", "r89", "r90", "r91", "r92", "r93", "r94", "r95",
"r96", "r97", "r98", "r99", "r100", "r101", "r102", "r103",
"r104", "r105", "r106", "r107", "r108", "r109", "r110", "r111",
"r112", "r113", "r114", "r115", "r116", "r117", "r118", "r119",
"r120", "r121", "r122", "r123", "r124", "r125", "r126", "r127",
};
static constexpr const char* spu_spreg_name[128] =
{
"spr0", "spr1", "spr2", "spr3", "spr4", "spr5", "spr6", "spr7",
"spr8", "spr9", "spr10", "spr11", "spr12", "spr13", "spr14", "spr15",
"spr16", "spr17", "spr18", "spr19", "spr20", "spr21", "spr22", "spr23",
"spr24", "spr25", "spr26", "spr27", "spr28", "spr29", "spr30", "spr31",
"spr32", "spr33", "spr34", "spr35", "spr36", "spr37", "spr38", "spr39",
"spr40", "spr41", "spr42", "spr43", "spr44", "spr45", "spr46", "spr47",
"spr48", "spr49", "spr50", "spr51", "spr52", "spr53", "spr54", "spr55",
"spr56", "spr57", "spr58", "spr59", "spr60", "spr61", "spr62", "spr63",
"spr64", "spr65", "spr66", "spr67", "spr68", "spr69", "spr70", "spr71",
"spr72", "spr73", "spr74", "spr75", "spr76", "spr77", "spr78", "spr79",
"spr80", "spr81", "spr82", "spr83", "spr84", "spr85", "spr86", "spr87",
"spr88", "spr89", "spr90", "spr91", "spr92", "spr93", "spr94", "spr95",
"spr96", "spr97", "spr98", "spr99", "spr100", "spr101", "spr102", "spr103",
"spr104", "spr105", "spr106", "spr107", "spr108", "spr109", "spr110", "spr111",
"spr112", "spr113", "spr114", "spr115", "spr116", "spr117", "spr118", "spr119",
"spr120", "spr121", "spr122", "spr123", "spr124", "spr125", "spr126", "spr127",
};
static constexpr const char* spu_ch_name[128] =
{
"SPU_RdEventStat", "SPU_WrEventMask", "SPU_WrEventAck", "SPU_RdSigNotify1",
"SPU_RdSigNotify2", "ch5", "ch6", "SPU_WrDec", "SPU_RdDec",
"MFC_WrMSSyncReq", "ch10", "SPU_RdEventMask", "MFC_RdTagMask", "SPU_RdMachStat",
"SPU_WrSRR0", "SPU_RdSRR0", "MFC_LSA", "MFC_EAH", "MFC_EAL", "MFC_Size",
"MFC_TagID", "MFC_Cmd", "MFC_WrTagMask", "MFC_WrTagUpdate", "MFC_RdTagStat",
"MFC_RdListStallStat", "MFC_WrListStallAck", "MFC_RdAtomicStat",
"SPU_WrOutMbox", "SPU_RdInMbox", "SPU_WrOutIntrMbox", "ch31", "ch32",
"ch33", "ch34", "ch35", "ch36", "ch37", "ch38", "ch39", "ch40",
"ch41", "ch42", "ch43", "ch44", "ch45", "ch46", "ch47", "ch48",
"ch49", "ch50", "ch51", "ch52", "ch53", "ch54", "ch55", "ch56",
"ch57", "ch58", "ch59", "ch60", "ch61", "ch62", "ch63", "ch64",
"ch65", "ch66", "ch67", "ch68", "SPU_Set_Bkmk_Tag", "SPU_PM_Start_Ev", "SPU_PM_Stop_Ev", "ch72",
"ch73", "ch74", "ch75", "ch76", "ch77", "ch78", "ch79", "ch80",
"ch81", "ch82", "ch83", "ch84", "ch85", "ch86", "ch87", "ch88",
"ch89", "ch90", "ch91", "ch92", "ch93", "ch94", "ch95", "ch96",
"ch97", "ch98", "ch99", "ch100", "ch101", "ch102", "ch103", "ch104",
"ch105", "ch106", "ch107", "ch108", "ch109", "ch110", "ch111", "ch112",
"ch113", "ch114", "ch115", "ch116", "ch117", "ch118", "ch119", "ch120",
"ch121", "ch122", "ch123", "ch124", "ch125", "ch126", "ch127",
};
namespace utils
{
class shm;
}
void comment_constant(std::string& last_opocde, u64 value, bool print_float = true);
class SPUDisAsm final : public PPCDisAsm
{
std::shared_ptr<utils::shm> m_shm;
public:
SPUDisAsm(cpu_disasm_mode mode, const u8* offset, u32 start_pc = 0) : PPCDisAsm(mode, offset, start_pc)
{
}
~SPUDisAsm() = default;
void set_shm(std::shared_ptr<utils::shm> shm)
{
m_shm = std::move(shm);
}
private:
virtual u32 DisAsmBranchTarget(const s32 imm) override
{
return spu_branch_target(dump_pc, imm);
}
static char BrIndirectSuffix(u32 de)
{
switch (de)
{
case 0b01: return 'e';
case 0b10: return 'd';
case 0b11: return '!';
default: return '\0';
}
}
void DisAsm(const char* op)
{
last_opcode += op;
}
void DisAsm(std::string_view op, u32 a1)
{
fmt::append(last_opcode, "%-*s 0x%x", PadOp(), op, a1);
}
void DisAsm(std::string_view op, const char* a1)
{
fmt::append(last_opcode, "%-*s %s", PadOp(), op, a1);
}
void DisAsm(std::string_view op, const char* a1, const char* a2)
{
fmt::append(last_opcode, "%-*s %s,%s", PadOp(), op, a1, a2);
}
void DisAsm(std::string_view op, int a1, const char* a2)
{
fmt::append(last_opcode, "%-*s 0x%x,%s", PadOp(), op, a1, a2);
}
void DisAsm(std::string_view op, const char* a1, int a2)
{
fmt::append(last_opcode, "%-*s %s,%s", PadOp(), op, a1, SignedHex(a2));
}
void DisAsm(std::string_view op, int a1, int a2)
{
fmt::append(last_opcode, "%-*s 0x%x,0x%x", PadOp(), op, a1, a2);
}
void DisAsm(std::string_view op, const char* a1, const char* a2, const char* a3)
{
fmt::append(last_opcode, "%-*s %s,%s,%s", PadOp(), op, a1, a2, a3);
}
void DisAsm(std::string_view op, const char* a1, int a2, const char* a3)
{
fmt::append(last_opcode, "%-*s %s,%s(%s)", PadOp(), op, a1, SignedHex(a2), a3);
}
void DisAsm(std::string_view op, const char* a1, const char* a2, int a3)
{
fmt::append(last_opcode, "%-*s %s,%s,%s", PadOp(), op, a1, a2, SignedHex(a3));
}
void DisAsm(std::string_view op, const char* a1, const char* a2, const char* a3, const char* a4)
{
fmt::append(last_opcode, "%-*s %s,%s,%s,%s", PadOp(), op, a1, a2, a3, a4);
}
using field_de_t = decltype(spu_opcode_t::de);
void DisAsm(std::string_view op, field_de_t de, const char* a1)
{
const char c = BrIndirectSuffix(de);
if (c == '!')
{
// Invalid
fmt::append(last_opcode, "?? ?? (%s)", op);
return;
}
fmt::append(last_opcode, "%-*s %s", PadOp(op, c ? 1 : 0), op, a1);
insert_char_if(op, !!c, c);
}
void DisAsm(std::string_view op, field_de_t de, const char* a1, const char* a2)
{
const char c = BrIndirectSuffix(de);
if (c == '!')
{
fmt::append(last_opcode, "?? ?? (%s)", op);
return;
}
fmt::append(last_opcode, "%-*s %s,%s", PadOp(op, c ? 1 : 0), op, a1, a2);
insert_char_if(op, !!c, c);
}
public:
u32 disasm(u32 pc) override;
std::pair<const void*, usz> get_memory_span() const override;
std::unique_ptr<CPUDisAsm> copy_type_erased() const override;
std::pair<bool, v128> try_get_const_value(u32 reg, u32 pc = -1, u32 TTL = 10) const;
// Get constant value if the original array is made of only repetitions of the same value
template <typename T> requires (sizeof(T) < sizeof(v128) && !(sizeof(v128) % sizeof(T)))
std::pair<bool, T> try_get_const_equal_value_array(u32 reg, u32 pc = -1, u32 TTL = 10) const
{
auto [ok, res] = try_get_const_value(reg, pc, TTL);
if (!ok)
{
return {};
}
v128 test_value{};
T sample{};
std::memcpy(&sample, res._bytes, sizeof(T));
for (u32 i = 0; i < sizeof(v128); i += sizeof(T))
{
std::memcpy(test_value._bytes + i, &sample, sizeof(T));
}
if (test_value != res)
{
return {};
}
return {ok, sample};
}
struct insert_mask_info
{
u32 type_size;
u32 dst_index;
u32 src_index;
};
static insert_mask_info try_get_insert_mask_info(const v128& mask);
//0 - 10
void STOP(spu_opcode_t op)
{
op.rb ? UNK(op) : DisAsm("stop", fmt::format("0x%x #%s", op.opcode & 0x3fff, spu_stop_syscall{op.opcode & 0x3fff}).c_str());
}
void LNOP(spu_opcode_t /*op*/)
{
DisAsm("lnop");
}
void SYNC(spu_opcode_t op)
{
DisAsm(op.c ? "syncc" : "sync");
}
void DSYNC(spu_opcode_t /*op*/)
{
DisAsm("dsync");
}
void MFSPR(spu_opcode_t op)
{
DisAsm("mfspr", spu_reg_name[op.rt], spu_spreg_name[op.ra]);
}
void RDCH(spu_opcode_t op)
{
DisAsm("rdch", spu_reg_name[op.rt], spu_ch_name[op.ra]);
}
void RCHCNT(spu_opcode_t op)
{
DisAsm("rchcnt", spu_reg_name[op.rt], spu_ch_name[op.ra]);
}
void SF(spu_opcode_t op)
{
DisAsm("sf", spu_reg_name[op.rt], spu_reg_name[op.ra], spu_reg_name[op.rb]);
}
void OR(spu_opcode_t op)
{
DisAsm("or", spu_reg_name[op.rt], spu_reg_name[op.ra], spu_reg_name[op.rb]);
}
void BG(spu_opcode_t op)
{
DisAsm("bg", spu_reg_name[op.rt], spu_reg_name[op.ra], spu_reg_name[op.rb]);
}
void SFH(spu_opcode_t op)
{
DisAsm("sfh", spu_reg_name[op.rt], spu_reg_name[op.ra], spu_reg_name[op.rb]);
}
void NOR(spu_opcode_t op)
{
DisAsm("nor", spu_reg_name[op.rt], spu_reg_name[op.ra], spu_reg_name[op.rb]);
}
void ABSDB(spu_opcode_t op)
{
DisAsm("absdb", spu_reg_name[op.rt], spu_reg_name[op.ra], spu_reg_name[op.rb]);
}
void ROT(spu_opcode_t op)
{
DisAsm("rot", spu_reg_name[op.rt], spu_reg_name[op.ra], spu_reg_name[op.rb]);
}
void ROTM(spu_opcode_t op)
{
DisAsm("rotm", spu_reg_name[op.rt], spu_reg_name[op.ra], spu_reg_name[op.rb]);
}
void ROTMA(spu_opcode_t op)
{
DisAsm("rotma", spu_reg_name[op.rt], spu_reg_name[op.ra], spu_reg_name[op.rb]);
}
void SHL(spu_opcode_t op)
{
DisAsm("shl", spu_reg_name[op.rt], spu_reg_name[op.ra], spu_reg_name[op.rb]);
}
void ROTH(spu_opcode_t op)
{
DisAsm("roth", spu_reg_name[op.rt], spu_reg_name[op.ra], spu_reg_name[op.rb]);
}
void ROTHM(spu_opcode_t op)
{
DisAsm("rothm", spu_reg_name[op.rt], spu_reg_name[op.ra], spu_reg_name[op.rb]);
}
void ROTMAH(spu_opcode_t op)
{
DisAsm("rotmah", spu_reg_name[op.rt], spu_reg_name[op.ra], spu_reg_name[op.rb]);
}
void SHLH(spu_opcode_t op)
{
DisAsm("shlh", spu_reg_name[op.rt], spu_reg_name[op.ra], spu_reg_name[op.rb]);
}
void ROTI(spu_opcode_t op)
{
DisAsm("roti", spu_reg_name[op.rt], spu_reg_name[op.ra], op.si7);
}
void ROTMI(spu_opcode_t op)
{
DisAsm("rotmi", spu_reg_name[op.rt], spu_reg_name[op.ra], op.si7);
}
void ROTMAI(spu_opcode_t op)
{
DisAsm("rotmai", spu_reg_name[op.rt], spu_reg_name[op.ra], op.si7);
}
void SHLI(spu_opcode_t op)
{
DisAsm("shli", spu_reg_name[op.rt], spu_reg_name[op.ra], op.si7);
}
void ROTHI(spu_opcode_t op)
{
DisAsm("rothi", spu_reg_name[op.rt], spu_reg_name[op.ra], op.si7);
}
void ROTHMI(spu_opcode_t op)
{
DisAsm("rothmi", spu_reg_name[op.rt], spu_reg_name[op.ra], op.si7);
}
void ROTMAHI(spu_opcode_t op)
{
DisAsm("rotmahi", spu_reg_name[op.rt], spu_reg_name[op.ra], op.si7);
}
void SHLHI(spu_opcode_t op)
{
DisAsm("shlhi", spu_reg_name[op.rt], spu_reg_name[op.ra], op.si7);
}
void A(spu_opcode_t op)
{
DisAsm("a", spu_reg_name[op.rt], spu_reg_name[op.ra], spu_reg_name[op.rb]);
}
void AND(spu_opcode_t op)
{
DisAsm("and", spu_reg_name[op.rt], spu_reg_name[op.ra], spu_reg_name[op.rb]);
}
void CG(spu_opcode_t op)
{
DisAsm("cg", spu_reg_name[op.rt], spu_reg_name[op.ra], spu_reg_name[op.rb]);
}
void AH(spu_opcode_t op)
{
DisAsm("ah", spu_reg_name[op.rt], spu_reg_name[op.ra], spu_reg_name[op.rb]);
}
void NAND(spu_opcode_t op)
{
DisAsm("nand", spu_reg_name[op.rt], spu_reg_name[op.ra], spu_reg_name[op.rb]);
}
void AVGB(spu_opcode_t op)
{
DisAsm("avgb", spu_reg_name[op.rt], spu_reg_name[op.ra], spu_reg_name[op.rb]);
}
void MTSPR(spu_opcode_t op)
{
DisAsm("mtspr", spu_spreg_name[op.ra], spu_reg_name[op.rt]);
}
void WRCH(spu_opcode_t op);
void BIZ(spu_opcode_t op)
{
DisAsm("biz", op.de, spu_reg_name[op.rt], spu_reg_name[op.ra]);
}
void BINZ(spu_opcode_t op)
{
DisAsm("binz", op.de, spu_reg_name[op.rt], spu_reg_name[op.ra]);
}
void BIHZ(spu_opcode_t op)
{
DisAsm("bihz", op.de, spu_reg_name[op.rt], spu_reg_name[op.ra]);
}
void BIHNZ(spu_opcode_t op)
{
DisAsm("bihnz", op.de, spu_reg_name[op.rt], spu_reg_name[op.ra]);
}
void STOPD(spu_opcode_t op)
{
DisAsm("stopd", spu_reg_name[op.rc], spu_reg_name[op.ra], spu_reg_name[op.rb]);
}
void STQX(spu_opcode_t op)
{
DisAsm("stqx", spu_reg_name[op.rt], spu_reg_name[op.ra], spu_reg_name[op.rb]);
}
void BI(spu_opcode_t op)
{
DisAsm("bi", op.de, spu_reg_name[op.ra]);
}
void BISL(spu_opcode_t op)
{
DisAsm("bisl", op.de, spu_reg_name[op.rt], spu_reg_name[op.ra]);
}
void IRET(spu_opcode_t op)
{
DisAsm("iret", op.de, spu_reg_name[op.ra]);
}
void BISLED(spu_opcode_t op)
{
DisAsm("bisled", op.de, spu_reg_name[op.rt], spu_reg_name[op.ra]);
}
void HBR(spu_opcode_t op)
{
DisAsm(op.c ? "hbrp" : "hbr", DisAsmBranchTarget((op.roh << 7) | op.rt), spu_reg_name[op.ra]);
}
void GB(spu_opcode_t op)
{
DisAsm("gb", spu_reg_name[op.rt], spu_reg_name[op.ra]);
}
void GBH(spu_opcode_t op)
{
DisAsm("gbh", spu_reg_name[op.rt], spu_reg_name[op.ra]);
}
void GBB(spu_opcode_t op)
{
DisAsm("gbb", spu_reg_name[op.rt], spu_reg_name[op.ra]);
}
void FSM(spu_opcode_t op)
{
DisAsm("fsm", spu_reg_name[op.rt], spu_reg_name[op.ra]);
}
void FSMH(spu_opcode_t op)
{
DisAsm("fsmh", spu_reg_name[op.rt], spu_reg_name[op.ra]);
}
void FSMB(spu_opcode_t op)
{
DisAsm("fsmb", spu_reg_name[op.rt], spu_reg_name[op.ra]);
}
void FREST(spu_opcode_t op)
{
DisAsm("frest", spu_reg_name[op.rt], spu_reg_name[op.ra]);
}
void FRSQEST(spu_opcode_t op)
{
DisAsm("frsqest", spu_reg_name[op.rt], spu_reg_name[op.ra]);
}
void LQX(spu_opcode_t op)
{
DisAsm("lqx", spu_reg_name[op.rt], spu_reg_name[op.ra], spu_reg_name[op.rb]);
}
void ROTQBYBI(spu_opcode_t op)
{
DisAsm("rotqbybi", spu_reg_name[op.rt], spu_reg_name[op.ra], spu_reg_name[op.rb]);
}
void ROTQMBYBI(spu_opcode_t op)
{
DisAsm("rotqmbybi", spu_reg_name[op.rt], spu_reg_name[op.ra], spu_reg_name[op.rb]);
}
void SHLQBYBI(spu_opcode_t op)
{
DisAsm("shlqbybi", spu_reg_name[op.rt], spu_reg_name[op.ra], spu_reg_name[op.rb]);
}
void CBX(spu_opcode_t op)
{
DisAsm("cbx", spu_reg_name[op.rt], spu_reg_name[op.ra], spu_reg_name[op.rb]);
}
void CHX(spu_opcode_t op)
{
DisAsm("chx", spu_reg_name[op.rt], spu_reg_name[op.ra], spu_reg_name[op.rb]);
}
void CWX(spu_opcode_t op)
{
DisAsm("cwx", spu_reg_name[op.rt], spu_reg_name[op.ra], spu_reg_name[op.rb]);
}
void CDX(spu_opcode_t op)
{
DisAsm("cdx", spu_reg_name[op.rt], spu_reg_name[op.ra], spu_reg_name[op.rb]);
}
void ROTQBI(spu_opcode_t op)
{
DisAsm("rotqbi", spu_reg_name[op.rt], spu_reg_name[op.ra], spu_reg_name[op.rb]);
}
void ROTQMBI(spu_opcode_t op)
{
DisAsm("rotqmbi", spu_reg_name[op.rt], spu_reg_name[op.ra], spu_reg_name[op.rb]);
}
void SHLQBI(spu_opcode_t op)
{
DisAsm("shlqbi", spu_reg_name[op.rt], spu_reg_name[op.ra], spu_reg_name[op.rb]);
}
void ROTQBY(spu_opcode_t op)
{
DisAsm("rotqby", spu_reg_name[op.rt], spu_reg_name[op.ra], spu_reg_name[op.rb]);
}
void ROTQMBY(spu_opcode_t op)
{
DisAsm("rotqmby", spu_reg_name[op.rt], spu_reg_name[op.ra], spu_reg_name[op.rb]);
}
void SHLQBY(spu_opcode_t op)
{
DisAsm("shlqby", spu_reg_name[op.rt], spu_reg_name[op.ra], spu_reg_name[op.rb]);
}
void ORX(spu_opcode_t op)
{
DisAsm("orx", spu_reg_name[op.rt], spu_reg_name[op.ra]);
}
void CBD(spu_opcode_t op)
{
DisAsm("cbd", spu_reg_name[op.rt], spu_reg_name[op.ra], op.si7);
}
void CHD(spu_opcode_t op)
{
DisAsm("chd", spu_reg_name[op.rt], spu_reg_name[op.ra], op.si7);
}
void CWD(spu_opcode_t op)
{
DisAsm("cwd", spu_reg_name[op.rt], spu_reg_name[op.ra], op.si7);
}
void CDD(spu_opcode_t op)
{
DisAsm("cdd", spu_reg_name[op.rt], spu_reg_name[op.ra], op.si7);
}
void ROTQBII(spu_opcode_t op)
{
DisAsm("rotqbii", spu_reg_name[op.rt], spu_reg_name[op.ra], op.si7);
}
void ROTQMBII(spu_opcode_t op)
{
DisAsm("rotqmbii", spu_reg_name[op.rt], spu_reg_name[op.ra], op.si7);
}
void SHLQBII(spu_opcode_t op)
{
DisAsm("shlqbii", spu_reg_name[op.rt], spu_reg_name[op.ra], op.si7);
}
void ROTQBYI(spu_opcode_t op)
{
DisAsm("rotqbyi", spu_reg_name[op.rt], spu_reg_name[op.ra], op.si7);
}
void ROTQMBYI(spu_opcode_t op)
{
DisAsm("rotqmbyi", spu_reg_name[op.rt], spu_reg_name[op.ra], op.si7);
}
void SHLQBYI(spu_opcode_t op)
{
if (!op.si7)
{
// Made-up mnemonic: as MR on PPU
DisAsm("mr", spu_reg_name[op.rt], spu_reg_name[op.ra]);
return;
}
DisAsm("shlqbyi", spu_reg_name[op.rt], spu_reg_name[op.ra], op.si7);
}
void NOP(spu_opcode_t op)
{
DisAsm("nop", spu_reg_name[op.rt]);
}
void CGT(spu_opcode_t op)
{
DisAsm("cgt", spu_reg_name[op.rt], spu_reg_name[op.ra], spu_reg_name[op.rb]);
}
void XOR(spu_opcode_t op)
{
DisAsm("xor", spu_reg_name[op.rt], spu_reg_name[op.ra], spu_reg_name[op.rb]);
}
void CGTH(spu_opcode_t op)
{
DisAsm("cgth", spu_reg_name[op.rt], spu_reg_name[op.ra], spu_reg_name[op.rb]);
}
void EQV(spu_opcode_t op)
{
DisAsm("eqv", spu_reg_name[op.rt], spu_reg_name[op.ra], spu_reg_name[op.rb]);
}
void CGTB(spu_opcode_t op)
{
DisAsm("cgtb", spu_reg_name[op.rt], spu_reg_name[op.ra], spu_reg_name[op.rb]);
}
void SUMB(spu_opcode_t op)
{
DisAsm("sumb", spu_reg_name[op.rt], spu_reg_name[op.ra], spu_reg_name[op.rb]);
}
void HGT(spu_opcode_t op)
{
DisAsm("hgt", spu_reg_name[op.rt], spu_reg_name[op.ra], spu_reg_name[op.rb]);
}
void CLZ(spu_opcode_t op)
{
DisAsm("clz", spu_reg_name[op.rt], spu_reg_name[op.ra]);
}
void XSWD(spu_opcode_t op)
{
DisAsm("xswd", spu_reg_name[op.rt], spu_reg_name[op.ra]);
}
void XSHW(spu_opcode_t op)
{
DisAsm("xshw", spu_reg_name[op.rt], spu_reg_name[op.ra]);
}
void CNTB(spu_opcode_t op)
{
DisAsm("cntb", spu_reg_name[op.rt], spu_reg_name[op.ra]);
}
void XSBH(spu_opcode_t op)
{
DisAsm("xsbh", spu_reg_name[op.rt], spu_reg_name[op.ra]);
}
void CLGT(spu_opcode_t op)
{
DisAsm("clgt", spu_reg_name[op.rt], spu_reg_name[op.ra], spu_reg_name[op.rb]);
}
void ANDC(spu_opcode_t op)
{
DisAsm("andc", spu_reg_name[op.rt], spu_reg_name[op.ra], spu_reg_name[op.rb]);
}
void FCGT(spu_opcode_t op)
{
DisAsm("fcgt", spu_reg_name[op.rt], spu_reg_name[op.ra], spu_reg_name[op.rb]);
}
void DFCGT(spu_opcode_t op)
{
DisAsm("dfcgt", spu_reg_name[op.rt], spu_reg_name[op.ra], spu_reg_name[op.rb]);
}
void FA(spu_opcode_t op)
{
DisAsm("fa", spu_reg_name[op.rt], spu_reg_name[op.ra], spu_reg_name[op.rb]);
}
void FS(spu_opcode_t op)
{
DisAsm("fs", spu_reg_name[op.rt], spu_reg_name[op.ra], spu_reg_name[op.rb]);
}
void FM(spu_opcode_t op)
{
DisAsm("fm", spu_reg_name[op.rt], spu_reg_name[op.ra], spu_reg_name[op.rb]);
}
void CLGTH(spu_opcode_t op)
{
DisAsm("clgth", spu_reg_name[op.rt], spu_reg_name[op.ra], spu_reg_name[op.rb]);
}
void ORC(spu_opcode_t op)
{
DisAsm("orc", spu_reg_name[op.rt], spu_reg_name[op.ra], spu_reg_name[op.rb]);
}
void FCMGT(spu_opcode_t op)
{
DisAsm("fcmgt", spu_reg_name[op.rt], spu_reg_name[op.ra], spu_reg_name[op.rb]);
}
void DFCMGT(spu_opcode_t op)
{
DisAsm("dfcmgt", spu_reg_name[op.rt], spu_reg_name[op.ra], spu_reg_name[op.rb]);
}
void DFA(spu_opcode_t op)
{
DisAsm("dfa", spu_reg_name[op.rt], spu_reg_name[op.ra], spu_reg_name[op.rb]);
}
void DFS(spu_opcode_t op)
{
DisAsm("dfs", spu_reg_name[op.rt], spu_reg_name[op.ra], spu_reg_name[op.rb]);
}
void DFM(spu_opcode_t op)
{
DisAsm("dfm", spu_reg_name[op.rt], spu_reg_name[op.ra], spu_reg_name[op.rb]);
}
void CLGTB(spu_opcode_t op)
{
DisAsm("clgtb", spu_reg_name[op.rt], spu_reg_name[op.ra], spu_reg_name[op.rb]);
}
void HLGT(spu_opcode_t op)
{
DisAsm("hlgt", spu_reg_name[op.rt], spu_reg_name[op.ra], spu_reg_name[op.rb]);
}
void DFMA(spu_opcode_t op)
{
DisAsm("dfma", spu_reg_name[op.rt], spu_reg_name[op.ra], spu_reg_name[op.rb]);
}
void DFMS(spu_opcode_t op)
{
DisAsm("dfms", spu_reg_name[op.rt], spu_reg_name[op.ra], spu_reg_name[op.rb]);
}
void DFNMS(spu_opcode_t op)
{
DisAsm("dfnms", spu_reg_name[op.rt], spu_reg_name[op.ra], spu_reg_name[op.rb]);
}
void DFNMA(spu_opcode_t op)
{
DisAsm("dfnma", spu_reg_name[op.rt], spu_reg_name[op.ra], spu_reg_name[op.rb]);
}
void CEQ(spu_opcode_t op)
{
DisAsm("ceq", spu_reg_name[op.rt], spu_reg_name[op.ra], spu_reg_name[op.rb]);
}
void MPYHHU(spu_opcode_t op)
{
DisAsm("mpyhhu", spu_reg_name[op.rt], spu_reg_name[op.ra], spu_reg_name[op.rb]);
}
void ADDX(spu_opcode_t op)
{
DisAsm("addx", spu_reg_name[op.rt], spu_reg_name[op.ra], spu_reg_name[op.rb]);
}
void SFX(spu_opcode_t op)
{
DisAsm("sfx", spu_reg_name[op.rt], spu_reg_name[op.ra], spu_reg_name[op.rb]);
}
void CGX(spu_opcode_t op)
{
DisAsm("cgx", spu_reg_name[op.rt], spu_reg_name[op.ra], spu_reg_name[op.rb]);
}
void BGX(spu_opcode_t op)
{
DisAsm("bgx", spu_reg_name[op.rt], spu_reg_name[op.ra], spu_reg_name[op.rb]);
}
void MPYHHA(spu_opcode_t op)
{
DisAsm("mpyhha", spu_reg_name[op.rt], spu_reg_name[op.ra], spu_reg_name[op.rb]);
}
void MPYHHAU(spu_opcode_t op)
{
DisAsm("mpyhhau", spu_reg_name[op.rt], spu_reg_name[op.ra], spu_reg_name[op.rb]);
}
void FSCRRD(spu_opcode_t op)
{
DisAsm("fscrrd", spu_reg_name[op.rt]);
}
void FESD(spu_opcode_t op)
{
DisAsm("fesd", spu_reg_name[op.rt], spu_reg_name[op.ra]);
}
void FRDS(spu_opcode_t op)
{
DisAsm("frds", spu_reg_name[op.rt], spu_reg_name[op.ra]);
}
void FSCRWR(spu_opcode_t op)
{
DisAsm("fscrwr", spu_reg_name[op.rt], spu_reg_name[op.ra]);
}
void DFTSV(spu_opcode_t op)
{
DisAsm("dftsv", spu_reg_name[op.rt], spu_reg_name[op.ra], op.si7);
}
void FCEQ(spu_opcode_t op)
{
DisAsm("fceq", spu_reg_name[op.rt], spu_reg_name[op.ra], spu_reg_name[op.rb]);
}
void DFCEQ(spu_opcode_t op)
{
DisAsm("dfceq", spu_reg_name[op.rt], spu_reg_name[op.ra], spu_reg_name[op.rb]);
}
void MPY(spu_opcode_t op)
{
DisAsm("mpy", spu_reg_name[op.rt], spu_reg_name[op.ra], spu_reg_name[op.rb]);
}
void MPYH(spu_opcode_t op)
{
DisAsm("mpyh", spu_reg_name[op.rt], spu_reg_name[op.ra], spu_reg_name[op.rb]);
}
void MPYHH(spu_opcode_t op)
{
DisAsm("mpyhh", spu_reg_name[op.rt], spu_reg_name[op.ra], spu_reg_name[op.rb]);
}
void MPYS(spu_opcode_t op)
{
DisAsm("mpys", spu_reg_name[op.rt], spu_reg_name[op.ra], spu_reg_name[op.rb]);
}
void CEQH(spu_opcode_t op)
{
DisAsm("ceqh", spu_reg_name[op.rt], spu_reg_name[op.ra], spu_reg_name[op.rb]);
}
void FCMEQ(spu_opcode_t op)
{
DisAsm("fcmeq", spu_reg_name[op.rt], spu_reg_name[op.ra], spu_reg_name[op.rb]);
}
void DFCMEQ(spu_opcode_t op)
{
DisAsm("dfcmeq", spu_reg_name[op.rt], spu_reg_name[op.ra], spu_reg_name[op.rb]);
}
void MPYU(spu_opcode_t op)
{
DisAsm("mpyu", spu_reg_name[op.rt], spu_reg_name[op.ra], spu_reg_name[op.rb]);
}
void CEQB(spu_opcode_t op)
{
DisAsm("ceqb", spu_reg_name[op.rt], spu_reg_name[op.ra], spu_reg_name[op.rb]);
}
void FI(spu_opcode_t op)
{
DisAsm("fi", spu_reg_name[op.rt], spu_reg_name[op.ra], spu_reg_name[op.rb]);
}
void HEQ(spu_opcode_t op)
{
DisAsm("heq", spu_reg_name[op.rt], spu_reg_name[op.ra], spu_reg_name[op.rb]);
}
//0 - 9
void CFLTS(spu_opcode_t op)
{
DisAsm("cflts", spu_reg_name[op.rt], spu_reg_name[op.ra], op.i8);
}
void CFLTU(spu_opcode_t op)
{
DisAsm("cfltu", spu_reg_name[op.rt], spu_reg_name[op.ra], op.i8);
}
void CSFLT(spu_opcode_t op)
{
DisAsm("csflt", spu_reg_name[op.rt], spu_reg_name[op.ra], op.i8);
}
void CUFLT(spu_opcode_t op)
{
DisAsm("cuflt", spu_reg_name[op.rt], spu_reg_name[op.ra], op.i8);
}
//0 - 8
void BRZ(spu_opcode_t op)
{
DisAsm("brz", spu_reg_name[op.rt], DisAsmBranchTarget(op.i16));
}
void STQA(spu_opcode_t op)
{
DisAsm("stqa", spu_reg_name[op.rt], DisAsmBranchTarget(op.i16 - dump_pc / 4));
}
void BRNZ(spu_opcode_t op)
{
DisAsm("brnz", spu_reg_name[op.rt], DisAsmBranchTarget(op.i16));
}
void BRHZ(spu_opcode_t op)
{
DisAsm("brhz", spu_reg_name[op.rt], DisAsmBranchTarget(op.i16));
}
void BRHNZ(spu_opcode_t op)
{
DisAsm("brhnz", spu_reg_name[op.rt], DisAsmBranchTarget(op.i16));
}
void STQR(spu_opcode_t op)
{
DisAsm("stqr", spu_reg_name[op.rt], DisAsmBranchTarget(op.i16));
}
void BRA(spu_opcode_t op)
{
DisAsm("bra", DisAsmBranchTarget(op.i16 - dump_pc / 4));
}
void LQA(spu_opcode_t op)
{
DisAsm("lqa", spu_reg_name[op.rt], DisAsmBranchTarget(op.i16 - dump_pc / 4));
}
void BRASL(spu_opcode_t op)
{
DisAsm("brasl", spu_reg_name[op.rt], DisAsmBranchTarget(op.i16 - dump_pc / 4));
}
void BR(spu_opcode_t op)
{
if (op.rt && op.rt != 127u)
{
// Valid but makes no sense
DisAsm("br??", DisAsmBranchTarget(op.i16));
return;
}
DisAsm("br", DisAsmBranchTarget(op.i16));
}
void FSMBI(spu_opcode_t op)
{
DisAsm("fsmbi", spu_reg_name[op.rt], op.i16);
}
void BRSL(spu_opcode_t op)
{
DisAsm("brsl", spu_reg_name[op.rt], DisAsmBranchTarget(op.i16));
}
void LQR(spu_opcode_t op)
{
DisAsm("lqr", spu_reg_name[op.rt], DisAsmBranchTarget(op.i16));
}
void IL(spu_opcode_t op)
{
DisAsm("il", spu_reg_name[op.rt], op.si16);
}
void ILHU(spu_opcode_t op)
{
DisAsm("ilhu", spu_reg_name[op.rt], op.i16);
comment_constant(last_opcode, op.i16 << 16);
}
void ILH(spu_opcode_t op)
{
DisAsm("ilh", spu_reg_name[op.rt], op.i16);
comment_constant(last_opcode, (op.i16 << 16) | op.i16);
}
void IOHL(spu_opcode_t op);
//0 - 7
void ORI(spu_opcode_t op)
{
if (!op.si10)
{
// Made-up mnemonic: as MR on PPU
DisAsm("mr", spu_reg_name[op.rt], spu_reg_name[op.ra]);
return;
}
DisAsm("ori", spu_reg_name[op.rt], spu_reg_name[op.ra], op.si10);
if (auto [is_const, value] = try_get_const_equal_value_array<u32>(+op.ra); is_const)
{
// Comment constant formation
comment_constant(last_opcode, value | static_cast<u32>(op.si10));
}
}
void ORHI(spu_opcode_t op)
{
DisAsm("orhi", spu_reg_name[op.rt], spu_reg_name[op.ra], op.si10);
}
void ORBI(spu_opcode_t op)
{
DisAsm("orbi", spu_reg_name[op.rt], spu_reg_name[op.ra], static_cast<u8>(op.si10));
}
void SFI(spu_opcode_t op)
{
DisAsm("sfi", spu_reg_name[op.rt], spu_reg_name[op.ra], op.si10);
}
void SFHI(spu_opcode_t op)
{
DisAsm("sfhi", spu_reg_name[op.rt], spu_reg_name[op.ra], op.si10);
}
void ANDI(spu_opcode_t op)
{
DisAsm("andi", spu_reg_name[op.rt], spu_reg_name[op.ra], op.si10);
}
void ANDHI(spu_opcode_t op)
{
DisAsm("andhi", spu_reg_name[op.rt], spu_reg_name[op.ra], op.si10);
}
void ANDBI(spu_opcode_t op)
{
DisAsm("andbi", spu_reg_name[op.rt], spu_reg_name[op.ra], static_cast<u8>(op.si10));
}
void AI(spu_opcode_t op)
{
DisAsm("ai", spu_reg_name[op.rt], spu_reg_name[op.ra], op.si10);
if (auto [is_const, value] = try_get_const_equal_value_array<u32>(op.ra); is_const)
{
// Comment constant formation
comment_constant(last_opcode, value + static_cast<u32>(op.si10));
}
}
void AHI(spu_opcode_t op)
{
DisAsm("ahi", spu_reg_name[op.rt], spu_reg_name[op.ra], op.si10);
}
void STQD(spu_opcode_t op)
{
DisAsm("stqd", spu_reg_name[op.rt], op.si10 << 4, spu_reg_name[op.ra]);
}
void LQD(spu_opcode_t op)
{
DisAsm("lqd", spu_reg_name[op.rt], op.si10 << 4, spu_reg_name[op.ra]);
}
void XORI(spu_opcode_t op)
{
DisAsm("xori", spu_reg_name[op.rt], spu_reg_name[op.ra], op.si10);
if (auto [is_const, value] = try_get_const_equal_value_array<u32>(op.ra); is_const)
{
// Comment constant formation
comment_constant(last_opcode, value ^ static_cast<u32>(op.si10));
}
}
void XORHI(spu_opcode_t op)
{
DisAsm("xorhi", spu_reg_name[op.rt], spu_reg_name[op.ra], op.si10);
}
void XORBI(spu_opcode_t op)
{
DisAsm("xorbi", spu_reg_name[op.rt], spu_reg_name[op.ra], static_cast<u8>(op.si10));
}
void CGTI(spu_opcode_t op)
{
DisAsm("cgti", spu_reg_name[op.rt], spu_reg_name[op.ra], op.si10);
}
void CGTHI(spu_opcode_t op)
{
DisAsm("cgthi", spu_reg_name[op.rt], spu_reg_name[op.ra], op.si10);
}
void CGTBI(spu_opcode_t op)
{
DisAsm("cgtbi", spu_reg_name[op.rt], spu_reg_name[op.ra], op.si10);
}
void HGTI(spu_opcode_t op)
{
DisAsm("hgti", spu_reg_name[op.rt], spu_reg_name[op.ra], op.si10);
}
void CLGTI(spu_opcode_t op)
{
DisAsm("clgti", spu_reg_name[op.rt], spu_reg_name[op.ra], op.si10);
}
void CLGTHI(spu_opcode_t op)
{
DisAsm("clgthi", spu_reg_name[op.rt], spu_reg_name[op.ra], op.si10);
}
void CLGTBI(spu_opcode_t op)
{
DisAsm("clgtbi", spu_reg_name[op.rt], spu_reg_name[op.ra], op.si10);
}
void HLGTI(spu_opcode_t op)
{
DisAsm("hlgti", spu_reg_name[op.rt], spu_reg_name[op.ra], op.si10);
}
void MPYI(spu_opcode_t op)
{
DisAsm("mpyi", spu_reg_name[op.rt], spu_reg_name[op.ra], op.si10);
}
void MPYUI(spu_opcode_t op)
{
DisAsm("mpyui", spu_reg_name[op.rt], spu_reg_name[op.ra], op.si10);
}
void CEQI(spu_opcode_t op)
{
DisAsm("ceqi", spu_reg_name[op.rt], spu_reg_name[op.ra], op.si10);
}
void CEQHI(spu_opcode_t op)
{
DisAsm("ceqhi", spu_reg_name[op.rt], spu_reg_name[op.ra], op.si10);
}
void CEQBI(spu_opcode_t op)
{
DisAsm("ceqbi", spu_reg_name[op.rt], spu_reg_name[op.ra], op.si10);
}
void HEQI(spu_opcode_t op)
{
DisAsm("heqi", spu_reg_name[op.rt], spu_reg_name[op.ra], op.si10);
}
//0 - 6
void HBRA(spu_opcode_t op)
{
DisAsm("hbra", DisAsmBranchTarget((op.r0h << 7) | op.rt), DisAsmBranchTarget(op.i16 - dump_pc / 4));
}
void HBRR(spu_opcode_t op)
{
DisAsm("hbrr", DisAsmBranchTarget((op.r0h << 7) | op.rt), DisAsmBranchTarget(op.i16));
}
void ILA(spu_opcode_t op)
{
DisAsm("ila", spu_reg_name[op.rt], op.i18);
}
//0 - 3
void SELB(spu_opcode_t op)
{
DisAsm("selb", spu_reg_name[op.rt4], spu_reg_name[op.ra], spu_reg_name[op.rb], spu_reg_name[op.rc]);
}
void SHUFB(spu_opcode_t op);
void MPYA(spu_opcode_t op)
{
DisAsm("mpya", spu_reg_name[op.rt4], spu_reg_name[op.ra], spu_reg_name[op.rb], spu_reg_name[op.rc]);
}
void FNMS(spu_opcode_t op)
{
DisAsm("fnms", spu_reg_name[op.rt4], spu_reg_name[op.ra], spu_reg_name[op.rb], spu_reg_name[op.rc]);
}
void FMA(spu_opcode_t op)
{
DisAsm("fma", spu_reg_name[op.rt4], spu_reg_name[op.ra], spu_reg_name[op.rb], spu_reg_name[op.rc]);
}
void FMS(spu_opcode_t op)
{
DisAsm("fms", spu_reg_name[op.rt4], spu_reg_name[op.ra], spu_reg_name[op.rb], spu_reg_name[op.rc]);
}
void UNK(spu_opcode_t /*op*/)
{
DisAsm("?? ??");
}
};
| 30,004
|
C++
|
.h
| 1,032
| 26.751938
| 126
| 0.634541
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,820
|
SPUInterpreter.h
|
RPCS3_rpcs3/rpcs3/Emu/Cell/SPUInterpreter.h
|
#pragma once
#include "SPUOpcodes.h"
class spu_thread;
using spu_intrp_func_t = bool(*)(spu_thread& spu, spu_opcode_t op);
template <typename IT>
struct spu_interpreter_t;
struct spu_interpreter
{
static void set_interrupt_status(spu_thread&, spu_opcode_t);
};
struct spu_interpreter_rt_base
{
protected:
std::unique_ptr<spu_interpreter_t<spu_intrp_func_t>> ptrs;
spu_interpreter_rt_base() noexcept;
spu_interpreter_rt_base(const spu_interpreter_rt_base&) = delete;
spu_interpreter_rt_base& operator=(const spu_interpreter_rt_base&) = delete;
virtual ~spu_interpreter_rt_base();
};
struct spu_interpreter_rt : spu_interpreter_rt_base
{
spu_interpreter_rt() noexcept;
spu_intrp_func_t decode(u32 op) const noexcept
{
return table.decode(op);
}
private:
spu_decoder<spu_interpreter_t<spu_intrp_func_t>, spu_intrp_func_t> table;
};
| 855
|
C++
|
.h
| 29
| 27.586207
| 77
| 0.766298
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,821
|
PPUThread.h
|
RPCS3_rpcs3/rpcs3/Emu/Cell/PPUThread.h
|
#pragma once
#include "../CPU/CPUThread.h"
#include "../CPU/Hypervisor.h"
#include "../Memory/vm_ptr.h"
#include "Utilities/lockless.h"
#include "Utilities/BitField.h"
#include "util/logs.hpp"
#include "util/v128.hpp"
LOG_CHANNEL(ppu_log, "PPU");
enum class ppu_cmd : u32
{
null,
opcode, // Execute PPU instruction from arg
set_gpr, // Set gpr[arg] (+1 cmd)
set_args, // Set general-purpose args (+arg cmd)
lle_call, // Load addr and rtoc at *arg or *gpr[arg] and execute
hle_call, // Execute function by index (arg)
ptr_call, // Execute function by pointer
opd_call, // Execute function by provided rtoc and address (unlike lle_call, does not read memory)
cia_call, // Execute from current CIA, mo GPR modification applied
entry_call, // Load addr and rtoc from entry_func
initialize, // ppu_initialize()
sleep,
reset_stack, // resets stack address
};
enum class ppu_join_status : u32
{
joinable = 0,
detached = 1,
zombie = 2,
exited = 3,
max = 4, // Values above it indicate PPU id of joining thread
};
enum ppu_thread_status : u32
{
PPU_THREAD_STATUS_IDLE,
PPU_THREAD_STATUS_RUNNABLE,
PPU_THREAD_STATUS_ONPROC,
PPU_THREAD_STATUS_SLEEP,
PPU_THREAD_STATUS_STOP,
PPU_THREAD_STATUS_ZOMBIE,
PPU_THREAD_STATUS_DELETED,
PPU_THREAD_STATUS_UNKNOWN,
};
// Formatting helper
enum class ppu_syscall_code : u64
{
};
enum : u32
{
ppu_stack_start_offset = 0x70,
};
// ppu function descriptor
struct ppu_func_opd_t
{
be_t<u32> addr;
be_t<u32> rtoc;
};
// ppu_thread constructor argument
struct ppu_thread_params
{
vm::addr_t stack_addr;
u32 stack_size;
u32 tls_addr;
ppu_func_opd_t entry;
u64 arg0;
u64 arg1;
};
struct cmd64
{
u64 m_data = 0;
constexpr cmd64() noexcept = default;
struct pair_t
{
u32 arg1;
u32 arg2;
};
template <typename T, typename T2 = std::common_type_t<T>>
cmd64(const T& value)
: m_data(std::bit_cast<u64, T2>(value))
{
}
template <typename T1, typename T2>
cmd64(const T1& arg1, const T2& arg2)
: cmd64(pair_t{std::bit_cast<u32>(arg1), std::bit_cast<u32>(arg2)})
{
}
explicit operator bool() const
{
return m_data != 0;
}
template <typename T>
T as() const
{
return std::bit_cast<T>(m_data);
}
template <typename T>
T arg1() const
{
return std::bit_cast<T>(std::bit_cast<pair_t>(m_data).arg1);
}
template <typename T>
T arg2() const
{
return std::bit_cast<T>(std::bit_cast<pair_t>(m_data).arg2);
}
};
enum class ppu_debugger_mode : u32
{
_default,
is_decimal,
max_mode,
};
class ppu_thread : public cpu_thread
{
public:
static const u32 id_base = 0x01000000; // TODO (used to determine thread type)
static const u32 id_step = 1;
static const u32 id_count = 100;
static constexpr std::pair<u32, u32> id_invl_range = {12, 12};
virtual void dump_regs(std::string&, std::any& custom_data) const override;
virtual std::string dump_callstack() const override;
virtual std::vector<std::pair<u32, u32>> dump_callstack_list() const override;
virtual std::string dump_misc() const override;
virtual void dump_all(std::string&) const override;
virtual void cpu_task() override final;
virtual void cpu_sleep() override;
virtual void cpu_on_stop() override;
virtual ~ppu_thread() override;
SAVESTATE_INIT_POS(3);
ppu_thread(const ppu_thread_params&, std::string_view name, u32 prio, int detached = 0);
ppu_thread(utils::serial& ar);
ppu_thread(const ppu_thread&) = delete;
ppu_thread& operator=(const ppu_thread&) = delete;
bool savable() const;
void serialize_common(utils::serial& ar);
void save(utils::serial& ar);
using cpu_thread::operator=;
u64 gpr[32] = {}; // General-Purpose Registers
f64 fpr[32] = {}; // Floating Point Registers
v128 vr[32] = {}; // Vector Registers
union alignas(16) cr_bits
{
u8 bits[32];
u32 fields[8];
u8& operator [](usz i)
{
return bits[i];
}
// Pack CR bits
u32 pack() const
{
u32 result{};
for (u32 bit : bits)
{
result <<= 1;
result |= bit;
}
return result;
}
// Unpack CR bits
void unpack(u32 value)
{
for (u8& b : bits)
{
b = !!(value & (1u << 31));
value <<= 1;
}
}
};
cr_bits cr{}; // Condition Registers (unpacked)
// Floating-Point Status and Control Register (unpacked)
union
{
struct
{
// TODO
bool _start[16];
bool fl; // FPCC.FL
bool fg; // FPCC.FG
bool fe; // FPCC.FE
bool fu; // FPCC.FU
bool _end[12];
};
u32 fields[8];
cr_bits bits;
}
fpscr{};
u64 lr{}; // Link Register
u64 ctr{}; // Counter Register
u32 vrsave{0xffffffff}; // VR Save Register
u32 cia{}; // Current Instruction Address
// Fixed-Point Exception Register (abstract representation)
struct
{
ENABLE_BITWISE_SERIALIZATION;
bool so{}; // Summary Overflow
bool ov{}; // Overflow
bool ca{}; // Carry
u8 cnt{}; // 0..6
}
xer;
/*
Non-Java. A mode control bit that determines whether vector floating-point operations will be performed
in a Java-IEEE-C9X-compliant mode or a possibly faster non-Java/non-IEEE mode.
0 The Java-IEEE-C9X-compliant mode is selected. Denormalized values are handled as specified
by Java, IEEE, and C9X standard.
1 The non-Java/non-IEEE-compliant mode is selected. If an element in a source vector register
contains a denormalized value, the value '0' is used instead. If an instruction causes an underflow
exception, the corresponding element in the target vr is cleared to '0'. In both cases, the '0'
has the same sign as the denormalized or underflowing value.
*/
bool nj = true;
// Sticky saturation bit
v128 sat{};
// Optimization: precomputed java-mode mask for handling denormals
u32 jm_mask = 0x7f80'0000;
u32 raddr{0}; // Reservation addr
u64 rtime{0};
alignas(64) std::byte rdata[128]{}; // Reservation data
bool use_full_rdata{};
u32 res_notify{0};
u64 res_notify_time{0};
union ppu_prio_t
{
u64 all;
bf_t<s64, 0, 13> prio; // Thread priority (0..3071) (firs 12-bits)
bf_t<s64, 13, 50> order; // Thread enqueue order (last 52-bits)
bf_t<u64, 63, 1> preserve_bit; // Preserve value for savestates
};
atomic_t<ppu_prio_t> prio{};
const u32 stack_size; // Stack size
const u32 stack_addr; // Stack address
atomic_t<ppu_join_status> joiner; // Joining thread or status
u32 hw_sleep_time = 0; // Very specific delay for hardware threads switching, see lv2_obj::awake_unlocked for more details
lf_fifo<atomic_t<cmd64>, 127> cmd_queue; // Command queue for asynchronous operations.
void cmd_push(cmd64);
void cmd_list(std::initializer_list<cmd64>);
void cmd_pop(u32 = 0);
cmd64 cmd_wait(); // Empty command means caller must return, like true from cpu_thread::check_status().
cmd64 cmd_get(u32 index) { return cmd_queue[cmd_queue.peek() + index].load(); }
atomic_t<u32> cmd_notify = 0;
alignas(64) const ppu_func_opd_t entry_func;
u64 start_time{0}; // Sleep start timepoint
u64 end_time{umax}; // Sleep end timepoint
s32 cancel_sleep{0}; // Flag to cancel the next lv2_obj::sleep call (when equals 2)
u64 syscall_args[8]{0}; // Last syscall arguments stored
const char* current_function{}; // Current function name for diagnosis, optimized for speed.
const char* last_function{}; // Sticky copy of current_function, is not cleared on function return
const char* current_module{}; // Current module name, for savestates.
const bool is_interrupt_thread; // True for interrupts-handler threads
// Thread name
atomic_ptr<std::string> ppu_tname;
// Hypervisor context data
rpcs3::hypervisor_context_t hv_ctx; // HV context for gate enter exit. Keep at a low struct offset.
u64 last_ftsc = 0;
u64 last_ftime = 0;
u32 last_faddr = 0;
u64 last_fail = 0;
u64 last_succ = 0;
u64 exec_bytes = 0; // Amount of "bytes" executed (4 for each instruction)
u32 dbg_step_pc = 0;
atomic_t<ppu_debugger_mode> debugger_mode{};
struct call_history_t
{
std::vector<u32> data;
u64 index = 0;
u64 last_r1 = umax;
u64 last_r2 = umax;
} call_history;
static constexpr u32 call_history_max_size = 4096;
struct syscall_history_t
{
struct entry_t
{
u64 cia;
const char* func_name;
u64 error;
std::array<u64, 4> args;
};
std::vector<entry_t> data;
u64 index = 0;
u32 count_debug_arguments;
} syscall_history;
static constexpr u32 syscall_history_max_size = 2048;
struct hle_func_call_with_toc_info_t
{
u32 cia;
u64 saved_lr;
u64 saved_r2;
};
std::vector<hle_func_call_with_toc_info_t> hle_func_calls_with_toc_info;
// For named_thread ctor
const struct thread_name_t
{
const ppu_thread* _this;
operator std::string() const;
} thread_name{ this };
// For savestates
bool stop_flag_removal_protection = false; // If set, Emulator::Run won't remove stop flag
bool loaded_from_savestate = false; // Indicates the thread had just started straight from savestate load
std::shared_ptr<utils::serial> optional_savestate_state;
bool interrupt_thread_executing = false;
ppu_thread* next_cpu{}; // LV2 sleep queues' node link
ppu_thread* next_ppu{}; // LV2 PPU running queue's node link
bool ack_suspend = false;
be_t<u64>* get_stack_arg(s32 i, u64 align = alignof(u64));
void exec_task();
void fast_call(u32 addr, u64 rtoc, bool is_thread_entry = false);
static std::pair<vm::addr_t, u32> stack_push(u32 size, u32 align_v);
static void stack_pop_verbose(u32 addr, u32 size) noexcept;
};
static_assert(ppu_join_status::max <= ppu_join_status{ppu_thread::id_base});
template<typename T, typename = void>
struct ppu_gpr_cast_impl
{
static_assert(!sizeof(T), "Invalid type for ppu_gpr_cast<>");
};
template<typename T>
struct ppu_gpr_cast_impl<T, std::enable_if_t<std::is_integral_v<T> || std::is_enum_v<T>>>
{
static_assert(sizeof(T) <= 8, "Too big integral type for ppu_gpr_cast<>()");
static_assert(std::is_same_v<std::decay_t<T>, bool> == false, "bool type is deprecated in ppu_gpr_cast<>(), use b8 instead");
static inline u64 to(const T& value)
{
return static_cast<u64>(value);
}
static inline T from(const u64 reg)
{
return static_cast<T>(reg);
}
};
template<>
struct ppu_gpr_cast_impl<b8, void>
{
static inline u64 to(const b8& value)
{
return value;
}
static inline b8 from(const u64 reg)
{
return static_cast<u32>(reg) != 0;
}
};
template<typename T, typename AT>
struct ppu_gpr_cast_impl<vm::_ptr_base<T, AT>, void>
{
static inline u64 to(const vm::_ptr_base<T, AT>& value)
{
return ppu_gpr_cast_impl<AT>::to(value.addr());
}
static inline vm::_ptr_base<T, AT> from(const u64 reg)
{
return vm::cast(ppu_gpr_cast_impl<AT>::from(reg));
}
};
template<typename T, typename AT>
struct ppu_gpr_cast_impl<vm::_ref_base<T, AT>, void>
{
static inline u64 to(const vm::_ref_base<T, AT>& value)
{
return ppu_gpr_cast_impl<AT>::to(value.addr());
}
static inline vm::_ref_base<T, AT> from(const u64 reg)
{
return vm::cast(ppu_gpr_cast_impl<AT>::from(reg));
}
};
template <>
struct ppu_gpr_cast_impl<vm::null_t, void>
{
static inline u64 to(const vm::null_t& /*value*/)
{
return 0;
}
static inline vm::null_t from(const u64 /*reg*/)
{
return vm::null;
}
};
template<typename To = u64, typename From>
inline To ppu_gpr_cast(const From& value)
{
return ppu_gpr_cast_impl<To>::from(ppu_gpr_cast_impl<From>::to(value));
}
| 11,229
|
C++
|
.h
| 385
| 26.818182
| 126
| 0.707396
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,822
|
PPUTranslator.h
|
RPCS3_rpcs3/rpcs3/Emu/Cell/PPUTranslator.h
|
#pragma once
#ifdef LLVM_AVAILABLE
#include "Emu/CPU/CPUTranslator.h"
#include "PPUOpcodes.h"
#include "PPUAnalyser.h"
#include "util/types.hpp"
class PPUTranslator final : public cpu_translator
{
// PPU Module
const ppu_module& m_info;
// Relevant relocations
std::map<u64, const ppu_reloc*> m_relocs;
// Attributes for function calls which are "pure" and may be optimized away if their results are unused
const llvm::AttributeList m_pure_attr;
// LLVM function
llvm::Function* m_function;
llvm::MDNode* m_md_unlikely;
llvm::MDNode* m_md_likely;
// Current position-independent address
u64 m_addr = 0;
// Function attributes
bs_t<ppu_attr> m_attr{};
// Relocation info
const ppu_segment* m_reloc = nullptr;
// Set by instruction code after processing the relocation
const ppu_reloc* m_rel = nullptr;
/* Variables */
// Memory base
llvm::Value* m_base;
// Thread context
llvm::Value* m_thread;
// Callable functions
llvm::Value* m_exec;
// Segment 0 address
llvm::Value* m_seg0;
// Thread context struct
llvm::StructType* m_thread_type;
llvm::GlobalVariable* m_mtocr_table{};
llvm::GlobalVariable* m_frsqrte_table{};
llvm::GlobalVariable* m_fres_table{};
llvm::Value* m_globals[175];
llvm::Value** const m_g_cr = m_globals + 99;
llvm::Value* m_locals[175];
llvm::Value** const m_gpr = m_locals + 3;
llvm::Value** const m_fpr = m_locals + 35;
llvm::Value** const m_vr = m_locals + 67;
llvm::Value** const m_cr = m_locals + 99;
llvm::Value** const m_fc = m_locals + 131; // FPSCR bits (used partially)
llvm::Value* nan_vec4;
bool m_may_be_mmio = false;
#define DEF_VALUE(loc, glb, pos)\
llvm::Value*& loc = m_locals[pos];\
llvm::Value*& glb = m_globals[pos];
DEF_VALUE(m_lr, m_g_lr, 163) // LR, Link Register
DEF_VALUE(m_ctr, m_g_ctr, 164) // CTR, Counter Register
DEF_VALUE(m_vrsave, m_g_vrsave, 165)
DEF_VALUE(m_cia, m_g_cia, 166)
DEF_VALUE(m_so, m_g_so, 167) // XER.SO bit, summary overflow
DEF_VALUE(m_ov, m_g_ov, 168) // XER.OV bit, overflow flag
DEF_VALUE(m_ca, m_g_ca, 169) // XER.CA bit, carry flag
DEF_VALUE(m_cnt, m_g_cnt, 170) // XER.CNT
DEF_VALUE(m_nj, m_g_nj, 171) // VSCR.NJ bit, non-Java mode
DEF_VALUE(m_sat, m_g_sat, 173) // VSCR.SAT bit, sticky saturation flag
DEF_VALUE(m_jm_mask, m_g_jm_mask, 174) // Java-Mode helper mask
#undef DEF_VALUE
public:
template <typename T>
value_t<T> get_vr(u32 vr)
{
value_t<T> result;
result.value = bitcast(GetVr(vr, VrType::vi32), value_t<T>::get_type(m_context));
return result;
}
template <typename T, typename... Args>
std::tuple<std::conditional_t<false, Args, value_t<T>>...> get_vrs(const Args&... args)
{
return {get_vr<T>(args)...};
}
template <typename T>
void set_vr(u32 vr, T&& expr)
{
SetVr(vr, expr.eval(m_ir));
}
llvm::Value* VecHandleNan(llvm::Value* val);
llvm::Value* VecHandleDenormal(llvm::Value* val);
llvm::Value* VecHandleResult(llvm::Value* val);
template <typename T>
auto vec_handle_result(T&& expr)
{
value_t<typename T::type> result;
result.value = VecHandleResult(expr.eval(m_ir));
return result;
}
// Update sticky VSCR.SAT bit (|=)
template <typename T>
void set_sat(T&& expr)
{
if (m_attr & ppu_attr::has_mfvscr)
{
const auto val = expr.eval(m_ir);
RegStore(m_ir->CreateOr(bitcast(RegLoad(m_sat), val->getType()), val), m_sat);
}
}
// Get current instruction address
llvm::Value* GetAddr(u64 _add = 0);
// Change integer size for integer or integer vector type (by 2^degree)
llvm::Type* ScaleType(llvm::Type*, s32 pow2 = 0);
// Extend arg to double width with its copy
llvm::Value* DuplicateExt(llvm::Value* arg);
// Rotate arg left by n (n must be < bitwidth)
llvm::Value* RotateLeft(llvm::Value* arg, u64 n);
// Rotate arg left by n (n will be masked)
llvm::Value* RotateLeft(llvm::Value* arg, llvm::Value* n);
// Emit function call
void CallFunction(u64 target, llvm::Value* indirect = nullptr);
// Emit state check mid-block
void TestAborted();
// Initialize global for writing
llvm::Value* RegInit(llvm::Value*& local);
// Load last register value
llvm::Value* RegLoad(llvm::Value*& local);
// Store register value locally
void RegStore(llvm::Value* value, llvm::Value*& local);
// Write global registers
void FlushRegisters();
// Load gpr
llvm::Value* GetGpr(u32 r, u32 num_bits = 64);
// Set gpr
void SetGpr(u32 r, llvm::Value* value);
// Get fpr
llvm::Value* GetFpr(u32 r, u32 bits = 64, bool as_int = false);
// Set fpr
void SetFpr(u32 r, llvm::Value* val);
// Vector register type
enum class VrType
{
vi8, // i8 vector
vi16, // i16 vector
vi32, // i32 vector
vf, // f32 vector
i128, // Solid 128-bit integer
};
// Load vr
llvm::Value* GetVr(u32 vr, VrType);
// Set vr to the specified value
void SetVr(u32 vr, llvm::Value*);
// Bitcast to scalar integer value
llvm::Value* Solid(llvm::Value*);
// Compare value with zero constant of appropriate size
llvm::Value* IsZero(llvm::Value*); llvm::Value* IsNotZero(llvm::Value*);
// Compare value with all-ones constant of appropriate size
llvm::Value* IsOnes(llvm::Value*); llvm::Value* IsNotOnes(llvm::Value*);
// Broadcast specified value
llvm::Value* Broadcast(llvm::Value* value, u32 count);
// Create shuffle instruction with constant args
llvm::Value* Shuffle(llvm::Value* left, llvm::Value* right, std::initializer_list<u32> indices);
// Create sign extension (with double size if type is nullptr)
llvm::Value* SExt(llvm::Value* value, llvm::Type* = nullptr);
template<usz N>
std::array<llvm::Value*, N> SExt(std::array<llvm::Value*, N> values, llvm::Type* type = nullptr)
{
for (usz i = 0; i < N; i++) values[i] = SExt(values[i], type);
return values;
}
// Create zero extension (with double size if type is nullptr)
llvm::Value* ZExt(llvm::Value*, llvm::Type* = nullptr);
template<usz N>
std::array<llvm::Value*, N> ZExt(std::array<llvm::Value*, N> values, llvm::Type* type = nullptr)
{
for (usz i = 0; i < N; i++) values[i] = ZExt(values[i], type);
return values;
}
// Add multiple elements
llvm::Value* Add(std::initializer_list<llvm::Value*>);
// Create tuncation (with half size if type is nullptr)
llvm::Value* Trunc(llvm::Value*, llvm::Type* = nullptr);
// Get specified CR bit
llvm::Value* GetCrb(u32 crb);
// Set specified CR bit
void SetCrb(u32 crb, llvm::Value* value);
// Set CR field, if `so` value (5th arg) is nullptr, loaded from XER.SO
void SetCrField(u32 group, llvm::Value* lt, llvm::Value* gt, llvm::Value* eq, llvm::Value* so = nullptr);
// Set CR field based on signed comparison
void SetCrFieldSignedCmp(u32 n, llvm::Value* a, llvm::Value* b);
// Set CR field based on unsigned comparison
void SetCrFieldUnsignedCmp(u32 n, llvm::Value* a, llvm::Value* b);
// Set CR field from FPSCR CC fieds
void SetCrFieldFPCC(u32 n);
// Set FPSCR CC fields provided, optionally updating CR1
void SetFPCC(llvm::Value* lt, llvm::Value* gt, llvm::Value* eq, llvm::Value* un, bool set_cr = false);
// Update FPRF fields for the value, optionally updating CR1
void SetFPRF(llvm::Value* value, bool set_cr);
// Update FR bit
void SetFPSCR_FR(llvm::Value* value);
// Update FI bit (and set XX exception)
void SetFPSCR_FI(llvm::Value* value);
// Update sticky FPSCR exception bit, update FPSCR.FX
void SetFPSCRException(llvm::Value* ptr, llvm::Value* value);
// Get FPSCR bit (exception bits are cleared)
llvm::Value* GetFPSCRBit(u32 n);
// Set FPSCR bit
void SetFPSCRBit(u32 n, llvm::Value*, bool update_fx);
// Get XER.CA bit
llvm::Value* GetCarry();
// Set XER.CA bit
void SetCarry(llvm::Value*);
// Set XER.OV bit, and update XER.SO bit (|=)
void SetOverflow(llvm::Value*);
// Check condition for trap instructions
llvm::Value* CheckTrapCondition(u32 to, llvm::Value* left, llvm::Value* right);
// Emit trap for current address
void Trap();
// Get condition for branch instructions
llvm::Value* CheckBranchCondition(u32 bo, u32 bi);
// Get hint for branch instructions
llvm::MDNode* CheckBranchProbability(u32 bo);
// Branch to next instruction if condition failed, never branch on nullptr
void UseCondition(llvm::MDNode* hint, llvm::Value* = nullptr);
// Get memory pointer
llvm::Value* GetMemory(llvm::Value* addr);
// Read from memory
llvm::Value* ReadMemory(llvm::Value* addr, llvm::Type* type, bool is_be = true, u32 align = 1);
// Write to memory
void WriteMemory(llvm::Value* addr, llvm::Value* value, bool is_be = true, u32 align = 1);
// Get an undefined value with specified type
template<typename T>
llvm::Value* GetUndef()
{
return llvm::UndefValue::get(GetType<T>());
}
// Call a function with attribute list
template<typename... Args>
llvm::CallInst* Call(llvm::Type* ret, llvm::AttributeList attr, llvm::StringRef name, Args... args)
{
// Call the function
return m_ir->CreateCall(m_module->getOrInsertFunction(name, attr, ret, args->getType()...), {args...});
}
// Call a function
template<typename... Args>
llvm::CallInst* Call(llvm::Type* ret, llvm::StringRef name, Args... args)
{
return Call(ret, llvm::AttributeList{}, name, args...);
}
// Handle compilation errors
void CompilationError(const std::string& error);
PPUTranslator(llvm::LLVMContext& context, llvm::Module* _module, const ppu_module& info, llvm::ExecutionEngine& engine);
~PPUTranslator();
// Get thread context struct type
llvm::Type* GetContextType();
// Parses PPU opcodes and translate them into LLVM IR
llvm::Function* Translate(const ppu_function& info);
llvm::Function* GetSymbolResolver(const ppu_module& info);
void MFVSCR(ppu_opcode_t op);
void MTVSCR(ppu_opcode_t op);
void VADDCUW(ppu_opcode_t op);
void VADDFP(ppu_opcode_t op);
void VADDSBS(ppu_opcode_t op);
void VADDSHS(ppu_opcode_t op);
void VADDSWS(ppu_opcode_t op);
void VADDUBM(ppu_opcode_t op);
void VADDUBS(ppu_opcode_t op);
void VADDUHM(ppu_opcode_t op);
void VADDUHS(ppu_opcode_t op);
void VADDUWM(ppu_opcode_t op);
void VADDUWS(ppu_opcode_t op);
void VAND(ppu_opcode_t op);
void VANDC(ppu_opcode_t op);
void VAVGSB(ppu_opcode_t op);
void VAVGSH(ppu_opcode_t op);
void VAVGSW(ppu_opcode_t op);
void VAVGUB(ppu_opcode_t op);
void VAVGUH(ppu_opcode_t op);
void VAVGUW(ppu_opcode_t op);
void VCFSX(ppu_opcode_t op);
void VCFUX(ppu_opcode_t op);
void VCMPBFP(ppu_opcode_t op);
void VCMPBFP_(ppu_opcode_t op) { return VCMPBFP(op); }
void VCMPEQFP(ppu_opcode_t op);
void VCMPEQFP_(ppu_opcode_t op) { return VCMPEQFP(op); }
void VCMPEQUB(ppu_opcode_t op);
void VCMPEQUB_(ppu_opcode_t op) { return VCMPEQUB(op); }
void VCMPEQUH(ppu_opcode_t op);
void VCMPEQUH_(ppu_opcode_t op) { return VCMPEQUH(op); }
void VCMPEQUW(ppu_opcode_t op);
void VCMPEQUW_(ppu_opcode_t op) { return VCMPEQUW(op); }
void VCMPGEFP(ppu_opcode_t op);
void VCMPGEFP_(ppu_opcode_t op) { return VCMPGEFP(op); }
void VCMPGTFP(ppu_opcode_t op);
void VCMPGTFP_(ppu_opcode_t op) { return VCMPGTFP(op); }
void VCMPGTSB(ppu_opcode_t op);
void VCMPGTSB_(ppu_opcode_t op) { return VCMPGTSB(op); }
void VCMPGTSH(ppu_opcode_t op);
void VCMPGTSH_(ppu_opcode_t op) { return VCMPGTSH(op); }
void VCMPGTSW(ppu_opcode_t op);
void VCMPGTSW_(ppu_opcode_t op) { return VCMPGTSW(op); }
void VCMPGTUB(ppu_opcode_t op);
void VCMPGTUB_(ppu_opcode_t op) { return VCMPGTUB(op); }
void VCMPGTUH(ppu_opcode_t op);
void VCMPGTUH_(ppu_opcode_t op) { return VCMPGTUH(op); }
void VCMPGTUW(ppu_opcode_t op);
void VCMPGTUW_(ppu_opcode_t op) { return VCMPGTUW(op); }
void VCTSXS(ppu_opcode_t op);
void VCTUXS(ppu_opcode_t op);
void VEXPTEFP(ppu_opcode_t op);
void VLOGEFP(ppu_opcode_t op);
void VMADDFP(ppu_opcode_t op);
void VMAXFP(ppu_opcode_t op);
void VMAXSB(ppu_opcode_t op);
void VMAXSH(ppu_opcode_t op);
void VMAXSW(ppu_opcode_t op);
void VMAXUB(ppu_opcode_t op);
void VMAXUH(ppu_opcode_t op);
void VMAXUW(ppu_opcode_t op);
void VMHADDSHS(ppu_opcode_t op);
void VMHRADDSHS(ppu_opcode_t op);
void VMINFP(ppu_opcode_t op);
void VMINSB(ppu_opcode_t op);
void VMINSH(ppu_opcode_t op);
void VMINSW(ppu_opcode_t op);
void VMINUB(ppu_opcode_t op);
void VMINUH(ppu_opcode_t op);
void VMINUW(ppu_opcode_t op);
void VMLADDUHM(ppu_opcode_t op);
void VMRGHB(ppu_opcode_t op);
void VMRGHH(ppu_opcode_t op);
void VMRGHW(ppu_opcode_t op);
void VMRGLB(ppu_opcode_t op);
void VMRGLH(ppu_opcode_t op);
void VMRGLW(ppu_opcode_t op);
void VMSUMMBM(ppu_opcode_t op);
void VMSUMSHM(ppu_opcode_t op);
void VMSUMSHS(ppu_opcode_t op);
void VMSUMUBM(ppu_opcode_t op);
void VMSUMUHM(ppu_opcode_t op);
void VMSUMUHS(ppu_opcode_t op);
void VMULESB(ppu_opcode_t op);
void VMULESH(ppu_opcode_t op);
void VMULEUB(ppu_opcode_t op);
void VMULEUH(ppu_opcode_t op);
void VMULOSB(ppu_opcode_t op);
void VMULOSH(ppu_opcode_t op);
void VMULOUB(ppu_opcode_t op);
void VMULOUH(ppu_opcode_t op);
void VNMSUBFP(ppu_opcode_t op);
void VNOR(ppu_opcode_t op);
void VOR(ppu_opcode_t op);
void VPERM(ppu_opcode_t op);
void VPKPX(ppu_opcode_t op);
void VPKSHSS(ppu_opcode_t op);
void VPKSHUS(ppu_opcode_t op);
void VPKSWSS(ppu_opcode_t op);
void VPKSWUS(ppu_opcode_t op);
void VPKUHUM(ppu_opcode_t op);
void VPKUHUS(ppu_opcode_t op);
void VPKUWUM(ppu_opcode_t op);
void VPKUWUS(ppu_opcode_t op);
void VREFP(ppu_opcode_t op);
void VRFIM(ppu_opcode_t op);
void VRFIN(ppu_opcode_t op);
void VRFIP(ppu_opcode_t op);
void VRFIZ(ppu_opcode_t op);
void VRLB(ppu_opcode_t op);
void VRLH(ppu_opcode_t op);
void VRLW(ppu_opcode_t op);
void VRSQRTEFP(ppu_opcode_t op);
void VSEL(ppu_opcode_t op);
void VSL(ppu_opcode_t op);
void VSLB(ppu_opcode_t op);
void VSLDOI(ppu_opcode_t op);
void VSLH(ppu_opcode_t op);
void VSLO(ppu_opcode_t op);
void VSLW(ppu_opcode_t op);
void VSPLTB(ppu_opcode_t op);
void VSPLTH(ppu_opcode_t op);
void VSPLTISB(ppu_opcode_t op);
void VSPLTISH(ppu_opcode_t op);
void VSPLTISW(ppu_opcode_t op);
void VSPLTW(ppu_opcode_t op);
void VSR(ppu_opcode_t op);
void VSRAB(ppu_opcode_t op);
void VSRAH(ppu_opcode_t op);
void VSRAW(ppu_opcode_t op);
void VSRB(ppu_opcode_t op);
void VSRH(ppu_opcode_t op);
void VSRO(ppu_opcode_t op);
void VSRW(ppu_opcode_t op);
void VSUBCUW(ppu_opcode_t op);
void VSUBFP(ppu_opcode_t op);
void VSUBSBS(ppu_opcode_t op);
void VSUBSHS(ppu_opcode_t op);
void VSUBSWS(ppu_opcode_t op);
void VSUBUBM(ppu_opcode_t op);
void VSUBUBS(ppu_opcode_t op);
void VSUBUHM(ppu_opcode_t op);
void VSUBUHS(ppu_opcode_t op);
void VSUBUWM(ppu_opcode_t op);
void VSUBUWS(ppu_opcode_t op);
void VSUMSWS(ppu_opcode_t op);
void VSUM2SWS(ppu_opcode_t op);
void VSUM4SBS(ppu_opcode_t op);
void VSUM4SHS(ppu_opcode_t op);
void VSUM4UBS(ppu_opcode_t op);
void VUPKHPX(ppu_opcode_t op);
void VUPKHSB(ppu_opcode_t op);
void VUPKHSH(ppu_opcode_t op);
void VUPKLPX(ppu_opcode_t op);
void VUPKLSB(ppu_opcode_t op);
void VUPKLSH(ppu_opcode_t op);
void VXOR(ppu_opcode_t op);
void TDI(ppu_opcode_t op);
void TWI(ppu_opcode_t op);
void MULLI(ppu_opcode_t op);
void SUBFIC(ppu_opcode_t op);
void CMPLI(ppu_opcode_t op);
void CMPI(ppu_opcode_t op);
void ADDIC(ppu_opcode_t op);
void ADDI(ppu_opcode_t op);
void ADDIS(ppu_opcode_t op);
void BC(ppu_opcode_t op);
void SC(ppu_opcode_t op);
void B(ppu_opcode_t op);
void MCRF(ppu_opcode_t op);
void BCLR(ppu_opcode_t op);
void CRNOR(ppu_opcode_t op);
void CRANDC(ppu_opcode_t op);
void ISYNC(ppu_opcode_t op);
void CRXOR(ppu_opcode_t op);
void CRNAND(ppu_opcode_t op);
void CRAND(ppu_opcode_t op);
void CREQV(ppu_opcode_t op);
void CRORC(ppu_opcode_t op);
void CROR(ppu_opcode_t op);
void BCCTR(ppu_opcode_t op);
void RLWIMI(ppu_opcode_t op);
void RLWINM(ppu_opcode_t op);
void RLWNM(ppu_opcode_t op);
void ORI(ppu_opcode_t op);
void ORIS(ppu_opcode_t op);
void XORI(ppu_opcode_t op);
void XORIS(ppu_opcode_t op);
void ANDI(ppu_opcode_t op);
void ANDIS(ppu_opcode_t op);
void RLDICL(ppu_opcode_t op);
void RLDICR(ppu_opcode_t op);
void RLDIC(ppu_opcode_t op);
void RLDIMI(ppu_opcode_t op);
void RLDCL(ppu_opcode_t op);
void RLDCR(ppu_opcode_t op);
void CMP(ppu_opcode_t op);
void TW(ppu_opcode_t op);
void LVSL(ppu_opcode_t op);
void LVEBX(ppu_opcode_t op);
void SUBFC(ppu_opcode_t op);
void MULHDU(ppu_opcode_t op);
void ADDC(ppu_opcode_t op);
void MULHWU(ppu_opcode_t op);
void MFOCRF(ppu_opcode_t op);
void LWARX(ppu_opcode_t op);
void LDX(ppu_opcode_t op);
void LWZX(ppu_opcode_t op);
void SLW(ppu_opcode_t op);
void CNTLZW(ppu_opcode_t op);
void SLD(ppu_opcode_t op);
void AND(ppu_opcode_t op);
void CMPL(ppu_opcode_t op);
void LVSR(ppu_opcode_t op);
void LVEHX(ppu_opcode_t op);
void SUBF(ppu_opcode_t op);
void LDUX(ppu_opcode_t op);
void DCBST(ppu_opcode_t op);
void LWZUX(ppu_opcode_t op);
void CNTLZD(ppu_opcode_t op);
void ANDC(ppu_opcode_t op);
void TD(ppu_opcode_t op);
void LVEWX(ppu_opcode_t op);
void MULHD(ppu_opcode_t op);
void MULHW(ppu_opcode_t op);
void LDARX(ppu_opcode_t op);
void DCBF(ppu_opcode_t op);
void LBZX(ppu_opcode_t op);
void LVX(ppu_opcode_t op);
void NEG(ppu_opcode_t op);
void LBZUX(ppu_opcode_t op);
void NOR(ppu_opcode_t op);
void STVEBX(ppu_opcode_t op);
void SUBFE(ppu_opcode_t op);
void ADDE(ppu_opcode_t op);
void MTOCRF(ppu_opcode_t op);
void STDX(ppu_opcode_t op);
void STWCX(ppu_opcode_t op);
void STWX(ppu_opcode_t op);
void STVEHX(ppu_opcode_t op);
void STDUX(ppu_opcode_t op);
void STWUX(ppu_opcode_t op);
void STVEWX(ppu_opcode_t op);
void SUBFZE(ppu_opcode_t op);
void ADDZE(ppu_opcode_t op);
void STDCX(ppu_opcode_t op);
void STBX(ppu_opcode_t op);
void STVX(ppu_opcode_t op);
void MULLD(ppu_opcode_t op);
void SUBFME(ppu_opcode_t op);
void ADDME(ppu_opcode_t op);
void MULLW(ppu_opcode_t op);
void DCBTST(ppu_opcode_t op);
void STBUX(ppu_opcode_t op);
void ADD(ppu_opcode_t op);
void DCBT(ppu_opcode_t op);
void LHZX(ppu_opcode_t op);
void EQV(ppu_opcode_t op);
void ECIWX(ppu_opcode_t op);
void LHZUX(ppu_opcode_t op);
void XOR(ppu_opcode_t op);
void MFSPR(ppu_opcode_t op);
void LWAX(ppu_opcode_t op);
void DST(ppu_opcode_t op);
void LHAX(ppu_opcode_t op);
void LVXL(ppu_opcode_t op);
void MFTB(ppu_opcode_t op);
void LWAUX(ppu_opcode_t op);
void DSTST(ppu_opcode_t op);
void LHAUX(ppu_opcode_t op);
void STHX(ppu_opcode_t op);
void ORC(ppu_opcode_t op);
void ECOWX(ppu_opcode_t op);
void STHUX(ppu_opcode_t op);
void OR(ppu_opcode_t op);
void DIVDU(ppu_opcode_t op);
void DIVWU(ppu_opcode_t op);
void MTSPR(ppu_opcode_t op);
void DCBI(ppu_opcode_t op);
void NAND(ppu_opcode_t op);
void STVXL(ppu_opcode_t op);
void DIVD(ppu_opcode_t op);
void DIVW(ppu_opcode_t op);
void LVLX(ppu_opcode_t op);
void LDBRX(ppu_opcode_t op);
void LSWX(ppu_opcode_t op);
void LWBRX(ppu_opcode_t op);
void LFSX(ppu_opcode_t op);
void SRW(ppu_opcode_t op);
void SRD(ppu_opcode_t op);
void LVRX(ppu_opcode_t op);
void LSWI(ppu_opcode_t op);
void LFSUX(ppu_opcode_t op);
void SYNC(ppu_opcode_t op);
void LFDX(ppu_opcode_t op);
void LFDUX(ppu_opcode_t op);
void STVLX(ppu_opcode_t op);
void STDBRX(ppu_opcode_t op);
void STSWX(ppu_opcode_t op);
void STWBRX(ppu_opcode_t op);
void STFSX(ppu_opcode_t op);
void STVRX(ppu_opcode_t op);
void STFSUX(ppu_opcode_t op);
void STSWI(ppu_opcode_t op);
void STFDX(ppu_opcode_t op);
void STFDUX(ppu_opcode_t op);
void LVLXL(ppu_opcode_t op);
void LHBRX(ppu_opcode_t op);
void SRAW(ppu_opcode_t op);
void SRAD(ppu_opcode_t op);
void LVRXL(ppu_opcode_t op);
void DSS(ppu_opcode_t op);
void SRAWI(ppu_opcode_t op);
void SRADI(ppu_opcode_t op);
void EIEIO(ppu_opcode_t op);
void STVLXL(ppu_opcode_t op);
void STHBRX(ppu_opcode_t op);
void EXTSH(ppu_opcode_t op);
void STVRXL(ppu_opcode_t op);
void EXTSB(ppu_opcode_t op);
void STFIWX(ppu_opcode_t op);
void EXTSW(ppu_opcode_t op);
void ICBI(ppu_opcode_t op);
void DCBZ(ppu_opcode_t op);
void LWZ(ppu_opcode_t op);
void LWZU(ppu_opcode_t op);
void LBZ(ppu_opcode_t op);
void LBZU(ppu_opcode_t op);
void STW(ppu_opcode_t op);
void STWU(ppu_opcode_t op);
void STB(ppu_opcode_t op);
void STBU(ppu_opcode_t op);
void LHZ(ppu_opcode_t op);
void LHZU(ppu_opcode_t op);
void LHA(ppu_opcode_t op);
void LHAU(ppu_opcode_t op);
void STH(ppu_opcode_t op);
void STHU(ppu_opcode_t op);
void LMW(ppu_opcode_t op);
void STMW(ppu_opcode_t op);
void LFS(ppu_opcode_t op);
void LFSU(ppu_opcode_t op);
void LFD(ppu_opcode_t op);
void LFDU(ppu_opcode_t op);
void STFS(ppu_opcode_t op);
void STFSU(ppu_opcode_t op);
void STFD(ppu_opcode_t op);
void STFDU(ppu_opcode_t op);
void LD(ppu_opcode_t op);
void LDU(ppu_opcode_t op);
void LWA(ppu_opcode_t op);
void STD(ppu_opcode_t op);
void STDU(ppu_opcode_t op);
void FDIVS(ppu_opcode_t op);
void FSUBS(ppu_opcode_t op);
void FADDS(ppu_opcode_t op);
void FSQRTS(ppu_opcode_t op);
void FRES(ppu_opcode_t op);
void FMULS(ppu_opcode_t op);
void FMADDS(ppu_opcode_t op);
void FMSUBS(ppu_opcode_t op);
void FNMSUBS(ppu_opcode_t op);
void FNMADDS(ppu_opcode_t op);
void MTFSB1(ppu_opcode_t op);
void MCRFS(ppu_opcode_t op);
void MTFSB0(ppu_opcode_t op);
void MTFSFI(ppu_opcode_t op);
void MFFS(ppu_opcode_t op);
void MTFSF(ppu_opcode_t op);
void FCMPU(ppu_opcode_t op);
void FRSP(ppu_opcode_t op);
void FCTIW(ppu_opcode_t op);
void FCTIWZ(ppu_opcode_t op);
void FDIV(ppu_opcode_t op);
void FSUB(ppu_opcode_t op);
void FADD(ppu_opcode_t op);
void FSQRT(ppu_opcode_t op);
void FSEL(ppu_opcode_t op);
void FMUL(ppu_opcode_t op);
void FRSQRTE(ppu_opcode_t op);
void FMSUB(ppu_opcode_t op);
void FMADD(ppu_opcode_t op);
void FNMSUB(ppu_opcode_t op);
void FNMADD(ppu_opcode_t op);
void FCMPO(ppu_opcode_t op);
void FNEG(ppu_opcode_t op);
void FMR(ppu_opcode_t op);
void FNABS(ppu_opcode_t op);
void FABS(ppu_opcode_t op);
void FCTID(ppu_opcode_t op);
void FCTIDZ(ppu_opcode_t op);
void FCFID(ppu_opcode_t op);
void UNK(ppu_opcode_t op);
void SUBFCO(ppu_opcode_t op) { return SUBFC(op); }
void ADDCO(ppu_opcode_t op) { return ADDC(op); }
void SUBFO(ppu_opcode_t op) { return SUBF(op); }
void NEGO(ppu_opcode_t op) { return NEG(op); }
void SUBFEO(ppu_opcode_t op) { return SUBFE(op); }
void ADDEO(ppu_opcode_t op) { return ADDE(op); }
void SUBFZEO(ppu_opcode_t op) { return SUBFZE(op); }
void ADDZEO(ppu_opcode_t op) { return ADDZE(op); }
void SUBFMEO(ppu_opcode_t op) { return SUBFME(op); }
void MULLDO(ppu_opcode_t op) { return MULLD(op); }
void ADDMEO(ppu_opcode_t op) { return ADDME(op); }
void MULLWO(ppu_opcode_t op) { return MULLW(op); }
void ADDO(ppu_opcode_t op) { return ADD(op); }
void DIVDUO(ppu_opcode_t op) { return DIVDU(op); }
void DIVWUO(ppu_opcode_t op) { return DIVWU(op); }
void DIVDO(ppu_opcode_t op) { return DIVD(op); }
void DIVWO(ppu_opcode_t op) { return DIVW(op); }
void SUBFCO_(ppu_opcode_t op) { return SUBFC(op); }
void ADDCO_(ppu_opcode_t op) { return ADDC(op); }
void SUBFO_(ppu_opcode_t op) { return SUBF(op); }
void NEGO_(ppu_opcode_t op) { return NEG(op); }
void SUBFEO_(ppu_opcode_t op) { return SUBFE(op); }
void ADDEO_(ppu_opcode_t op) { return ADDE(op); }
void SUBFZEO_(ppu_opcode_t op) { return SUBFZE(op); }
void ADDZEO_(ppu_opcode_t op) { return ADDZE(op); }
void SUBFMEO_(ppu_opcode_t op) { return SUBFME(op); }
void MULLDO_(ppu_opcode_t op) { return MULLD(op); }
void ADDMEO_(ppu_opcode_t op) { return ADDME(op); }
void MULLWO_(ppu_opcode_t op) { return MULLW(op); }
void ADDO_(ppu_opcode_t op) { return ADD(op); }
void DIVDUO_(ppu_opcode_t op) { return DIVDU(op); }
void DIVWUO_(ppu_opcode_t op) { return DIVWU(op); }
void DIVDO_(ppu_opcode_t op) { return DIVD(op); }
void DIVWO_(ppu_opcode_t op) { return DIVW(op); }
void RLWIMI_(ppu_opcode_t op) { return RLWIMI(op); }
void RLWINM_(ppu_opcode_t op) { return RLWINM(op); }
void RLWNM_(ppu_opcode_t op) { return RLWNM(op); }
void RLDICL_(ppu_opcode_t op) { return RLDICL(op); }
void RLDICR_(ppu_opcode_t op) { return RLDICR(op); }
void RLDIC_(ppu_opcode_t op) { return RLDIC(op); }
void RLDIMI_(ppu_opcode_t op) { return RLDIMI(op); }
void RLDCL_(ppu_opcode_t op) { return RLDCL(op); }
void RLDCR_(ppu_opcode_t op) { return RLDCR(op); }
void SUBFC_(ppu_opcode_t op) { return SUBFC(op); }
void MULHDU_(ppu_opcode_t op) { return MULHDU(op); }
void ADDC_(ppu_opcode_t op) { return ADDC(op); }
void MULHWU_(ppu_opcode_t op) { return MULHWU(op); }
void SLW_(ppu_opcode_t op) { return SLW(op); }
void CNTLZW_(ppu_opcode_t op) { return CNTLZW(op); }
void SLD_(ppu_opcode_t op) { return SLD(op); }
void AND_(ppu_opcode_t op) { return AND(op); }
void SUBF_(ppu_opcode_t op) { return SUBF(op); }
void CNTLZD_(ppu_opcode_t op) { return CNTLZD(op); }
void ANDC_(ppu_opcode_t op) { return ANDC(op); }
void MULHD_(ppu_opcode_t op) { return MULHD(op); }
void MULHW_(ppu_opcode_t op) { return MULHW(op); }
void NEG_(ppu_opcode_t op) { return NEG(op); }
void NOR_(ppu_opcode_t op) { return NOR(op); }
void SUBFE_(ppu_opcode_t op) { return SUBFE(op); }
void ADDE_(ppu_opcode_t op) { return ADDE(op); }
void SUBFZE_(ppu_opcode_t op) { return SUBFZE(op); }
void ADDZE_(ppu_opcode_t op) { return ADDZE(op); }
void MULLD_(ppu_opcode_t op) { return MULLD(op); }
void SUBFME_(ppu_opcode_t op) { return SUBFME(op); }
void ADDME_(ppu_opcode_t op) { return ADDME(op); }
void MULLW_(ppu_opcode_t op) { return MULLW(op); }
void ADD_(ppu_opcode_t op) { return ADD(op); }
void EQV_(ppu_opcode_t op) { return EQV(op); }
void XOR_(ppu_opcode_t op) { return XOR(op); }
void ORC_(ppu_opcode_t op) { return ORC(op); }
void OR_(ppu_opcode_t op) { return OR(op); }
void DIVDU_(ppu_opcode_t op) { return DIVDU(op); }
void DIVWU_(ppu_opcode_t op) { return DIVWU(op); }
void NAND_(ppu_opcode_t op) { return NAND(op); }
void DIVD_(ppu_opcode_t op) { return DIVD(op); }
void DIVW_(ppu_opcode_t op) { return DIVW(op); }
void SRW_(ppu_opcode_t op) { return SRW(op); }
void SRD_(ppu_opcode_t op) { return SRD(op); }
void SRAW_(ppu_opcode_t op) { return SRAW(op); }
void SRAD_(ppu_opcode_t op) { return SRAD(op); }
void SRAWI_(ppu_opcode_t op) { return SRAWI(op); }
void SRADI_(ppu_opcode_t op) { return SRADI(op); }
void EXTSH_(ppu_opcode_t op) { return EXTSH(op); }
void EXTSB_(ppu_opcode_t op) { return EXTSB(op); }
void EXTSW_(ppu_opcode_t op) { return EXTSW(op); }
void FDIVS_(ppu_opcode_t op) { return FDIVS(op); }
void FSUBS_(ppu_opcode_t op) { return FSUBS(op); }
void FADDS_(ppu_opcode_t op) { return FADDS(op); }
void FSQRTS_(ppu_opcode_t op) { return FSQRTS(op); }
void FRES_(ppu_opcode_t op) { return FRES(op); }
void FMULS_(ppu_opcode_t op) { return FMULS(op); }
void FMADDS_(ppu_opcode_t op) { return FMADDS(op); }
void FMSUBS_(ppu_opcode_t op) { return FMSUBS(op); }
void FNMSUBS_(ppu_opcode_t op) { return FNMSUBS(op); }
void FNMADDS_(ppu_opcode_t op) { return FNMADDS(op); }
void MTFSB1_(ppu_opcode_t op) { return MTFSB1(op); }
void MTFSB0_(ppu_opcode_t op) { return MTFSB0(op); }
void MTFSFI_(ppu_opcode_t op) { return MTFSFI(op); }
void MFFS_(ppu_opcode_t op) { return MFFS(op); }
void MTFSF_(ppu_opcode_t op) { return MTFSF(op); }
void FRSP_(ppu_opcode_t op) { return FRSP(op); }
void FCTIW_(ppu_opcode_t op) { return FCTIW(op); }
void FCTIWZ_(ppu_opcode_t op) { return FCTIWZ(op); }
void FDIV_(ppu_opcode_t op) { return FDIV(op); }
void FSUB_(ppu_opcode_t op) { return FSUB(op); }
void FADD_(ppu_opcode_t op) { return FADD(op); }
void FSQRT_(ppu_opcode_t op) { return FSQRT(op); }
void FSEL_(ppu_opcode_t op) { return FSEL(op); }
void FMUL_(ppu_opcode_t op) { return FMUL(op); }
void FRSQRTE_(ppu_opcode_t op) { return FRSQRTE(op); }
void FMSUB_(ppu_opcode_t op) { return FMSUB(op); }
void FMADD_(ppu_opcode_t op) { return FMADD(op); }
void FNMSUB_(ppu_opcode_t op) { return FNMSUB(op); }
void FNMADD_(ppu_opcode_t op) { return FNMADD(op); }
void FNEG_(ppu_opcode_t op) { return FNEG(op); }
void FMR_(ppu_opcode_t op) { return FMR(op); }
void FNABS_(ppu_opcode_t op) { return FNABS(op); }
void FABS_(ppu_opcode_t op) { return FABS(op); }
void FCTID_(ppu_opcode_t op) { return FCTID(op); }
void FCTIDZ_(ppu_opcode_t op) { return FCTIDZ(op); }
void FCFID_(ppu_opcode_t op) { return FCFID(op); }
void build_interpreter();
};
#endif
| 28,146
|
C++
|
.h
| 769
| 34.452536
| 121
| 0.706283
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,823
|
MFC.h
|
RPCS3_rpcs3/rpcs3/Emu/Cell/MFC.h
|
#pragma once
#include "util/types.hpp"
enum MFC : u8
{
MFC_PUT_CMD = 0x20, MFC_PUTB_CMD = 0x21, MFC_PUTF_CMD = 0x22,
MFC_PUTS_CMD = 0x28, MFC_PUTBS_CMD = 0x29, MFC_PUTFS_CMD = 0x2a,
MFC_PUTR_CMD = 0x30, MFC_PUTRB_CMD = 0x31, MFC_PUTRF_CMD = 0x32,
MFC_GET_CMD = 0x40, MFC_GETB_CMD = 0x41, MFC_GETF_CMD = 0x42,
MFC_GETS_CMD = 0x48, MFC_GETBS_CMD = 0x49, MFC_GETFS_CMD = 0x4a,
MFC_PUTL_CMD = 0x24, MFC_PUTLB_CMD = 0x25, MFC_PUTLF_CMD = 0x26,
MFC_PUTRL_CMD = 0x34, MFC_PUTRLB_CMD = 0x35, MFC_PUTRLF_CMD = 0x36,
MFC_GETL_CMD = 0x44, MFC_GETLB_CMD = 0x45, MFC_GETLF_CMD = 0x46,
MFC_GETLLAR_CMD = 0xD0,
MFC_PUTLLC_CMD = 0xB4,
MFC_PUTLLUC_CMD = 0xB0,
MFC_PUTQLLUC_CMD = 0xB8,
MFC_SNDSIG_CMD = 0xA0, MFC_SNDSIGB_CMD = 0xA1, MFC_SNDSIGF_CMD = 0xA2,
MFC_BARRIER_CMD = 0xC0,
MFC_EIEIO_CMD = 0xC8,
MFC_SYNC_CMD = 0xCC,
MFC_BARRIER_MASK = 0x01,
MFC_FENCE_MASK = 0x02,
MFC_LIST_MASK = 0x04,
MFC_START_MASK = 0x08,
MFC_RESULT_MASK = 0x10, // ???
MFC_SDCRT_CMD = 0x80,
MFC_SDCRTST_CMD = 0x81,
MFC_SDCRZ_CMD = 0x89,
MFC_SDCRS_CMD = 0x8D,
MFC_SDCRF_CMD = 0x8F,
};
// Atomic Status Update
enum mfc_atomic_status : u32
{
MFC_PUTLLC_SUCCESS = 0,
MFC_PUTLLC_FAILURE = 1, // reservation was lost
MFC_PUTLLUC_SUCCESS = 2,
MFC_GETLLAR_SUCCESS = 4,
};
// MFC Write Tag Status Update Request Channel (ch23) operations
enum mfc_tag_update : u32
{
MFC_TAG_UPDATE_IMMEDIATE = 0,
MFC_TAG_UPDATE_ANY = 1,
MFC_TAG_UPDATE_ALL = 2,
};
enum : u32
{
MFC_PPU_DMA_CMD_ENQUEUE_SUCCESSFUL = 0x00,
MFC_PPU_DMA_CMD_SEQUENCE_ERROR = 0x01,
MFC_PPU_DMA_QUEUE_FULL = 0x02,
};
enum : u32
{
MFC_PROXY_COMMAND_QUEUE_EMPTY_FLAG = 0x80000000,
};
enum : u32
{
MFC_PPU_MAX_QUEUE_SPACE = 0x08,
MFC_SPU_MAX_QUEUE_SPACE = 0x10,
};
enum : u32
{
MFC_DMA_TAG_STATUS_UPDATE_EVENT = 0x00000001,
MFC_DMA_TAG_CMD_STALL_NOTIFY_EVENT = 0x00000002,
MFC_DMA_QUEUE_VACANCY_EVENT = 0x00000008,
MFC_SPU_MAILBOX_WRITTEN_EVENT = 0x00000010,
MFC_DECREMENTER_EVENT = 0x00000020,
MFC_PU_INT_MAILBOX_AVAIL_EVENT = 0x00000040,
MFC_PU_MAILBOX_AVAIL_EVENT = 0x00000080,
MFC_SIGNAL_2_EVENT = 0x00000100,
MFC_SIGNAL_1_EVENT = 0x00000200,
MFC_LLR_LOST_EVENT = 0x00000400,
MFC_PRIV_ATTN_EVENT = 0x00000800,
MFC_MULTISOURCE_SYNC_EVENT = 0x00001000,
};
struct alignas(16) spu_mfc_cmd
{
ENABLE_BITWISE_SERIALIZATION;
MFC cmd;
u8 tag;
u16 size;
u32 lsa;
u32 eal;
u32 eah;
};
enum class spu_block_hash : u64;
struct mfc_cmd_dump
{
spu_mfc_cmd cmd;
u64 block_hash;
alignas(16) u8 data[128];
};
| 2,785
|
C++
|
.h
| 93
| 28.129032
| 75
| 0.634666
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,824
|
SPUThread.h
|
RPCS3_rpcs3/rpcs3/Emu/Cell/SPUThread.h
|
#pragma once
#include "Emu/CPU/CPUThread.h"
#include "Emu/CPU/Hypervisor.h"
#include "Emu/Cell/SPUInterpreter.h"
#include "Emu/Memory/vm.h"
#include "MFC.h"
#include "util/v128.hpp"
#include "util/logs.hpp"
#include "util/to_endian.hpp"
#include "Loader/ELF.h"
#include <span>
LOG_CHANNEL(spu_log, "SPU");
struct lv2_event_queue;
struct lv2_spu_group;
struct lv2_int_tag;
namespace utils
{
class shm;
}
// LUTs for SPU
extern const u32 spu_frest_fraction_lut[32];
extern const u32 spu_frest_exponent_lut[256];
extern const u32 spu_frsqest_fraction_lut[64];
extern const u32 spu_frsqest_exponent_lut[256];
// JIT Block
using spu_function_t = void(*)(spu_thread&, void*, u8*);
// SPU Channels
enum : u32
{
SPU_RdEventStat = 0, // Read event status with mask applied
SPU_WrEventMask = 1, // Write event mask
SPU_WrEventAck = 2, // Write end of event processing
SPU_RdSigNotify1 = 3, // Signal notification 1
SPU_RdSigNotify2 = 4, // Signal notification 2
SPU_WrDec = 7, // Write decrementer count
SPU_RdDec = 8, // Read decrementer count
SPU_RdEventMask = 11, // Read event mask
SPU_RdMachStat = 13, // Read SPU run status
SPU_WrSRR0 = 14, // Write SPU machine state save/restore register 0 (SRR0)
SPU_RdSRR0 = 15, // Read SPU machine state save/restore register 0 (SRR0)
SPU_WrOutMbox = 28, // Write outbound mailbox contents
SPU_RdInMbox = 29, // Read inbound mailbox contents
SPU_WrOutIntrMbox = 30, // Write outbound interrupt mailbox contents (interrupting PPU)
SPU_Set_Bkmk_Tag = 69, // Causes an event that can be logged in the performance monitor logic if enabled in the SPU
SPU_PM_Start_Ev = 70, // Starts the performance monitor event if enabled
SPU_PM_Stop_Ev = 71, // Stops the performance monitor event if enabled
};
// MFC Channels
enum : u32
{
MFC_WrMSSyncReq = 9, // Write multisource synchronization request
MFC_RdTagMask = 12, // Read tag mask
MFC_LSA = 16, // Write local memory address command parameter
MFC_EAH = 17, // Write high order DMA effective address command parameter
MFC_EAL = 18, // Write low order DMA effective address command parameter
MFC_Size = 19, // Write DMA transfer size command parameter
MFC_TagID = 20, // Write tag identifier command parameter
MFC_Cmd = 21, // Write and enqueue DMA command with associated class ID
MFC_WrTagMask = 22, // Write tag mask
MFC_WrTagUpdate = 23, // Write request for conditional or unconditional tag status update
MFC_RdTagStat = 24, // Read tag status with mask applied
MFC_RdListStallStat = 25, // Read DMA list stall-and-notify status
MFC_WrListStallAck = 26, // Write DMA list stall-and-notify acknowledge
MFC_RdAtomicStat = 27, // Read completion status of last completed immediate MFC atomic update command
};
// SPU Events
enum : u32
{
SPU_EVENT_MS = 0x1000, // Multisource Synchronization event
SPU_EVENT_A = 0x800, // Privileged Attention event
SPU_EVENT_LR = 0x400, // Lock Line Reservation Lost event
SPU_EVENT_S1 = 0x200, // Signal Notification Register 1 available
SPU_EVENT_S2 = 0x100, // Signal Notification Register 2 available
SPU_EVENT_LE = 0x80, // SPU Outbound Mailbox available
SPU_EVENT_ME = 0x40, // SPU Outbound Interrupt Mailbox available
SPU_EVENT_TM = 0x20, // SPU Decrementer became negative (?)
SPU_EVENT_MB = 0x10, // SPU Inbound mailbox available
SPU_EVENT_QV = 0x8, // MFC SPU Command Queue available
SPU_EVENT_SN = 0x2, // MFC List Command stall-and-notify event
SPU_EVENT_TG = 0x1, // MFC Tag Group status update event
SPU_EVENT_IMPLEMENTED = SPU_EVENT_LR | SPU_EVENT_TM | SPU_EVENT_SN | SPU_EVENT_S1 | SPU_EVENT_S2, // Mask of implemented events
SPU_EVENT_INTR_IMPLEMENTED = SPU_EVENT_SN,
SPU_EVENT_INTR_BUSY_CHECK = SPU_EVENT_IMPLEMENTED & ~SPU_EVENT_INTR_IMPLEMENTED,
};
// SPU Class 0 Interrupts
enum : u64
{
SPU_INT0_STAT_DMA_ALIGNMENT_INT = (1ull << 0),
SPU_INT0_STAT_INVALID_DMA_CMD_INT = (1ull << 1),
SPU_INT0_STAT_SPU_ERROR_INT = (1ull << 2),
};
// SPU Class 2 Interrupts
enum : u64
{
SPU_INT2_STAT_MAILBOX_INT = (1ull << 0),
SPU_INT2_STAT_SPU_STOP_AND_SIGNAL_INT = (1ull << 1),
SPU_INT2_STAT_SPU_HALT_OR_STEP_INT = (1ull << 2),
SPU_INT2_STAT_DMA_TAG_GROUP_COMPLETION_INT = (1ull << 3),
SPU_INT2_STAT_SPU_MAILBOX_THRESHOLD_INT = (1ull << 4),
};
enum : u32
{
SPU_RUNCNTL_STOP_REQUEST = 0,
SPU_RUNCNTL_RUN_REQUEST = 1,
};
// SPU Status Register bits (not accurate)
enum : u32
{
SPU_STATUS_STOPPED = 0x0,
SPU_STATUS_RUNNING = 0x1,
SPU_STATUS_STOPPED_BY_STOP = 0x2,
SPU_STATUS_STOPPED_BY_HALT = 0x4,
SPU_STATUS_WAITING_FOR_CHANNEL = 0x8,
SPU_STATUS_SINGLE_STEP = 0x10,
SPU_STATUS_IS_ISOLATED = 0x80,
};
enum : s32
{
SPU_LS_SIZE = 0x40000,
};
enum : u32
{
SYS_SPU_THREAD_BASE_LOW = 0xf0000000,
SYS_SPU_THREAD_OFFSET = 0x100000,
SYS_SPU_THREAD_SNR1 = 0x5400c,
SYS_SPU_THREAD_SNR2 = 0x5C00c,
};
enum
{
MFC_LSA_offs = 0x3004,
MFC_EAH_offs = 0x3008,
MFC_EAL_offs = 0x300C,
MFC_Size_Tag_offs = 0x3010,
MFC_Class_CMD_offs = 0x3014,
MFC_CMDStatus_offs = 0x3014,
MFC_QStatus_offs = 0x3104,
Prxy_QueryType_offs = 0x3204,
Prxy_QueryMask_offs = 0x321C,
Prxy_TagStatus_offs = 0x322C,
SPU_Out_MBox_offs = 0x4004,
SPU_In_MBox_offs = 0x400C,
SPU_MBox_Status_offs = 0x4014,
SPU_RunCntl_offs = 0x401C,
SPU_Status_offs = 0x4024,
SPU_NPC_offs = 0x4034,
SPU_RdSigNotify1_offs = 0x1400C,
SPU_RdSigNotify2_offs = 0x1C00C,
};
enum : u32
{
RAW_SPU_BASE_ADDR = 0xE0000000,
RAW_SPU_OFFSET = 0x00100000,
RAW_SPU_LS_OFFSET = 0x00000000,
RAW_SPU_PROB_OFFSET = 0x00040000,
SPU_FAKE_BASE_ADDR = 0xE8000000,
};
struct spu_channel_op_state
{
u8 old_count;
u8 count;
bool notify;
bool op_done;
};
struct alignas(16) spu_channel
{
// Low 32 bits contain value
atomic_t<u64> data{};
// Pending value to be inserted when it is possible in pop() or pop_wait()
atomic_t<u64> jostling_value{};
public:
static constexpr u32 off_wait = 32;
static constexpr u32 off_occupy = 32;
static constexpr u32 off_count = 63;
static constexpr u64 bit_wait = 1ull << off_wait;
static constexpr u64 bit_occupy = 1ull << off_occupy;
static constexpr u64 bit_count = 1ull << off_count;
// Returns true on success
bool try_push(u32 value)
{
return data.fetch_op([value](u64& data)
{
if (!(data & bit_count)) [[likely]]
{
data = bit_count | value;
return true;
}
return false;
}).second;
}
// Push unconditionally, may require notification
// Performing bitwise OR with previous value if specified, otherwise overwiting it
// Returns old count and new count
spu_channel_op_state push(u32 value, bool to_or = false, bool postpone_notify = false)
{
while (true)
{
const auto [old, pushed_to_data] = data.fetch_op([&](u64& data)
{
if (data & bit_occupy)
{
return false;
}
if (to_or)
{
data = bit_count | (static_cast<u32>(data) | value);
}
else
{
data = bit_count | value;
}
return true;
});
if (!pushed_to_data)
{
// Insert the pending value in special storage for waiting SPUs, leave no time in which the channel has data
if (!jostling_value.compare_and_swap_test(bit_occupy, value))
{
// Other thread has inserted a value through jostling_value, retry
continue;
}
}
if (old & bit_wait)
{
// Turn off waiting bit manually (must succeed because waiting bit can only be resetted by the thread pushed to jostling_value)
if (!this->data.bit_test_reset(off_wait))
{
// Could be fatal or at emulation stopping, to be checked by the caller
return { (old & bit_count) == 0, 0, false, false };
}
if (!postpone_notify)
{
utils::bless<atomic_t<u32>>(&data)[1].notify_one();
}
}
// Return true if count has changed from 0 to 1, this condition is considered satisfied even if we pushed a value directly to the special storage for waiting SPUs
return { (old & bit_count) == 0, 1, (old & bit_wait) != 0, true };
}
}
void notify()
{
utils::bless<atomic_t<u32>>(&data)[1].notify_one();
}
// Returns true on success
bool try_pop(u32& out)
{
return data.fetch_op([&out](u64& data)
{
if (data & bit_count) [[likely]]
{
out = static_cast<u32>(data);
data = 0;
return true;
}
return false;
}).second;
}
// Reading without modification
bool try_read(u32& out) const
{
const u64 old = data.load();
out = static_cast<u32>(old);
if (old & bit_count) [[likely]]
{
return true;
}
return false;
}
// Pop unconditionally (loading last value), may require notification
// If the SPU tries to insert a value, do it instead the SPU
u32 pop()
{
// Value is not cleared and may be read again
constexpr u64 mask = bit_count | bit_occupy;
const u64 old = data.fetch_op([&](u64& data)
{
if ((data & mask) == mask)
{
// Insert the pending value, leave no time in which the channel has no data
data = bit_count | static_cast<u32>(jostling_value);
return;
}
data &= ~(mask | bit_wait);
});
if (old & bit_wait)
{
utils::bless<atomic_t<u32>>(&data)[1].notify_one();
}
return static_cast<u32>(old);
}
// Waiting for channel pop state availability, actually popping if specified
s64 pop_wait(cpu_thread& spu, bool pop = true);
// Waiting for channel push state availability, actually pushing if specified
bool push_wait(cpu_thread& spu, u32 value, bool push = true);
void set_value(u32 value, bool count = true)
{
data.release(u64{count} << off_count | value);
}
u32 get_value() const
{
return static_cast<u32>(data);
}
u32 get_count() const
{
return (data & bit_count) ? 1 : 0;
}
};
struct spu_channel_4_t
{
struct alignas(16) sync_var_t
{
u8 waiting;
u8 count;
u16 value3_inval;
u32 value0;
u32 value1;
u32 value2;
};
atomic_t<sync_var_t> values;
atomic_t<u64> jostling_value;
atomic_t<u32> value3;
static constexpr u32 off_wait = 0;
static constexpr u32 off_occupy = 7;
static constexpr u64 bit_wait = 1ull << off_wait;
static constexpr u64 bit_occupy = 1ull << off_occupy;
static constexpr u64 jostling_flag = 1ull << 63;
void clear()
{
values.release({});
jostling_value.release(0);
value3.release(0);
}
// push unconditionally (overwriting latest value), returns true if needs signaling
// returning if could be aborted (operation failed unexpectedly)
spu_channel_op_state push(u32 value, bool postpone_notify = false);
void notify()
{
utils::bless<atomic_t<u32>>(&values)[0].notify_one();
}
// returns non-zero value on success: queue size before removal
uint try_pop(u32& out)
{
return values.atomic_op([&](sync_var_t& data)
{
const uint result = data.count;
if (result != 0)
{
data.waiting = 0;
data.count--;
out = data.value0;
data.value0 = data.value1;
data.value1 = data.value2;
data.value2 = this->value3;
}
return result;
});
}
// Returns [previous count, value] (if aborted 0 count is returned)
std::pair<u32, u32> pop_wait(cpu_thread& spu, bool pop_value = true);
// returns current queue size without modification
uint try_read(u32 (&out)[4]) const
{
const sync_var_t data = values.load();
const uint result = data.count;
if (result != 0)
{
out[0] = data.value0;
out[1] = data.value1;
out[2] = data.value2;
out[3] = value3;
}
return result;
}
u32 get_count() const
{
return atomic_storage<u8>::load(std::as_const(values).raw().count);
}
void set_values(u32 count, u32 value0, u32 value1 = 0, u32 value2 = 0, u32 value3 = 0)
{
this->values.raw() = { 0, static_cast<u8>(count), {}, value0, value1, value2 };
this->value3 = value3;
}
};
struct spu_int_ctrl_t
{
atomic_t<u64> mask;
atomic_t<u64> stat;
std::shared_ptr<struct lv2_int_tag> tag;
void set(u64 ints);
void clear(u64 ints)
{
stat &= ~ints;
}
void clear()
{
mask.release(0);
stat.release(0);
tag.reset();
}
};
struct spu_imm_table_t
{
v128 sldq_pshufb[32]; // table for SHLQBYBI, SHLQBY, SHLQBYI instructions
v128 srdq_pshufb[32]; // table for ROTQMBYBI, ROTQMBY, ROTQMBYI instructions
v128 rldq_pshufb[16]; // table for ROTQBYBI, ROTQBY, ROTQBYI instructions
class scale_table_t
{
std::array<v128, 155 + 174> m_data;
public:
scale_table_t();
FORCE_INLINE const v128& operator [](s32 scale) const
{
return m_data[scale + 155];
}
}
const scale;
spu_imm_table_t();
};
extern const spu_imm_table_t g_spu_imm;
enum FPSCR_EX
{
//Single-precision exceptions
FPSCR_SOVF = 1 << 2, //Overflow
FPSCR_SUNF = 1 << 1, //Underflow
FPSCR_SDIFF = 1 << 0, //Different (could be IEEE non-compliant)
//Double-precision exceptions
FPSCR_DOVF = 1 << 13, //Overflow
FPSCR_DUNF = 1 << 12, //Underflow
FPSCR_DINX = 1 << 11, //Inexact
FPSCR_DINV = 1 << 10, //Invalid operation
FPSCR_DNAN = 1 << 9, //NaN
FPSCR_DDENORM = 1 << 8, //Denormal
};
//Is 128 bits, but bits 0-19, 24-28, 32-49, 56-60, 64-81, 88-92, 96-115, 120-124 are unused
class SPU_FPSCR
{
public:
u32 _u32[4]{};
SPU_FPSCR() {}
std::string ToString() const
{
return fmt::format("%08x%08x%08x%08x", _u32[3], _u32[2], _u32[1], _u32[0]);
}
void Reset()
{
memset(this, 0, sizeof(*this));
}
//slice -> 0 - 1 (double-precision slice index)
//NOTE: slices follow v128 indexing, i.e. slice 0 is RIGHT end of register!
//roundTo -> FPSCR_RN_*
void setSliceRounding(u8 slice, u8 roundTo)
{
int shift = 8 + 2*slice;
//rounding is located in the left end of the FPSCR
this->_u32[3] = (this->_u32[3] & ~(3 << shift)) | (roundTo << shift);
}
//Slice 0 or 1
u8 checkSliceRounding(u8 slice) const
{
switch(slice)
{
case 0:
return this->_u32[3] >> 8 & 0x3;
case 1:
return this->_u32[3] >> 10 & 0x3;
default:
fmt::throw_exception("Unexpected slice value (%d)", slice);
}
}
//Single-precision exception flags (all 4 slices)
//slice -> slice number (0-3)
//exception: FPSCR_S* bitmask
void setSinglePrecisionExceptionFlags(u8 slice, u32 exceptions)
{
_u32[slice] |= exceptions;
}
//Single-precision divide-by-zero flags (all 4 slices)
//slice -> slice number (0-3)
void setDivideByZeroFlag(u8 slice)
{
_u32[0] |= 1 << (8 + slice);
}
//Double-precision exception flags
//slice -> slice number (0-1)
//exception: FPSCR_D* bitmask
void setDoublePrecisionExceptionFlags(u8 slice, u32 exceptions)
{
_u32[1 + slice] |= exceptions;
}
// Write the FPSCR
void Write(const v128& r)
{
_u32[3] = r._u32[3] & 0x00000F07;
_u32[2] = r._u32[2] & 0x00003F07;
_u32[1] = r._u32[1] & 0x00003F07;
_u32[0] = r._u32[0] & 0x00000F07;
}
// Read the FPSCR
void Read(v128& r) const
{
r._u32[3] = _u32[3];
r._u32[2] = _u32[2];
r._u32[1] = _u32[1];
r._u32[0] = _u32[0];
}
};
enum class spu_type : u32
{
threaded,
raw,
isolated,
};
struct spu_memory_segment_dump_data
{
u32 ls_addr;
const u8* src_addr;
u32 segment_size;
u32 flags = umax;
};
enum class spu_debugger_mode : u32
{
_default,
is_float,
is_decimal,
max_mode,
};
enum class spu_block_hash : u64 {};
class spu_thread : public cpu_thread
{
public:
virtual void dump_regs(std::string&, std::any& custom_data) const override;
virtual std::string dump_callstack() const override;
virtual std::vector<std::pair<u32, u32>> dump_callstack_list() const override;
virtual std::string dump_misc() const override;
virtual void cpu_task() override final;
virtual void cpu_on_stop() override;
virtual void cpu_return() override;
virtual void cpu_work() override;
virtual ~spu_thread() override;
void cleanup();
void cpu_init();
static const u32 id_base = 0x02000000; // TODO (used to determine thread type)
static const u32 id_step = 1;
static const u32 id_count = (0xFFFC0000 - SPU_FAKE_BASE_ADDR) / SPU_LS_SIZE;
spu_thread(lv2_spu_group* group, u32 index, std::string_view name, u32 lv2_id, bool is_isolated = false, u32 option = 0);
spu_thread(const spu_thread&) = delete;
spu_thread& operator=(const spu_thread&) = delete;
using cpu_thread::operator=;
SAVESTATE_INIT_POS(5);
spu_thread(utils::serial& ar, lv2_spu_group* group = nullptr);
void serialize_common(utils::serial& ar);
void save(utils::serial& ar);
bool savable() const { return get_type() != spu_type::threaded; } // Threaded SPUs are saved as part of the SPU group
u32 pc = 0;
u32 dbg_step_pc = 0;
// May be used internally by recompilers.
u32 base_pc = 0;
// May be used by recompilers.
u8* memory_base_addr = vm::g_base_addr;
u8* memory_sudo_addr = vm::g_sudo_addr;
u8* reserv_base_addr = vm::g_reservations;
// General-Purpose Registers
std::array<v128, 128> gpr{};
SPU_FPSCR fpscr{};
// MFC command data
spu_mfc_cmd ch_mfc_cmd{};
// MFC command queue
spu_mfc_cmd mfc_queue[16]{};
u32 mfc_size = 0;
u32 mfc_barrier = -1;
u32 mfc_fence = -1;
// Timestamp of the first postponed command (transfers shuffling related)
u64 mfc_last_timestamp = 0;
// MFC proxy command data
spu_mfc_cmd mfc_prxy_cmd{};
shared_mutex mfc_prxy_mtx;
atomic_t<u32> mfc_prxy_mask = 0;
// Tracks writes to MFC proxy command data
union
{
u8 all;
bf_t<u8, 0, 1> lsa;
bf_t<u8, 1, 1> eal;
bf_t<u8, 2, 1> eah;
bf_t<u8, 3, 1> tag_size;
bf_t<u8, 4, 1> cmd;
} mfc_prxy_write_state{};
// Reservation Data
u64 rtime = 0;
alignas(64) std::byte rdata[128]{};
u32 raddr = 0;
const decltype(rdata)* resrv_mem{};
// Range Lock pointer
atomic_t<u64, 64>* range_lock{};
u32 srr0 = 0;
u32 ch_tag_upd = 0;
u32 ch_tag_mask = 0;
spu_channel ch_tag_stat;
u32 ch_stall_mask = 0;
spu_channel ch_stall_stat;
spu_channel ch_atomic_stat;
spu_channel_4_t ch_in_mbox{};
spu_channel ch_out_mbox;
spu_channel ch_out_intr_mbox;
u64 snr_config = 0; // SPU SNR Config Register
spu_channel ch_snr1{}; // SPU Signal Notification Register 1
spu_channel ch_snr2{}; // SPU Signal Notification Register 2
union ch_events_t
{
u64 all;
bf_t<u64, 0, 16> events;
bf_t<u64, 16, 8> locks;
bf_t<u64, 30, 1> waiting;
bf_t<u64, 31, 1> count;
bf_t<u64, 32, 32> mask;
};
atomic_t<ch_events_t> ch_events;
bool interrupts_enabled = false;
u64 ch_dec_start_timestamp = 0; // timestamp of writing decrementer value
u32 ch_dec_value = 0; // written decrementer value
bool is_dec_frozen = false;
std::pair<u32, u32> read_dec() const; // Read decrementer
atomic_t<u32> run_ctrl = 0; // SPU Run Control register (only provided to get latest data written)
shared_mutex run_ctrl_mtx;
struct alignas(8) status_npc_sync_var
{
u32 status; // SPU Status register
u32 npc; // SPU Next Program Counter register
};
atomic_t<status_npc_sync_var> status_npc{};
std::array<spu_int_ctrl_t, 3> int_ctrl{}; // SPU Class 0, 1, 2 Interrupt Management
std::array<std::pair<u32, std::shared_ptr<lv2_event_queue>>, 32> spuq{}; // Event Queue Keys for SPU Thread
std::shared_ptr<lv2_event_queue> spup[64]; // SPU Ports
spu_channel exit_status{}; // Threaded SPU exit status (not a channel, but the interface fits)
atomic_t<u32> last_exit_status; // Value to be written in exit_status after checking group termination
lv2_spu_group* const group; // SPU Thread Group (access by the spu threads in the group only! From other threads obtain a shared pointer to group using group ID)
const u32 index; // SPU index
const spu_type thread_type;
std::shared_ptr<utils::shm> shm; // SPU memory
const std::add_pointer_t<u8> ls; // SPU LS pointer
const u32 option; // sys_spu_thread_initialize option
const u32 lv2_id; // The actual id that is used by syscalls
u32 spurs_addr = 0;
bool spurs_waited = false;
bool spurs_entered_wait = false;
u64 spurs_wait_duration_last = 0;
u64 spurs_average_task_duration = 0;
u64 spurs_last_task_timestamp = 0;
static constexpr u64 spurs_task_count_to_calculate = 10;
spu_thread* next_cpu{}; // LV2 thread queues' node link
// Thread name
atomic_ptr<std::string> spu_tname;
std::unique_ptr<class spu_recompiler_base> jit; // Recompiler instance
u64 block_counter = 0;
u64 block_recover = 0;
u64 block_failure = 0;
rpcs3::hypervisor_context_t hv_ctx; // NOTE: The offset within the class must be within the first 1MiB
u64 ftx = 0; // Failed transactions
u64 stx = 0; // Succeeded transactions (pure counters)
u64 last_ftsc = 0;
u64 last_ftime = 0;
u32 last_faddr = 0;
u64 last_fail = 0;
u64 last_succ = 0;
u64 last_gtsc = 0;
u32 last_getllar = umax; // LS address of last GETLLAR (if matches current GETLLAR we can let the thread rest)
u32 last_getllar_gpr1 = umax;
u32 last_getllar_addr = umax;
u32 getllar_spin_count = 0;
u32 getllar_busy_waiting_switch = umax; // umax means the test needs evaluation, otherwise it's a boolean
u64 getllar_evaluate_time = 0;
std::vector<mfc_cmd_dump> mfc_history;
u64 mfc_dump_idx = 0;
static constexpr u32 max_mfc_dump_idx = 4096;
bool in_cpu_work = false;
bool allow_interrupts_in_cpu_work = false;
u8 cpu_work_iteration_count = 0;
std::array<v128, 0x4000> stack_mirror; // Return address information
const char* current_func{}; // Current STOP or RDCH blocking function
u64 start_time{}; // Starting time of STOP or RDCH bloking function
bool unsavable = false; // Flag indicating whether saving the spu thread state is currently unsafe
atomic_t<spu_debugger_mode> debugger_mode{};
// PC-based breakpoint list
std::array<atomic_t<u8>, SPU_LS_SIZE / 4 / 8> local_breakpoints{};
atomic_t<bool> has_active_local_bps = false;
u32 current_bp_pc = umax;
bool stop_flag_removal_protection = false;
std::array<std::array<u8, 4>, SPU_LS_SIZE / 128> getllar_wait_time{};
void push_snr(u32 number, u32 value);
static void do_dma_transfer(spu_thread* _this, const spu_mfc_cmd& args, u8* ls);
bool do_dma_check(const spu_mfc_cmd& args);
bool do_list_transfer(spu_mfc_cmd& args);
void do_putlluc(const spu_mfc_cmd& args);
bool do_putllc(const spu_mfc_cmd& args);
bool do_mfc(bool can_escape = true, bool must_finish = true);
u32 get_mfc_completed() const;
bool process_mfc_cmd();
ch_events_t get_events(u64 mask_hint = umax, bool waiting = false, bool reading = false);
void set_events(u32 bits);
void set_interrupt_status(bool enable);
bool check_mfc_interrupts(u32 next_pc);
static bool is_exec_code(u32 addr, std::span<const u8> ls_ptr, u32 base_addr = 0, bool avoid_dead_code = false); // Only a hint, do not rely on it other than debugging purposes
static std::vector<u32> discover_functions(u32 base_addr, std::span<const u8> ls, bool is_known_addr, u32 /*entry*/);
u32 get_ch_count(u32 ch);
s64 get_ch_value(u32 ch);
bool set_ch_value(u32 ch, u32 value);
bool stop_and_signal(u32 code);
void halt();
void fast_call(u32 ls_addr);
std::array<std::shared_ptr<utils::serial>, 32> rewind_captures; // shared_ptr to avoid header inclusion
u8 current_rewind_capture_idx = 0;
static spu_exec_object capture_memory_as_elf(std::span<spu_memory_segment_dump_data> segs, u32 pc_hint = umax);
bool capture_state();
bool try_load_debug_capture();
void wakeup_delay(u32 div = 1) const;
// Convert specified SPU LS address to a pointer of specified (possibly converted to BE) type
template<typename T>
to_be_t<T>* _ptr(u32 lsa) const
{
return reinterpret_cast<to_be_t<T>*>(ls + (lsa % SPU_LS_SIZE));
}
// Convert specified SPU LS address to a reference of specified (possibly converted to BE) type
template<typename T>
to_be_t<T>& _ref(u32 lsa) const
{
return *_ptr<T>(lsa);
}
spu_type get_type() const
{
return thread_type;
}
u32 vm_offset() const
{
return group ? SPU_FAKE_BASE_ADDR + SPU_LS_SIZE * (id & 0xffffff) : RAW_SPU_BASE_ADDR + RAW_SPU_OFFSET * index;
}
static u8* map_ls(utils::shm& shm, void* ptr = nullptr);
// Returns true if reservation existed but was just discovered to be lost
// It is safe to use on any address, even if not directly accessed by SPU (so it's slower)
bool reservation_check(u32 addr, const decltype(rdata)& data) const;
bool read_reg(const u32 addr, u32& value);
bool write_reg(const u32 addr, const u32 value);
static bool test_is_problem_state_register_offset(u32 offset, bool for_read, bool for_write) noexcept;
static atomic_t<u32> g_raw_spu_ctr;
static atomic_t<u32> g_raw_spu_id[5];
static atomic_t<u32> g_spu_work_count;
static u32 find_raw_spu(u32 id)
{
if (id < std::size(g_raw_spu_id)) [[likely]]
{
return g_raw_spu_id[id];
}
return -1;
}
// For named_thread ctor
const struct thread_name_t
{
const spu_thread* _this;
operator std::string() const;
} thread_name{ this };
union spu_prio_t
{
u64 all;
bf_t<s64, 0, 9> prio; // Thread priority (0..3071) (firs 9-bits)
bf_t<s64, 9, 55> order; // Thread enqueue order (TODO, last 52-bits)
};
// For lv2_obj::schedule<spu_thread>
struct priority_t
{
const spu_thread* _this;
spu_prio_t load() const;
template <typename Func>
auto atomic_op(Func&& func)
{
return static_cast<std::conditional_t<std::is_void_v<Func>, Func, decltype(_this->group)>>(_this->group)->prio.atomic_op(std::move(func));
}
} prio{ this };
};
class spu_function_logger
{
spu_thread& spu;
public:
spu_function_logger(spu_thread& spu, const char* func) noexcept;
~spu_function_logger() noexcept
{
if (!spu.is_stopped())
{
spu.start_time = 0;
}
}
};
| 25,464
|
C++
|
.h
| 789
| 29.773131
| 177
| 0.692603
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,825
|
Common.h
|
RPCS3_rpcs3/rpcs3/Emu/Cell/Common.h
|
#pragma once
#include "util/types.hpp"
// Floating-point rounding mode (for both PPU and SPU)
enum FPSCR_RN
{
FPSCR_RN_NEAR = 0,
FPSCR_RN_ZERO = 1,
FPSCR_RN_PINF = 2,
FPSCR_RN_MINF = 3,
};
// Get the exponent of a float
inline int fexpf(float x)
{
return (std::bit_cast<u32>(x) >> 23) & 0xff;
}
constexpr u32 ppu_fres_mantissas[128] =
{
0x007f0000,
0x007d0800,
0x007b1800,
0x00793000,
0x00775000,
0x00757000,
0x0073a000,
0x0071e000,
0x00700000,
0x006e4000,
0x006ca000,
0x006ae000,
0x00694000,
0x00678000,
0x00660000,
0x00646000,
0x0062c000,
0x00614000,
0x005fc000,
0x005e4000,
0x005cc000,
0x005b4000,
0x0059c000,
0x00584000,
0x00570000,
0x00558000,
0x00540000,
0x0052c000,
0x00518000,
0x00500000,
0x004ec000,
0x004d8000,
0x004c0000,
0x004b0000,
0x00498000,
0x00488000,
0x00474000,
0x00460000,
0x0044c000,
0x00438000,
0x00428000,
0x00418000,
0x00400000,
0x003f0000,
0x003e0000,
0x003d0000,
0x003bc000,
0x003ac000,
0x00398000,
0x00388000,
0x00378000,
0x00368000,
0x00358000,
0x00348000,
0x00338000,
0x00328000,
0x00318000,
0x00308000,
0x002f8000,
0x002ec000,
0x002e0000,
0x002d0000,
0x002c0000,
0x002b0000,
0x002a0000,
0x00298000,
0x00288000,
0x00278000,
0x0026c000,
0x00260000,
0x00250000,
0x00244000,
0x00238000,
0x00228000,
0x00220000,
0x00210000,
0x00200000,
0x001f8000,
0x001e8000,
0x001e0000,
0x001d0000,
0x001c8000,
0x001b8000,
0x001b0000,
0x001a0000,
0x00198000,
0x00190000,
0x00180000,
0x00178000,
0x00168000,
0x00160000,
0x00158000,
0x00148000,
0x00140000,
0x00138000,
0x00128000,
0x00120000,
0x00118000,
0x00108000,
0x00100000,
0x000f8000,
0x000f0000,
0x000e0000,
0x000d8000,
0x000d0000,
0x000c8000,
0x000b8000,
0x000b0000,
0x000a8000,
0x000a0000,
0x00098000,
0x00090000,
0x00080000,
0x00078000,
0x00070000,
0x00068000,
0x00060000,
0x00058000,
0x00050000,
0x00048000,
0x00040000,
0x00038000,
0x00030000,
0x00028000,
0x00020000,
0x00018000,
0x00010000,
0x00000000,
};
constexpr u32 ppu_frsqrte_mantissas[16] =
{
0x000f1000u, 0x000d8000u, 0x000c0000u, 0x000a8000u,
0x00098000u, 0x00088000u, 0x00080000u, 0x00070000u,
0x00060000u, 0x0004c000u, 0x0003c000u, 0x00030000u,
0x00020000u, 0x00018000u, 0x00010000u, 0x00008000u,
};
// Large lookup table for FRSQRTE instruction
inline struct ppu_frsqrte_lut_t
{
// Store only high 32 bits of doubles
u32 data[0x8000]{};
constexpr ppu_frsqrte_lut_t() noexcept
{
for (u64 i = 0; i < 0x8000; i++)
{
// Decomposed LUT index
const u64 sign = i >> 14;
const u64 expv = (i >> 3) & 0x7ff;
// (0x3FF - (((EXP_BITS(b) - 0x3FF) >> 1) + 1)) << 52
const u64 exp = 0x3fe0'0000 - (((expv + 0x1c01) >> 1) << (52 - 32));
if (expv == 0) // ±INF on zero/denormal, not accurate
{
data[i] = static_cast<u32>(0x7ff0'0000 | (sign << 31));
}
else if (expv == 0x7ff)
{
if (i == (0x7ff << 3))
data[i] = 0; // Zero on +INF, inaccurate
else
data[i] = 0x7ff8'0000; // QNaN
}
else if (sign)
{
data[i] = 0x7ff8'0000; // QNaN
}
else
{
// ((MAN_BITS(b) >> 49) & 7ull) + (!(EXP_BITS(b) & 1) << 3)
const u64 idx = 8 ^ (i & 0xf);
data[i] = static_cast<u32>(ppu_frsqrte_mantissas[idx] | exp);
}
}
}
} ppu_frqrte_lut;
| 3,277
|
C++
|
.h
| 191
| 14.863874
| 71
| 0.730819
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,826
|
PPUFunction.h
|
RPCS3_rpcs3/rpcs3/Emu/Cell/PPUFunction.h
|
#pragma once
#include "PPUThread.h"
#include "PPUInterpreter.h"
#include "util/v128.hpp"
// BIND_FUNC macro "converts" any appropriate HLE function to ppu_intrp_func_t, binding it to PPU thread context.
#define BIND_FUNC(func, ...) (static_cast<ppu_intrp_func_t>([](ppu_thread& ppu, ppu_opcode_t, be_t<u32>* this_op, ppu_intrp_func*) {\
const auto old_f = ppu.current_function;\
if (!old_f) ppu.last_function = #func;\
ppu.current_function = #func;\
ppu.cia = vm::get_addr(this_op); \
std::memcpy(ppu.syscall_args, ppu.gpr + 3, sizeof(ppu.syscall_args)); \
ppu_func_detail::do_call(ppu, func);\
static_cast<void>(ppu.test_stopped());\
auto& history = ppu.syscall_history.data[ppu.syscall_history.index++ % ppu.syscall_history.data.size()];\
history.cia = ppu.cia;\
history.func_name = ppu.current_function;\
history.error = ppu.gpr[3];\
if (ppu.syscall_history.count_debug_arguments) std::copy_n(ppu.syscall_args, std::size(history.args), history.args.data());\
ppu.current_function = old_f;\
ppu.cia += 4;\
__VA_ARGS__;\
}))
struct ppu_va_args_t
{
u32 count; // Number of 64-bit args passed
};
namespace ppu_func_detail
{
// argument type classification
enum arg_class : u32
{
ARG_GENERAL, // argument stored in gpr (from r3 to r10)
ARG_FLOAT, // argument stored in fpr (from f1 to f13)
ARG_VECTOR, // argument stored in vr (from v2 to v13)
ARG_STACK, // argument stored on the stack
ARG_CONTEXT, // ppu_thread& passed, doesn't affect g/f/v_count
ARG_VARIADIC, // argument count at specific position, doesn't affect g/f/v_count
ARG_UNKNOWN,
};
template<typename T, arg_class type, u32 g_count, u32 f_count, u32 v_count>
struct bind_arg
{
static_assert(type == ARG_GENERAL, "Unknown function argument type");
static_assert(!std::is_pointer_v<T>, "Invalid function argument type (pointer)");
static_assert(!std::is_reference_v<T>, "Invalid function argument type (reference)");
static_assert(sizeof(T) <= 8, "Invalid function argument type for ARG_GENERAL");
static inline T get_arg(ppu_thread& ppu)
{
return ppu_gpr_cast<T>(ppu.gpr[g_count + 2]);
}
};
template<typename T, u32 g_count, u32 f_count, u32 v_count>
struct bind_arg<T, ARG_FLOAT, g_count, f_count, v_count>
{
static_assert(sizeof(T) <= 8, "Invalid function argument type for ARG_FLOAT");
static inline T get_arg(ppu_thread& ppu)
{
return static_cast<T>(ppu.fpr[f_count]);
}
};
template<typename T, u32 g_count, u32 f_count, u32 v_count>
struct bind_arg<T, ARG_VECTOR, g_count, f_count, v_count>
{
static_assert(std::is_same_v<std::decay_t<T>, v128>, "Invalid function argument type for ARG_VECTOR");
static FORCE_INLINE T get_arg(ppu_thread& ppu)
{
return ppu.vr[v_count + 1];
}
};
template<typename T, u32 g_count, u32 f_count, u32 v_count>
struct bind_arg<T, ARG_STACK, g_count, f_count, v_count>
{
static_assert(alignof(T) <= 16, "Unsupported type alignment for ARG_STACK");
static FORCE_INLINE T get_arg(ppu_thread& ppu)
{
return ppu_gpr_cast<T, u64>(*ppu.get_stack_arg(g_count, alignof(T))); // TODO
}
};
template<typename T, u32 g_count, u32 f_count, u32 v_count>
struct bind_arg<T, ARG_CONTEXT, g_count, f_count, v_count>
{
static_assert(std::is_base_of_v<std::decay_t<T>, ppu_thread>, "Invalid function argument type for ARG_CONTEXT");
static FORCE_INLINE T& get_arg(ppu_thread& ppu)
{
return ppu;
}
};
template<typename T, u32 g_count, u32 f_count, u32 v_count>
struct bind_arg<T, ARG_VARIADIC, g_count, f_count, v_count>
{
static_assert(std::is_same_v<std::decay_t<T>, ppu_va_args_t>, "Invalid function argument type for ARG_VARIADIC");
static FORCE_INLINE ppu_va_args_t get_arg(ppu_thread&)
{
return {g_count};
}
};
template<typename T, arg_class type>
struct bind_result
{
static_assert(type == ARG_GENERAL, "Unknown function result type");
static_assert(sizeof(T) <= 8, "Invalid function result type for ARG_GENERAL");
static FORCE_INLINE void put_result(ppu_thread& ppu, const T& result)
{
if (ppu.state & cpu_flag::again) return;
ppu.gpr[3] = ppu_gpr_cast(result);
}
};
template<typename T>
struct bind_result<T, ARG_FLOAT>
{
static_assert(sizeof(T) <= 8, "Invalid function result type for ARG_FLOAT");
static FORCE_INLINE void put_result(ppu_thread& ppu, const T& result)
{
if (ppu.state & cpu_flag::again) return;
ppu.fpr[1] = static_cast<T>(result);
}
};
template<typename T>
struct bind_result<T, ARG_VECTOR>
{
static_assert(std::is_same_v<std::decay_t<T>, v128>, "Invalid function result type for ARG_VECTOR");
static FORCE_INLINE void put_result(ppu_thread& ppu, const T& result)
{
if (ppu.state & cpu_flag::again) return;
ppu.vr[2] = result;
}
};
// wrapper for variadic argument info list, each value contains packed argument type and counts of GENERAL, FLOAT and VECTOR arguments
template<u32... Values> struct arg_info_pack_t;
template<u32 First, u32... Values> struct arg_info_pack_t<First, Values...>
{
static const u32 last_value = arg_info_pack_t<Values...>::last_value;
};
template<u32 First> struct arg_info_pack_t<First>
{
static const u32 last_value = First;
};
template<> struct arg_info_pack_t<>
{
static const u32 last_value = 0;
};
// argument type + g/f/v_count unpacker
template<typename T, u32 type_pack> struct bind_arg_packed
{
static FORCE_INLINE T get_arg(ppu_thread& ppu)
{
return bind_arg<T, static_cast<arg_class>(type_pack & 0xff), (type_pack >> 8) & 0xff, (type_pack >> 16) & 0xff, (type_pack >> 24)>::get_arg(ppu);
}
};
template<u32... Info, typename RT, typename... Args>
FORCE_INLINE RT call(ppu_thread& ppu, RT(*func)(Args...), arg_info_pack_t<Info...>)
{
// do the actual function call when all arguments are prepared (simultaneous unpacking of Args... and Info...)
return func(bind_arg_packed<Args, Info>::get_arg(ppu)...);
}
template<typename T, typename... Types, u32... Info, typename RT, typename... Args>
FORCE_INLINE RT call(ppu_thread& ppu, RT(*func)(Args...), arg_info_pack_t<Info...> info)
{
// unpack previous type counts (0/0/0 for the first time)
const u32 g_count = (info.last_value >> 8) & 0xff;
const u32 f_count = (info.last_value >> 16) & 0xff;
const u32 v_count = (info.last_value >> 24);
// TODO: check calculations
const bool is_float = std::is_floating_point_v<T>;
const bool is_vector = std::is_same_v<std::decay_t<T>, v128>;
const bool is_context = std::is_base_of_v<std::decay_t<T>, ppu_thread>;
const bool is_variadic = std::is_same_v<std::decay_t<T>, ppu_va_args_t>;
const bool is_general = !is_float && !is_vector && !is_context && !is_variadic;
const arg_class t =
is_general ? (g_count >= 8 ? ARG_STACK : ARG_GENERAL) :
is_float ? (f_count >= 13 ? ARG_STACK : ARG_FLOAT) :
is_vector ? (v_count >= 12 ? ARG_STACK : ARG_VECTOR) :
is_context ? ARG_CONTEXT :
is_variadic ? ARG_VARIADIC :
ARG_UNKNOWN;
const u32 g = g_count + (is_general || is_float ? 1 : is_vector ? (g_count & 1) + 2 : 0);
const u32 f = f_count + is_float;
const u32 v = v_count + is_vector;
return call<Types...>(ppu, func, arg_info_pack_t<Info..., t | (g << 8) | (f << 16) | (v << 24)>{});
}
template<typename RT>
struct result_type
{
static_assert(!std::is_pointer_v<RT>, "Invalid function result type (pointer)");
static_assert(!std::is_reference_v<RT>, "Invalid function result type (reference)");
static const bool is_float = std::is_floating_point_v<RT>;
static const bool is_vector = std::is_same_v<std::decay_t<RT>, v128>;
static const arg_class value = is_float ? ARG_FLOAT : (is_vector ? ARG_VECTOR : ARG_GENERAL);
};
template<typename RT, typename... T> struct func_binder;
template<typename... T>
struct func_binder<void, T...>
{
using func_t = void(*)(T...);
static FORCE_INLINE void do_call(ppu_thread& ppu, func_t func)
{
call<T...>(ppu, func, arg_info_pack_t<>{});
}
};
template<typename RT, typename... T>
struct func_binder
{
using func_t = RT(*)(T...);
static FORCE_INLINE void do_call(ppu_thread& ppu, func_t func)
{
bind_result<RT, result_type<RT>::value>::put_result(ppu, call<T...>(ppu, func, arg_info_pack_t<>{}));
}
};
template<typename RT, typename... T>
FORCE_INLINE void do_call(ppu_thread& ppu, RT(*func)(T...))
{
func_binder<RT, T...>::do_call(ppu, func);
}
}
class ppu_function_manager
{
// Global variable for each registered function
template<typename T, T Func>
struct registered
{
static u32 index;
};
// Access global function list
static std::vector<ppu_intrp_func_t>& access(bool ghc = false);
static u32 add_function(ppu_intrp_func_t function);
public:
ppu_function_manager() = default;
ppu_function_manager(const ppu_function_manager&) = delete;
ppu_function_manager& operator=(const ppu_function_manager&) = delete;
// Register function (shall only be called during global initialization)
template<typename T, T Func>
static inline u32 register_function(ppu_intrp_func_t func)
{
return registered<T, Func>::index = add_function(func);
}
// Get function index
template<typename T, T Func>
static inline u32 get_index()
{
return registered<T, Func>::index;
}
// Read all registered functions
static inline const auto& get(bool llvm = false)
{
return access(llvm);
}
u32 func_addr(u32 index, bool is_code_addr = false) const
{
if (index >= access().size() || !addr)
{
return 0;
}
return addr + index * 8 + (is_code_addr ? 4 : 0);
}
bool is_func(u32 cia) const
{
if (cia % 4 || !addr || cia < addr)
{
return false;
}
return (cia - addr) / 8 < access().size();
}
// Allocation address
u32 addr = 0;
void save(utils::serial& ar);
ppu_function_manager(utils::serial& ar);
};
template<typename T, T Func>
u32 ppu_function_manager::registered<T, Func>::index = 0;
#define FIND_FUNC(func) ppu_function_manager::get_index<decltype(&func), &func>()
| 9,939
|
C++
|
.h
| 270
| 34.144444
| 148
| 0.688378
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,827
|
SPUAnalyser.h
|
RPCS3_rpcs3/rpcs3/Emu/Cell/SPUAnalyser.h
|
#pragma once
#include "util/types.hpp"
// SPU Instruction Type
struct spu_itype
{
static constexpr struct memory_tag{} memory{}; // Memory Load/Store Instructions
static constexpr struct constant_tag{} constant{}; // Constant Formation Instructions
static constexpr struct integer_tag{} integer{}; // Integer and Logical Instructions
static constexpr struct shiftrot_tag{} shiftrot{}; // Shift and Rotate Instructions
static constexpr struct compare_tag{} compare{}; // Compare Instructions
static constexpr struct branch_tag{} branch{}; // Branch Instructions
static constexpr struct floating_tag{} floating{}; // Floating-Point Instructions
static constexpr struct quadrop_tag{} _quadrop{}; // 4-op Instructions
static constexpr struct xfloat_tag{} xfloat{}; // Instructions producing xfloat values
static constexpr struct zregmod_tag{} zregmod{}; // Instructions not modifying any GPR
enum class type : unsigned char
{
UNK = 0,
HEQ, // zregmod_tag first
HEQI,
HGT,
HGTI,
HLGT,
HLGTI,
HBR,
HBRA,
HBRR,
STOP,
STOPD,
LNOP,
NOP,
SYNC,
DSYNC,
MTSPR,
WRCH,
STQD, // memory_tag first
STQX,
STQA,
STQR, // zregmod_tag last
LQD,
LQX,
LQA,
LQR, // memory_tag last
MFSPR,
RDCH,
RCHCNT,
BR, // branch_tag first
BRA,
BRNZ,
BRZ,
BRHNZ,
BRHZ,
BRSL,
BRASL,
IRET,
BI,
BISLED,
BISL,
BIZ,
BINZ,
BIHZ,
BIHNZ, // branch_tag last
ILH, // constant_tag_first
ILHU,
IL,
ILA,
FSMBI, // constant_tag last
AH, // integer_tag first
AHI,
A,
AI,
SFH,
SFHI,
SF,
SFI,
ADDX,
CG,
CGX,
SFX,
BG,
BGX,
MPY,
MPYU,
MPYI,
MPYUI,
MPYH,
MPYS,
MPYHH,
MPYHHA,
MPYHHU,
MPYHHAU,
CBD,
CHD,
CWD,
CDD,
CBX,
CHX,
CWX,
CDX,
CLZ,
CNTB,
FSMB,
FSMH,
FSM,
GBB,
GBH,
GB,
AVGB,
ABSDB,
SUMB,
XSBH,
XSHW,
XSWD,
AND,
ANDC,
ANDBI,
ANDHI,
ANDI,
OR,
ORC,
ORBI,
ORHI,
IOHL,
ORI,
ORX,
XOR,
XORBI,
XORHI,
XORI,
NAND,
NOR,
EQV,
MPYA, // quadrop_tag first
SELB,
SHUFB, // integer_tag last
FMA, // floating_tag first
FNMS,
FMS, // quadrop_tag last
FA,
FS,
FM,
FREST,
FRSQEST,
FI,
CSFLT,
CUFLT,
FRDS, // xfloat_tag last
DFA,
DFS,
DFM,
DFMA,
DFNMS,
DFMS,
DFNMA,
FESD,
CFLTS,
CFLTU,
FCEQ,
FCMEQ,
FCGT,
FCMGT,
FSCRWR,
FSCRRD,
DFCEQ,
DFCMEQ,
DFCGT,
DFCMGT,
DFTSV, // floating_tag last
SHLH, // shiftrot_tag first
SHLHI,
SHL,
SHLI,
SHLQBI,
SHLQBII,
SHLQBY,
SHLQBYI,
SHLQBYBI,
ROTH,
ROTHI,
ROT,
ROTI,
ROTQBY,
ROTQBYI,
ROTQBYBI,
ROTQBI,
ROTQBII,
ROTHM,
ROTHMI,
ROTM,
ROTMI,
ROTQMBY,
ROTQMBYI,
ROTQMBYBI,
ROTQMBI,
ROTQMBII,
ROTMAH,
ROTMAHI,
ROTMA,
ROTMAI, // shiftrot_tag last
CEQB, // compare_tag first
CEQBI,
CEQH,
CEQHI,
CEQ,
CEQI,
CGTB,
CGTBI,
CGTH,
CGTHI,
CGT,
CGTI,
CLGTB,
CLGTBI,
CLGTH,
CLGTHI,
CLGT,
CLGTI, // compare_tag last
};
using enum type;
// Enable address-of operator for spu_decoder<>
friend constexpr type operator &(type value)
{
return value;
}
// Test for branch instruction
friend constexpr bool operator &(type value, branch_tag)
{
return value >= BR && value <= BIHNZ;
}
// Test for floating point instruction
friend constexpr bool operator &(type value, floating_tag)
{
return value >= FMA && value <= DFTSV;
}
// Test for 4-op instruction
friend constexpr bool operator &(type value, quadrop_tag)
{
return value >= MPYA && value <= FMS;
}
// Test for xfloat instruction
friend constexpr bool operator &(type value, xfloat_tag)
{
return value >= FMA && value <= FRDS;
}
// Test for memory instruction
friend constexpr bool operator &(type value, memory_tag)
{
return value >= STQD && value <= LQR;
}
// Test for compare instruction
friend constexpr bool operator &(type value, compare_tag)
{
return value >= CEQB && value <= CLGTI;
}
// Test for integer instruction
friend constexpr bool operator &(type value, integer_tag)
{
return value >= AH && value <= SHUFB;
}
// Test for shift or rotate instruction
friend constexpr bool operator &(type value, shiftrot_tag)
{
return value >= SHLH && value <= ROTMAI;
}
// Test for constant loading instruction
friend constexpr bool operator &(type value, constant_tag)
{
return value >= ILH && value <= FSMBI;
}
// Test for non register-modifying instruction
friend constexpr bool operator &(type value, zregmod_tag)
{
return value >= HEQ && value <= STQR;
}
};
struct spu_iflag
{
enum
{
use_ra = 1 << 8,
use_rb = 1 << 9,
use_rc = 1 << 10,
};
enum flag
{
UNK = 0,
HBR,
HBRA,
HBRR,
STOP,
STOPD,
LNOP,
NOP,
SYNC,
DSYNC,
MFSPR,
MTSPR,
DFCEQ,
DFCMEQ,
DFCGT,
DFCMGT,
DFTSV,
RDCH,
RCHCNT,
LQA,
LQR,
ILH,
ILHU,
IL,
ILA,
FSMBI,
BR,
BRA,
BRSL,
BRASL,
IRET,
FSCRRD,
WRCH = use_rc,
IOHL,
STQA,
STQR,
BRNZ,
BRZ,
BRHNZ,
BRHZ,
STQD = use_ra | use_rc,
BIZ,
BINZ,
BIHZ,
BIHNZ,
STQX = use_ra | use_rb | use_rc,
ADDX,
CGX,
SFX,
BGX,
MPYHHA,
MPYHHAU,
MPYA,
SELB,
SHUFB,
DFMA,
DFNMS,
DFMS,
DFNMA,
FMA,
FNMS,
FMS,
HEQI = use_ra,
HGTI,
HLGTI,
LQD,
CBD,
CHD,
CWD,
CDD,
AHI,
AI,
SFHI,
SFI,
MPYI,
MPYUI,
CLZ,
CNTB,
FSMB,
FSMH,
FSM,
GBB,
GBH,
GB,
XSBH,
XSHW,
XSWD,
ANDBI,
ANDHI,
ANDI,
ORBI,
ORHI,
ORI,
ORX,
XORBI,
XORHI,
XORI,
SHLHI,
SHLI,
SHLQBII,
SHLQBYI,
ROTHI,
ROTI,
ROTQBYI,
ROTQBII,
ROTHMI,
ROTMI,
ROTQMBYI,
ROTQMBII,
ROTMAHI,
ROTMAI,
CEQBI,
CEQHI,
CEQI,
CGTBI,
CGTHI,
CGTI,
CLGTBI,
CLGTHI,
CLGTI,
BI,
BISLED,
BISL,
FREST,
FRSQEST,
CSFLT,
CFLTS,
CUFLT,
CFLTU,
FRDS,
FESD,
FSCRWR,
HEQ = use_ra | use_rb,
HGT,
HLGT,
LQX,
CBX,
CHX,
CWX,
CDX,
AH,
A,
SFH,
SF,
CG,
BG,
MPYHHU,
MPY,
MPYU,
MPYH,
MPYS,
MPYHH,
AVGB,
ABSDB,
SUMB,
AND,
ANDC,
OR,
ORC,
XOR,
NAND,
NOR,
EQV,
SHLH,
SHL,
SHLQBI,
SHLQBY,
SHLQBYBI,
ROTH,
ROT,
ROTQBY,
ROTQBYBI,
ROTQBI,
ROTHM,
ROTM,
ROTQMBY,
ROTQMBYBI,
ROTQMBI,
ROTMAH,
ROTMA,
CEQB,
CEQH,
CEQ,
CGTB,
CGTH,
CGT,
CLGTB,
CLGTH,
CLGT,
FA,
DFA,
FS,
DFS,
FM,
DFM,
FI,
FCEQ,
FCMEQ,
FCGT,
FCMGT,
};
// Enable address-of operator for spu_decoder<>
friend constexpr flag operator &(flag value)
{
return value;
}
};
#define NAME(x) static constexpr const char& x = *#x
struct spu_iname
{
NAME(UNK);
NAME(HEQ);
NAME(HEQI);
NAME(HGT);
NAME(HGTI);
NAME(HLGT);
NAME(HLGTI);
NAME(HBR);
NAME(HBRA);
NAME(HBRR);
NAME(STOP);
NAME(STOPD);
NAME(LNOP);
NAME(NOP);
NAME(SYNC);
NAME(DSYNC);
NAME(MFSPR);
NAME(MTSPR);
NAME(RDCH);
NAME(RCHCNT);
NAME(WRCH);
NAME(LQD);
NAME(LQX);
NAME(LQA);
NAME(LQR);
NAME(STQD);
NAME(STQX);
NAME(STQA);
NAME(STQR);
NAME(CBD);
NAME(CBX);
NAME(CHD);
NAME(CHX);
NAME(CWD);
NAME(CWX);
NAME(CDD);
NAME(CDX);
NAME(ILH);
NAME(ILHU);
NAME(IL);
NAME(ILA);
NAME(IOHL);
NAME(FSMBI);
NAME(AH);
NAME(AHI);
NAME(A);
NAME(AI);
NAME(SFH);
NAME(SFHI);
NAME(SF);
NAME(SFI);
NAME(ADDX);
NAME(CG);
NAME(CGX);
NAME(SFX);
NAME(BG);
NAME(BGX);
NAME(MPY);
NAME(MPYU);
NAME(MPYI);
NAME(MPYUI);
NAME(MPYH);
NAME(MPYS);
NAME(MPYHH);
NAME(MPYHHA);
NAME(MPYHHU);
NAME(MPYHHAU);
NAME(CLZ);
NAME(CNTB);
NAME(FSMB);
NAME(FSMH);
NAME(FSM);
NAME(GBB);
NAME(GBH);
NAME(GB);
NAME(AVGB);
NAME(ABSDB);
NAME(SUMB);
NAME(XSBH);
NAME(XSHW);
NAME(XSWD);
NAME(AND);
NAME(ANDC);
NAME(ANDBI);
NAME(ANDHI);
NAME(ANDI);
NAME(OR);
NAME(ORC);
NAME(ORBI);
NAME(ORHI);
NAME(ORI);
NAME(ORX);
NAME(XOR);
NAME(XORBI);
NAME(XORHI);
NAME(XORI);
NAME(NAND);
NAME(NOR);
NAME(EQV);
NAME(MPYA);
NAME(SELB);
NAME(SHUFB);
NAME(SHLH);
NAME(SHLHI);
NAME(SHL);
NAME(SHLI);
NAME(SHLQBI);
NAME(SHLQBII);
NAME(SHLQBY);
NAME(SHLQBYI);
NAME(SHLQBYBI);
NAME(ROTH);
NAME(ROTHI);
NAME(ROT);
NAME(ROTI);
NAME(ROTQBY);
NAME(ROTQBYI);
NAME(ROTQBYBI);
NAME(ROTQBI);
NAME(ROTQBII);
NAME(ROTHM);
NAME(ROTHMI);
NAME(ROTM);
NAME(ROTMI);
NAME(ROTQMBY);
NAME(ROTQMBYI);
NAME(ROTQMBYBI);
NAME(ROTQMBI);
NAME(ROTQMBII);
NAME(ROTMAH);
NAME(ROTMAHI);
NAME(ROTMA);
NAME(ROTMAI);
NAME(CEQB);
NAME(CEQBI);
NAME(CEQH);
NAME(CEQHI);
NAME(CEQ);
NAME(CEQI);
NAME(CGTB);
NAME(CGTBI);
NAME(CGTH);
NAME(CGTHI);
NAME(CGT);
NAME(CGTI);
NAME(CLGTB);
NAME(CLGTBI);
NAME(CLGTH);
NAME(CLGTHI);
NAME(CLGT);
NAME(CLGTI);
NAME(BR);
NAME(BRA);
NAME(BRSL);
NAME(BRASL);
NAME(BI);
NAME(IRET);
NAME(BISLED);
NAME(BISL);
NAME(BRNZ);
NAME(BRZ);
NAME(BRHNZ);
NAME(BRHZ);
NAME(BIZ);
NAME(BINZ);
NAME(BIHZ);
NAME(BIHNZ);
NAME(FA);
NAME(DFA);
NAME(FS);
NAME(DFS);
NAME(FM);
NAME(DFM);
NAME(DFMA);
NAME(DFNMS);
NAME(DFMS);
NAME(DFNMA);
NAME(FREST);
NAME(FRSQEST);
NAME(FI);
NAME(CSFLT);
NAME(CFLTS);
NAME(CUFLT);
NAME(CFLTU);
NAME(FRDS);
NAME(FESD);
NAME(FCEQ);
NAME(FCMEQ);
NAME(FCGT);
NAME(FCMGT);
NAME(FSCRWR);
NAME(FSCRRD);
NAME(DFCEQ);
NAME(DFCMEQ);
NAME(DFCGT);
NAME(DFCMGT);
NAME(DFTSV);
NAME(FMA);
NAME(FNMS);
NAME(FMS);
};
#undef NAME
| 9,261
|
C++
|
.h
| 697
| 10.651363
| 87
| 0.660526
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,828
|
SPUOpcodes.h
|
RPCS3_rpcs3/rpcs3/Emu/Cell/SPUOpcodes.h
|
#pragma once
#include "Utilities/BitField.h"
union spu_opcode_t
{
u32 opcode;
bf_t<u32, 0, 7> rt; // 25..31, for 3-op instructions
bf_t<u32, 0, 7> rc; // 25..31
bf_t<u32, 7, 7> ra; // 18..24
bf_t<u32, 14, 7> rb; // 11..17
bf_t<u32, 21, 7> rt4; // 4..10, for 4-op instructions
bf_t<u32, 18, 1> e; // 13, "enable interrupts" bit
bf_t<u32, 19, 1> d; // 12, "disable interrupts" bit
bf_t<u32, 18, 2> de; // 12..13 combined 'e' and 'd' bits
bf_t<u32, 20, 1> c; // 11, "C" bit for SYNC instruction
bf_t<s32, 23, 2> r0h; // 7..8, signed
bf_t<s32, 14, 2> roh; // 16..17, signed
bf_t<u32, 14, 7> i7; // 11..17
bf_t<s32, 14, 7> si7; // 11..17, signed
bf_t<u32, 14, 8> i8; // 10..17
bf_t<s32, 14, 10> si10; // 8..17, signed
bf_t<u32, 7, 16> i16; // 9..24
bf_t<s32, 7, 16> si16; // 9..24, signed
bf_t<u32, 7, 18> i18; // 7..24
};
constexpr u32 spu_branch_target(u32 pc, u32 imm = 0)
{
return (pc + (imm << 2)) & 0x3fffc;
}
constexpr u32 spu_ls_target(u32 pc, u32 imm = 0)
{
return (pc + (imm << 2)) & 0x3fff0;
}
constexpr u32 spu_decode(u32 inst)
{
return inst >> 21;
}
std::array<u32, 2> op_branch_targets(u32 pc, spu_opcode_t op);
// SPU decoder object. D provides functions. T is function pointer type returned.
template <typename D, typename T = decltype(&D::UNK)>
class spu_decoder
{
// Fast lookup table
std::array<T, 2048> m_table{};
struct instruction_info
{
u32 magn; // Count = 2 ^ magn
u32 value;
T pointer;
instruction_info(u32 m, u32 v, T p) noexcept
: magn(m)
, value(v)
, pointer(p)
{
}
instruction_info(u32 m, u32 v, const T* p) noexcept
: magn(m)
, value(v)
, pointer(*p)
{
}
};
// Helper
static const D& _first(const D& arg)
{
return arg;
}
public:
template <typename... Args>
spu_decoder(const Args&... args) noexcept
{
// If an object is passed to the constructor, assign values from that object
#define GET(name) [&]{ if constexpr (sizeof...(Args) > 0) return _first(args...).name; else return &D::name; }()
static_assert(sizeof...(Args) <= 1);
const std::initializer_list<instruction_info> instructions
{
{ 0, 0x0, GET(STOP) },
{ 0, 0x1, GET(LNOP) },
{ 0, 0x2, GET(SYNC) },
{ 0, 0x3, GET(DSYNC) },
{ 0, 0xc, GET(MFSPR) },
{ 0, 0xd, GET(RDCH) },
{ 0, 0xf, GET(RCHCNT) },
{ 0, 0x40, GET(SF) },
{ 0, 0x41, GET(OR) },
{ 0, 0x42, GET(BG) },
{ 0, 0x48, GET(SFH) },
{ 0, 0x49, GET(NOR) },
{ 0, 0x53, GET(ABSDB) },
{ 0, 0x58, GET(ROT) },
{ 0, 0x59, GET(ROTM) },
{ 0, 0x5a, GET(ROTMA) },
{ 0, 0x5b, GET(SHL) },
{ 0, 0x5c, GET(ROTH) },
{ 0, 0x5d, GET(ROTHM) },
{ 0, 0x5e, GET(ROTMAH) },
{ 0, 0x5f, GET(SHLH) },
{ 0, 0x78, GET(ROTI) },
{ 0, 0x79, GET(ROTMI) },
{ 0, 0x7a, GET(ROTMAI) },
{ 0, 0x7b, GET(SHLI) },
{ 0, 0x7c, GET(ROTHI) },
{ 0, 0x7d, GET(ROTHMI) },
{ 0, 0x7e, GET(ROTMAHI) },
{ 0, 0x7f, GET(SHLHI) },
{ 0, 0xc0, GET(A) },
{ 0, 0xc1, GET(AND) },
{ 0, 0xc2, GET(CG) },
{ 0, 0xc8, GET(AH) },
{ 0, 0xc9, GET(NAND) },
{ 0, 0xd3, GET(AVGB) },
{ 0, 0x10c, GET(MTSPR) },
{ 0, 0x10d, GET(WRCH) },
{ 0, 0x128, GET(BIZ) },
{ 0, 0x129, GET(BINZ) },
{ 0, 0x12a, GET(BIHZ) },
{ 0, 0x12b, GET(BIHNZ) },
{ 0, 0x140, GET(STOPD) },
{ 0, 0x144, GET(STQX) },
{ 0, 0x1a8, GET(BI) },
{ 0, 0x1a9, GET(BISL) },
{ 0, 0x1aa, GET(IRET) },
{ 0, 0x1ab, GET(BISLED) },
{ 0, 0x1ac, GET(HBR) },
{ 0, 0x1b0, GET(GB) },
{ 0, 0x1b1, GET(GBH) },
{ 0, 0x1b2, GET(GBB) },
{ 0, 0x1b4, GET(FSM) },
{ 0, 0x1b5, GET(FSMH) },
{ 0, 0x1b6, GET(FSMB) },
{ 0, 0x1b8, GET(FREST) },
{ 0, 0x1b9, GET(FRSQEST) },
{ 0, 0x1c4, GET(LQX) },
{ 0, 0x1cc, GET(ROTQBYBI) },
{ 0, 0x1cd, GET(ROTQMBYBI) },
{ 0, 0x1cf, GET(SHLQBYBI) },
{ 0, 0x1d4, GET(CBX) },
{ 0, 0x1d5, GET(CHX) },
{ 0, 0x1d6, GET(CWX) },
{ 0, 0x1d7, GET(CDX) },
{ 0, 0x1d8, GET(ROTQBI) },
{ 0, 0x1d9, GET(ROTQMBI) },
{ 0, 0x1db, GET(SHLQBI) },
{ 0, 0x1dc, GET(ROTQBY) },
{ 0, 0x1dd, GET(ROTQMBY) },
{ 0, 0x1df, GET(SHLQBY) },
{ 0, 0x1f0, GET(ORX) },
{ 0, 0x1f4, GET(CBD) },
{ 0, 0x1f5, GET(CHD) },
{ 0, 0x1f6, GET(CWD) },
{ 0, 0x1f7, GET(CDD) },
{ 0, 0x1f8, GET(ROTQBII) },
{ 0, 0x1f9, GET(ROTQMBII) },
{ 0, 0x1fb, GET(SHLQBII) },
{ 0, 0x1fc, GET(ROTQBYI) },
{ 0, 0x1fd, GET(ROTQMBYI) },
{ 0, 0x1ff, GET(SHLQBYI) },
{ 0, 0x201, GET(NOP) },
{ 0, 0x240, GET(CGT) },
{ 0, 0x241, GET(XOR) },
{ 0, 0x248, GET(CGTH) },
{ 0, 0x249, GET(EQV) },
{ 0, 0x250, GET(CGTB) },
{ 0, 0x253, GET(SUMB) },
{ 0, 0x258, GET(HGT) },
{ 0, 0x2a5, GET(CLZ) },
{ 0, 0x2a6, GET(XSWD) },
{ 0, 0x2ae, GET(XSHW) },
{ 0, 0x2b4, GET(CNTB) },
{ 0, 0x2b6, GET(XSBH) },
{ 0, 0x2c0, GET(CLGT) },
{ 0, 0x2c1, GET(ANDC) },
{ 0, 0x2c2, GET(FCGT) },
{ 0, 0x2c3, GET(DFCGT) },
{ 0, 0x2c4, GET(FA) },
{ 0, 0x2c5, GET(FS) },
{ 0, 0x2c6, GET(FM) },
{ 0, 0x2c8, GET(CLGTH) },
{ 0, 0x2c9, GET(ORC) },
{ 0, 0x2ca, GET(FCMGT) },
{ 0, 0x2cb, GET(DFCMGT) },
{ 0, 0x2cc, GET(DFA) },
{ 0, 0x2cd, GET(DFS) },
{ 0, 0x2ce, GET(DFM) },
{ 0, 0x2d0, GET(CLGTB) },
{ 0, 0x2d8, GET(HLGT) },
{ 0, 0x35c, GET(DFMA) },
{ 0, 0x35d, GET(DFMS) },
{ 0, 0x35e, GET(DFNMS) },
{ 0, 0x35f, GET(DFNMA) },
{ 0, 0x3c0, GET(CEQ) },
{ 0, 0x3ce, GET(MPYHHU) },
{ 0, 0x340, GET(ADDX) },
{ 0, 0x341, GET(SFX) },
{ 0, 0x342, GET(CGX) },
{ 0, 0x343, GET(BGX) },
{ 0, 0x346, GET(MPYHHA) },
{ 0, 0x34e, GET(MPYHHAU) },
{ 0, 0x398, GET(FSCRRD) },
{ 0, 0x3b8, GET(FESD) },
{ 0, 0x3b9, GET(FRDS) },
{ 0, 0x3ba, GET(FSCRWR) },
{ 0, 0x3bf, GET(DFTSV) },
{ 0, 0x3c2, GET(FCEQ) },
{ 0, 0x3c3, GET(DFCEQ) },
{ 0, 0x3c4, GET(MPY) },
{ 0, 0x3c5, GET(MPYH) },
{ 0, 0x3c6, GET(MPYHH) },
{ 0, 0x3c7, GET(MPYS) },
{ 0, 0x3c8, GET(CEQH) },
{ 0, 0x3ca, GET(FCMEQ) },
{ 0, 0x3cb, GET(DFCMEQ) },
{ 0, 0x3cc, GET(MPYU) },
{ 0, 0x3d0, GET(CEQB) },
{ 0, 0x3d4, GET(FI) },
{ 0, 0x3d8, GET(HEQ) },
{ 1, 0x1d8, GET(CFLTS) },
{ 1, 0x1d9, GET(CFLTU) },
{ 1, 0x1da, GET(CSFLT) },
{ 1, 0x1db, GET(CUFLT) },
{ 2, 0x40, GET(BRZ) },
{ 2, 0x41, GET(STQA) },
{ 2, 0x42, GET(BRNZ) },
{ 2, 0x44, GET(BRHZ) },
{ 2, 0x46, GET(BRHNZ) },
{ 2, 0x47, GET(STQR) },
{ 2, 0x60, GET(BRA) },
{ 2, 0x61, GET(LQA) },
{ 2, 0x62, GET(BRASL) },
{ 2, 0x64, GET(BR) },
{ 2, 0x65, GET(FSMBI) },
{ 2, 0x66, GET(BRSL) },
{ 2, 0x67, GET(LQR) },
{ 2, 0x81, GET(IL) },
{ 2, 0x82, GET(ILHU) },
{ 2, 0x83, GET(ILH) },
{ 2, 0xc1, GET(IOHL) },
{ 3, 0x4, GET(ORI) },
{ 3, 0x5, GET(ORHI) },
{ 3, 0x6, GET(ORBI) },
{ 3, 0xc, GET(SFI) },
{ 3, 0xd, GET(SFHI) },
{ 3, 0x14, GET(ANDI) },
{ 3, 0x15, GET(ANDHI) },
{ 3, 0x16, GET(ANDBI) },
{ 3, 0x1c, GET(AI) },
{ 3, 0x1d, GET(AHI) },
{ 3, 0x24, GET(STQD) },
{ 3, 0x34, GET(LQD) },
{ 3, 0x44, GET(XORI) },
{ 3, 0x45, GET(XORHI) },
{ 3, 0x46, GET(XORBI) },
{ 3, 0x4c, GET(CGTI) },
{ 3, 0x4d, GET(CGTHI) },
{ 3, 0x4e, GET(CGTBI) },
{ 3, 0x4f, GET(HGTI) },
{ 3, 0x5c, GET(CLGTI) },
{ 3, 0x5d, GET(CLGTHI) },
{ 3, 0x5e, GET(CLGTBI) },
{ 3, 0x5f, GET(HLGTI) },
{ 3, 0x74, GET(MPYI) },
{ 3, 0x75, GET(MPYUI) },
{ 3, 0x7c, GET(CEQI) },
{ 3, 0x7d, GET(CEQHI) },
{ 3, 0x7e, GET(CEQBI) },
{ 3, 0x7f, GET(HEQI) },
{ 4, 0x8, GET(HBRA) },
{ 4, 0x9, GET(HBRR) },
{ 4, 0x21, GET(ILA) },
{ 7, 0x8, GET(SELB) },
{ 7, 0xb, GET(SHUFB) },
{ 7, 0xc, GET(MPYA) },
{ 7, 0xd, GET(FNMS) },
{ 7, 0xe, GET(FMA) },
{ 7, 0xf, GET(FMS) },
};
for (auto& x : m_table)
{
x = GET(UNK);
}
for (auto& entry : instructions)
{
for (u32 i = 0; i < 1u << entry.magn; i++)
{
m_table[entry.value << entry.magn | i] = entry.pointer;
}
}
}
const std::array<T, 2048>& get_table() const noexcept
{
return m_table;
}
T decode(u32 inst) const noexcept
{
return m_table[spu_decode(inst)];
}
};
#undef GET
| 8,009
|
C++
|
.h
| 297
| 23.481481
| 112
| 0.521451
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,829
|
PPUAnalyser.h
|
RPCS3_rpcs3/rpcs3/Emu/Cell/PPUAnalyser.h
|
#pragma once
#include <string>
#include <map>
#include <set>
#include <deque>
#include "util/types.hpp"
#include "util/endian.hpp"
#include "util/asm.hpp"
#include "util/to_endian.hpp"
#include "Utilities/bit_set.h"
#include "PPUOpcodes.h"
// PPU Function Attributes
enum class ppu_attr : u32
{
known_addr,
known_size,
no_return,
no_size,
has_mfvscr,
__bitset_enum_max
};
// PPU Function Information
struct ppu_function
{
u32 addr = 0;
u32 toc = 0;
u32 size = 0;
bs_t<ppu_attr> attr{};
u32 stack_frame = 0;
u32 trampoline = 0;
std::map<u32, u32> blocks{}; // Basic blocks: addr -> size
std::set<u32> calls{}; // Set of called functions
std::set<u32> callers{};
std::string name{}; // Function name
};
// PPU Relocation Information
struct ppu_reloc
{
u32 addr;
u32 type;
u64 data;
// Operator for sorting
bool operator <(const ppu_reloc& rhs) const
{
return addr < rhs.addr;
}
bool operator <(u32 rhs) const
{
return addr < rhs;
}
};
// PPU Segment Information
struct ppu_segment
{
u32 addr;
u32 size;
u32 type;
u32 flags;
u32 filesz;
void* ptr{};
};
// PPU Module Information
struct ppu_module
{
ppu_module() noexcept = default;
ppu_module(const ppu_module&) = delete;
ppu_module(ppu_module&&) noexcept = default;
ppu_module& operator=(const ppu_module&) = delete;
ppu_module& operator=(ppu_module&&) noexcept = default;
uchar sha1[20]{};
std::string name{};
std::string path{};
s64 offset = 0; // Offset of file
std::string cache{};
std::vector<ppu_reloc> relocs{};
std::vector<ppu_segment> segs{};
std::vector<ppu_segment> secs{};
std::vector<ppu_function> funcs{};
std::deque<std::shared_ptr<void>> allocations;
std::map<u32, u32> addr_to_seg_index;
// Copy info without functions
void copy_part(const ppu_module& info)
{
std::memcpy(sha1, info.sha1, sizeof(sha1));
name = info.name;
path = info.path;
relocs = info.relocs;
segs = info.segs;
secs = info.secs;
allocations = info.allocations;
addr_to_seg_index = info.addr_to_seg_index;
}
bool analyse(u32 lib_toc, u32 entry, u32 end, const std::vector<u32>& applied, const std::vector<u32>& exported_funcs = std::vector<u32>{}, std::function<bool()> check_aborted = {});
void validate(u32 reloc);
template <typename T>
to_be_t<T>* get_ptr(u32 addr, u32 size_bytes) const
{
auto it = addr_to_seg_index.upper_bound(addr);
if (it == addr_to_seg_index.begin())
{
return nullptr;
}
it--;
const auto& seg = segs[it->second];
const u32 seg_size = seg.size;
const u32 seg_addr = seg.addr;
if (seg_size >= std::max<usz>(size_bytes, 1) && addr <= utils::align<u32>(seg_addr + seg_size, 0x10000) - size_bytes)
{
return reinterpret_cast<to_be_t<T>*>(static_cast<u8*>(seg.ptr) + (addr - seg_addr));
}
return nullptr;
}
template <typename T>
to_be_t<T>* get_ptr(u32 addr) const
{
constexpr usz size_element = std::is_void_v<T> ? 0 : sizeof(std::conditional_t<std::is_void_v<T>, char, T>);
return get_ptr<T>(addr, u32{size_element});
}
template <typename T, typename U> requires requires (const U& obj) { obj.get_ptr(); }
to_be_t<T>* get_ptr(U&& addr) const
{
constexpr usz size_element = std::is_void_v<T> ? 0 : sizeof(std::conditional_t<std::is_void_v<T>, char, T>);
return get_ptr<T>(addr.addr(), u32{size_element});
}
template <typename T>
to_be_t<T>& get_ref(u32 addr, std::source_location src_loc = std::source_location::current()) const
{
constexpr usz size_element = std::is_void_v<T> ? 0 : sizeof(std::conditional_t<std::is_void_v<T>, char, T>);
if (auto ptr = get_ptr<T>(addr, u32{size_element}))
{
return *ptr;
}
fmt::throw_exception("get_ref(): Failure! (addr=0x%x)%s", addr, src_loc);
return *std::add_pointer_t<to_be_t<T>>{};
}
template <typename T, typename U> requires requires (const U& obj) { obj.get_ptr(); }
to_be_t<T>& get_ref(U&& addr, u32 index = 0, std::source_location src_loc = std::source_location::current()) const
{
constexpr usz size_element = std::is_void_v<T> ? 0 : sizeof(std::conditional_t<std::is_void_v<T>, char, T>);
if (auto ptr = get_ptr<T>((addr + index).addr(), u32{size_element}))
{
return *ptr;
}
fmt::throw_exception("get_ref(): Failure! (addr=0x%x)%s", (addr + index).addr(), src_loc);
return *std::add_pointer_t<to_be_t<T>>{};
}
};
struct main_ppu_module : public ppu_module
{
u32 elf_entry{};
u32 seg0_code_end{};
std::vector<u32> applied_patches;
};
// Aux
struct ppu_pattern
{
be_t<u32> opcode;
be_t<u32> mask;
ppu_pattern() = default;
ppu_pattern(u32 op)
: opcode(op)
, mask(0xffffffff)
{
}
ppu_pattern(u32 op, u32 ign)
: opcode(op & ~ign)
, mask(~ign)
{
}
};
struct ppu_pattern_array
{
const ppu_pattern* ptr;
usz count;
template <usz N>
constexpr ppu_pattern_array(const ppu_pattern(&array)[N])
: ptr(array)
, count(N)
{
}
constexpr const ppu_pattern* begin() const
{
return ptr;
}
constexpr const ppu_pattern* end() const
{
return ptr + count;
}
};
struct ppu_pattern_matrix
{
const ppu_pattern_array* ptr;
usz count;
template <usz N>
constexpr ppu_pattern_matrix(const ppu_pattern_array(&array)[N])
: ptr(array)
, count(N)
{
}
constexpr const ppu_pattern_array* begin() const
{
return ptr;
}
constexpr const ppu_pattern_array* end() const
{
return ptr + count;
}
};
// PPU Instruction Type
struct ppu_itype
{
static constexpr struct branch_tag{} branch{}; // Branch Instructions
static constexpr struct trap_tag{} trap{}; // Branch Instructions
enum class type
{
UNK = 0,
MFVSCR,
MTVSCR,
VADDCUW,
VADDFP,
VADDSBS,
VADDSHS,
VADDSWS,
VADDUBM,
VADDUBS,
VADDUHM,
VADDUHS,
VADDUWM,
VADDUWS,
VAND,
VANDC,
VAVGSB,
VAVGSH,
VAVGSW,
VAVGUB,
VAVGUH,
VAVGUW,
VCFSX,
VCFUX,
VCMPBFP,
VCMPBFP_,
VCMPEQFP,
VCMPEQFP_,
VCMPEQUB,
VCMPEQUB_,
VCMPEQUH,
VCMPEQUH_,
VCMPEQUW,
VCMPEQUW_,
VCMPGEFP,
VCMPGEFP_,
VCMPGTFP,
VCMPGTFP_,
VCMPGTSB,
VCMPGTSB_,
VCMPGTSH,
VCMPGTSH_,
VCMPGTSW,
VCMPGTSW_,
VCMPGTUB,
VCMPGTUB_,
VCMPGTUH,
VCMPGTUH_,
VCMPGTUW,
VCMPGTUW_,
VCTSXS,
VCTUXS,
VEXPTEFP,
VLOGEFP,
VMADDFP,
VMAXFP,
VMAXSB,
VMAXSH,
VMAXSW,
VMAXUB,
VMAXUH,
VMAXUW,
VMHADDSHS,
VMHRADDSHS,
VMINFP,
VMINSB,
VMINSH,
VMINSW,
VMINUB,
VMINUH,
VMINUW,
VMLADDUHM,
VMRGHB,
VMRGHH,
VMRGHW,
VMRGLB,
VMRGLH,
VMRGLW,
VMSUMMBM,
VMSUMSHM,
VMSUMSHS,
VMSUMUBM,
VMSUMUHM,
VMSUMUHS,
VMULESB,
VMULESH,
VMULEUB,
VMULEUH,
VMULOSB,
VMULOSH,
VMULOUB,
VMULOUH,
VNMSUBFP,
VNOR,
VOR,
VPERM,
VPKPX,
VPKSHSS,
VPKSHUS,
VPKSWSS,
VPKSWUS,
VPKUHUM,
VPKUHUS,
VPKUWUM,
VPKUWUS,
VREFP,
VRFIM,
VRFIN,
VRFIP,
VRFIZ,
VRLB,
VRLH,
VRLW,
VRSQRTEFP,
VSEL,
VSL,
VSLB,
VSLDOI,
VSLH,
VSLO,
VSLW,
VSPLTB,
VSPLTH,
VSPLTISB,
VSPLTISH,
VSPLTISW,
VSPLTW,
VSR,
VSRAB,
VSRAH,
VSRAW,
VSRB,
VSRH,
VSRO,
VSRW,
VSUBCUW,
VSUBFP,
VSUBSBS,
VSUBSHS,
VSUBSWS,
VSUBUBM,
VSUBUBS,
VSUBUHM,
VSUBUHS,
VSUBUWM,
VSUBUWS,
VSUMSWS,
VSUM2SWS,
VSUM4SBS,
VSUM4SHS,
VSUM4UBS,
VUPKHPX,
VUPKHSB,
VUPKHSH,
VUPKLPX,
VUPKLSB,
VUPKLSH,
VXOR,
MULLI,
SUBFIC,
CMPLI,
CMPI,
ADDIC,
ADDI,
ADDIS,
SC,
MCRF,
CRNOR,
CRANDC,
ISYNC,
CRXOR,
CRNAND,
CRAND,
CREQV,
CRORC,
CROR,
RLWIMI,
RLWINM,
RLWNM,
ORI,
ORIS,
XORI,
XORIS,
ANDI,
ANDIS,
RLDICL,
RLDICR,
RLDIC,
RLDIMI,
RLDCL,
RLDCR,
CMP,
LVSL,
LVEBX,
SUBFC,
SUBFCO,
ADDC,
ADDCO,
MULHDU,
MULHWU,
MFOCRF,
LWARX,
LDX,
LWZX,
SLW,
CNTLZW,
SLD,
AND,
CMPL,
LVSR,
LVEHX,
SUBF,
SUBFO,
LDUX,
DCBST,
LWZUX,
CNTLZD,
ANDC,
LVEWX,
MULHD,
MULHW,
LDARX,
DCBF,
LBZX,
LVX,
NEG,
NEGO,
LBZUX,
NOR,
STVEBX,
SUBFE,
SUBFEO,
ADDE,
ADDEO,
MTOCRF,
STDX,
STWCX,
STWX,
STVEHX,
STDUX,
STWUX,
STVEWX,
SUBFZE,
SUBFZEO,
ADDZE,
ADDZEO,
STDCX,
STBX,
STVX,
SUBFME,
SUBFMEO,
MULLD,
MULLDO,
ADDME,
ADDMEO,
MULLW,
MULLWO,
DCBTST,
STBUX,
ADD,
ADDO,
DCBT,
LHZX,
EQV,
ECIWX,
LHZUX,
XOR,
MFSPR,
LWAX,
DST,
LHAX,
LVXL,
MFTB,
LWAUX,
DSTST,
LHAUX,
STHX,
ORC,
ECOWX,
STHUX,
OR,
DIVDU,
DIVDUO,
DIVWU,
DIVWUO,
MTSPR,
DCBI,
NAND,
STVXL,
DIVD,
DIVDO,
DIVW,
DIVWO,
LVLX,
LDBRX,
LSWX,
LWBRX,
LFSX,
SRW,
SRD,
LVRX,
LSWI,
LFSUX,
SYNC,
LFDX,
LFDUX,
STVLX,
STDBRX,
STSWX,
STWBRX,
STFSX,
STVRX,
STFSUX,
STSWI,
STFDX,
STFDUX,
LVLXL,
LHBRX,
SRAW,
SRAD,
LVRXL,
DSS,
SRAWI,
SRADI,
EIEIO,
STVLXL,
STHBRX,
EXTSH,
STVRXL,
EXTSB,
STFIWX,
EXTSW,
ICBI,
DCBZ,
LWZ,
LWZU,
LBZ,
LBZU,
STW,
STWU,
STB,
STBU,
LHZ,
LHZU,
LHA,
LHAU,
STH,
STHU,
LMW,
STMW,
LFS,
LFSU,
LFD,
LFDU,
STFS,
STFSU,
STFD,
STFDU,
LD,
LDU,
LWA,
STD,
STDU,
FDIVS,
FSUBS,
FADDS,
FSQRTS,
FRES,
FMULS,
FMADDS,
FMSUBS,
FNMSUBS,
FNMADDS,
MTFSB1,
MCRFS,
MTFSB0,
MTFSFI,
MFFS,
MTFSF,
FCMPU,
FRSP,
FCTIW,
FCTIWZ,
FDIV,
FSUB,
FADD,
FSQRT,
FSEL,
FMUL,
FRSQRTE,
FMSUB,
FMADD,
FNMSUB,
FNMADD,
FCMPO,
FNEG,
FMR,
FNABS,
FABS,
FCTID,
FCTIDZ,
FCFID,
SUBFCO_,
ADDCO_,
SUBFO_,
NEGO_,
SUBFEO_,
ADDEO_,
SUBFZEO_,
ADDZEO_,
SUBFMEO_,
MULLDO_,
ADDMEO_,
MULLWO_,
ADDO_,
DIVDUO_,
DIVWUO_,
DIVDO_,
DIVWO_,
RLWIMI_,
RLWINM_,
RLWNM_,
RLDICL_,
RLDICR_,
RLDIC_,
RLDIMI_,
RLDCL_,
RLDCR_,
SUBFC_,
MULHDU_,
ADDC_,
MULHWU_,
SLW_,
CNTLZW_,
SLD_,
AND_,
SUBF_,
CNTLZD_,
ANDC_,
MULHD_,
MULHW_,
NEG_,
NOR_,
SUBFE_,
ADDE_,
SUBFZE_,
ADDZE_,
MULLD_,
SUBFME_,
ADDME_,
MULLW_,
ADD_,
EQV_,
XOR_,
ORC_,
OR_,
DIVDU_,
DIVWU_,
NAND_,
DIVD_,
DIVW_,
SRW_,
SRD_,
SRAW_,
SRAD_,
SRAWI_,
SRADI_,
EXTSH_,
EXTSB_,
EXTSW_,
FDIVS_,
FSUBS_,
FADDS_,
FSQRTS_,
FRES_,
FMULS_,
FMADDS_,
FMSUBS_,
FNMSUBS_,
FNMADDS_,
MTFSB1_,
MTFSB0_,
MTFSFI_,
MFFS_,
MTFSF_,
FRSP_,
FCTIW_,
FCTIWZ_,
FDIV_,
FSUB_,
FADD_,
FSQRT_,
FSEL_,
FMUL_,
FRSQRTE_,
FMSUB_,
FMADD_,
FNMSUB_,
FNMADD_,
FNEG_,
FMR_,
FNABS_,
FABS_,
FCTID_,
FCTIDZ_,
FCFID_,
B, // branch_tag first
BC,
BCLR,
BCCTR, // branch_tag last
TD, // trap_tag first
TW,
TDI,
TWI, // trap_tag last
};
using enum type;
// Enable address-of operator for ppu_decoder<>
friend constexpr type operator &(type value)
{
return value;
}
friend constexpr bool operator &(type value, branch_tag)
{
return value >= B && value <= BCCTR;
}
friend constexpr bool operator &(type value, trap_tag)
{
return value >= TD && value <= TWI;
}
};
struct ppu_iname
{
#define NAME(x) static constexpr const char& x = *#x;
#define NAME_(x) static constexpr const char& x##_ = *#x ".";
NAME(UNK)
NAME(MFVSCR)
NAME(MTVSCR)
NAME(VADDCUW)
NAME(VADDFP)
NAME(VADDSBS)
NAME(VADDSHS)
NAME(VADDSWS)
NAME(VADDUBM)
NAME(VADDUBS)
NAME(VADDUHM)
NAME(VADDUHS)
NAME(VADDUWM)
NAME(VADDUWS)
NAME(VAND)
NAME(VANDC)
NAME(VAVGSB)
NAME(VAVGSH)
NAME(VAVGSW)
NAME(VAVGUB)
NAME(VAVGUH)
NAME(VAVGUW)
NAME(VCFSX)
NAME(VCFUX)
NAME(VCMPBFP)
NAME_(VCMPBFP)
NAME(VCMPEQFP)
NAME_(VCMPEQFP)
NAME(VCMPEQUB)
NAME_(VCMPEQUB)
NAME(VCMPEQUH)
NAME_(VCMPEQUH)
NAME(VCMPEQUW)
NAME_(VCMPEQUW)
NAME(VCMPGEFP)
NAME_(VCMPGEFP)
NAME(VCMPGTFP)
NAME_(VCMPGTFP)
NAME(VCMPGTSB)
NAME_(VCMPGTSB)
NAME(VCMPGTSH)
NAME_(VCMPGTSH)
NAME(VCMPGTSW)
NAME_(VCMPGTSW)
NAME(VCMPGTUB)
NAME_(VCMPGTUB)
NAME(VCMPGTUH)
NAME_(VCMPGTUH)
NAME(VCMPGTUW)
NAME_(VCMPGTUW)
NAME(VCTSXS)
NAME(VCTUXS)
NAME(VEXPTEFP)
NAME(VLOGEFP)
NAME(VMADDFP)
NAME(VMAXFP)
NAME(VMAXSB)
NAME(VMAXSH)
NAME(VMAXSW)
NAME(VMAXUB)
NAME(VMAXUH)
NAME(VMAXUW)
NAME(VMHADDSHS)
NAME(VMHRADDSHS)
NAME(VMINFP)
NAME(VMINSB)
NAME(VMINSH)
NAME(VMINSW)
NAME(VMINUB)
NAME(VMINUH)
NAME(VMINUW)
NAME(VMLADDUHM)
NAME(VMRGHB)
NAME(VMRGHH)
NAME(VMRGHW)
NAME(VMRGLB)
NAME(VMRGLH)
NAME(VMRGLW)
NAME(VMSUMMBM)
NAME(VMSUMSHM)
NAME(VMSUMSHS)
NAME(VMSUMUBM)
NAME(VMSUMUHM)
NAME(VMSUMUHS)
NAME(VMULESB)
NAME(VMULESH)
NAME(VMULEUB)
NAME(VMULEUH)
NAME(VMULOSB)
NAME(VMULOSH)
NAME(VMULOUB)
NAME(VMULOUH)
NAME(VNMSUBFP)
NAME(VNOR)
NAME(VOR)
NAME(VPERM)
NAME(VPKPX)
NAME(VPKSHSS)
NAME(VPKSHUS)
NAME(VPKSWSS)
NAME(VPKSWUS)
NAME(VPKUHUM)
NAME(VPKUHUS)
NAME(VPKUWUM)
NAME(VPKUWUS)
NAME(VREFP)
NAME(VRFIM)
NAME(VRFIN)
NAME(VRFIP)
NAME(VRFIZ)
NAME(VRLB)
NAME(VRLH)
NAME(VRLW)
NAME(VRSQRTEFP)
NAME(VSEL)
NAME(VSL)
NAME(VSLB)
NAME(VSLDOI)
NAME(VSLH)
NAME(VSLO)
NAME(VSLW)
NAME(VSPLTB)
NAME(VSPLTH)
NAME(VSPLTISB)
NAME(VSPLTISH)
NAME(VSPLTISW)
NAME(VSPLTW)
NAME(VSR)
NAME(VSRAB)
NAME(VSRAH)
NAME(VSRAW)
NAME(VSRB)
NAME(VSRH)
NAME(VSRO)
NAME(VSRW)
NAME(VSUBCUW)
NAME(VSUBFP)
NAME(VSUBSBS)
NAME(VSUBSHS)
NAME(VSUBSWS)
NAME(VSUBUBM)
NAME(VSUBUBS)
NAME(VSUBUHM)
NAME(VSUBUHS)
NAME(VSUBUWM)
NAME(VSUBUWS)
NAME(VSUMSWS)
NAME(VSUM2SWS)
NAME(VSUM4SBS)
NAME(VSUM4SHS)
NAME(VSUM4UBS)
NAME(VUPKHPX)
NAME(VUPKHSB)
NAME(VUPKHSH)
NAME(VUPKLPX)
NAME(VUPKLSB)
NAME(VUPKLSH)
NAME(VXOR)
NAME(TDI)
NAME(TWI)
NAME(MULLI)
NAME(SUBFIC)
NAME(CMPLI)
NAME(CMPI)
NAME(ADDIC)
NAME(ADDI)
NAME(ADDIS)
NAME(BC)
NAME(SC)
NAME(B)
NAME(MCRF)
NAME(BCLR)
NAME(CRNOR)
NAME(CRANDC)
NAME(ISYNC)
NAME(CRXOR)
NAME(CRNAND)
NAME(CRAND)
NAME(CREQV)
NAME(CRORC)
NAME(CROR)
NAME(BCCTR)
NAME(RLWIMI)
NAME(RLWINM)
NAME(RLWNM)
NAME(ORI)
NAME(ORIS)
NAME(XORI)
NAME(XORIS)
NAME(ANDI)
NAME(ANDIS)
NAME(RLDICL)
NAME(RLDICR)
NAME(RLDIC)
NAME(RLDIMI)
NAME(RLDCL)
NAME(RLDCR)
NAME(CMP)
NAME(TW)
NAME(LVSL)
NAME(LVEBX)
NAME(SUBFC)
NAME(ADDC)
NAME(MULHDU)
NAME(MULHWU)
NAME(MFOCRF)
NAME(LWARX)
NAME(LDX)
NAME(LWZX)
NAME(SLW)
NAME(CNTLZW)
NAME(SLD)
NAME(AND)
NAME(CMPL)
NAME(LVSR)
NAME(LVEHX)
NAME(SUBF)
NAME(LDUX)
NAME(DCBST)
NAME(LWZUX)
NAME(CNTLZD)
NAME(ANDC)
NAME(TD)
NAME(LVEWX)
NAME(MULHD)
NAME(MULHW)
NAME(LDARX)
NAME(DCBF)
NAME(LBZX)
NAME(LVX)
NAME(NEG)
NAME(LBZUX)
NAME(NOR)
NAME(STVEBX)
NAME(SUBFE)
NAME(ADDE)
NAME(MTOCRF)
NAME(STDX)
NAME(STWCX)
NAME(STWX)
NAME(STVEHX)
NAME(STDUX)
NAME(STWUX)
NAME(STVEWX)
NAME(SUBFZE)
NAME(ADDZE)
NAME(STDCX)
NAME(STBX)
NAME(STVX)
NAME(SUBFME)
NAME(MULLD)
NAME(ADDME)
NAME(MULLW)
NAME(DCBTST)
NAME(STBUX)
NAME(ADD)
NAME(DCBT)
NAME(LHZX)
NAME(EQV)
NAME(ECIWX)
NAME(LHZUX)
NAME(XOR)
NAME(MFSPR)
NAME(LWAX)
NAME(DST)
NAME(LHAX)
NAME(LVXL)
NAME(MFTB)
NAME(LWAUX)
NAME(DSTST)
NAME(LHAUX)
NAME(STHX)
NAME(ORC)
NAME(ECOWX)
NAME(STHUX)
NAME(OR)
NAME(DIVDU)
NAME(DIVWU)
NAME(MTSPR)
NAME(DCBI)
NAME(NAND)
NAME(STVXL)
NAME(DIVD)
NAME(DIVW)
NAME(LVLX)
NAME(LDBRX)
NAME(LSWX)
NAME(LWBRX)
NAME(LFSX)
NAME(SRW)
NAME(SRD)
NAME(LVRX)
NAME(LSWI)
NAME(LFSUX)
NAME(SYNC)
NAME(LFDX)
NAME(LFDUX)
NAME(STVLX)
NAME(STDBRX)
NAME(STSWX)
NAME(STWBRX)
NAME(STFSX)
NAME(STVRX)
NAME(STFSUX)
NAME(STSWI)
NAME(STFDX)
NAME(STFDUX)
NAME(LVLXL)
NAME(LHBRX)
NAME(SRAW)
NAME(SRAD)
NAME(LVRXL)
NAME(DSS)
NAME(SRAWI)
NAME(SRADI)
NAME(EIEIO)
NAME(STVLXL)
NAME(STHBRX)
NAME(EXTSH)
NAME(STVRXL)
NAME(EXTSB)
NAME(STFIWX)
NAME(EXTSW)
NAME(ICBI)
NAME(DCBZ)
NAME(LWZ)
NAME(LWZU)
NAME(LBZ)
NAME(LBZU)
NAME(STW)
NAME(STWU)
NAME(STB)
NAME(STBU)
NAME(LHZ)
NAME(LHZU)
NAME(LHA)
NAME(LHAU)
NAME(STH)
NAME(STHU)
NAME(LMW)
NAME(STMW)
NAME(LFS)
NAME(LFSU)
NAME(LFD)
NAME(LFDU)
NAME(STFS)
NAME(STFSU)
NAME(STFD)
NAME(STFDU)
NAME(LD)
NAME(LDU)
NAME(LWA)
NAME(STD)
NAME(STDU)
NAME(FDIVS)
NAME(FSUBS)
NAME(FADDS)
NAME(FSQRTS)
NAME(FRES)
NAME(FMULS)
NAME(FMADDS)
NAME(FMSUBS)
NAME(FNMSUBS)
NAME(FNMADDS)
NAME(MTFSB1)
NAME(MCRFS)
NAME(MTFSB0)
NAME(MTFSFI)
NAME(MFFS)
NAME(MTFSF)
NAME(FCMPU)
NAME(FRSP)
NAME(FCTIW)
NAME(FCTIWZ)
NAME(FDIV)
NAME(FSUB)
NAME(FADD)
NAME(FSQRT)
NAME(FSEL)
NAME(FMUL)
NAME(FRSQRTE)
NAME(FMSUB)
NAME(FMADD)
NAME(FNMSUB)
NAME(FNMADD)
NAME(FCMPO)
NAME(FNEG)
NAME(FMR)
NAME(FNABS)
NAME(FABS)
NAME(FCTID)
NAME(FCTIDZ)
NAME(FCFID)
NAME(SUBFCO)
NAME(ADDCO)
NAME(SUBFO)
NAME(NEGO)
NAME(SUBFEO)
NAME(ADDEO)
NAME(SUBFZEO)
NAME(ADDZEO)
NAME(SUBFMEO)
NAME(MULLDO)
NAME(ADDMEO)
NAME(MULLWO)
NAME(ADDO)
NAME(DIVDUO)
NAME(DIVWUO)
NAME(DIVDO)
NAME(DIVWO)
NAME_(SUBFCO)
NAME_(ADDCO)
NAME_(SUBFO)
NAME_(NEGO)
NAME_(SUBFEO)
NAME_(ADDEO)
NAME_(SUBFZEO)
NAME_(ADDZEO)
NAME_(SUBFMEO)
NAME_(MULLDO)
NAME_(ADDMEO)
NAME_(MULLWO)
NAME_(ADDO)
NAME_(DIVDUO)
NAME_(DIVWUO)
NAME_(DIVDO)
NAME_(DIVWO)
NAME_(RLWIMI)
NAME_(RLWINM)
NAME_(RLWNM)
NAME_(RLDICL)
NAME_(RLDICR)
NAME_(RLDIC)
NAME_(RLDIMI)
NAME_(RLDCL)
NAME_(RLDCR)
NAME_(SUBFC)
NAME_(MULHDU)
NAME_(ADDC)
NAME_(MULHWU)
NAME_(SLW)
NAME_(CNTLZW)
NAME_(SLD)
NAME_(AND)
NAME_(SUBF)
NAME_(CNTLZD)
NAME_(ANDC)
NAME_(MULHD)
NAME_(MULHW)
NAME_(NEG)
NAME_(NOR)
NAME_(SUBFE)
NAME_(ADDE)
NAME_(SUBFZE)
NAME_(ADDZE)
NAME_(MULLD)
NAME_(SUBFME)
NAME_(ADDME)
NAME_(MULLW)
NAME_(ADD)
NAME_(EQV)
NAME_(XOR)
NAME_(ORC)
NAME_(OR)
NAME_(DIVDU)
NAME_(DIVWU)
NAME_(NAND)
NAME_(DIVD)
NAME_(DIVW)
NAME_(SRW)
NAME_(SRD)
NAME_(SRAW)
NAME_(SRAD)
NAME_(SRAWI)
NAME_(SRADI)
NAME_(EXTSH)
NAME_(EXTSB)
NAME_(EXTSW)
NAME_(FDIVS)
NAME_(FSUBS)
NAME_(FADDS)
NAME_(FSQRTS)
NAME_(FRES)
NAME_(FMULS)
NAME_(FMADDS)
NAME_(FMSUBS)
NAME_(FNMSUBS)
NAME_(FNMADDS)
NAME_(MTFSB1)
NAME_(MTFSB0)
NAME_(MTFSFI)
NAME_(MFFS)
NAME_(MTFSF)
NAME_(FRSP)
NAME_(FCTIW)
NAME_(FCTIWZ)
NAME_(FDIV)
NAME_(FSUB)
NAME_(FADD)
NAME_(FSQRT)
NAME_(FSEL)
NAME_(FMUL)
NAME_(FRSQRTE)
NAME_(FMSUB)
NAME_(FMADD)
NAME_(FNMSUB)
NAME_(FNMADD)
NAME_(FNEG)
NAME_(FMR)
NAME_(FNABS)
NAME_(FABS)
NAME_(FCTID)
NAME_(FCTIDZ)
NAME_(FCFID)
#undef NAME
#undef NAME_
};
// PPU Analyser Context
struct ppu_acontext
{
// General-purpose register range
struct spec_gpr
{
// Integral range: normalized undef = (0;UINT64_MAX), unnormalized undefs are possible (when max = min - 1)
// Bit range: constant 0 = (0;0), constant 1 = (1;1), normalized undef = (0;1), unnormalized undef = (1;0)
u64 imin = 0ull; // Integral range begin
u64 imax = ~0ull; // Integral range end
u64 bmin = 0ull; // Bit range begin
u64 bmax = ~0ull; // Bit range end
void set_undef()
{
imin = 0;
imax = -1;
bmin = 0;
bmax = -1;
}
// (Number of possible values - 1), 0 = const
u64 div() const
{
return imax - imin;
}
// Return zero bits for zeros, ones for ones or undefs
u64 mask() const
{
return bmin | bmax;
}
// Return one bits for ones, zeros for zeros or undefs
u64 ones() const
{
return bmin & bmax;
}
// Return one bits for undefs
u64 undefs() const
{
return bmin ^ bmax;
}
// Return number of trailing zero bits
u64 tz() const
{
return std::countr_zero(mask());
}
// Range NOT
spec_gpr operator ~() const
{
spec_gpr r;
r.imin = ~imax;
r.imax = ~imin;
r.bmin = ~bmax;
r.bmax = ~bmin;
return r;
}
// Range ADD
spec_gpr operator +(const spec_gpr& rhs) const
{
spec_gpr r{};
const u64 adiv = div();
const u64 bdiv = rhs.div();
// Check overflow, generate normalized range
if (adiv != umax && bdiv != umax && adiv <= adiv + bdiv)
{
r = range(imin + rhs.imin, imax + rhs.imax);
}
// Carry for bitrange computation
u64 cmin = 0;
u64 cmax = 0;
const u64 amask = mask();
const u64 bmask = rhs.mask();
const u64 aones = ones();
const u64 bones = rhs.ones();
for (u32 i = 0; i < 64; i++)
{
cmin += ((amask >> i) & 1) + ((bmask >> i) & 1);
cmax += ((aones >> i) & 1) + ((bones >> i) & 1);
// Discover some constant bits
if (cmin == cmax)
{
r.bmin |= (cmin & 1) << i;
r.bmax &= ~((~cmin & 1) << i);
}
cmin >>= 1;
cmax >>= 1;
}
return r;
}
// Range AND
spec_gpr operator &(const spec_gpr& rhs) const
{
// Ignore inverted ranges (TODO)
if (imin > imax || rhs.imin > rhs.imax)
{
return approx(ones() & rhs.ones(), mask() & rhs.mask());
}
// Const (TODO: remove when unnecessary)
if (imin == imax && rhs.imin == rhs.imax)
{
return fixed(imin & rhs.imin);
}
// Swap (TODO: remove when unnecessary)
if (imin == imax || rhs.undefs() > undefs())
{
return rhs & *this;
}
// Copy and attempt to partially preserve integral range
spec_gpr r = *this;
for (u32 i = 63; ~i; i--)
{
const u64 m = 1ull << i;
if (!(rhs.mask() & m))
{
if (r.undefs() & m)
{
// undef -> 0
r.imin &= ~(m - 1);
r.imax |= (m - 1);
r.imin &= ~m;
r.imax &= ~m;
}
else if (r.ones() & m)
{
// 1 -> 0
if ((r.imin ^ r.imax) > (m - 1))
{
r.imin &= ~(m - 1);
r.imax |= (m - 1);
}
r.imin &= ~m;
r.imax &= ~m;
}
}
else if (rhs.undefs() & m)
{
// -> undef
r.imin &= ~(m - 1);
r.imax |= (m - 1);
r.imin &= ~m;
r.imax |= m;
}
}
r.bmin = ones() & rhs.ones();
r.bmax = mask() & rhs.mask();
return r;
}
// Range OR
spec_gpr operator |(const spec_gpr& rhs) const
{
// Ignore inverted ranges (TODO)
if (imin > imax || rhs.imin > rhs.imax)
{
return approx(ones() | rhs.ones(), mask() | rhs.mask());
}
// Const (TODO: remove when unnecessary)
if (imin == imax && rhs.imin == rhs.imax)
{
return fixed(imin | rhs.imin);
}
// Swap (TODO: remove when unnecessary)
if (imin == imax || rhs.undefs() > undefs())
{
return rhs | *this;
}
// Copy and attempt to partially preserve integral range
spec_gpr r = *this;
for (u32 i = 63; ~i; i--)
{
const u64 m = 1ull << i;
if (rhs.ones() & m)
{
if (r.undefs() & m)
{
// undef -> 1
r.imin &= ~(m - 1);
r.imax |= (m - 1);
r.imin |= m;
r.imax |= m;
}
else if (!(r.mask() & m))
{
// 0 -> 1
if ((r.imin ^ r.imax) > (m - 1))
{
r.imin &= ~(m - 1);
r.imax |= (m - 1);
}
r.imin |= m;
r.imax |= m;
}
}
else if (rhs.undefs() & m)
{
// -> undef
r.imin &= ~(m - 1);
r.imax |= (m - 1);
r.imin &= ~m;
r.imax |= m;
}
}
r.bmin = ones() | rhs.ones();
r.bmax = mask() | rhs.mask();
return r;
}
// Range XOR
spec_gpr operator ^(const spec_gpr& rhs) const
{
return (~*this & rhs) | (*this & ~rhs);
}
// Check whether the value is in range
bool test(u64 value) const
{
if (imin <= imax)
{
if (value < imin || value > imax)
{
return false;
}
}
else
{
if (value < imin && value > imax)
{
return false;
}
}
if ((value & mask()) != value)
{
return false;
}
if ((value | ones()) != value)
{
return false;
}
return true;
}
// Constant value
static spec_gpr fixed(u64 value)
{
spec_gpr r;
r.imin = value;
r.imax = value;
r.bmin = value;
r.bmax = value;
return r;
}
// Range (tz = number of constant trailing zeros)
static spec_gpr range(u64 min, u64 max, u64 tz = 0)
{
const u64 mask = tz < 64 ? ~0ull << tz : 0ull;
spec_gpr r;
r.bmin = 0;
r.bmax = mask;
// Normalize min/max for tz (TODO)
if (min < max)
{
// Inverted constant MSB mask
const u64 mix = ~0ull >> std::countl_zero(min ^ max);
r.bmin |= min & ~mix;
r.bmax &= max | mix;
r.imin = (min + ~mask) & mask;
r.imax = max & mask;
ensure(r.imin <= r.imax); // "Impossible range"
}
else
{
r.imin = min & mask;
r.imax = (max + ~mask) & mask;
ensure(r.imin >= r.imax); // "Impossible range"
}
// Fix const values
if (r.imin == r.imax)
{
r.bmin = r.imin;
r.bmax = r.imax;
}
return r;
}
// Make from bitrange (normalize, approximate range values)
static spec_gpr approx(u64 bmin, u64 bmax)
{
spec_gpr r;
r.imin = bmin & ~(bmin ^ bmax);
r.imax = bmax | (bmin ^ bmax);
r.bmin = bmin & ~(bmin ^ bmax);
r.bmax = bmax | (bmin ^ bmax);
return r;
}
} gpr[32]{};
// Vector registers (draft)
struct spec_vec
{
u8 imin8[16]{};
u8 imax8[16]{255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255};
u16 imin16[8]{};
u16 imax16[8]{0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff};
u32 imin32[4]{};
u32 imax32[4]{0xffffffffu, 0xffffffffu, 0xffffffffu, 0xffffffffu};
u64 bmin64[2]{};
u64 bmax64[2]{0xffffffffffffffffull, 0xffffffffffffffffull};
};
// Info
u32 cia;
// Analyser step
void UNK(ppu_opcode_t);
void MFVSCR(ppu_opcode_t);
void MTVSCR(ppu_opcode_t);
void VADDCUW(ppu_opcode_t);
void VADDFP(ppu_opcode_t);
void VADDSBS(ppu_opcode_t);
void VADDSHS(ppu_opcode_t);
void VADDSWS(ppu_opcode_t);
void VADDUBM(ppu_opcode_t);
void VADDUBS(ppu_opcode_t);
void VADDUHM(ppu_opcode_t);
void VADDUHS(ppu_opcode_t);
void VADDUWM(ppu_opcode_t);
void VADDUWS(ppu_opcode_t);
void VAND(ppu_opcode_t);
void VANDC(ppu_opcode_t);
void VAVGSB(ppu_opcode_t);
void VAVGSH(ppu_opcode_t);
void VAVGSW(ppu_opcode_t);
void VAVGUB(ppu_opcode_t);
void VAVGUH(ppu_opcode_t);
void VAVGUW(ppu_opcode_t);
void VCFSX(ppu_opcode_t);
void VCFUX(ppu_opcode_t);
void VCMPBFP(ppu_opcode_t);
void VCMPEQFP(ppu_opcode_t);
void VCMPEQUB(ppu_opcode_t);
void VCMPEQUH(ppu_opcode_t);
void VCMPEQUW(ppu_opcode_t);
void VCMPGEFP(ppu_opcode_t);
void VCMPGTFP(ppu_opcode_t);
void VCMPGTSB(ppu_opcode_t);
void VCMPGTSH(ppu_opcode_t);
void VCMPGTSW(ppu_opcode_t);
void VCMPGTUB(ppu_opcode_t);
void VCMPGTUH(ppu_opcode_t);
void VCMPGTUW(ppu_opcode_t);
void VCTSXS(ppu_opcode_t);
void VCTUXS(ppu_opcode_t);
void VEXPTEFP(ppu_opcode_t);
void VLOGEFP(ppu_opcode_t);
void VMADDFP(ppu_opcode_t);
void VMAXFP(ppu_opcode_t);
void VMAXSB(ppu_opcode_t);
void VMAXSH(ppu_opcode_t);
void VMAXSW(ppu_opcode_t);
void VMAXUB(ppu_opcode_t);
void VMAXUH(ppu_opcode_t);
void VMAXUW(ppu_opcode_t);
void VMHADDSHS(ppu_opcode_t);
void VMHRADDSHS(ppu_opcode_t);
void VMINFP(ppu_opcode_t);
void VMINSB(ppu_opcode_t);
void VMINSH(ppu_opcode_t);
void VMINSW(ppu_opcode_t);
void VMINUB(ppu_opcode_t);
void VMINUH(ppu_opcode_t);
void VMINUW(ppu_opcode_t);
void VMLADDUHM(ppu_opcode_t);
void VMRGHB(ppu_opcode_t);
void VMRGHH(ppu_opcode_t);
void VMRGHW(ppu_opcode_t);
void VMRGLB(ppu_opcode_t);
void VMRGLH(ppu_opcode_t);
void VMRGLW(ppu_opcode_t);
void VMSUMMBM(ppu_opcode_t);
void VMSUMSHM(ppu_opcode_t);
void VMSUMSHS(ppu_opcode_t);
void VMSUMUBM(ppu_opcode_t);
void VMSUMUHM(ppu_opcode_t);
void VMSUMUHS(ppu_opcode_t);
void VMULESB(ppu_opcode_t);
void VMULESH(ppu_opcode_t);
void VMULEUB(ppu_opcode_t);
void VMULEUH(ppu_opcode_t);
void VMULOSB(ppu_opcode_t);
void VMULOSH(ppu_opcode_t);
void VMULOUB(ppu_opcode_t);
void VMULOUH(ppu_opcode_t);
void VNMSUBFP(ppu_opcode_t);
void VNOR(ppu_opcode_t);
void VOR(ppu_opcode_t);
void VPERM(ppu_opcode_t);
void VPKPX(ppu_opcode_t);
void VPKSHSS(ppu_opcode_t);
void VPKSHUS(ppu_opcode_t);
void VPKSWSS(ppu_opcode_t);
void VPKSWUS(ppu_opcode_t);
void VPKUHUM(ppu_opcode_t);
void VPKUHUS(ppu_opcode_t);
void VPKUWUM(ppu_opcode_t);
void VPKUWUS(ppu_opcode_t);
void VREFP(ppu_opcode_t);
void VRFIM(ppu_opcode_t);
void VRFIN(ppu_opcode_t);
void VRFIP(ppu_opcode_t);
void VRFIZ(ppu_opcode_t);
void VRLB(ppu_opcode_t);
void VRLH(ppu_opcode_t);
void VRLW(ppu_opcode_t);
void VRSQRTEFP(ppu_opcode_t);
void VSEL(ppu_opcode_t);
void VSL(ppu_opcode_t);
void VSLB(ppu_opcode_t);
void VSLDOI(ppu_opcode_t);
void VSLH(ppu_opcode_t);
void VSLO(ppu_opcode_t);
void VSLW(ppu_opcode_t);
void VSPLTB(ppu_opcode_t);
void VSPLTH(ppu_opcode_t);
void VSPLTISB(ppu_opcode_t);
void VSPLTISH(ppu_opcode_t);
void VSPLTISW(ppu_opcode_t);
void VSPLTW(ppu_opcode_t);
void VSR(ppu_opcode_t);
void VSRAB(ppu_opcode_t);
void VSRAH(ppu_opcode_t);
void VSRAW(ppu_opcode_t);
void VSRB(ppu_opcode_t);
void VSRH(ppu_opcode_t);
void VSRO(ppu_opcode_t);
void VSRW(ppu_opcode_t);
void VSUBCUW(ppu_opcode_t);
void VSUBFP(ppu_opcode_t);
void VSUBSBS(ppu_opcode_t);
void VSUBSHS(ppu_opcode_t);
void VSUBSWS(ppu_opcode_t);
void VSUBUBM(ppu_opcode_t);
void VSUBUBS(ppu_opcode_t);
void VSUBUHM(ppu_opcode_t);
void VSUBUHS(ppu_opcode_t);
void VSUBUWM(ppu_opcode_t);
void VSUBUWS(ppu_opcode_t);
void VSUMSWS(ppu_opcode_t);
void VSUM2SWS(ppu_opcode_t);
void VSUM4SBS(ppu_opcode_t);
void VSUM4SHS(ppu_opcode_t);
void VSUM4UBS(ppu_opcode_t);
void VUPKHPX(ppu_opcode_t);
void VUPKHSB(ppu_opcode_t);
void VUPKHSH(ppu_opcode_t);
void VUPKLPX(ppu_opcode_t);
void VUPKLSB(ppu_opcode_t);
void VUPKLSH(ppu_opcode_t);
void VXOR(ppu_opcode_t);
void TDI(ppu_opcode_t);
void TWI(ppu_opcode_t);
void MULLI(ppu_opcode_t);
void SUBFIC(ppu_opcode_t);
void CMPLI(ppu_opcode_t);
void CMPI(ppu_opcode_t);
void ADDIC(ppu_opcode_t);
void ADDI(ppu_opcode_t);
void ADDIS(ppu_opcode_t);
void BC(ppu_opcode_t);
void SC(ppu_opcode_t);
void B(ppu_opcode_t);
void MCRF(ppu_opcode_t);
void BCLR(ppu_opcode_t);
void CRNOR(ppu_opcode_t);
void CRANDC(ppu_opcode_t);
void ISYNC(ppu_opcode_t);
void CRXOR(ppu_opcode_t);
void CRNAND(ppu_opcode_t);
void CRAND(ppu_opcode_t);
void CREQV(ppu_opcode_t);
void CRORC(ppu_opcode_t);
void CROR(ppu_opcode_t);
void BCCTR(ppu_opcode_t);
void RLWIMI(ppu_opcode_t);
void RLWINM(ppu_opcode_t);
void RLWNM(ppu_opcode_t);
void ORI(ppu_opcode_t);
void ORIS(ppu_opcode_t);
void XORI(ppu_opcode_t);
void XORIS(ppu_opcode_t);
void ANDI(ppu_opcode_t);
void ANDIS(ppu_opcode_t);
void RLDICL(ppu_opcode_t);
void RLDICR(ppu_opcode_t);
void RLDIC(ppu_opcode_t);
void RLDIMI(ppu_opcode_t);
void RLDCL(ppu_opcode_t);
void RLDCR(ppu_opcode_t);
void CMP(ppu_opcode_t);
void TW(ppu_opcode_t);
void LVSL(ppu_opcode_t);
void LVEBX(ppu_opcode_t);
void SUBFC(ppu_opcode_t);
void ADDC(ppu_opcode_t);
void MULHDU(ppu_opcode_t);
void MULHWU(ppu_opcode_t);
void MFOCRF(ppu_opcode_t);
void LWARX(ppu_opcode_t);
void LDX(ppu_opcode_t);
void LWZX(ppu_opcode_t);
void SLW(ppu_opcode_t);
void CNTLZW(ppu_opcode_t);
void SLD(ppu_opcode_t);
void AND(ppu_opcode_t);
void CMPL(ppu_opcode_t);
void LVSR(ppu_opcode_t);
void LVEHX(ppu_opcode_t);
void SUBF(ppu_opcode_t);
void LDUX(ppu_opcode_t);
void DCBST(ppu_opcode_t);
void LWZUX(ppu_opcode_t);
void CNTLZD(ppu_opcode_t);
void ANDC(ppu_opcode_t);
void TD(ppu_opcode_t);
void LVEWX(ppu_opcode_t);
void MULHD(ppu_opcode_t);
void MULHW(ppu_opcode_t);
void LDARX(ppu_opcode_t);
void DCBF(ppu_opcode_t);
void LBZX(ppu_opcode_t);
void LVX(ppu_opcode_t);
void NEG(ppu_opcode_t);
void LBZUX(ppu_opcode_t);
void NOR(ppu_opcode_t);
void STVEBX(ppu_opcode_t);
void SUBFE(ppu_opcode_t);
void ADDE(ppu_opcode_t);
void MTOCRF(ppu_opcode_t);
void STDX(ppu_opcode_t);
void STWCX(ppu_opcode_t);
void STWX(ppu_opcode_t);
void STVEHX(ppu_opcode_t);
void STDUX(ppu_opcode_t);
void STWUX(ppu_opcode_t);
void STVEWX(ppu_opcode_t);
void SUBFZE(ppu_opcode_t);
void ADDZE(ppu_opcode_t);
void STDCX(ppu_opcode_t);
void STBX(ppu_opcode_t);
void STVX(ppu_opcode_t);
void SUBFME(ppu_opcode_t);
void MULLD(ppu_opcode_t);
void ADDME(ppu_opcode_t);
void MULLW(ppu_opcode_t);
void DCBTST(ppu_opcode_t);
void STBUX(ppu_opcode_t);
void ADD(ppu_opcode_t);
void DCBT(ppu_opcode_t);
void LHZX(ppu_opcode_t);
void EQV(ppu_opcode_t);
void ECIWX(ppu_opcode_t);
void LHZUX(ppu_opcode_t);
void XOR(ppu_opcode_t);
void MFSPR(ppu_opcode_t);
void LWAX(ppu_opcode_t);
void DST(ppu_opcode_t);
void LHAX(ppu_opcode_t);
void LVXL(ppu_opcode_t);
void MFTB(ppu_opcode_t);
void LWAUX(ppu_opcode_t);
void DSTST(ppu_opcode_t);
void LHAUX(ppu_opcode_t);
void STHX(ppu_opcode_t);
void ORC(ppu_opcode_t);
void ECOWX(ppu_opcode_t);
void STHUX(ppu_opcode_t);
void OR(ppu_opcode_t);
void DIVDU(ppu_opcode_t);
void DIVWU(ppu_opcode_t);
void MTSPR(ppu_opcode_t);
void DCBI(ppu_opcode_t);
void NAND(ppu_opcode_t);
void STVXL(ppu_opcode_t);
void DIVD(ppu_opcode_t);
void DIVW(ppu_opcode_t);
void LVLX(ppu_opcode_t);
void LDBRX(ppu_opcode_t);
void LSWX(ppu_opcode_t);
void LWBRX(ppu_opcode_t);
void LFSX(ppu_opcode_t);
void SRW(ppu_opcode_t);
void SRD(ppu_opcode_t);
void LVRX(ppu_opcode_t);
void LSWI(ppu_opcode_t);
void LFSUX(ppu_opcode_t);
void SYNC(ppu_opcode_t);
void LFDX(ppu_opcode_t);
void LFDUX(ppu_opcode_t);
void STVLX(ppu_opcode_t);
void STDBRX(ppu_opcode_t);
void STSWX(ppu_opcode_t);
void STWBRX(ppu_opcode_t);
void STFSX(ppu_opcode_t);
void STVRX(ppu_opcode_t);
void STFSUX(ppu_opcode_t);
void STSWI(ppu_opcode_t);
void STFDX(ppu_opcode_t);
void STFDUX(ppu_opcode_t);
void LVLXL(ppu_opcode_t);
void LHBRX(ppu_opcode_t);
void SRAW(ppu_opcode_t);
void SRAD(ppu_opcode_t);
void LVRXL(ppu_opcode_t);
void DSS(ppu_opcode_t);
void SRAWI(ppu_opcode_t);
void SRADI(ppu_opcode_t);
void EIEIO(ppu_opcode_t);
void STVLXL(ppu_opcode_t);
void STHBRX(ppu_opcode_t);
void EXTSH(ppu_opcode_t);
void STVRXL(ppu_opcode_t);
void EXTSB(ppu_opcode_t);
void STFIWX(ppu_opcode_t);
void EXTSW(ppu_opcode_t);
void ICBI(ppu_opcode_t);
void DCBZ(ppu_opcode_t);
void LWZ(ppu_opcode_t);
void LWZU(ppu_opcode_t);
void LBZ(ppu_opcode_t);
void LBZU(ppu_opcode_t);
void STW(ppu_opcode_t);
void STWU(ppu_opcode_t);
void STB(ppu_opcode_t);
void STBU(ppu_opcode_t);
void LHZ(ppu_opcode_t);
void LHZU(ppu_opcode_t);
void LHA(ppu_opcode_t);
void LHAU(ppu_opcode_t);
void STH(ppu_opcode_t);
void STHU(ppu_opcode_t);
void LMW(ppu_opcode_t);
void STMW(ppu_opcode_t);
void LFS(ppu_opcode_t);
void LFSU(ppu_opcode_t);
void LFD(ppu_opcode_t);
void LFDU(ppu_opcode_t);
void STFS(ppu_opcode_t);
void STFSU(ppu_opcode_t);
void STFD(ppu_opcode_t);
void STFDU(ppu_opcode_t);
void LD(ppu_opcode_t);
void LDU(ppu_opcode_t);
void LWA(ppu_opcode_t);
void STD(ppu_opcode_t);
void STDU(ppu_opcode_t);
void FDIVS(ppu_opcode_t);
void FSUBS(ppu_opcode_t);
void FADDS(ppu_opcode_t);
void FSQRTS(ppu_opcode_t);
void FRES(ppu_opcode_t);
void FMULS(ppu_opcode_t);
void FMADDS(ppu_opcode_t);
void FMSUBS(ppu_opcode_t);
void FNMSUBS(ppu_opcode_t);
void FNMADDS(ppu_opcode_t);
void MTFSB1(ppu_opcode_t);
void MCRFS(ppu_opcode_t);
void MTFSB0(ppu_opcode_t);
void MTFSFI(ppu_opcode_t);
void MFFS(ppu_opcode_t);
void MTFSF(ppu_opcode_t);
void FCMPU(ppu_opcode_t);
void FRSP(ppu_opcode_t);
void FCTIW(ppu_opcode_t);
void FCTIWZ(ppu_opcode_t);
void FDIV(ppu_opcode_t);
void FSUB(ppu_opcode_t);
void FADD(ppu_opcode_t);
void FSQRT(ppu_opcode_t);
void FSEL(ppu_opcode_t);
void FMUL(ppu_opcode_t);
void FRSQRTE(ppu_opcode_t);
void FMSUB(ppu_opcode_t);
void FMADD(ppu_opcode_t);
void FNMSUB(ppu_opcode_t);
void FNMADD(ppu_opcode_t);
void FCMPO(ppu_opcode_t);
void FNEG(ppu_opcode_t);
void FMR(ppu_opcode_t);
void FNABS(ppu_opcode_t);
void FABS(ppu_opcode_t);
void FCTID(ppu_opcode_t);
void FCTIDZ(ppu_opcode_t);
void FCFID(ppu_opcode_t);
};
| 35,118
|
C++
|
.h
| 1,950
| 15.335385
| 183
| 0.672394
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,830
|
SPURecompiler.h
|
RPCS3_rpcs3/rpcs3/Emu/Cell/SPURecompiler.h
|
#pragma once
#include "Utilities/File.h"
#include "Utilities/lockless.h"
#include "Utilities/address_range.h"
#include "SPUThread.h"
#include <vector>
#include <bitset>
#include <memory>
#include <string>
#include <deque>
// Helper class
class spu_cache
{
fs::file m_file;
public:
spu_cache() = default;
spu_cache(const std::string& loc);
spu_cache(spu_cache&&) noexcept = default;
spu_cache& operator=(spu_cache&&) noexcept = default;
~spu_cache();
operator bool() const
{
return m_file.operator bool();
}
std::deque<struct spu_program> get();
void add(const struct spu_program& func);
static void initialize(bool build_existing_cache = true);
struct precompile_data_t
{
u32 vaddr;
std::vector<u32> inst_data;
std::vector<u32> funcs;
};
bool collect_funcs_to_precompile = true;
lf_queue<precompile_data_t> precompile_funcs;
};
struct spu_program
{
// Address of the entry point in LS
u32 entry_point;
// Address of the data in LS
u32 lower_bound;
// Program data with intentionally wrong endianness (on LE platform opcode values are swapped)
std::vector<u32> data;
bool operator==(const spu_program& rhs) const noexcept;
bool operator<(const spu_program& rhs) const noexcept;
};
class spu_item
{
public:
// SPU program
const spu_program data;
// Compiled function pointer
atomic_t<spu_function_t> compiled = nullptr;
// Ubertrampoline generated for this item when it was latest
atomic_t<spu_function_t> trampoline = nullptr;
atomic_t<u8> cached = false;
atomic_t<u8> logged = false;
spu_item(spu_program&& data)
: data(std::move(data))
{
}
spu_item(const spu_item&) = delete;
spu_item& operator=(const spu_item&) = delete;
};
// Helper class
class spu_runtime
{
// All functions (2^20 bunches)
std::array<lf_bunch<spu_item>, (1 << 20)> m_stuff;
// Debug module output location
std::string m_cache_path;
public:
// Trampoline to spu_recompiler_base::dispatch
static const spu_function_t tr_dispatch;
// Trampoline to spu_recompiler_base::branch
static const spu_function_t tr_branch;
// Trampoline to legacy interpreter
static const spu_function_t tr_interpreter;
// Detect and call any recompiled function
static const spu_function_t tr_all;
public:
spu_runtime();
spu_runtime(const spu_runtime&) = delete;
spu_runtime& operator=(const spu_runtime&) = delete;
const std::string& get_cache_path() const
{
return m_cache_path;
}
// Rebuild ubertrampoline for given identifier (first instruction)
spu_function_t rebuild_ubertrampoline(u32 id_inst);
private:
friend class spu_cache;
public:
// Return new pointer for add()
spu_item* add_empty(spu_program&&);
// Find existing function
spu_function_t find(const u32* ls, u32 addr) const;
// Generate a patchable trampoline to spu_recompiler_base::branch
spu_function_t make_branch_patchpoint(u16 data = 0) const;
// All dispatchers (array allocated in jit memory)
static std::array<atomic_t<spu_function_t>, (1 << 20)>* const g_dispatcher;
// Recompiler entry point
static const spu_function_t g_gateway;
// Longjmp to the end of the gateway function (native CC)
static void(*const g_escape)(spu_thread*);
// Similar to g_escape, but doing tail call to the new function.
static void(*const g_tail_escape)(spu_thread*, spu_function_t, u8*);
// Interpreter table (spu_itype -> ptr)
static std::array<u64, 256> g_interpreter_table;
// Interpreter entry point
static spu_function_t g_interpreter;
};
// SPU Recompiler instance base class
class spu_recompiler_base
{
public:
enum : u8
{
s_reg_lr = 0,
s_reg_sp = 1,
s_reg_80 = 80,
s_reg_127 = 127,
s_reg_mfc_eal,
s_reg_mfc_lsa,
s_reg_mfc_tag,
s_reg_mfc_size,
// Max number of registers (for m_regmod)
s_reg_max
};
// Classify terminator instructions
enum class term_type : unsigned char
{
br,
ret,
call,
fallthrough,
indirect_call,
interrupt_call,
};
// Value flags (TODO: only is_const is implemented)
enum class vf : u32
{
is_const,
is_mask,
is_rel,
is_null,
__bitset_enum_max
};
struct reg_state_t
{
bs_t<vf> flag{+vf::is_null};
u32 value{};
u32 tag = umax;
u32 known_ones{};
u32 known_zeroes{};
u32 origin = SPU_LS_SIZE;
bool is_instruction = false;
bool is_const() const;
bool operator&(vf to_test) const;
bool is_less_than(u32 imm) const;
bool operator==(const reg_state_t& r) const;
bool operator==(u32 imm) const;
// Compare equality but try to ignore changes in unmasked bits
bool compare_with_mask_indifference(const reg_state_t& r, u32 mask_bits) const;
bool compare_with_mask_indifference(u32 imm, u32 mask_bits) const;
bool unequal_with_mask_indifference(const reg_state_t& r, u32 mask_bits) const;
// Convert constant-based value to mask-based value
reg_state_t downgrade() const;
// Connect two register states between different blocks
reg_state_t merge(const reg_state_t& rhs, u32 current_pc) const;
// Override value with newer value if needed
reg_state_t build_on_top_of(const reg_state_t& rhs) const;
// Get known zeroes mask
u32 get_known_zeroes() const;
// Get known ones mask
u32 get_known_ones() const;
// Invalidate value if non-constant and reached the point in history of its creation
void invalidate_if_created(u32 current_pc);
template <usz Count = 1>
static std::conditional_t<Count == 1, reg_state_t, std::array<reg_state_t, Count>> make_unknown(u32 pc, u32 current_pc = SPU_LS_SIZE) noexcept
{
if constexpr (Count == 1)
{
reg_state_t v{};
v.tag = alloc_tag();
v.flag = {};
v.origin = pc;
v.is_instruction = pc == current_pc;
return v;
}
else
{
std::array<reg_state_t, Count> result{};
for (reg_state_t& state : result)
{
state = make_unknown<1>(pc, current_pc);
}
return result;
}
}
bool compare_tags(const reg_state_t& rhs) const;
static reg_state_t from_value(u32 value) noexcept;
static u32 alloc_tag(bool reset = false) noexcept;
};
protected:
spu_runtime* m_spurt{};
u32 m_pos;
u32 m_size;
u64 m_hash_start;
// Bit indicating start of the block
std::bitset<0x10000> m_block_info;
// GPR modified by the instruction (-1 = not set)
std::array<u8, 0x10000> m_regmod;
std::bitset<0x10000> m_use_ra;
std::bitset<0x10000> m_use_rb;
std::bitset<0x10000> m_use_rc;
// List of possible targets for the instruction (entry shouldn't exist for simple instructions)
std::unordered_map<u32, std::vector<u32>, value_hash<u32, 2>> m_targets;
// List of block predecessors
std::unordered_map<u32, std::vector<u32>, value_hash<u32, 2>> m_preds;
// List of function entry points and return points (set after BRSL, BRASL, BISL, BISLED)
std::bitset<0x10000> m_entry_info;
// Set after return points and disjoint chunks
std::bitset<0x10000> m_ret_info;
// Basic block information
struct block_info
{
// Address of the chunk entry point (chunk this block belongs to)
u32 chunk = 0x40000;
// Number of instructions
u16 size = 0;
// Internal use flag
bool analysed = false;
// Terminator instruction type
term_type terminator;
// Bit mask of the registers modified in the block
std::bitset<s_reg_max> reg_mod{};
// Set if last modifying instruction produces xfloat
std::bitset<s_reg_max> reg_mod_xf{};
// Set if the initial register value in this block may be xfloat
std::bitset<s_reg_max> reg_maybe_xf{};
// Bit mask of the registers used (before modified)
std::bitset<s_reg_max> reg_use{};
// Bit mask of the trivial (u32 x 4) constant value resulting in this block
std::bitset<s_reg_max> reg_const{};
// Bit mask of register saved onto the stack before use
std::bitset<s_reg_max> reg_save_dom{};
// Address of the function
u32 func = 0x40000;
// Value subtracted from $SP in this block, negative if something funny is done on $SP
u32 stack_sub = 0;
// Constant values associated with reg_const
std::array<u32, s_reg_max> reg_val32;
// Registers loaded from the stack in this block (stack offset)
std::array<u32, s_reg_max> reg_load_mod{};
// Single source of the reg value (dominating block address within the same chunk) or a negative number
std::array<u32, s_reg_max> reg_origin, reg_origin_abs;
// All possible successor blocks
std::vector<u32> targets;
// All predeccessor blocks
std::vector<u32> preds;
};
// Sorted basic block info
std::map<u32, block_info> m_bbs;
// Sorted advanced block (chunk) list
std::vector<u32> m_chunks;
// Function information
struct func_info
{
// Size to the end of last basic block
u16 size = 0;
// Determines whether a function is eligible for optimizations
bool good = false;
// Call targets
std::vector<u32> calls;
// Register save info (stack offset)
std::array<u32, s_reg_max> reg_save_off{};
};
// Sorted function info
std::map<u32, func_info> m_funcs;
// TODO: Add patterns
// Not a bitset to allow more possibilities
enum class inst_attr : u8
{
none,
omit,
putllc16,
putllc0,
rchcnt_loop,
};
std::vector<inst_attr> m_inst_attrs;
struct pattern_info
{
utils::address_range range;
};
std::unordered_map<u32, pattern_info> m_patterns;
void add_pattern(bool fill_all, inst_attr attr, u32 start, u32 end = -1);
private:
// For private use
std::bitset<0x10000> m_bits;
// For private use
std::vector<u32> workload;
public:
spu_recompiler_base();
virtual ~spu_recompiler_base();
// Initialize
virtual void init() = 0;
// Compile function
virtual spu_function_t compile(spu_program&&) = 0;
// Default dispatch function fallback (second arg is unused)
static void dispatch(spu_thread&, void*, u8* rip);
// Target for the unresolved patch point (second arg is unused)
static void branch(spu_thread&, void*, u8* rip);
// Legacy interpreter loop
static void old_interpreter(spu_thread&, void* ls, u8*);
// Get the function data at specified address
spu_program analyse(const be_t<u32>* ls, u32 entry_point, std::map<u32, std::vector<u32>>* out_target_list = nullptr);
// Print analyser internal state
void dump(const spu_program& result, std::string& out);
// Get SPU Runtime
spu_runtime& get_runtime()
{
if (!m_spurt)
{
init();
}
return *m_spurt;
}
// Create recompiler instance (ASMJIT)
static std::unique_ptr<spu_recompiler_base> make_asmjit_recompiler();
// Create recompiler instance (LLVM)
static std::unique_ptr<spu_recompiler_base> make_llvm_recompiler(u8 magn = 0);
// Create recompiler instance (interpreter-based LLVM)
static std::unique_ptr<spu_recompiler_base> make_fast_llvm_recompiler();
};
| 10,628
|
C++
|
.h
| 336
| 28.886905
| 144
| 0.722883
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,831
|
timers.hpp
|
RPCS3_rpcs3/rpcs3/Emu/Cell/timers.hpp
|
#pragma once
#include "util/types.hpp"
u64 convert_to_timebased_time(u64 time);
u64 get_timebased_time();
// Returns some relative time in microseconds, don't change this fact
u64 get_system_time();
// As get_system_time but obeys Clocks scaling setting. Microseconds.
u64 get_guest_system_time(u64 time = umax);
| 317
|
C++
|
.h
| 8
| 38.125
| 69
| 0.780328
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,832
|
PPUModule.h
|
RPCS3_rpcs3/rpcs3/Emu/Cell/PPUModule.h
|
#pragma once
#include "PPUFunction.h"
#include "PPUCallback.h"
#include "ErrorCodes.h"
#include "Emu/Memory/vm_var.h"
// Helper function
constexpr const char* ppu_select_name(const char* name, u32 /*id*/)
{
return name;
}
// Helper function
constexpr const char* ppu_select_name(const char* /*name*/, const char* orig_name)
{
return orig_name;
}
// Generate FNID or VNID for given name
extern u32 ppu_generate_id(std::string_view name);
// Overload for REG_FNID, REG_VNID macro
constexpr u32 ppu_generate_id(u32 id)
{
return id;
}
// Flags set with REG_FUNC
enum ppu_static_module_flags : u32
{
MFF_FORCED_HLE = (1 << 0), // Always call HLE function
MFF_PERFECT = (1 << 1), // Indicates complete implementation and LLE interchangeability
MFF_HIDDEN = (1 << 2), // Invisible variable for internal use (TODO)
};
// HLE function information
struct ppu_static_function
{
const char* name;
u32 index; // Index for ppu_function_manager
u32 flags;
std::vector<const char*> args; // Arg names
const u32* export_addr;
ppu_static_function& flag(ppu_static_module_flags value)
{
flags |= value;
return *this;
}
};
// HLE variable information
struct ppu_static_variable
{
const char* name;
u32* var; // Pointer to variable address storage
void(*init)(); // Variable initialization function
u32 size;
u32 align;
u32 flags;
u32 addr;
const u32* export_addr;
ppu_static_variable& flag(ppu_static_module_flags value)
{
flags |= value;
return *this;
}
};
// HLE module information
class ppu_static_module final
{
std::vector<void(*)(ppu_static_module*)> m_on_init;
public:
const std::string name;
std::unordered_map<u32, ppu_static_function, value_hash<u32>> functions{};
std::unordered_map<u32, ppu_static_variable, value_hash<u32>> variables{};
ppu_static_module(const char* name);
public:
ppu_static_module(const char* name, void(*init)())
: ppu_static_module(name)
{
init();
}
ppu_static_module(const char* name, void(*init)(ppu_static_module* _this))
: ppu_static_module(name)
{
init(this);
}
void add_init_func(void(*func)(ppu_static_module*));
void initialize();
};
class ppu_module_manager final
{
friend class ppu_static_module;
static void register_module(ppu_static_module*);
static ppu_static_function& access_static_function(const char* _module, u32 fnid);
static ppu_static_variable& access_static_variable(const char* _module, u32 vnid);
// Global variable for each registered function
template <auto* Func>
struct registered
{
static ppu_static_function* info;
};
public:
static const ppu_static_module* get_module(const std::string& name);
static void initialize_modules();
template <auto* Func>
static auto& register_static_function(const char* _module, const char* name, ppu_intrp_func_t func, u32 fnid)
{
auto& info = access_static_function(_module, fnid);
info.name = name;
info.index = ppu_function_manager::register_function<decltype(Func), Func>(func);
info.flags = 0;
registered<Func>::info = &info;
return info;
}
template <auto* Func>
static auto& find_static_function()
{
return *registered<Func>::info;
}
template <auto* Var>
static auto& register_static_variable(const char* _module, const char* name, u32 vnid)
{
using gvar = std::decay_t<decltype(*Var)>;
static_assert(std::is_same_v<u32, typename gvar::addr_type>, "Static variable registration: vm::gvar<T> expected");
auto& info = access_static_variable(_module, vnid);
info.name = name;
info.var = &Var->raw();
info.init = [] {};
info.size = gvar::alloc_size;
info.align = gvar::alloc_align;
info.flags = 0;
info.addr = 0;
return info;
}
// We need this to deal with the enumeration over all ppu_static_modules that happens in ppu_initialize_modules
static std::unordered_map<std::string, ppu_static_module*>& get();
static const ppu_static_module cellAdec;
static const ppu_static_module cellAtrac;
static const ppu_static_module cellAtracMulti;
static const ppu_static_module cellAtracXdec;
static const ppu_static_module cellAudio;
static const ppu_static_module cellAvconfExt;
static const ppu_static_module cellAuthDialogUtility;
static const ppu_static_module cellBGDL;
static const ppu_static_module cellCamera;
static const ppu_static_module cellCelp8Enc;
static const ppu_static_module cellCelpEnc;
static const ppu_static_module cellCrossController;
static const ppu_static_module cellDaisy;
static const ppu_static_module cellDmux;
static const ppu_static_module cellDtcpIpUtility;
static const ppu_static_module cellFiber;
static const ppu_static_module cellFont;
static const ppu_static_module cellFontFT;
static const ppu_static_module cell_FreeType2;
static const ppu_static_module cellFs;
static const ppu_static_module cellGame;
static const ppu_static_module cellGameExec;
static const ppu_static_module cellGcmSys;
static const ppu_static_module cellGem;
static const ppu_static_module cellGifDec;
static const ppu_static_module cellHttp;
static const ppu_static_module cellHttps;
static const ppu_static_module cellHttpUtil;
static const ppu_static_module cellImeJp;
static const ppu_static_module cellJpgDec;
static const ppu_static_module cellJpgEnc;
static const ppu_static_module cellKey2char;
static const ppu_static_module cellL10n;
static const ppu_static_module cellLibprof;
static const ppu_static_module cellMic;
static const ppu_static_module cellMusic;
static const ppu_static_module cellMusicDecode;
static const ppu_static_module cellMusicExport;
static const ppu_static_module cellNetAoi;
static const ppu_static_module cellNetCtl;
static const ppu_static_module cellOskDialog;
static const ppu_static_module cellOvis;
static const ppu_static_module cellPamf;
static const ppu_static_module cellPesmUtility;
static const ppu_static_module cellPhotoDecode;
static const ppu_static_module cellPhotoExport;
static const ppu_static_module cellPhotoImportUtil;
static const ppu_static_module cellPngDec;
static const ppu_static_module cellPngEnc;
static const ppu_static_module cellPrint;
static const ppu_static_module cellRec;
static const ppu_static_module cellRemotePlay;
static const ppu_static_module cellResc;
static const ppu_static_module cellRtc;
static const ppu_static_module cellRtcAlarm;
static const ppu_static_module cellRudp;
static const ppu_static_module cellSail;
static const ppu_static_module cellSailRec;
static const ppu_static_module cellSaveData;
static const ppu_static_module cellMinisSaveData;
static const ppu_static_module cellScreenShot;
static const ppu_static_module cellSearch;
static const ppu_static_module cellSheap;
static const ppu_static_module cellSpudll;
static const ppu_static_module cellSpurs;
static const ppu_static_module cellSpursJq;
static const ppu_static_module cellSsl;
static const ppu_static_module cellSubDisplay;
static const ppu_static_module cellSync;
static const ppu_static_module cellSync2;
static const ppu_static_module cellSysconf;
static const ppu_static_module cellSysmodule;
static const ppu_static_module cellSysutil;
static const ppu_static_module cellSysutilAp;
static const ppu_static_module cellSysutilAvc2;
static const ppu_static_module cellSysutilAvcExt;
static const ppu_static_module cellSysutilNpEula;
static const ppu_static_module cellSysutilMisc;
static const ppu_static_module cellUsbd;
static const ppu_static_module cellUsbPspcm;
static const ppu_static_module cellUserInfo;
static const ppu_static_module cellVdec;
static const ppu_static_module cellVideoExport;
static const ppu_static_module cellVideoPlayerUtility;
static const ppu_static_module cellVideoUpload;
static const ppu_static_module cellVoice;
static const ppu_static_module cellVpost;
static const ppu_static_module libad_async;
static const ppu_static_module libad_core;
static const ppu_static_module libfs_utility_init;
static const ppu_static_module libmedi;
static const ppu_static_module libmixer;
static const ppu_static_module libsnd3;
static const ppu_static_module libsynth2;
static const ppu_static_module sceNp;
static const ppu_static_module sceNp2;
static const ppu_static_module sceNpClans;
static const ppu_static_module sceNpCommerce2;
static const ppu_static_module sceNpMatchingInt;
static const ppu_static_module sceNpSns;
static const ppu_static_module sceNpTrophy;
static const ppu_static_module sceNpTus;
static const ppu_static_module sceNpUtil;
static const ppu_static_module sceNpPlus;
static const ppu_static_module sys_crashdump;
static const ppu_static_module sys_io;
static const ppu_static_module sys_net;
static const ppu_static_module sysPrxForUser;
static const ppu_static_module sys_libc;
static const ppu_static_module sys_lv2dbg;
static const ppu_static_module static_hle;
static const ppu_static_module hle_patches;
};
template <auto* Func>
ppu_static_function* ppu_module_manager::registered<Func>::info = nullptr;
// Call specified function directly if LLE is not available, call LLE equivalent in callback style otherwise
template <auto* Func, typename... Args, typename RT = std::invoke_result_t<decltype(Func), ppu_thread&, Args...>>
inline RT ppu_execute(ppu_thread& ppu, Args... args)
{
vm::ptr<RT(Args...)> func = vm::cast(*ppu_module_manager::find_static_function<Func>().export_addr);
return func(ppu, args...);
}
#define BIND_FUNC_WITH_BLR(func, _module) BIND_FUNC(func, if (cpu_flag::again - ppu.state) ppu.cia = static_cast<u32>(ppu.lr) & ~3; else ppu.current_module = _module)
#define REG_FNID(_module, nid, func) ppu_module_manager::register_static_function<&func>(#_module, ppu_select_name(#func, nid), BIND_FUNC_WITH_BLR(func, #_module), ppu_generate_id(nid))
#define REG_FUNC(_module, func) REG_FNID(_module, #func, func)
#define REG_VNID(_module, nid, var) ppu_module_manager::register_static_variable<&var>(#_module, ppu_select_name(#var, nid), ppu_generate_id(nid))
#define REG_VAR(_module, var) REG_VNID(_module, #var, var)
#define REG_HIDDEN_FUNC(func) ppu_function_manager::register_function<decltype(&func), &func>(BIND_FUNC_WITH_BLR(func, ""))
#define REG_HIDDEN_FUNC_PURE(func) ppu_function_manager::register_function<decltype(&func), &func>(func)
#define REINIT_FUNC(func) (ppu_module_manager::find_static_function<&func>().flags = 0, ppu_module_manager::find_static_function<&func>())
#define UNIMPLEMENTED_FUNC(_module) _module.todo("%s()", __func__)
| 10,463
|
C++
|
.h
| 261
| 38.019157
| 185
| 0.782155
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,833
|
PPUOpcodes.h
|
RPCS3_rpcs3/rpcs3/Emu/Cell/PPUOpcodes.h
|
#pragma once
#include "Utilities/BitField.h"
template<typename T, u32 I, u32 N> using ppu_bf_t = bf_t<T, sizeof(T) * 8 - N - I, N>;
union ppu_opcode_t
{
u32 opcode;
ppu_bf_t<u32, 0, 6> main; // 0..5
cf_t<ppu_bf_t<u32, 30, 1>, ppu_bf_t<u32, 16, 5>> sh64; // 30 + 16..20
cf_t<ppu_bf_t<u32, 26, 1>, ppu_bf_t<u32, 21, 5>> mbe64; // 26 + 21..25
ppu_bf_t<u32, 11, 5> vuimm; // 11..15
ppu_bf_t<u32, 6, 5> vs; // 6..10
ppu_bf_t<u32, 22, 4> vsh; // 22..25
ppu_bf_t<u32, 21, 1> oe; // 21
ppu_bf_t<u32, 11, 10> spr; // 11..20
ppu_bf_t<u32, 21, 5> vc; // 21..25
ppu_bf_t<u32, 16, 5> vb; // 16..20
ppu_bf_t<u32, 11, 5> va; // 11..15
ppu_bf_t<u32, 6, 5> vd; // 6..10
ppu_bf_t<u32, 31, 1> lk; // 31
ppu_bf_t<u32, 30, 1> aa; // 30
ppu_bf_t<u32, 16, 5> rb; // 16..20
ppu_bf_t<u32, 11, 5> ra; // 11..15
ppu_bf_t<u32, 6, 5> rd; // 6..10
ppu_bf_t<u32, 16, 16> uimm16; // 16..31
ppu_bf_t<u32, 11, 1> l11; // 11
ppu_bf_t<u32, 6, 5> rs; // 6..10
ppu_bf_t<s32, 16, 16> simm16; // 16..31, signed
ppu_bf_t<s32, 16, 14> ds; // 16..29, signed
ppu_bf_t<s32, 11, 5> vsimm; // 11..15, signed
ppu_bf_t<s32, 6, 26> ll; // 6..31, signed
ppu_bf_t<s32, 6, 24> li; // 6..29, signed
ppu_bf_t<u32, 20, 7> lev; // 20..26
ppu_bf_t<u32, 16, 4> i; // 16..19
ppu_bf_t<u32, 11, 3> crfs; // 11..13
ppu_bf_t<u32, 10, 1> l10; // 10
ppu_bf_t<u32, 6, 3> crfd; // 6..8
ppu_bf_t<u32, 16, 5> crbb; // 16..20
ppu_bf_t<u32, 11, 5> crba; // 11..15
ppu_bf_t<u32, 6, 5> crbd; // 6..10
ppu_bf_t<u32, 31, 1> rc; // 31
ppu_bf_t<u32, 26, 5> me32; // 26..30
ppu_bf_t<u32, 21, 5> mb32; // 21..25
ppu_bf_t<u32, 16, 5> sh32; // 16..20
ppu_bf_t<u32, 11, 5> bi; // 11..15
ppu_bf_t<u32, 6, 5> bo; // 6..10
ppu_bf_t<u32, 19, 2> bh; // 19..20
ppu_bf_t<u32, 21, 5> frc; // 21..25
ppu_bf_t<u32, 16, 5> frb; // 16..20
ppu_bf_t<u32, 11, 5> fra; // 11..15
ppu_bf_t<u32, 6, 5> frd; // 6..10
ppu_bf_t<u32, 12, 8> crm; // 12..19
ppu_bf_t<u32, 6, 5> frs; // 6..10
ppu_bf_t<u32, 7, 8> flm; // 7..14
ppu_bf_t<u32, 6, 1> l6; // 6
ppu_bf_t<u32, 15, 1> l15; // 15
cf_t<ppu_bf_t<s32, 16, 14>, ff_t<u32, 0, 2>> bt14;
cf_t<ppu_bf_t<s32, 6, 24>, ff_t<u32, 0, 2>> bt24;
};
constexpr u64 ppu_rotate_mask(u32 mb, u32 me)
{
const u64 mask = ~0ull << (~(me - mb) & 63);
return (mask >> (mb & 63)) | (mask << ((64 - mb) & 63));
}
constexpr u32 ppu_decode(u32 inst)
{
return ((inst >> 26) | (inst << 6)) & 0x1ffff; // Rotate + mask
}
std::array<u32, 2> op_branch_targets(u32 pc, ppu_opcode_t op);
// PPU decoder object. D provides functions. T is function pointer type returned.
template <typename D, typename T = decltype(&D::UNK)>
class ppu_decoder
{
// Fast lookup table
std::array<T, 0x20000> m_table{};
struct instruction_info
{
u32 value;
T ptr0;
T ptr_rc;
u32 magn; // Non-zero for "columns" (effectively, number of most significant bits "eaten")
constexpr instruction_info(u32 v, T p, T p_rc, u32 m = 0)
: value(v)
, ptr0(p)
, ptr_rc(p_rc)
, magn(m)
{
}
constexpr instruction_info(u32 v, const T* p, const T* p_rc, u32 m = 0)
: value(v)
, ptr0(*p)
, ptr_rc(*p_rc)
, magn(m)
{
}
};
// Fill lookup table
void fill_table(u32 main_op, u32 count, u32 sh, std::initializer_list<instruction_info> entries) noexcept
{
if (sh < 11)
{
for (const auto& v : entries)
{
for (u32 i = 0; i < 1u << (v.magn + (11 - sh - count)); i++)
{
for (u32 j = 0; j < 1u << sh; j++)
{
const u32 k = (((i << (count - v.magn)) | v.value) << sh) | j;
::at32(m_table, (k << 6) | main_op) = k & 1 ? v.ptr_rc : v.ptr0;
}
}
}
}
else
{
// Main table (special case)
for (const auto& v : entries)
{
for (u32 i = 0; i < 1u << 11; i++)
{
::at32(m_table, i << 6 | v.value) = i & 1 ? v.ptr_rc : v.ptr0;
}
}
}
}
// Helper
static const D& _first(const D& arg)
{
return arg;
}
public:
template <typename... Args>
ppu_decoder(const Args&... args) noexcept
{
// If an object is passed to the constructor, assign values from that object
#define GET_(name) [&]{ if constexpr (sizeof...(Args) > 0) return _first(args...).name; else return &D::name; }()
#define GET(name) GET_(name), GET_(name)
#define GETRC(name) GET_(name), GET_(name##_)
static_assert(sizeof...(Args) <= 1);
for (auto& x : m_table)
{
x = GET(UNK);
}
// Main opcodes (field 0..5)
fill_table(0x00, 6, -1,
{
{ 0x02, GET(TDI) },
{ 0x03, GET(TWI) },
{ 0x07, GET(MULLI) },
{ 0x08, GET(SUBFIC) },
{ 0x0a, GET(CMPLI) },
{ 0x0b, GET(CMPI) },
{ 0x0c, GET(ADDIC) },
{ 0x0d, GET(ADDIC) },
{ 0x0e, GET(ADDI) },
{ 0x0f, GET(ADDIS) },
{ 0x10, GET(BC) },
{ 0x11, GET(SC) },
{ 0x12, GET(B) },
{ 0x14, GETRC(RLWIMI) },
{ 0x15, GETRC(RLWINM) },
{ 0x17, GETRC(RLWNM) },
{ 0x18, GET(ORI) },
{ 0x19, GET(ORIS) },
{ 0x1a, GET(XORI) },
{ 0x1b, GET(XORIS) },
{ 0x1c, GET(ANDI) },
{ 0x1d, GET(ANDIS) },
{ 0x20, GET(LWZ) },
{ 0x21, GET(LWZU) },
{ 0x22, GET(LBZ) },
{ 0x23, GET(LBZU) },
{ 0x24, GET(STW) },
{ 0x25, GET(STWU) },
{ 0x26, GET(STB) },
{ 0x27, GET(STBU) },
{ 0x28, GET(LHZ) },
{ 0x29, GET(LHZU) },
{ 0x2a, GET(LHA) },
{ 0x2b, GET(LHAU) },
{ 0x2c, GET(STH) },
{ 0x2d, GET(STHU) },
{ 0x2e, GET(LMW) },
{ 0x2f, GET(STMW) },
{ 0x30, GET(LFS) },
{ 0x31, GET(LFSU) },
{ 0x32, GET(LFD) },
{ 0x33, GET(LFDU) },
{ 0x34, GET(STFS) },
{ 0x35, GET(STFSU) },
{ 0x36, GET(STFD) },
{ 0x37, GET(STFDU) },
});
// Group 0x04 opcodes (field 21..31)
fill_table(0x04, 11, 0,
{
{ 0x0, GET(VADDUBM) },
{ 0x2, GET(VMAXUB) },
{ 0x4, GET(VRLB) },
{ 0x006, GET(VCMPEQUB) },
{ 0x406, GET(VCMPEQUB_) },
{ 0x8, GET(VMULOUB) },
{ 0xa, GET(VADDFP) },
{ 0xc, GET(VMRGHB) },
{ 0xe, GET(VPKUHUM) },
{ 0x20, GET(VMHADDSHS), 5 },
{ 0x21, GET(VMHRADDSHS), 5 },
{ 0x22, GET(VMLADDUHM), 5 },
{ 0x24, GET(VMSUMUBM), 5 },
{ 0x25, GET(VMSUMMBM), 5 },
{ 0x26, GET(VMSUMUHM), 5 },
{ 0x27, GET(VMSUMUHS), 5 },
{ 0x28, GET(VMSUMSHM), 5 },
{ 0x29, GET(VMSUMSHS), 5 },
{ 0x2a, GET(VSEL), 5 },
{ 0x2b, GET(VPERM), 5 },
{ 0x2c, GET(VSLDOI), 5 },
{ 0x2e, GET(VMADDFP), 5 },
{ 0x2f, GET(VNMSUBFP), 5 },
{ 0x40, GET(VADDUHM) },
{ 0x42, GET(VMAXUH) },
{ 0x44, GET(VRLH) },
{ 0x046, GET(VCMPEQUH) },
{ 0x446, GET(VCMPEQUH_) },
{ 0x48, GET(VMULOUH) },
{ 0x4a, GET(VSUBFP) },
{ 0x4c, GET(VMRGHH) },
{ 0x4e, GET(VPKUWUM) },
{ 0x80, GET(VADDUWM) },
{ 0x82, GET(VMAXUW) },
{ 0x84, GET(VRLW) },
{ 0x086, GET(VCMPEQUW) },
{ 0x486, GET(VCMPEQUW_) },
{ 0x8c, GET(VMRGHW) },
{ 0x8e, GET(VPKUHUS) },
{ 0x0c6, GET(VCMPEQFP) },
{ 0x4c6, GET(VCMPEQFP_) },
{ 0xce, GET(VPKUWUS) },
{ 0x102, GET(VMAXSB) },
{ 0x104, GET(VSLB) },
{ 0x108, GET(VMULOSB) },
{ 0x10a, GET(VREFP) },
{ 0x10c, GET(VMRGLB) },
{ 0x10e, GET(VPKSHUS) },
{ 0x142, GET(VMAXSH) },
{ 0x144, GET(VSLH) },
{ 0x148, GET(VMULOSH) },
{ 0x14a, GET(VRSQRTEFP) },
{ 0x14c, GET(VMRGLH) },
{ 0x14e, GET(VPKSWUS) },
{ 0x180, GET(VADDCUW) },
{ 0x182, GET(VMAXSW) },
{ 0x184, GET(VSLW) },
{ 0x18a, GET(VEXPTEFP) },
{ 0x18c, GET(VMRGLW) },
{ 0x18e, GET(VPKSHSS) },
{ 0x1c4, GET(VSL) },
{ 0x1c6, GET(VCMPGEFP) },
{ 0x5c6, GET(VCMPGEFP_) },
{ 0x1ca, GET(VLOGEFP) },
{ 0x1ce, GET(VPKSWSS) },
{ 0x200, GET(VADDUBS) },
{ 0x202, GET(VMINUB) },
{ 0x204, GET(VSRB) },
{ 0x206, GET(VCMPGTUB) },
{ 0x606, GET(VCMPGTUB_) },
{ 0x208, GET(VMULEUB) },
{ 0x20a, GET(VRFIN) },
{ 0x20c, GET(VSPLTB) },
{ 0x20e, GET(VUPKHSB) },
{ 0x240, GET(VADDUHS) },
{ 0x242, GET(VMINUH) },
{ 0x244, GET(VSRH) },
{ 0x246, GET(VCMPGTUH) },
{ 0x646, GET(VCMPGTUH_) },
{ 0x248, GET(VMULEUH) },
{ 0x24a, GET(VRFIZ) },
{ 0x24c, GET(VSPLTH) },
{ 0x24e, GET(VUPKHSH) },
{ 0x280, GET(VADDUWS) },
{ 0x282, GET(VMINUW) },
{ 0x284, GET(VSRW) },
{ 0x286, GET(VCMPGTUW) },
{ 0x686, GET(VCMPGTUW_) },
{ 0x28a, GET(VRFIP) },
{ 0x28c, GET(VSPLTW) },
{ 0x28e, GET(VUPKLSB) },
{ 0x2c4, GET(VSR) },
{ 0x2c6, GET(VCMPGTFP) },
{ 0x6c6, GET(VCMPGTFP_) },
{ 0x2ca, GET(VRFIM) },
{ 0x2ce, GET(VUPKLSH) },
{ 0x300, GET(VADDSBS) },
{ 0x302, GET(VMINSB) },
{ 0x304, GET(VSRAB) },
{ 0x306, GET(VCMPGTSB) },
{ 0x706, GET(VCMPGTSB_) },
{ 0x308, GET(VMULESB) },
{ 0x30a, GET(VCFUX) },
{ 0x30c, GET(VSPLTISB) },
{ 0x30e, GET(VPKPX) },
{ 0x340, GET(VADDSHS) },
{ 0x342, GET(VMINSH) },
{ 0x344, GET(VSRAH) },
{ 0x346, GET(VCMPGTSH) },
{ 0x746, GET(VCMPGTSH_) },
{ 0x348, GET(VMULESH) },
{ 0x34a, GET(VCFSX) },
{ 0x34c, GET(VSPLTISH) },
{ 0x34e, GET(VUPKHPX) },
{ 0x380, GET(VADDSWS) },
{ 0x382, GET(VMINSW) },
{ 0x384, GET(VSRAW) },
{ 0x386, GET(VCMPGTSW) },
{ 0x786, GET(VCMPGTSW_) },
{ 0x38a, GET(VCTUXS) },
{ 0x38c, GET(VSPLTISW) },
{ 0x3c6, GET(VCMPBFP) },
{ 0x7c6, GET(VCMPBFP_) },
{ 0x3ca, GET(VCTSXS) },
{ 0x3ce, GET(VUPKLPX) },
{ 0x400, GET(VSUBUBM) },
{ 0x402, GET(VAVGUB) },
{ 0x404, GET(VAND) },
{ 0x40a, GET(VMAXFP) },
{ 0x40c, GET(VSLO) },
{ 0x440, GET(VSUBUHM) },
{ 0x442, GET(VAVGUH) },
{ 0x444, GET(VANDC) },
{ 0x44a, GET(VMINFP) },
{ 0x44c, GET(VSRO) },
{ 0x480, GET(VSUBUWM) },
{ 0x482, GET(VAVGUW) },
{ 0x484, GET(VOR) },
{ 0x4c4, GET(VXOR) },
{ 0x502, GET(VAVGSB) },
{ 0x504, GET(VNOR) },
{ 0x542, GET(VAVGSH) },
{ 0x580, GET(VSUBCUW) },
{ 0x582, GET(VAVGSW) },
{ 0x600, GET(VSUBUBS) },
{ 0x604, GET(MFVSCR) },
{ 0x608, GET(VSUM4UBS) },
{ 0x640, GET(VSUBUHS) },
{ 0x644, GET(MTVSCR) },
{ 0x648, GET(VSUM4SHS) },
{ 0x680, GET(VSUBUWS) },
{ 0x688, GET(VSUM2SWS) },
{ 0x700, GET(VSUBSBS) },
{ 0x708, GET(VSUM4SBS) },
{ 0x740, GET(VSUBSHS) },
{ 0x780, GET(VSUBSWS) },
{ 0x788, GET(VSUMSWS) },
});
// Group 0x13 opcodes (field 21..30)
fill_table(0x13, 10, 1,
{
{ 0x000, GET(MCRF) },
{ 0x010, GET(BCLR) },
{ 0x021, GET(CRNOR) },
{ 0x081, GET(CRANDC) },
{ 0x096, GET(ISYNC) },
{ 0x0c1, GET(CRXOR) },
{ 0x0e1, GET(CRNAND) },
{ 0x101, GET(CRAND) },
{ 0x121, GET(CREQV) },
{ 0x1a1, GET(CRORC) },
{ 0x1c1, GET(CROR) },
{ 0x210, GET(BCCTR) },
});
// Group 0x1e opcodes (field 27..30)
fill_table(0x1e, 4, 1,
{
{ 0x0, GETRC(RLDICL) },
{ 0x1, GETRC(RLDICL) },
{ 0x2, GETRC(RLDICR) },
{ 0x3, GETRC(RLDICR) },
{ 0x4, GETRC(RLDIC) },
{ 0x5, GETRC(RLDIC) },
{ 0x6, GETRC(RLDIMI) },
{ 0x7, GETRC(RLDIMI) },
{ 0x8, GETRC(RLDCL) },
{ 0x9, GETRC(RLDCR) },
});
// Group 0x1f opcodes (field 21..30)
fill_table(0x1f, 10, 1,
{
{ 0x000, GET(CMP) },
{ 0x004, GET(TW) },
{ 0x006, GET(LVSL) },
{ 0x007, GET(LVEBX) },
{ 0x008, GETRC(SUBFC) },
{ 0x208, GETRC(SUBFCO) },
{ 0x009, GETRC(MULHDU) },
{ 0x00a, GETRC(ADDC) },
{ 0x20a, GETRC(ADDCO) },
{ 0x00b, GETRC(MULHWU) },
{ 0x013, GET(MFOCRF) },
{ 0x014, GET(LWARX) },
{ 0x015, GET(LDX) },
{ 0x017, GET(LWZX) },
{ 0x018, GETRC(SLW) },
{ 0x01a, GETRC(CNTLZW) },
{ 0x01b, GETRC(SLD) },
{ 0x01c, GETRC(AND) },
{ 0x020, GET(CMPL) },
{ 0x026, GET(LVSR) },
{ 0x027, GET(LVEHX) },
{ 0x028, GETRC(SUBF) },
{ 0x228, GETRC(SUBFO) },
{ 0x035, GET(LDUX) },
{ 0x036, GET(DCBST) },
{ 0x037, GET(LWZUX) },
{ 0x03a, GETRC(CNTLZD) },
{ 0x03c, GETRC(ANDC) },
{ 0x044, GET(TD) },
{ 0x047, GET(LVEWX) },
{ 0x049, GETRC(MULHD) },
{ 0x04b, GETRC(MULHW) },
{ 0x054, GET(LDARX) },
{ 0x056, GET(DCBF) },
{ 0x057, GET(LBZX) },
{ 0x067, GET(LVX) },
{ 0x068, GETRC(NEG) },
{ 0x268, GETRC(NEGO) },
{ 0x077, GET(LBZUX) },
{ 0x07c, GETRC(NOR) },
{ 0x087, GET(STVEBX) },
{ 0x088, GETRC(SUBFE) },
{ 0x288, GETRC(SUBFEO) },
{ 0x08a, GETRC(ADDE) },
{ 0x28a, GETRC(ADDEO) },
{ 0x090, GET(MTOCRF) },
{ 0x095, GET(STDX) },
{ 0x096, GET(STWCX) },
{ 0x097, GET(STWX) },
{ 0x0a7, GET(STVEHX) },
{ 0x0b5, GET(STDUX) },
{ 0x0b7, GET(STWUX) },
{ 0x0c7, GET(STVEWX) },
{ 0x0c8, GETRC(SUBFZE) },
{ 0x2c8, GETRC(SUBFZEO) },
{ 0x0ca, GETRC(ADDZE) },
{ 0x2ca, GETRC(ADDZEO) },
{ 0x0d6, GET(STDCX) },
{ 0x0d7, GET(STBX) },
{ 0x0e7, GET(STVX) },
{ 0x0e8, GETRC(SUBFME) },
{ 0x2e8, GETRC(SUBFMEO) },
{ 0x0e9, GETRC(MULLD) },
{ 0x2e9, GETRC(MULLDO) },
{ 0x0ea, GETRC(ADDME) },
{ 0x2ea, GETRC(ADDMEO) },
{ 0x0eb, GETRC(MULLW) },
{ 0x2eb, GETRC(MULLWO) },
{ 0x0f6, GET(DCBTST) },
{ 0x0f7, GET(STBUX) },
{ 0x10a, GETRC(ADD) },
{ 0x30a, GETRC(ADDO) },
{ 0x116, GET(DCBT) },
{ 0x117, GET(LHZX) },
{ 0x11c, GETRC(EQV) },
{ 0x136, GET(ECIWX) },
{ 0x137, GET(LHZUX) },
{ 0x13c, GETRC(XOR) },
{ 0x153, GET(MFSPR) },
{ 0x155, GET(LWAX) },
{ 0x156, GET(DST) },
{ 0x157, GET(LHAX) },
{ 0x167, GET(LVXL) },
{ 0x173, GET(MFTB) },
{ 0x175, GET(LWAUX) },
{ 0x176, GET(DSTST) },
{ 0x177, GET(LHAUX) },
{ 0x197, GET(STHX) },
{ 0x19c, GETRC(ORC) },
{ 0x1b6, GET(ECOWX) },
{ 0x1b7, GET(STHUX) },
{ 0x1bc, GETRC(OR) },
{ 0x1c9, GETRC(DIVDU) },
{ 0x3c9, GETRC(DIVDUO) },
{ 0x1cb, GETRC(DIVWU) },
{ 0x3cb, GETRC(DIVWUO) },
{ 0x1d3, GET(MTSPR) },
{ 0x1d6, GET(DCBI) },
{ 0x1dc, GETRC(NAND) },
{ 0x1e7, GET(STVXL) },
{ 0x1e9, GETRC(DIVD) },
{ 0x3e9, GETRC(DIVDO) },
{ 0x1eb, GETRC(DIVW) },
{ 0x3eb, GETRC(DIVWO) },
{ 0x207, GET(LVLX) },
{ 0x214, GET(LDBRX) },
{ 0x215, GET(LSWX) },
{ 0x216, GET(LWBRX) },
{ 0x217, GET(LFSX) },
{ 0x218, GETRC(SRW) },
{ 0x21b, GETRC(SRD) },
{ 0x227, GET(LVRX) },
{ 0x237, GET(LFSUX) },
{ 0x255, GET(LSWI) },
{ 0x256, GET(SYNC) },
{ 0x257, GET(LFDX) },
{ 0x277, GET(LFDUX) },
{ 0x287, GET(STVLX) },
{ 0x294, GET(STDBRX) },
{ 0x295, GET(STSWX) },
{ 0x296, GET(STWBRX) },
{ 0x297, GET(STFSX) },
{ 0x2a7, GET(STVRX) },
{ 0x2b7, GET(STFSUX) },
{ 0x2d5, GET(STSWI) },
{ 0x2d7, GET(STFDX) },
{ 0x2f7, GET(STFDUX) },
{ 0x307, GET(LVLXL) },
{ 0x316, GET(LHBRX) },
{ 0x318, GETRC(SRAW) },
{ 0x31a, GETRC(SRAD) },
{ 0x327, GET(LVRXL) },
{ 0x336, GET(DSS) },
{ 0x338, GETRC(SRAWI) },
{ 0x33a, GETRC(SRADI) },
{ 0x33b, GETRC(SRADI) },
{ 0x356, GET(EIEIO) },
{ 0x387, GET(STVLXL) },
{ 0x396, GET(STHBRX) },
{ 0x39a, GETRC(EXTSH) },
{ 0x3a7, GET(STVRXL) },
{ 0x3ba, GETRC(EXTSB) },
{ 0x3d7, GET(STFIWX) },
{ 0x3da, GETRC(EXTSW) },
{ 0x3d6, GET(ICBI) },
{ 0x3f6, GET(DCBZ) },
});
// Group 0x3a opcodes (field 30..31)
fill_table(0x3a, 2, 0,
{
{ 0x0, GET(LD) },
{ 0x1, GET(LDU) },
{ 0x2, GET(LWA) },
});
// Group 0x3b opcodes (field 21..30)
fill_table(0x3b, 10, 1,
{
{ 0x12, GETRC(FDIVS), 5 },
{ 0x14, GETRC(FSUBS), 5 },
{ 0x15, GETRC(FADDS), 5 },
{ 0x16, GETRC(FSQRTS), 5 },
{ 0x18, GETRC(FRES), 5 },
{ 0x19, GETRC(FMULS), 5 },
{ 0x1c, GETRC(FMSUBS), 5 },
{ 0x1d, GETRC(FMADDS), 5 },
{ 0x1e, GETRC(FNMSUBS), 5 },
{ 0x1f, GETRC(FNMADDS), 5 },
});
// Group 0x3e opcodes (field 30..31)
fill_table(0x3e, 2, 0,
{
{ 0x0, GET(STD) },
{ 0x1, GET(STDU) },
});
// Group 0x3f opcodes (field 21..30)
fill_table(0x3f, 10, 1,
{
{ 0x026, GETRC(MTFSB1) },
{ 0x040, GET(MCRFS) },
{ 0x046, GETRC(MTFSB0) },
{ 0x086, GETRC(MTFSFI) },
{ 0x247, GETRC(MFFS) },
{ 0x2c7, GETRC(MTFSF) },
{ 0x000, GET(FCMPU) },
{ 0x00c, GETRC(FRSP) },
{ 0x00e, GETRC(FCTIW) },
{ 0x00f, GETRC(FCTIWZ) },
{ 0x012, GETRC(FDIV), 5 },
{ 0x014, GETRC(FSUB), 5 },
{ 0x015, GETRC(FADD), 5 },
{ 0x016, GETRC(FSQRT), 5 },
{ 0x017, GETRC(FSEL), 5 },
{ 0x019, GETRC(FMUL), 5 },
{ 0x01a, GETRC(FRSQRTE), 5 },
{ 0x01c, GETRC(FMSUB), 5 },
{ 0x01d, GETRC(FMADD), 5 },
{ 0x01e, GETRC(FNMSUB), 5 },
{ 0x01f, GETRC(FNMADD), 5 },
{ 0x020, GET(FCMPO) },
{ 0x028, GETRC(FNEG) },
{ 0x048, GETRC(FMR) },
{ 0x088, GETRC(FNABS) },
{ 0x108, GETRC(FABS) },
{ 0x32e, GETRC(FCTID) },
{ 0x32f, GETRC(FCTIDZ) },
{ 0x34e, GETRC(FCFID) },
});
}
const std::array<T, 0x20000>& get_table() const noexcept
{
return m_table;
}
T decode(u32 inst) const noexcept
{
return m_table[ppu_decode(inst)];
}
};
#undef GET_
#undef GET
#undef GETRC
namespace ppu_instructions
{
namespace fields
{
enum
{
r0, r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11,
r12, r13, r14, r15, r16, r17, r18, r19, r20, r21,
r22, r23, r24, r25, r26, r27, r28, r29, r30, r31,
};
enum
{
f0, f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, f11,
f12, f13, f14, f15, F16, f17, f18, f19, f20, f21,
f22, f23, f24, f25, f26, f27, f28, f29, f30, f31,
};
enum
{
v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11,
v12, v13, v14, v15, v16, v17, v18, v19, v20, v21,
v22, v23, v24, v25, v26, v27, v28, v29, v30, v31,
};
enum
{
cr0, cr1, cr2, cr3, cr4, cr5, cr6, cr7,
};
}
using namespace fields;
inline u32 ADDI(u32 rt, u32 ra, s32 si) { ppu_opcode_t op{ 0x0eu << 26 }; op.rd = rt; op.ra = ra; op.simm16 = si; return op.opcode; }
inline u32 ADDIS(u32 rt, u32 ra, s32 si) { ppu_opcode_t op{ 0x0fu << 26 }; op.rd = rt; op.ra = ra; op.simm16 = si; return op.opcode; }
inline u32 XORIS(u32 rt, u32 ra, s32 si) { ppu_opcode_t op{ 0x1bu << 26 }; op.rd = rt; op.ra = ra; op.simm16 = si; return op.opcode; }
inline u32 ORI(u32 rt, u32 ra, u32 ui) { ppu_opcode_t op{ 0x18u << 26 }; op.rd = rt; op.ra = ra; op.uimm16 = ui; return op.opcode; }
inline u32 ORIS(u32 rt, u32 ra, u32 ui) { ppu_opcode_t op{ 0x19u << 26 }; op.rd = rt; op.ra = ra; op.uimm16 = ui; return op.opcode; }
inline u32 OR(u32 ra, u32 rs, u32 rb, bool rc = false) { ppu_opcode_t op{ 0x1fu << 26 | 0x1bcu << 1 }; op.rs = rs; op.ra = ra; op.rb = rb; op.rc = rc; return op.opcode; }
inline u32 SC(u32 lev) { ppu_opcode_t op{ 0x11u << 26 | 1 << 1 }; op.lev = lev; return op.opcode; }
inline u32 B(s32 li, bool aa = false, bool lk = false) { ppu_opcode_t op{0x12u << 26}; op.ll = li; op.aa = aa; op.lk = lk; return op.opcode; }
inline u32 BC(u32 bo, u32 bi, s32 bd, bool aa = false, bool lk = false) { ppu_opcode_t op{ 0x10u << 26 }; op.bo = bo; op.bi = bi; op.ds = bd / 4; op.aa = aa; op.lk = lk; return op.opcode; }
inline u32 BCLR(u32 bo, u32 bi, u32 bh, bool lk = false) { ppu_opcode_t op{ 0x13u << 26 | 0x10u << 1 }; op.bo = bo; op.bi = bi; op.bh = bh; op.lk = lk; return op.opcode; }
inline u32 BCCTR(u32 bo, u32 bi, u32 bh, bool lk = false) { ppu_opcode_t op{ 0x13u << 26 | 0x210u << 1 }; op.bo = bo; op.bi = bi; op.bh = bh; op.lk = lk; return op.opcode; }
inline u32 MFSPR(u32 rt, u32 spr) { ppu_opcode_t op{ 0x1fu << 26 | 0x153u << 1 }; op.rd = rt; op.spr = spr; return op.opcode; }
inline u32 MTSPR(u32 spr, u32 rs) { ppu_opcode_t op{ 0x1fu << 26 | 0x1d3u << 1 }; op.rs = rs; op.spr = spr; return op.opcode; }
inline u32 LWZ(u32 rt, u32 ra, s32 si) { ppu_opcode_t op{ 0x20u << 26 }; op.rd = rt; op.ra = ra; op.simm16 = si; return op.opcode; }
inline u32 STW(u32 rt, u32 ra, s32 si) { ppu_opcode_t op{ 0x24u << 26 }; op.rd = rt; op.ra = ra; op.simm16 = si; return op.opcode; }
inline u32 STD(u32 rs, u32 ra, s32 si) { ppu_opcode_t op{ 0x3eu << 26 }; op.rs = rs; op.ra = ra; op.ds = si / 4; return op.opcode; }
inline u32 STDU(u32 rs, u32 ra, s32 si) { ppu_opcode_t op{ 0x3eu << 26 | 1 }; op.rs = rs; op.ra = ra; op.ds = si / 4; return op.opcode; }
inline u32 LD(u32 rt, u32 ra, s32 si) { ppu_opcode_t op{ 0x3au << 26 }; op.rd = rt; op.ra = ra; op.ds = si / 4; return op.opcode; }
inline u32 LDU(u32 rt, u32 ra, s32 si) { ppu_opcode_t op{ 0x3au << 26 | 1 }; op.rd = rt; op.ra = ra; op.ds = si / 4; return op.opcode; }
inline u32 CMPI(u32 bf, u32 l, u32 ra, u32 ui) { ppu_opcode_t op{ 0xbu << 26 }; op.crfd = bf; op.l10 = l; op.ra = ra; op.uimm16 = ui; return op.opcode; }
inline u32 CMPLI(u32 bf, u32 l, u32 ra, u32 ui) { ppu_opcode_t op{ 0xau << 26 }; op.crfd = bf; op.l10 = l; op.ra = ra; op.uimm16 = ui; return op.opcode; }
inline u32 RLDICL(u32 ra, u32 rs, u32 sh, u32 mb, bool rc = false) { ppu_opcode_t op{ 30 << 26 }; op.ra = ra; op.rs = rs; op.sh64 = sh; op.mbe64 = mb; op.rc = rc; return op.opcode; }
inline u32 RLDICR(u32 ra, u32 rs, u32 sh, u32 mb, bool rc = false) { return RLDICL(ra, rs, sh, mb, rc) | 1 << 2; }
inline u32 STFD(u32 frs, u32 ra, s32 si) { ppu_opcode_t op{ 54u << 26 }; op.frs = frs; op.ra = ra; op.simm16 = si; return op.opcode; }
inline u32 STVX(u32 vs, u32 ra, u32 rb) { ppu_opcode_t op{ 31 << 26 | 231 << 1 }; op.vs = vs; op.ra = ra; op.rb = rb; return op.opcode; }
inline u32 LFD(u32 frd, u32 ra, s32 si) { ppu_opcode_t op{ 50u << 26 }; op.frd = frd; op.ra = ra; op.simm16 = si; return op.opcode; }
inline u32 LVX(u32 vd, u32 ra, u32 rb) { ppu_opcode_t op{ 31 << 26 | 103 << 1 }; op.vd = vd; op.ra = ra; op.rb = rb; return op.opcode; }
inline constexpr u32 EIEIO() { return 0x7c0006ac; }
namespace implicts
{
inline u32 NOP() { return ORI(r0, r0, 0); }
inline u32 MR(u32 rt, u32 ra) { return OR(rt, ra, ra, false); }
inline u32 LI(u32 rt, u32 imm) { return ADDI(rt, r0, imm); }
inline u32 LIS(u32 rt, u32 imm) { return ADDIS(rt, r0, imm); }
inline u32 BLR() { return BCLR(0x10 | 0x04, 0, 0); }
inline u32 BCTR() { return BCCTR(0x10 | 0x04, 0, 0); }
inline u32 BCTRL() { return BCCTR(0x10 | 0x04, 0, 0, true); }
inline u32 MFCTR(u32 reg) { return MFSPR(reg, 9 << 5); }
inline u32 MTCTR(u32 reg) { return MTSPR(9 << 5, reg); }
inline u32 MFLR(u32 reg) { return MFSPR(reg, 8 << 5); }
inline u32 MTLR(u32 reg) { return MTSPR(8 << 5, reg); }
inline u32 BNE(u32 cr, s32 imm) { return BC(4, 2 | cr << 2, imm); }
inline u32 BEQ(u32 cr, s32 imm) { return BC(12, 2 | cr << 2, imm); }
inline u32 BGT(u32 cr, s32 imm) { return BC(12, 1 | cr << 2, imm); }
inline u32 BNE(s32 imm) { return BNE(cr0, imm); }
inline u32 BEQ(s32 imm) { return BEQ(cr0, imm); }
inline u32 BGT(s32 imm) { return BGT(cr0, imm); }
inline u32 CMPDI(u32 cr, u32 reg, u32 imm) { return CMPI(cr, 1, reg, imm); }
inline u32 CMPDI(u32 reg, u32 imm) { return CMPDI(cr0, reg, imm); }
inline u32 CMPWI(u32 cr, u32 reg, u32 imm) { return CMPI(cr, 0, reg, imm); }
inline u32 CMPWI(u32 reg, u32 imm) { return CMPWI(cr0, reg, imm); }
inline u32 CMPLDI(u32 cr, u32 reg, u32 imm) { return CMPLI(cr, 1, reg, imm); }
inline u32 CMPLDI(u32 reg, u32 imm) { return CMPLDI(cr0, reg, imm); }
inline u32 CMPLWI(u32 cr, u32 reg, u32 imm) { return CMPLI(cr, 0, reg, imm); }
inline u32 CMPLWI(u32 reg, u32 imm) { return CMPLWI(cr0, reg, imm); }
inline u32 EXTRDI(u32 x, u32 y, u32 n, u32 b) { return RLDICL(x, y, b + n, 64 - b, false); }
inline u32 SRDI(u32 x, u32 y, u32 n) { return RLDICL(x, y, 64 - n, n, false); }
inline u32 CLRLDI(u32 x, u32 y, u32 n) { return RLDICL(x, y, 0, n, false); }
inline u32 CLRRDI(u32 x, u32 y, u32 n) { return RLDICR(x, y, 0, 63 - n, false); }
inline constexpr u32 TRAP() { return 0x7FE00008; } // tw 31,r0,r0
}
using namespace implicts;
}
| 23,016
|
C++
|
.h
| 697
| 29.519369
| 190
| 0.561378
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,834
|
cellBgdl.h
|
RPCS3_rpcs3/rpcs3/Emu/Cell/Modules/cellBgdl.h
|
#pragma once
#include "Emu/Memory/vm_ptr.h"
// Return Codes
enum
{
CELL_BGDL_UTIL_ERROR_BUSY = 0x8002ce01,
CELL_BGDL_UTIL_ERROR_INTERNAL = 0x8002ce02,
CELL_BGDL_UTIL_ERROR_PARAM = 0x8002ce03,
CELL_BGDL_UTIL_ERROR_ACCESS_ERROR = 0x8002ce04,
CELL_BGDL_UTIL_ERROR_INITIALIZE = 0x8002ce05,
};
enum CellBGDLState : s32
{
CELL_BGDL_STATE_ERROR = 0,
CELL_BGDL_STATE_PAUSE,
CELL_BGDL_STATE_READY,
CELL_BGDL_STATE_RUN,
CELL_BGDL_STATE_COMPLETE,
};
enum CellBGDLMode : s32
{
CELL_BGDL_MODE_AUTO = 0,
CELL_BGDL_MODE_ALWAYS_ALLOW,
};
struct CellBGDLInfo
{
be_t<u64> received_size;
be_t<u64> content_size;
be_t<s32> state; // CellBGDLState
vm::bptr<void> reserved;
};
| 697
|
C++
|
.h
| 31
| 20.806452
| 48
| 0.73525
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,835
|
cellWebBrowser.h
|
RPCS3_rpcs3/rpcs3/Emu/Cell/Modules/cellWebBrowser.h
|
#pragma once
#include "cellSysutil.h"
#include "Emu/Memory/vm_ptr.h"
//events
enum CellWebBrowserEvent : s32
{
CELL_SYSUTIL_WEBBROWSER_INITIALIZING_FINISHED = 1,
CELL_SYSUTIL_WEBBROWSER_SHUTDOWN_FINISHED = 4,
CELL_SYSUTIL_WEBBROWSER_LOADING_FINISHED = 5,
CELL_SYSUTIL_WEBBROWSER_UNLOADING_FINISHED = 7,
CELL_SYSUTIL_WEBBROWSER_RELEASED = 9,
CELL_SYSUTIL_WEBBROWSER_GRABBED = 11,
};
using CellWebBrowserCallback = void(s32 cb_type, vm::ptr<void> client_session, vm::ptr<void> usrdata);
using CellWebComponentCallback = void(s32 web_browser_id, s32 cb_type, vm::ptr<void> client_session, vm::ptr<void> usrdata);
using CellWebBrowserSystemCallback = void(s32 cb_type, vm::ptr<void> usrdata);
using CellWebBrowserMIMETypeCallback = void(vm::cptr<char> mimetype, vm::cptr<char> url, vm::ptr<void> usrdata);
using CellWebBrowserErrorCallback = void(s32 err_type, vm::ptr<void> usrdata);
using CellWebBrowserStatusCallback = void(s32 err_type, vm::ptr<void> usrdata);
using CellWebBrowserNotify = void(vm::cptr<char> message, vm::ptr<void> usrdata);
using CellWebBrowserUsrdata = void(vm::ptr<void> usrdata);
struct CellWebBrowserMimeSet
{
vm::bcptr<char> type;
vm::bcptr<char> directory;
};
struct CellWebBrowserPos
{
be_t<s32> x;
be_t<s32> y;
};
struct CellWebBrowserSize
{
be_t<s32> width;
be_t<s32> height;
};
struct CellWebBrowserRect
{
CellWebBrowserPos pos;
CellWebBrowserSize size;
};
struct CellWebBrowserConfig
{
be_t<s32> version;
be_t<s32> heap_size;
vm::bcptr<CellWebBrowserMimeSet> mimesets;
be_t<s32> mimeset_num;
be_t<s32> functions;
be_t<s32> tab_count;
vm::bptr<CellWebBrowserCallback> exit_cb;
vm::bptr<CellWebBrowserCallback> download_cb;
vm::bptr<CellWebBrowserCallback> navigated_cb;
};
struct CellWebBrowserConfig2
{
be_t<s32> version;
be_t<s32> heap_size;
be_t<s32> functions;
be_t<s32> tab_count;
be_t<s32> size_mode;
be_t<s32> view_restriction;
vm::bptr<CellWebBrowserMIMETypeCallback> unknown_mimetype_cb;
vm::bptr<CellWebBrowserErrorCallback> error_cb;
vm::bptr<CellWebBrowserStatusCallback> status_error_cb;
vm::bptr<CellWebBrowserNotify> notify_cb;
vm::bptr<CellWebBrowserCallback> request_cb;
CellWebBrowserRect rect;
be_t<f32> resolution_factor;
be_t<s32> magic_number_;
};
| 2,257
|
C++
|
.h
| 70
| 30.557143
| 124
| 0.78125
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,836
|
cellSaveData.h
|
RPCS3_rpcs3/rpcs3/Emu/Cell/Modules/cellSaveData.h
|
#pragma once
#include "util/types.hpp"
#include "util/endian.hpp"
#include "Emu/Memory/vm_ptr.h"
#include <string>
#include <vector>
// Return codes
enum CellSaveDataError : u32
{
CELL_SAVEDATA_ERROR_CBRESULT = 0x8002b401,
CELL_SAVEDATA_ERROR_ACCESS_ERROR = 0x8002b402,
CELL_SAVEDATA_ERROR_INTERNAL = 0x8002b403,
CELL_SAVEDATA_ERROR_PARAM = 0x8002b404,
CELL_SAVEDATA_ERROR_NOSPACE = 0x8002b405,
CELL_SAVEDATA_ERROR_BROKEN = 0x8002b406,
CELL_SAVEDATA_ERROR_FAILURE = 0x8002b407,
CELL_SAVEDATA_ERROR_BUSY = 0x8002b408,
CELL_SAVEDATA_ERROR_NOUSER = 0x8002b409,
CELL_SAVEDATA_ERROR_SIZEOVER = 0x8002b40a,
CELL_SAVEDATA_ERROR_NODATA = 0x8002b40b,
CELL_SAVEDATA_ERROR_NOTSUPPORTED = 0x8002b40c,
};
// Callback return codes
enum
{
CELL_SAVEDATA_CBRESULT_OK_LAST_NOCONFIRM = 2,
CELL_SAVEDATA_CBRESULT_OK_LAST = 1,
CELL_SAVEDATA_CBRESULT_OK_NEXT = 0,
CELL_SAVEDATA_CBRESULT_ERR_NOSPACE = -1,
CELL_SAVEDATA_CBRESULT_ERR_FAILURE = -2,
CELL_SAVEDATA_CBRESULT_ERR_BROKEN = -3,
CELL_SAVEDATA_CBRESULT_ERR_NODATA = -4,
CELL_SAVEDATA_CBRESULT_ERR_INVALID = -5,
};
// Bind stat return codes
enum
{
CELL_SAVEDATA_BINDSTAT_OK = 0,
CELL_SAVEDATA_BINDSTAT_ERR_CONSOLE = 1 << 0,
CELL_SAVEDATA_BINDSTAT_ERR_DISC = 1 << 1,
CELL_SAVEDATA_BINDSTAT_ERR_PROGRAM = 1 << 2,
CELL_SAVEDATA_BINDSTAT_ERR_NOACCOUNTI = 1 << 3,
CELL_SAVEDATA_BINDSTAT_ERR_NOUSER = 1 << 3,
CELL_SAVEDATA_BINDSTAT_ERR_ACCOUNTID = 1 << 4,
CELL_SAVEDATA_BINDSTAT_ERR_OTHERS = 1 << 4,
CELL_SAVEDATA_BINDSTAT_ERR_NOUSERID = 1 << 5,
CELL_SAVEDATA_BINDSTAT_ERR_USERID = 1 << 6,
CELL_SAVEDATA_BINDSTAT_ERR_NOOWNER = 1 << 8,
CELL_SAVEDATA_BINDSTAT_ERR_OWNER = 1 << 9,
CELL_SAVEDATA_BINDSTAT_ERR_LOCALOWNER = 1 << 10,
};
// Constants
enum
{
// CellSaveDataParamSize
CELL_SAVEDATA_DIRNAME_SIZE = 32,
CELL_SAVEDATA_FILENAME_SIZE = 13,
CELL_SAVEDATA_SECUREFILEID_SIZE = 16,
CELL_SAVEDATA_PREFIX_SIZE = 256,
CELL_SAVEDATA_LISTITEM_MAX = 2048,
CELL_SAVEDATA_SECUREFILE_MAX = 113,
CELL_SAVEDATA_DIRLIST_MAX = 2048,
CELL_SAVEDATA_INVALIDMSG_MAX = 256,
CELL_SAVEDATA_INDICATORMSG_MAX = 64,
// CellSaveDataSystemParamSize
CELL_SAVEDATA_SYSP_TITLE_SIZE = 128,
CELL_SAVEDATA_SYSP_SUBTITLE_SIZE = 128,
CELL_SAVEDATA_SYSP_DETAIL_SIZE = 1024,
CELL_SAVEDATA_SYSP_LPARAM_SIZE = 8,
// CellSaveDataSortType
CELL_SAVEDATA_SORTTYPE_MODIFIEDTIME = 0,
CELL_SAVEDATA_SORTTYPE_SUBTITLE = 1,
// CellSaveDataSortOrder
CELL_SAVEDATA_SORTORDER_DESCENT = 0,
CELL_SAVEDATA_SORTORDER_ASCENT = 1,
// CellSaveDataIsNewData
CELL_SAVEDATA_ISNEWDATA_NO = 0,
CELL_SAVEDATA_ISNEWDATA_YES = 1,
// CellSaveDataFocusPosition
CELL_SAVEDATA_FOCUSPOS_DIRNAME = 0,
CELL_SAVEDATA_FOCUSPOS_LISTHEAD = 1,
CELL_SAVEDATA_FOCUSPOS_LISTTAIL = 2,
CELL_SAVEDATA_FOCUSPOS_LATEST = 3,
CELL_SAVEDATA_FOCUSPOS_OLDEST = 4,
CELL_SAVEDATA_FOCUSPOS_NEWDATA = 5,
// CellSaveDataFileOperation
CELL_SAVEDATA_FILEOP_READ = 0,
CELL_SAVEDATA_FILEOP_WRITE = 1,
CELL_SAVEDATA_FILEOP_DELETE = 2,
CELL_SAVEDATA_FILEOP_WRITE_NOTRUNC = 3,
// CellSaveDataFileType
CELL_SAVEDATA_FILETYPE_SECUREFILE = 0,
CELL_SAVEDATA_FILETYPE_NORMALFILE = 1,
CELL_SAVEDATA_FILETYPE_CONTENT_ICON0 = 2,
CELL_SAVEDATA_FILETYPE_CONTENT_ICON1 = 3,
CELL_SAVEDATA_FILETYPE_CONTENT_PIC1 = 4,
CELL_SAVEDATA_FILETYPE_CONTENT_SND0 = 5,
// CellSaveDataSystemFileParam attribute
CELL_SAVEDATA_ATTR_NORMAL = 0,
CELL_SAVEDATA_ATTR_NODUPLICATE = 1,
// reCreateMode
CELL_SAVEDATA_RECREATE_NO = 0,
CELL_SAVEDATA_RECREATE_NO_NOBROKEN = 1,
CELL_SAVEDATA_RECREATE_YES = 2,
CELL_SAVEDATA_RECREATE_YES_RESET_OWNER = 3,
CELL_SAVEDATA_RECREATE_MASK = 0xfffeffff,
// Version
CELL_SAVEDATA_VERSION_OLD = 0,
CELL_SAVEDATA_VERSION_420 = 1,
// Error Dialog
CELL_SAVEDATA_ERRDIALOG_NONE = 0,
CELL_SAVEDATA_ERRDIALOG_ALWAYS = 1,
CELL_SAVEDATA_ERRDIALOG_NOREPEAT = 2,
// Options for funcFixed dialog
CELL_SAVEDATA_OPTION_NONE = 0,
CELL_SAVEDATA_OPTION_NOCONFIRM = 1,
// CellSaveDataAutoIndicatorDispPosition
CELL_SAVEDATA_INDICATORPOS_LOWER_RIGHT = 0,
CELL_SAVEDATA_INDICATORPOS_LOWER_LEFT = 1,
CELL_SAVEDATA_INDICATORPOS_UPPER_RIGHT = 2,
CELL_SAVEDATA_INDICATORPOS_UPPER_LEFT = 3,
CELL_SAVEDATA_INDICATORPOS_CENTER = 4,
// CellSaveDataAutoIndicatorDispMsgAlign
CELL_SAVEDATA_INDICATORPOS_MSGALIGN_LEFT = 0 << 4,
CELL_SAVEDATA_INDICATORPOS_MSGALIGN_RIGHT = 1 << 4,
CELL_SAVEDATA_INDICATORPOS_MSGALIGN_CENTER = 2 << 4,
// CellSaveDataAutoIndicatorDispMode
CELL_SAVEDATA_INDICATORMODE_FIXED = 0,
CELL_SAVEDATA_INDICATORMODE_BLINK = 1,
CELL_SAVEDATA_INDICATORMODE_BLINK_FAST = 2,
CELL_SAVEDATA_INDICATORMODE_BLINK_SLOW = 3,
// Trophy ownership
CELL_SAVEDATA_DISABLE_TROPHY_OWNERSHIP_CHECK = 1 << 16,
};
// CellSaveDataListNewData::iconPosition
enum : u32
{
CELL_SAVEDATA_ICONPOS_HEAD = 0,
CELL_SAVEDATA_ICONPOS_TAIL = 1,
};
// Datatypes
struct CellSaveDataSetList
{
be_t<u32> sortType;
be_t<u32> sortOrder;
vm::bptr<char> dirNamePrefix;
vm::bptr<void> reserved;
};
struct CellSaveDataSetBuf
{
be_t<u32> dirListMax;
be_t<u32> fileListMax;
be_t<u32> reserved[6];
be_t<u32> bufSize;
vm::bptr<void> buf;
};
struct CellSaveDataNewDataIcon
{
vm::bptr<char> title;
be_t<u32> iconBufSize;
vm::bptr<void> iconBuf;
vm::bptr<void> reserved;
};
struct CellSaveDataListNewData
{
be_t<u32> iconPosition;
vm::bptr<char> dirName;
vm::bptr<CellSaveDataNewDataIcon> icon;
vm::bptr<void> reserved;
};
struct CellSaveDataDirList
{
char dirName[CELL_SAVEDATA_DIRNAME_SIZE];
char listParam[CELL_SAVEDATA_SYSP_LPARAM_SIZE];
char reserved[8];
};
struct CellSaveDataListGet
{
be_t<u32> dirNum;
be_t<u32> dirListNum;
vm::bptr<CellSaveDataDirList> dirList;
char reserved[64];
};
struct CellSaveDataListSet
{
be_t<u32> focusPosition;
vm::bptr<char> focusDirName;
be_t<u32> fixedListNum;
vm::bptr<CellSaveDataDirList> fixedList;
vm::bptr<CellSaveDataListNewData> newData;
vm::bptr<void> reserved;
};
struct CellSaveDataFixedSet
{
vm::bptr<char> dirName;
vm::bptr<CellSaveDataNewDataIcon> newIcon;
be_t<u32> option;
};
struct CellSaveDataSystemFileParam
{
char title[CELL_SAVEDATA_SYSP_TITLE_SIZE];
char subTitle[CELL_SAVEDATA_SYSP_SUBTITLE_SIZE];
char detail[CELL_SAVEDATA_SYSP_DETAIL_SIZE];
be_t<u32> attribute;
be_t<u32> parental_level; // char reserved2[4] in firmware 3.70 or higher
char listParam[CELL_SAVEDATA_SYSP_LPARAM_SIZE];
char reserved[256];
};
struct CellSaveDataDirStat
{
be_t<s64> atime;
be_t<s64> mtime;
be_t<s64> ctime;
char dirName[CELL_SAVEDATA_DIRNAME_SIZE];
};
struct CellSaveDataFileStat
{
be_t<u32> fileType;
char reserved1[4];
be_t<u64> size;
be_t<s64> atime;
be_t<s64> mtime;
be_t<s64> ctime;
char fileName[CELL_SAVEDATA_FILENAME_SIZE];
char reserved2[3];
};
struct CellSaveDataStatGet
{
be_t<s32> hddFreeSizeKB;
be_t<u32> isNewData;
CellSaveDataDirStat dir;
CellSaveDataSystemFileParam getParam;
be_t<u32> bind;
be_t<s32> sizeKB;
be_t<s32> sysSizeKB;
be_t<u32> fileNum;
be_t<u32> fileListNum;
vm::bptr<CellSaveDataFileStat> fileList;
char reserved[64];
};
struct CellSaveDataAutoIndicator
{
be_t<u32> dispPosition;
be_t<u32> dispMode;
vm::bptr<char> dispMsg;
be_t<u32> picBufSize;
vm::bptr<void> picBuf;
vm::bptr<void> reserved;
};
struct CellSaveDataStatSet
{
vm::bptr<CellSaveDataSystemFileParam> setParam;
be_t<u32> reCreateMode;
vm::bptr<CellSaveDataAutoIndicator> indicator;
};
struct CellSaveDataFileGet
{
be_t<u32> excSize;
char reserved[64];
};
struct CellSaveDataFileSet
{
be_t<u32> fileOperation;
vm::bptr<void> reserved;
be_t<u32> fileType;
be_t<u128, 1> secureFileId;
vm::bptr<char> fileName;
be_t<u32> fileOffset;
be_t<u32> fileSize;
be_t<u32> fileBufSize;
vm::bptr<void> fileBuf;
};
struct CellSaveDataCBResult
{
be_t<s32> result;
be_t<u32> progressBarInc;
be_t<s32> errNeedSizeKB;
vm::bptr<char> invalidMsg;
vm::bptr<void> userdata;
};
struct CellSaveDataDoneGet
{
be_t<s32> excResult;
char dirName[CELL_SAVEDATA_DIRNAME_SIZE];
be_t<s32> sizeKB;
be_t<s32> hddFreeSizeKB;
char reserved[64];
};
// Callback Functions
using CellSaveDataFixedCallback = void(vm::ptr<CellSaveDataCBResult> cbResult, vm::ptr<CellSaveDataListGet> get, vm::ptr<CellSaveDataFixedSet> set);
using CellSaveDataListCallback = void(vm::ptr<CellSaveDataCBResult> cbResult, vm::ptr<CellSaveDataListGet> get, vm::ptr<CellSaveDataListSet> set);
using CellSaveDataStatCallback = void(vm::ptr<CellSaveDataCBResult> cbResult, vm::ptr<CellSaveDataStatGet> get, vm::ptr<CellSaveDataStatSet> set);
using CellSaveDataFileCallback = void(vm::ptr<CellSaveDataCBResult> cbResult, vm::ptr<CellSaveDataFileGet> get, vm::ptr<CellSaveDataFileSet> set);
using CellSaveDataDoneCallback = void(vm::ptr<CellSaveDataCBResult> cbResult, vm::ptr<CellSaveDataDoneGet> get);
// Auxiliary Structs
struct SaveDataEntry
{
std::string escaped;
std::string dirName;
std::string listParam;
std::string title;
std::string subtitle;
std::string details;
u64 size{0};
s64 atime{0};
s64 mtime{0};
s64 ctime{0};
std::vector<uchar> iconBuf;
bool isNew{false};
std::string date() const;
std::string data_size() const;
};
class SaveDialogBase
{
public:
virtual ~SaveDialogBase();
virtual s32 ShowSaveDataList(std::vector<SaveDataEntry>& save_entries, s32 focused, u32 op, vm::ptr<CellSaveDataListSet> listSet, bool enable_overlay) = 0;
};
| 9,743
|
C++
|
.h
| 318
| 28.786164
| 156
| 0.736909
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,837
|
cellCamera.h
|
RPCS3_rpcs3/rpcs3/Emu/Cell/Modules/cellCamera.h
|
#pragma once
#include "Utilities/Timer.h"
#include "Emu/Cell/lv2/sys_memory.h"
#include "Utilities/Thread.h"
#include "Emu/Io/camera_handler_base.h"
#include <map>
// Error Codes
enum CellCameraError : u32
{
CELL_CAMERA_ERROR_ALREADY_INIT = 0x80140801,
CELL_CAMERA_ERROR_NOT_INIT = 0x80140803,
CELL_CAMERA_ERROR_PARAM = 0x80140804,
CELL_CAMERA_ERROR_ALREADY_OPEN = 0x80140805,
CELL_CAMERA_ERROR_NOT_OPEN = 0x80140806,
CELL_CAMERA_ERROR_DEVICE_NOT_FOUND = 0x80140807,
CELL_CAMERA_ERROR_DEVICE_DEACTIVATED = 0x80140808,
CELL_CAMERA_ERROR_NOT_STARTED = 0x80140809,
CELL_CAMERA_ERROR_FORMAT_UNKNOWN = 0x8014080a,
CELL_CAMERA_ERROR_RESOLUTION_UNKNOWN = 0x8014080b,
CELL_CAMERA_ERROR_BAD_FRAMERATE = 0x8014080c,
CELL_CAMERA_ERROR_TIMEOUT = 0x8014080d,
CELL_CAMERA_ERROR_BUSY = 0x8014080e,
CELL_CAMERA_ERROR_FATAL = 0x8014080f,
CELL_CAMERA_ERROR_MUTEX = 0x80140810,
};
// Event masks
enum
{
CELL_CAMERA_EFLAG_FRAME_UPDATE = 0x00000001,
CELL_CAMERA_EFLAG_OPEN = 0x00000002,
CELL_CAMERA_EFLAG_CLOSE = 0x00000004,
CELL_CAMERA_EFLAG_START = 0x00000008,
CELL_CAMERA_EFLAG_STOP = 0x00000010,
CELL_CAMERA_EFLAG_RESET = 0x00000020,
};
// Event types
enum
{
CELL_CAMERA_DETACH = 0,
CELL_CAMERA_ATTACH = 1,
CELL_CAMERA_FRAME_UPDATE = 2,
CELL_CAMERA_OPEN = 3,
CELL_CAMERA_CLOSE = 4,
CELL_CAMERA_START = 5,
CELL_CAMERA_STOP = 6,
CELL_CAMERA_RESET = 7
};
// Read mode
enum
{
CELL_CAMERA_READ_FUNCCALL = 0,
CELL_CAMERA_READ_DIRECT = 1,
};
// Colormatching
enum
{
CELL_CAMERA_CM_CP_UNSPECIFIED = 0,
CELL_CAMERA_CM_CP_BT709_sRGB = 1,
CELL_CAMERA_CM_CP_BT470_2M = 2,
CELL_CAMERA_CM_CP_BT470_2BG = 3,
CELL_CAMERA_CM_CP_SMPTE170M = 4,
CELL_CAMERA_CM_CP_SMPTE240M = 5,
CELL_CAMERA_CM_TC_UNSPECIFIED = 0,
CELL_CAMERA_CM_TC_BT709 = 1,
CELL_CAMERA_CM_TC_BT470_2M = 2,
CELL_CAMERA_CM_TC_BT470_2BG = 3,
CELL_CAMERA_CM_TC_SMPTE170M = 4,
CELL_CAMERA_CM_TC_SMPTE240M = 5,
CELL_CAMERA_CM_TC_LINEAR = 6,
CELL_CAMERA_CM_TC_sRGB = 7,
CELL_CAMERA_CM_MC_UNSPECIFIED = 0,
CELL_CAMERA_CM_MC_BT709 = 1,
CELL_CAMERA_CM_MC_FCC = 2,
CELL_CAMERA_CM_MC_BT470_2BG = 3,
CELL_CAMERA_CM_MC_SMPTE170M = 4,
CELL_CAMERA_CM_MC_SMPTE240M = 5,
};
// Power Line Frequency
enum
{
CELL_CAMERA_PLFREQ_DISABLED = 0,
CELL_CAMERA_PLFREQ_50Hz = 1,
CELL_CAMERA_PLFREQ_60Hz = 2,
};
// DEVICECAP
enum
{
CELL_CAMERA_CTC_SCANNING_MODE = (1 << 0),
CELL_CAMERA_CTC_AUTO_EXPOSURE_MODE = (1 << 1),
CELL_CAMERA_CTC_AUTO_EXPOSURE_PRIORITY = (1 << 2),
CELL_CAMERA_CTC_EXPOSURE_TIME_ABS = (1 << 3),
CELL_CAMERA_CTC_EXPOSURE_TIME_REL = (1 << 4),
CELL_CAMERA_CTC_FOCUS_ABS = (1 << 5),
CELL_CAMERA_CTC_FOCUS_REL = (1 << 6),
CELL_CAMERA_CTC_IRIS_ABS = (1 << 7),
CELL_CAMERA_CTC_IRIS_REL = (1 << 8),
CELL_CAMERA_CTC_ZOOM_ABS = (1 << 9),
CELL_CAMERA_CTC_ZOOM_REL = (1 << 10),
CELL_CAMERA_CTC_PANTILT_ABS = (1 << 11),
CELL_CAMERA_CTC_PANTILT_REL = (1 << 12),
CELL_CAMERA_CTC_ROLL_ABS = (1 << 13),
CELL_CAMERA_CTC_ROLL_REL = (1 << 14),
CELL_CAMERA_CTC_RESERVED_15 = (1 << 15),
CELL_CAMERA_CTC_RESERVED_16 = (1 << 16),
CELL_CAMERA_CTC_FOCUS_AUTO = (1 << 17),
CELL_CAMERA_CTC_PRIVACY = (1 << 18),
CELL_CAMERA_PUC_BRIGHTNESS = (1 << 0),
CELL_CAMERA_PUC_CONTRAST = (1 << 1),
CELL_CAMERA_PUC_HUE = (1 << 2),
CELL_CAMERA_PUC_SATURATION = (1 << 3),
CELL_CAMERA_PUC_SHARPNESS = (1 << 4),
CELL_CAMERA_PUC_GAMMA = (1 << 5),
CELL_CAMERA_PUC_WHITE_BALANCE_TEMPERATURE = (1 << 6),
CELL_CAMERA_PUC_WHITE_BALANCE_COMPONENT = (1 << 7),
CELL_CAMERA_PUC_BACKLIGHT_COMPENSATION = (1 << 8),
CELL_CAMERA_PUC_GAIN = (1 << 9),
CELL_CAMERA_PUC_POWER_LINE_FREQUENCY = (1 << 10),
CELL_CAMERA_PUC_HUE_AUTO = (1 << 11),
CELL_CAMERA_PUC_WHITE_BALANCE_TEMPERATURE_AUTO = (1 << 12),
CELL_CAMERA_PUC_WHITE_BALANCE_COMPONENT_AUTO = (1 << 13),
CELL_CAMERA_PUC_DIGITAL_MULTIPLIER = (1 << 14),
CELL_CAMERA_PUC_DIGITAL_MULTIPLIER_LIMIT = (1 << 15),
CELL_CAMERA_PUC_ANALOG_VIDEO_STANDARD = (1 << 16),
CELL_CAMERA_PUC_ANALOG_VIDEO_LOCK_STATUS = (1 << 17),
};
// UVCREQCODE Control Selector
enum
{
CELL_CAMERA_CS_SHIFT = 0,
CELL_CAMERA_CS_BITS = 0x000000ff,
CELL_CAMERA_CAP_SHIFT = 8,
CELL_CAMERA_CAP_BITS = 0x0000ff00,
CELL_CAMERA_NUM_SHIFT = 16,
CELL_CAMERA_NUM_BITS = 0x000f0000,
CELL_CAMERA_NUM_1 = 0x00010000,
CELL_CAMERA_NUM_2 = 0x00020000,
CELL_CAMERA_NUM_3 = 0x00030000,
CELL_CAMERA_NUM_4 = 0x00040000,
CELL_CAMERA_LEN_SHIFT = 20,
CELL_CAMERA_LEN_BITS = 0x00f00000,
CELL_CAMERA_LEN_1 = 0x00100000,
CELL_CAMERA_LEN_2 = 0x00200000,
CELL_CAMERA_LEN_4 = 0x00400000,
CELL_CAMERA_ID_SHIFT = 24,
CELL_CAMERA_ID_BITS = 0x0f000000,
CELL_CAMERA_ID_CT = 0x01000000,
CELL_CAMERA_ID_SU = 0x02000000,
CELL_CAMERA_ID_PU = 0x04000000,
};
// UVCREQCODE Camera Terminal Control
enum
{
CELL_CAMERA_UVC_SCANNING_MODE = 0x01110001,
CELL_CAMERA_UVC_AUTO_EXPOSURE_MODE = 0x01110102,
CELL_CAMERA_UVC_AUTO_EXPOSURE_PRIORITY = 0x01110203,
CELL_CAMERA_UVC_EXPOSURE_TIME_ABS = 0x01410304,
CELL_CAMERA_UVC_EXPOSURE_TIME_REL = 0x01110405,
CELL_CAMERA_UVC_FOCUS_ABS = 0x01210506,
CELL_CAMERA_UVC_FOCUS_REL = 0x01120607,
CELL_CAMERA_UVC_FOCUS_AUTO = 0x01111108,
CELL_CAMERA_UVC_IRIS_ABS = 0x01210709,
CELL_CAMERA_UVC_IRIS_REL = 0x0111080a,
CELL_CAMERA_UVC_ZOOM_ABS = 0x0121090b,
CELL_CAMERA_UVC_ZOOM_REL = 0x01130a0c,
CELL_CAMERA_UVC_PANTILT_ABS = 0x01420b0d,
CELL_CAMERA_UVC_PANTILT_REL = 0x01140c0e,
CELL_CAMERA_UVC_ROLL_ABS = 0x01210d0f,
CELL_CAMERA_UVC_ROLL_REL = 0x01120e10,
CELL_CAMERA_UVC_PRIVACY = 0x01111211,
};
// UVCREQCODE Selector Unit Control/Processing Unit Control
enum
{
CELL_CAMERA_UVC_INPUT_SELECT = 0x02110101,
CELL_CAMERA_UVC_BACKLIGHT_COMPENSATION = 0x04210801,
CELL_CAMERA_UVC_BRIGHTNESS = 0x04210002,
CELL_CAMERA_UVC_CONTRAST = 0x04210103,
CELL_CAMERA_UVC_GAIN = 0x04210904,
CELL_CAMERA_UVC_POWER_LINE_FREQUENCY = 0x04110a05,
CELL_CAMERA_UVC_HUE = 0x04210206,
CELL_CAMERA_UVC_HUE_AUTO = 0x04110b10,
CELL_CAMERA_UVC_SATURATION = 0x04210307,
CELL_CAMERA_UVC_SHARPNESS = 0x04210408,
CELL_CAMERA_UVC_GAMMA = 0x04210509,
CELL_CAMERA_UVC_WHITE_BALANCE_TEMPERATURE = 0x0421060a,
CELL_CAMERA_UVC_WHITE_BALANCE_TEMPERATURE_AUTO = 0x04110c0b,
CELL_CAMERA_UVC_WHITE_BALANCE_COMPONENT = 0x0422070c,
CELL_CAMERA_UVC_WHITE_BALANCE_COMPONENT_AUTO = 0x04110d0d,
CELL_CAMERA_UVC_DIGITAL_MULTIPLIER = 0x04210e0e,
CELL_CAMERA_UVC_DIGITAL_MULTIPLIER_LIMIT = 0x04210f0f,
CELL_CAMERA_UVC_ANALOG_VIDEO_STANDARD = 0x04111011,
CELL_CAMERA_UVC_ANALOG_VIDEO_LOCK_STATUS = 0x04111112,
};
// UVCREQCODE Request code bits
enum
{
CELL_CAMERA_RC_CUR = 0x81,
CELL_CAMERA_RC_MIN = 0x82,
CELL_CAMERA_RC_MAX = 0x83,
CELL_CAMERA_RC_RES = 0x84,
CELL_CAMERA_RC_LEN = 0x85,
CELL_CAMERA_RC_INFO = 0x86,
CELL_CAMERA_RC_DEF = 0x87,
};
// Camera types
enum CellCameraType : s32
{
CELL_CAMERA_TYPE_UNKNOWN,
CELL_CAMERA_EYETOY,
CELL_CAMERA_EYETOY2,
CELL_CAMERA_USBVIDEOCLASS,
};
// Image format
enum CellCameraFormat : s32
{
CELL_CAMERA_FORMAT_UNKNOWN,
CELL_CAMERA_JPG,
CELL_CAMERA_RAW8,
CELL_CAMERA_YUV422,
CELL_CAMERA_RAW10,
CELL_CAMERA_RGBA,
CELL_CAMERA_YUV420,
CELL_CAMERA_V_Y1_U_Y0,
CELL_CAMERA_Y0_U_Y1_V = CELL_CAMERA_YUV422,
};
// Image resolution
enum CellCameraResolution : s32
{
CELL_CAMERA_RESOLUTION_UNKNOWN,
CELL_CAMERA_VGA,
CELL_CAMERA_QVGA,
CELL_CAMERA_WGA,
CELL_CAMERA_SPECIFIED_WIDTH_HEIGHT,
};
// Camera attributes
enum CellCameraAttribute : s32
{
CELL_CAMERA_GAIN,
CELL_CAMERA_REDBLUEGAIN,
CELL_CAMERA_SATURATION,
CELL_CAMERA_EXPOSURE,
CELL_CAMERA_BRIGHTNESS,
CELL_CAMERA_AEC,
CELL_CAMERA_AGC,
CELL_CAMERA_AWB,
CELL_CAMERA_ABC,
CELL_CAMERA_LED,
CELL_CAMERA_AUDIOGAIN,
CELL_CAMERA_QS,
CELL_CAMERA_NONZEROCOEFFS,
CELL_CAMERA_YUVFLAG,
CELL_CAMERA_JPEGFLAG,
CELL_CAMERA_BACKLIGHTCOMP,
CELL_CAMERA_MIRRORFLAG,
CELL_CAMERA_MEASUREDQS,
CELL_CAMERA_422FLAG,
CELL_CAMERA_USBLOAD,
CELL_CAMERA_GAMMA,
CELL_CAMERA_GREENGAIN,
CELL_CAMERA_AGCLIMIT,
CELL_CAMERA_DENOISE,
CELL_CAMERA_FRAMERATEADJUST,
CELL_CAMERA_PIXELOUTLIERFILTER,
CELL_CAMERA_AGCLOW,
CELL_CAMERA_AGCHIGH,
CELL_CAMERA_DEVICELOCATION,
CELL_CAMERA_FORMATCAP = 100,
CELL_CAMERA_FORMATINDEX,
CELL_CAMERA_NUMFRAME,
CELL_CAMERA_FRAMEINDEX,
CELL_CAMERA_FRAMESIZE,
CELL_CAMERA_INTERVALTYPE,
CELL_CAMERA_INTERVALINDEX,
CELL_CAMERA_INTERVALVALUE,
CELL_CAMERA_COLORMATCHING,
CELL_CAMERA_PLFREQ,
CELL_CAMERA_DEVICEID,
CELL_CAMERA_DEVICECAP,
CELL_CAMERA_DEVICESPEED,
CELL_CAMERA_UVCREQCODE,
CELL_CAMERA_UVCREQDATA,
CELL_CAMERA_DEVICEID2,
CELL_CAMERA_READMODE = 300,
CELL_CAMERA_GAMEPID,
CELL_CAMERA_PBUFFER,
CELL_CAMERA_READFINISH,
CELL_CAMERA_ATTRIBUTE_UNKNOWN = 500,
};
// Request codes
enum
{
SET_CUR = 0x01,
GET_CUR = 0x81,
GET_MIN = 0x82,
GET_MAX = 0x83,
GET_RES = 0x84,
GET_LEN = 0x85,
GET_INFO = 0x86,
GET_DEF = 0x87,
};
enum // version
{
CELL_CAMERA_INFO_VER_100 = 0x0100,
CELL_CAMERA_INFO_VER_101 = 0x0101,
CELL_CAMERA_INFO_VER_200 = 0x0200,
CELL_CAMERA_INFO_VER = CELL_CAMERA_INFO_VER_200,
CELL_CAMERA_READ_VER_100 = 0x0100,
CELL_CAMERA_READ_VER = CELL_CAMERA_READ_VER_100,
};
// Other
enum
{
CELL_CAMERA_MAX_CAMERAS = 1
};
struct CellCameraInfo
{
// filled in by application as inputs for open
be_t<s32> format;
be_t<s32> resolution;
be_t<s32> framerate;
// filled in by open
vm::bptr<u8> buffer;
be_t<s32> bytesize;
be_t<s32> width;
be_t<s32> height;
be_t<s32> dev_num;
be_t<s32> guid;
};
struct CellCameraInfoEx
{
be_t<CellCameraFormat> format; // CellCameraFormat
be_t<s32> resolution; // CellCameraResolution
be_t<s32> framerate;
vm::bptr<u8> buffer;
be_t<s32> bytesize;
be_t<s32> width; // only used if resolution == CELL_CAMERA_SPECIFIED_WIDTH_HEIGHT
be_t<s32> height; // likewise
be_t<s32> dev_num;
be_t<s32> guid;
be_t<s32> info_ver;
be_t<u32> container;
be_t<s32> read_mode;
vm::bptr<u8> pbuf[2];
ENABLE_BITWISE_SERIALIZATION;
};
struct CellCameraReadEx
{
be_t<s32> version;
be_t<u32> frame;
be_t<u32> bytesread;
be_t<u64> timestamp; // system_time_t (microseconds)
vm::bptr<u8> pbuf;
};
class camera_context
{
struct notify_event_data
{
u64 source;
u64 flag;
ENABLE_BITWISE_SERIALIZATION;
};
public:
void operator()();
void reset_state();
void send_attach_state(bool attached);
void set_attr(s32 attrib, u32 arg1, u32 arg2);
/**
* \brief Sets up notify event queue supplied and immediately sends an ATTACH event to it
* \param key Event queue key to add
* \param source Event source port
* \param flag Event flag (CELL_CAMERA_EFLAG_*)
*/
void add_queue(u64 key, u64 source, u64 flag);
/**
* \brief Unsets/removes event queue specified
* \param key Event queue key to remove
*/
void remove_queue(u64 key);
std::map<u64, notify_event_data> notify_data_map;
shared_mutex mutex;
shared_mutex mutex_notify_data_map;
u64 start_timestamp_us = 0;
atomic_t<u8> read_mode{CELL_CAMERA_READ_FUNCCALL};
atomic_t<bool> is_streaming{false};
atomic_t<bool> is_attached{false};
atomic_t<bool> is_open{false};
CellCameraInfoEx info{};
atomic_t<u32> pbuf_write_index = 0;
std::array<atomic_t<bool>, 2> pbuf_locked = { false, false };
u32 pbuf_next_index() const;
struct attr_t
{
u32 v1, v2;
ENABLE_BITWISE_SERIALIZATION;
};
attr_t attr[500]{};
atomic_t<bool> has_new_frame = false;
atomic_t<u32> frame_num = 0;
atomic_t<u64> frame_timestamp_us = 0;
atomic_t<u32> bytes_read = 0;
atomic_t<u8> init = 0;
SAVESTATE_INIT_POS(16);
camera_context() = default;
camera_context(utils::serial& ar);
void save(utils::serial& ar);
static constexpr auto thread_name = "Camera Thread"sv;
std::shared_ptr<camera_handler_base> handler;
bool open_camera();
bool start_camera();
bool get_camera_frame(u8* dst, u32& width, u32& height, u64& frame_number, u64& bytes_read);
void stop_camera();
void close_camera();
bool on_handler_state(camera_handler_base::camera_handler_state state);
};
using camera_thread = named_thread<camera_context>;
/// Shared data between cellGem and cellCamera
struct gem_camera_shared
{
atomic_t<u64> frame_timestamp_us{}; // latest read timestamp from cellCamera (cellCameraRead(Ex))
atomic_t<s32> width{640};
atomic_t<s32> height{480};
atomic_t<s32> size{0};
atomic_t<CellCameraFormat> format{CELL_CAMERA_RAW8};
};
| 13,520
|
C++
|
.h
| 424
| 29.950472
| 98
| 0.662909
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,838
|
cellHttpUtil.h
|
RPCS3_rpcs3/rpcs3/Emu/Cell/Modules/cellHttpUtil.h
|
#pragma once
#include "Emu/Memory/vm_ptr.h"
// libHttp_Util: 0x80711001 - 0x807110ff
// Error Codes
enum CellHttpUtilError : u32
{
CELL_HTTP_UTIL_ERROR_NO_MEMORY = 0x80711001,
CELL_HTTP_UTIL_ERROR_NO_BUFFER = 0x80711002,
CELL_HTTP_UTIL_ERROR_NO_STRING = 0x80711003,
CELL_HTTP_UTIL_ERROR_INSUFFICIENT = 0x80711004,
CELL_HTTP_UTIL_ERROR_INVALID_URI = 0x80711005,
CELL_HTTP_UTIL_ERROR_INVALID_HEADER = 0x80711006,
CELL_HTTP_UTIL_ERROR_INVALID_REQUEST = 0x80711007,
CELL_HTTP_UTIL_ERROR_INVALID_RESPONSE = 0x80711008,
CELL_HTTP_UTIL_ERROR_INVALID_LENGTH = 0x80711009,
CELL_HTTP_UTIL_ERROR_INVALID_CHARACTER = 0x8071100a,
};
enum
{
CELL_HTTP_UTIL_URI_FLAG_FULL_URI = 0x00000000,
CELL_HTTP_UTIL_URI_FLAG_NO_SCHEME = 0x00000001,
CELL_HTTP_UTIL_URI_FLAG_NO_CREDENTIALS = 0x00000002,
CELL_HTTP_UTIL_URI_FLAG_NO_PASSWORD = 0x00000004,
CELL_HTTP_UTIL_URI_FLAG_NO_PATH = 0x00000008
};
struct CellHttpUri
{
vm::bcptr<char> scheme;
vm::bcptr<char> hostname;
vm::bcptr<char> username;
vm::bcptr<char> password;
vm::bcptr<char> path;
be_t<u32> port;
u8 reserved[4];
};
struct CellHttpUriPath
{
vm::bcptr<char> path;
vm::bcptr<char> query;
vm::bcptr<char> fragment;
};
struct CellHttpRequestLine
{
vm::bcptr<char> method;
vm::bcptr<char> path;
vm::bcptr<char> protocol;
be_t<u32> majorVersion;
be_t<u32> minorVersion;
};
struct CellHttpStatusLine
{
vm::bcptr<char> protocol;
be_t<u32> majorVersion;
be_t<u32> minorVersion;
vm::bcptr<char> reasonPhrase;
be_t<s32> statusCode;
u8 reserved[4];
};
struct CellHttpHeader
{
vm::bcptr<char> name;
vm::bcptr<char> value;
};
error_code cellHttpUtilCopyUri(vm::ptr<CellHttpUri> dest, vm::cptr<CellHttpUri> src, vm::ptr<void> pool, u32 poolSize, vm::ptr<u32> required);
| 1,805
|
C++
|
.h
| 64
| 26.453125
| 142
| 0.736568
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,839
|
libsynth2.h
|
RPCS3_rpcs3/rpcs3/Emu/Cell/Modules/libsynth2.h
|
#pragma once
// Error Codes
enum CellSoundSynth2Error : u32
{
CELL_SOUND_SYNTH2_ERROR_FATAL = 0x80310201,
CELL_SOUND_SYNTH2_ERROR_INVALID_PARAMETER = 0x80310202,
CELL_SOUND_SYNTH2_ERROR_ALREADY_INITIALIZED = 0x80310203,
};
struct CellSoundSynth2EffectAttr
{
be_t<u16> core;
be_t<u16> mode;
be_t<s16> depth_L;
be_t<s16> depth_R;
be_t<u16> delay;
be_t<u16> feedback;
};
| 379
|
C++
|
.h
| 17
| 20.647059
| 58
| 0.766667
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,840
|
cellJpgDec.h
|
RPCS3_rpcs3/rpcs3/Emu/Cell/Modules/cellJpgDec.h
|
#pragma once
//Return Codes
enum CellJpgDecError : u32
{
CELL_JPGDEC_ERROR_HEADER = 0x80611101,
CELL_JPGDEC_ERROR_STREAM_FORMAT = 0x80611102,
CELL_JPGDEC_ERROR_ARG = 0x80611103,
CELL_JPGDEC_ERROR_SEQ = 0x80611104,
CELL_JPGDEC_ERROR_BUSY = 0x80611105,
CELL_JPGDEC_ERROR_FATAL = 0x80611106,
CELL_JPGDEC_ERROR_OPEN_FILE = 0x80611107,
CELL_JPGDEC_ERROR_SPU_UNSUPPORT = 0x80611108,
CELL_JPGDEC_ERROR_CB_PARAM = 0x80611109,
};
enum CellJpgDecColorSpace
{
CELL_JPG_UNKNOWN = 0,
CELL_JPG_GRAYSCALE = 1,
CELL_JPG_RGB = 2,
CELL_JPG_YCbCr = 3,
CELL_JPG_RGBA = 10,
CELL_JPG_UPSAMPLE_ONLY = 11,
CELL_JPG_ARGB = 20,
CELL_JPG_GRAYSCALE_TO_ALPHA_RGBA = 40,
CELL_JPG_GRAYSCALE_TO_ALPHA_ARGB = 41,
};
enum CellJpgDecStreamSrcSel
{
CELL_JPGDEC_FILE = 0,
CELL_JPGDEC_BUFFER = 1,
};
enum CellJpgDecDecodeStatus
{
CELL_JPGDEC_DEC_STATUS_FINISH = 0, // Decoding finished
CELL_JPGDEC_DEC_STATUS_STOP = 1, // Decoding halted
};
enum CellJpgDecOutputMode
{
CELL_JPGDEC_TOP_TO_BOTTOM = 0, // Top left to bottom right
CELL_JPGDEC_BOTTOM_TO_TOP = 1, // Bottom left to top right
};
struct CellJpgDecInfo
{
be_t<u32> imageWidth;
be_t<u32> imageHeight;
be_t<u32> numComponents;
be_t<u32> colorSpace; // CellJpgDecColorSpace
};
struct CellJpgDecSrc
{
be_t<u32> srcSelect; // CellJpgDecStreamSrcSel
vm::bcptr<char> fileName;
be_t<u64> fileOffset; // int64_t
be_t<u32> fileSize;
be_t<u32> streamPtr;
be_t<u32> streamSize;
be_t<u32> spuThreadEnable; // CellJpgDecSpuThreadEna
};
struct CellJpgDecInParam
{
be_t<u32> commandPtr;
be_t<u32> downScale;
be_t<u32> method; // CellJpgDecMethod
be_t<u32> outputMode; // CellJpgDecOutputMode
be_t<u32> outputColorSpace; // CellJpgDecColorSpace
u8 outputColorAlpha;
u8 reserved[3];
};
struct CellJpgDecOutParam
{
be_t<u64> outputWidthByte;
be_t<u32> outputWidth;
be_t<u32> outputHeight;
be_t<u32> outputComponents;
be_t<u32> outputMode; // CellJpgDecOutputMode
be_t<u32> outputColorSpace; // CellJpgDecColorSpace
be_t<u32> downScale;
be_t<u32> useMemorySpace;
};
struct CellJpgDecOpnInfo
{
be_t<u32> initSpaceAllocated;
};
struct CellJpgDecDataCtrlParam
{
be_t<u64> outputBytesPerLine;
};
struct CellJpgDecDataOutInfo
{
be_t<float> mean;
be_t<u32> outputLines;
be_t<u32> status;
};
// Custom structs
struct CellJpgDecSubHandle
{
static const u32 id_base = 1;
static const u32 id_step = 1;
static const u32 id_count = 1023;
SAVESTATE_INIT_POS(35);
u32 fd;
u64 fileSize;
CellJpgDecInfo info;
CellJpgDecOutParam outParam;
CellJpgDecSrc src;
};
| 2,734
|
C++
|
.h
| 106
| 24.056604
| 59
| 0.707345
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,841
|
StaticHLE.h
|
RPCS3_rpcs3/rpcs3/Emu/Cell/Modules/StaticHLE.h
|
#pragma once
#include "util/types.hpp"
#include "Emu/Memory/vm_ptr.h"
#include <vector>
struct shle_pattern
{
u16 start_pattern[32];
u8 crc16_length;
u16 crc16;
u16 total_length;
std::string _module;
std::string name;
u32 fnid;
};
class statichle_handler
{
public:
statichle_handler(int);
~statichle_handler();
statichle_handler(const statichle_handler&) = delete;
statichle_handler& operator=(const statichle_handler&) = delete;
bool load_patterns();
bool check_against_patterns(vm::cptr<u8>& data, u32 size, u32 addr);
protected:
static u16 gen_CRC16(const u8* data_p, usz length);
std::vector<shle_pattern> hle_patterns;
};
| 650
|
C++
|
.h
| 27
| 22.222222
| 69
| 0.760976
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,842
|
cellResc.h
|
RPCS3_rpcs3/rpcs3/Emu/Cell/Modules/cellResc.h
|
#pragma once
enum CellRescError : u32
{
CELL_RESC_ERROR_NOT_INITIALIZED = 0x80210301,
CELL_RESC_ERROR_REINITIALIZED = 0x80210302,
CELL_RESC_ERROR_BAD_ALIGNMENT = 0x80210303,
CELL_RESC_ERROR_BAD_ARGUMENT = 0x80210304,
CELL_RESC_ERROR_LESS_MEMORY = 0x80210305,
CELL_RESC_ERROR_GCM_FLIP_QUE_FULL = 0x80210306,
CELL_RESC_ERROR_BAD_COMBINATION = 0x80210307,
CELL_RESC_ERROR_x308 = 0x80210308, // TODO: find proper name
};
enum
{
COLOR_BUFFER_ALIGNMENT = 128,
VERTEX_BUFFER_ALIGNMENT = 4,
FRAGMENT_SHADER_ALIGNMENT = 64,
VERTEX_NUMBER_NORMAL = 4,
SRC_BUFFER_NUM = 8,
MAX_DST_BUFFER_NUM = 6,
RESC_PARAM_NUM
};
enum CellRescBufferMode
{
CELL_RESC_720x480 = 0x1,
CELL_RESC_720x576 = 0x2,
CELL_RESC_1280x720 = 0x4,
CELL_RESC_1920x1080 = 0x8,
};
enum CellRescPalTemporalMode
{
CELL_RESC_PAL_50 = 0,
CELL_RESC_PAL_60_DROP = 1,
CELL_RESC_PAL_60_INTERPOLATE = 2,
CELL_RESC_PAL_60_INTERPOLATE_30_DROP = 3,
CELL_RESC_PAL_60_INTERPOLATE_DROP_FLEXIBLE = 4,
CELL_RESC_PAL_60_FOR_HSYNC = 5,
};
enum CellRescRatioConvertMode
{
CELL_RESC_FULLSCREEN = 0,
CELL_RESC_LETTERBOX = 1,
CELL_RESC_PANSCAN = 2,
};
enum CellRescFlipMode
{
CELL_RESC_DISPLAY_VSYNC = 0,
CELL_RESC_DISPLAY_HSYNC = 1,
};
enum CellRescDstFormat
{
CELL_RESC_SURFACE_A8R8G8B8 = 8, // == CELL_GCM_SURFACE_A8R8G8B8
CELL_RESC_SURFACE_F_W16Z16Y16X16 = 11, // == CELL_GCM_SURFACE_F_W16Z16Y16X16
};
enum CellRescResourcePolicy
{
CELL_RESC_CONSTANT_VRAM = 0x0,
CELL_RESC_MINIMUM_VRAM = 0x1,
CELL_RESC_CONSTANT_GPU_LOAD = 0x0,
CELL_RESC_MINIMUM_GPU_LOAD = 0x2,
};
enum CellRescConvolutionFilterMode
{
CELL_RESC_NORMAL_BILINEAR = 0,
CELL_RESC_INTERLACE_FILTER = 1,
CELL_RESC_3X3_GAUSSIAN = 2,
CELL_RESC_2X3_QUINCUNX = 3,
CELL_RESC_2X3_QUINCUNX_ALT = 4,
};
struct CellRescDsts
{
be_t<u32> format;
be_t<u32> pitch;
be_t<u32> heightAlign;
};
struct CellRescInitConfig
{
be_t<u32> size; // usz
be_t<u32> resourcePolicy;
be_t<u32> supportModes;
be_t<u32> ratioMode;
be_t<u32> palTemporalMode;
be_t<u32> interlaceMode;
be_t<u32> flipMode;
};
struct CellRescSrc
{
be_t<u32> format;
be_t<u32> pitch;
be_t<u16> width;
be_t<u16> height;
be_t<u32> offset;
};
struct cell_resc_manager
{
atomic_t<bool> is_initialized = false;
u32 buffer_mode{};
struct
{
u32 size{};
u32 resource_policy{};
u32 support_modes{};
u32 ratio_mode{};
u32 pal_temporal_mode{};
u32 interlace_mode{};
u32 flip_mode{};
} config;
};
| 2,683
|
C++
|
.h
| 108
| 23
| 77
| 0.667839
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,843
|
cellRemotePlay.h
|
RPCS3_rpcs3/rpcs3/Emu/Cell/Modules/cellRemotePlay.h
|
#pragma once
enum CellRemotePlayError : u32
{
CELL_REMOTEPLAY_ERROR_INTERNAL = 0x80029830
};
enum
{
CELL_REMOTEPLAY_STATUS_LOADING = 0x00000000,
CELL_REMOTEPLAY_STATUS_WAIT = 0x00000001,
CELL_REMOTEPLAY_STATUS_RUNNING = 0x00000002,
CELL_REMOTEPLAY_STATUS_UNLOADING = 0x00000003,
CELL_REMOTEPLAY_STATUS_FATALERROR = 0x00000004,
CELL_REMOTEPLAY_STATUS_PREMOEND = 0x00000005,
};
enum
{
CELL_REMOTEPLAY_M4V_MEMORY_CONTAINER_SIZE = 8 * 1024 * 1024,
CELL_REMOTEPLAY_AVC_MEMORY_CONTAINER_SIZE = 10 * 1024 * 1024,
CELL_REMOTEPLAY_480P_MEMORY_CONTAINER_SIZE = 10 * 1024 * 1024,
};
| 602
|
C++
|
.h
| 20
| 28.45
| 63
| 0.766839
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,844
|
cellGem.h
|
RPCS3_rpcs3/rpcs3/Emu/Cell/Modules/cellGem.h
|
#pragma once
#include "Emu/Memory/vm_ptr.h"
static const float CELL_GEM_SPHERE_RADIUS_MM = 22.5f;
// Error codes
enum CellGemError : u32
{
CELL_GEM_ERROR_RESOURCE_ALLOCATION_FAILED = 0x80121801,
CELL_GEM_ERROR_ALREADY_INITIALIZED = 0x80121802,
CELL_GEM_ERROR_UNINITIALIZED = 0x80121803,
CELL_GEM_ERROR_INVALID_PARAMETER = 0x80121804,
CELL_GEM_ERROR_INVALID_ALIGNMENT = 0x80121805,
CELL_GEM_ERROR_UPDATE_NOT_FINISHED = 0x80121806,
CELL_GEM_ERROR_UPDATE_NOT_STARTED = 0x80121807,
CELL_GEM_ERROR_CONVERT_NOT_FINISHED = 0x80121808,
CELL_GEM_ERROR_CONVERT_NOT_STARTED = 0x80121809,
CELL_GEM_ERROR_WRITE_NOT_FINISHED = 0x8012180A,
CELL_GEM_ERROR_NOT_A_HUE = 0x8012180B,
};
// Runtime statuses
enum CellGemStatus : u32
{
CELL_GEM_NOT_CONNECTED = 1,
CELL_GEM_SPHERE_NOT_CALIBRATED = 2,
CELL_GEM_SPHERE_CALIBRATING = 3,
CELL_GEM_COMPUTING_AVAILABLE_COLORS = 4,
CELL_GEM_HUE_NOT_SET = 5,
CELL_GEM_NO_VIDEO = 6,
CELL_GEM_TIME_OUT_OF_RANGE = 7,
CELL_GEM_NOT_CALIBRATED = 8,
CELL_GEM_NO_EXTERNAL_PORT_DEVICE = 9,
};
// CellGemInfo status flags.
enum
{
CELL_GEM_STATUS_DISCONNECTED = 0,
CELL_GEM_STATUS_READY = 1,
};
// CellGemPadData defines for bit assignment of digital buttons.
enum
{
CELL_GEM_CTRL_SELECT = 1 << 0,
CELL_GEM_CTRL_T = 1 << 1,
CELL_GEM_CTRL_MOVE = 1 << 2,
CELL_GEM_CTRL_START = 1 << 3,
CELL_GEM_CTRL_TRIANGLE = 1 << 4,
CELL_GEM_CTRL_CIRCLE = 1 << 5,
CELL_GEM_CTRL_CROSS = 1 << 6,
CELL_GEM_CTRL_SQUARE = 1 << 7,
};
// Bit assignments for CellGemExtPortData status member.
enum
{
CELL_GEM_EXT_CONNECTED = 1 << 0,
CELL_GEM_EXT_EXT0 = 1 << 1,
CELL_GEM_EXT_EXT1 = 1 << 2,
};
// Values used to describe characteristics of the extension connector.
enum
{
CELL_GEM_EXTERNAL_PORT_DEVICE_INFO_SIZE = 38,
CELL_GEM_EXTERNAL_PORT_OUTPUT_SIZE = 40,
};
// Limits for cellGemPrepareCamera max_exposure argument.
enum
{
CELL_GEM_MIN_CAMERA_EXPOSURE = 40,
CELL_GEM_MAX_CAMERA_EXPOSURE = 511,
};
// Flags for cellGemGetState.
enum
{
CELL_GEM_STATE_FLAG_CURRENT_TIME = 0,
CELL_GEM_STATE_FLAG_LATEST_IMAGE_TIME = 1,
CELL_GEM_STATE_FLAG_TIMESTAMP = 2,
};
// Flags for cellGemGetInertialState.
enum
{
CELL_GEM_INERTIAL_STATE_FLAG_LATEST = 0,
CELL_GEM_INERTIAL_STATE_FLAG_PREVIOUS = 1,
CELL_GEM_INERTIAL_STATE_FLAG_NEXT = 2,
};
// Special values for cellGemTrackHues.
enum : u32
{
CELL_GEM_DONT_TRACK_HUE = 2 << 24,
CELL_GEM_DONT_CARE_HUE = 4 << 24,
CELL_GEM_DONT_CHANGE_HUE = 8 << 24,
};
// Masks for cellGemGetStatusFlags.
enum
{
CELL_GEM_FLAG_CALIBRATION_OCCURRED = 1 << 0,
CELL_GEM_FLAG_CALIBRATION_SUCCEEDED = 1 << 1,
CELL_GEM_FLAG_CALIBRATION_FAILED_CANT_FIND_SPHERE = 1 << 2,
CELL_GEM_FLAG_CALIBRATION_FAILED_MOTION_DETECTED = 1 << 3,
CELL_GEM_FLAG_CALIBRATION_FAILED_BRIGHT_LIGHTING = 1 << 4,
CELL_GEM_FLAG_CALIBRATION_WARNING_MOTION_DETECTED = 1 << 5,
CELL_GEM_FLAG_CALIBRATION_WARNING_BRIGHT_LIGHTING = 1 << 6,
CELL_GEM_FLAG_LIGHTING_CHANGED = 1 << 7,
CELL_GEM_FLAG_WRONG_FIELD_OF_VIEW_SETTING = 1 << 8,
CELL_GEM_FLAG_CAMERA_PITCH_ANGLE_CHANGED = 1 << 9,
CELL_GEM_FLAG_VARIABLE_MAGNETIC_FIELD = 1 << 10,
CELL_GEM_FLAG_WEAK_MAGNETIC_FIELD = 1 << 11,
CELL_GEM_FLAG_VERY_COLORFUL_ENVIRONMENT = 1 << 12,
CELL_GEM_FLAG_CURRENT_HUE_CONFLICTS_WITH_ENVIRONMENT = 1 << 13,
CELL_GEM_ALL_FLAGS = 0xffffffffffffffffull
};
// Masks for CellGemState tracking_flags member
enum
{
CELL_GEM_TRACKING_FLAG_POSITION_TRACKED = 1 << 0,
CELL_GEM_TRACKING_FLAG_VISIBLE = 1 << 1,
};
// General constants
enum
{
CELL_GEM_LATENCY_OFFSET = -22000,
CELL_GEM_MAX_NUM = 4,
CELL_GEM_VERSION = 2,
};
// Video conversion flags
enum
{
CELL_GEM_AUTO_WHITE_BALANCE = 0x1,
CELL_GEM_GAMMA_BOOST = 0x2,
CELL_GEM_COMBINE_PREVIOUS_INPUT_FRAME = 0x4,
CELL_GEM_FILTER_OUTLIER_PIXELS = 0x8
};
// Video conversion output formats
enum CellGemVideoConvertFormatEnum : s32
{
CELL_GEM_NO_VIDEO_OUTPUT = 1,
CELL_GEM_RGBA_640x480 = 2,
CELL_GEM_YUV_640x480 = 3,
CELL_GEM_YUV422_640x480 = 4,
CELL_GEM_YUV411_640x480 = 5,
CELL_GEM_RGBA_320x240 = 6,
CELL_GEM_BAYER_RESTORED = 7,
CELL_GEM_BAYER_RESTORED_RGGB = 8,
CELL_GEM_BAYER_RESTORED_RASTERIZED = 9
};
// External device IDs (types)
enum
{
SHARP_SHOOTER_DEVICE_ID = 0x8081
};
struct CellGemAttribute
{
be_t<u32> version;
be_t<u32> max_connect;
be_t<u32> memory_ptr;
be_t<u32> spurs_addr;
u8 spu_priorities[8];
ENABLE_BITWISE_SERIALIZATION;
};
struct CellGemCameraState
{
be_t<s32> exposure;
be_t<f32> exposure_time;
be_t<f32> gain;
be_t<f32> pitch_angle;
be_t<f32> pitch_angle_estimate;
ENABLE_BITWISE_SERIALIZATION;
};
struct CellGemExtPortData
{
be_t<u16> status;
be_t<u16> digital1;
be_t<u16> digital2;
be_t<u16> analog_right_x;
be_t<u16> analog_right_y;
be_t<u16> analog_left_x;
be_t<u16> analog_left_y;
u8 custom[5];
};
struct CellGemImageState
{
be_t<u64> frame_timestamp; // time the frame was captured by libCamera. system_time_t (usecs)
be_t<u64> timestamp; // time processing of the frame was finished. system_time_t (usecs)
be_t<f32> u; // horizontal screen position in pixels
be_t<f32> v; // vertical screen position in pixels
be_t<f32> r; // size of sphere on screen in pixels
be_t<f32> projectionx;
be_t<f32> projectiony;
be_t<f32> distance; // Move sphere distance from camera (probably)
u8 visible; // whether the sphere is visible in the current frame
u8 r_valid; // whether `r` contains valid size
};
struct CellGemPadData
{
be_t<u16> digitalbuttons;
be_t<u16> analog_T;
};
struct CellGemInertialState
{
be_t<f32> accelerometer[4]; // accelerometer readings including accelerometer_bias (G units)
be_t<f32> gyro[4]; // gyro readings including gyro_bias (radians/s)
be_t<f32> accelerometer_bias[4]; // accelerometer bias (G units)
be_t<f32> gyro_bias[4]; // gyro bias (radians/s)
CellGemPadData pad;
CellGemExtPortData ext;
be_t<u64> timestamp; // system_time_t (microseconds)
be_t<s32> counter;
be_t<f32> temperature;
};
struct CellGemInfo
{
be_t<u32> max_connect;
be_t<u32> now_connect;
be_t<u32> status[CELL_GEM_MAX_NUM];
be_t<u32> port[CELL_GEM_MAX_NUM];
};
// origin is the center of the camera
// x increases to right (facing the camera)
// y increases upwards
// z increases towards user (away from the camera)
struct CellGemState
{
be_t<f32> pos[4]; // center of sphere (mm)
be_t<f32> vel[4]; // velocity of sphere (mm/s)
be_t<f32> accel[4]; // acceleration of sphere (mm/s²)
be_t<f32> quat[4]; // quaternion orientation (x,y,z,w) of controller relative to default (facing the camera with buttons up)
be_t<f32> angvel[4]; // angular velocity of controller (radians/s)
be_t<f32> angaccel[4]; // angular acceleration of controller (radians/s²)
be_t<f32> handle_pos[4]; // center of controller handle (mm)
be_t<f32> handle_vel[4]; // velocity of controller handle (mm/s)
be_t<f32> handle_accel[4]; // acceleration of controller handle (mm/s²)
CellGemPadData pad;
CellGemExtPortData ext;
be_t<u64> timestamp; // system_time_t (microseconds)
be_t<f32> temperature;
be_t<f32> camera_pitch_angle;
be_t<u32> tracking_flags;
};
struct CellGemVideoConvertAttribute
{
be_t<s32> version;
be_t<CellGemVideoConvertFormatEnum> output_format;
be_t<s32> conversion_flags;
be_t<f32> gain;
be_t<f32> red_gain;
be_t<f32> green_gain;
be_t<f32> blue_gain;
vm::bptr<u8> buffer_memory;
vm::bptr<u8> video_data_out;
u8 alpha;
ENABLE_BITWISE_SERIALIZATION;
};
| 8,057
|
C++
|
.h
| 249
| 30.618474
| 133
| 0.668939
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,845
|
cellSail.h
|
RPCS3_rpcs3/rpcs3/Emu/Cell/Modules/cellSail.h
|
#pragma once
#include "cellVpost.h"
#include "Emu/Memory/vm_ptr.h"
// Error Codes
enum CellSailError : u32
{
CELL_SAIL_ERROR_INVALID_ARG = 0x80610701,
CELL_SAIL_ERROR_INVALID_STATE = 0x80610702,
CELL_SAIL_ERROR_UNSUPPORTED_STREAM = 0x80610703,
CELL_SAIL_ERROR_INDEX_OUT_OF_RANGE = 0x80610704,
CELL_SAIL_ERROR_EMPTY = 0x80610705,
CELL_SAIL_ERROR_FULLED = 0x80610706,
CELL_SAIL_ERROR_USING = 0x80610707,
CELL_SAIL_ERROR_NOT_AVAILABLE = 0x80610708,
CELL_SAIL_ERROR_CANCEL = 0x80610709,
CELL_SAIL_ERROR_MEMORY = 0x806107F0,
CELL_SAIL_ERROR_INVALID_FD = 0x806107F1,
CELL_SAIL_ERROR_FATAL = 0x806107FF,
};
// Call types
enum
{
CELL_SAIL_PLAYER_CALL_NONE = 0,
CELL_SAIL_PLAYER_CALL_BOOT = 1,
CELL_SAIL_PLAYER_CALL_OPEN_STREAM = 2,
CELL_SAIL_PLAYER_CALL_CLOSE_STREAM = 3,
CELL_SAIL_PLAYER_CALL_OPEN_ES_AUDIO = 4,
CELL_SAIL_PLAYER_CALL_OPEN_ES_VIDEO = 5,
CELL_SAIL_PLAYER_CALL_OPEN_ES_USER = 6,
CELL_SAIL_PLAYER_CALL_CLOSE_ES_AUDIO = 7,
CELL_SAIL_PLAYER_CALL_CLOSE_ES_VIDEO = 8,
CELL_SAIL_PLAYER_CALL_CLOSE_ES_USER = 9,
CELL_SAIL_PLAYER_CALL_START = 10,
CELL_SAIL_PLAYER_CALL_STOP = 11,
CELL_SAIL_PLAYER_CALL_NEXT = 12,
CELL_SAIL_PLAYER_CALL_REOPEN_ES_AUDIO = 13,
CELL_SAIL_PLAYER_CALL_REOPEN_ES_VIDEO = 14,
CELL_SAIL_PLAYER_CALL_REOPEN_ES_USER = 15,
_CELL_SAIL_PLAYER_CALL_TYPE_NUM_OF_ELEMENTS = 16, // Never used?
};
// State types
enum
{
CELL_SAIL_PLAYER_STATE_INITIALIZED = 0,
CELL_SAIL_PLAYER_STATE_BOOT_TRANSITION = 1,
CELL_SAIL_PLAYER_STATE_CLOSED = 2,
CELL_SAIL_PLAYER_STATE_OPEN_TRANSITION = 3,
CELL_SAIL_PLAYER_STATE_OPENED = 4,
CELL_SAIL_PLAYER_STATE_START_TRANSITION = 5,
CELL_SAIL_PLAYER_STATE_RUNNING = 6,
CELL_SAIL_PLAYER_STATE_STOP_TRANSITION = 7,
CELL_SAIL_PLAYER_STATE_CLOSE_TRANSITION = 8,
CELL_SAIL_PLAYER_STATE_LOST = 9,
_CELL_SAIL_PLAYER_STATE_TYPE_NUM_OF_ELEMENTS = 10, // Never used?
};
// Preset types
enum
{
CELL_SAIL_PLAYER_PRESET_AV_SYNC = 0, // Deprecated, same as 59_94HZ
CELL_SAIL_PLAYER_PRESET_AS_IS = 1,
CELL_SAIL_PLAYER_PRESET_AV_SYNC_59_94HZ = 2,
CELL_SAIL_PLAYER_PRESET_AV_SYNC_29_97HZ = 3,
CELL_SAIL_PLAYER_PRESET_AV_SYNC_50HZ = 4,
CELL_SAIL_PLAYER_PRESET_AV_SYNC_25HZ = 5,
CELL_SAIL_PLAYER_PRESET_AV_SYNC_AUTO_DETECT = 6,
};
// Event types
enum
{
CELL_SAIL_EVENT_EMPTY = 0, // NEVER USED
CELL_SAIL_EVENT_ERROR_OCCURED = 1,
CELL_SAIL_EVENT_PLAYER_CALL_COMPLETED = 2,
CELL_SAIL_EVENT_PLAYER_STATE_CHANGED = 3,
CELL_SAIL_EVENT_STREAM_OPENED = 4,
CELL_SAIL_EVENT_STREAM_CLOSED = 5,
CELL_SAIL_EVENT_SESSION_STARTED = 6,
CELL_SAIL_EVENT_PAUSE_STATE_CHANGED = 7,
CELL_SAIL_EVENT_SOURCE_EOS = 8,
CELL_SAIL_EVENT_ES_OPENED = 9,
CELL_SAIL_EVENT_ES_CLOSED = 10,
CELL_SAIL_EVENT_MEDIA_STATE_CHANGED = 11,
_CELL_SAIL_EVENT_TYPE_NUM_OF_ELEMENTS = 12, // DO NOT USE
};
// Parameter types
enum
{
CELL_SAIL_PARAMETER_ENABLE_VPOST = 0,
// Player
CELL_SAIL_PARAMETER_CONTROL_QUEUE_DEPTH = 1,
CELL_SAIL_PARAMETER_CONTROL_PPU_THREAD_PRIORITY = 2,
// SPURS
CELL_SAIL_PARAMETER_SPURS_NUM_OF_SPUS = 3,
CELL_SAIL_PARAMETER_SPURS_SPU_THREAD_PRIORITY = 4,
CELL_SAIL_PARAMETER_SPURS_PPU_THREAD_PRIORITY = 5,
CELL_SAIL_PARAMETER_SPURS_EXIT_IF_NO_WORK = 6,
// Source
CELL_SAIL_PARAMETER_IO_PPU_THREAD_PRIORITY = 7,
// Dmux
CELL_SAIL_PARAMETER_DMUX_PPU_THREAD_PRIORITY = 8,
CELL_SAIL_PARAMETER_DMUX_SPU_THREAD_PRIORITY = 9, // Deprecated
CELL_SAIL_PARAMETER_DMUX_NUM_OF_SPUS = 10,
CELL_SAIL_PARAMETER_DMUX_SPURS_TASK_PRIORITIES = 11,
// Adec
CELL_SAIL_PARAMETER_ADEC_PPU_THREAD_PRIORITY = 12,
CELL_SAIL_PARAMETER_ADEC_SPU_THREAD_PRIORITY = 13, // Deprecated
CELL_SAIL_PARAMETER_ADEC_NUM_OF_SPUS = 14,
CELL_SAIL_PARAMETER_ADEC_SPURS_TASK_PRIORITIES = 15,
// Vdec
CELL_SAIL_PARAMETER_VDEC_PPU_THREAD_PRIORITY = 16,
CELL_SAIL_PARAMETER_VDEC_SPU_THREAD_PRIORITY = 17, // Deprecated
CELL_SAIL_PARAMETER_VDEC_M2V_NUM_OF_SPUS = 18,
CELL_SAIL_PARAMETER_VDEC_AVC_NUM_OF_SPUS = 19,
CELL_SAIL_PARAMETER_VDEC_SPURS_TASK_PRIORITIES = 20,
// Vpost */
CELL_SAIL_PARAMETER_VPOST_PPU_THREAD_PRIORITY = 21, // Deprecated
CELL_SAIL_PARAMETER_VPOST_SPU_THREAD_PRIORITY = 22, // Deprecated
CELL_SAIL_PARAMETER_VPOST_NUM_OF_SPUS = 23,
CELL_SAIL_PARAMETER_VPOST_SPURS_TASK_PRIORITIES = 24,
// Graphics Adapter
CELL_SAIL_PARAMETER_GRAPHICS_ADAPTER_BUFFER_RELEASE_DELAY = 25,
// AV Sync
CELL_SAIL_PARAMETER_AV_SYNC_ES_AUDIO = 26,
CELL_SAIL_PARAMETER_AV_SYNC_ES_VIDEO = 27,
CELL_SAIL_PARAMETER_AV_SYNC_ES_USER = 28, // Not available
// Control
CELL_SAIL_PARAMETER_CONTROL_PPU_THREAD_STACK_SIZE = 29,
CELL_SAIL_PARAMETER_RESERVED0_ = 30, // Should be never used
CELL_SAIL_PARAMETER_RESERVED1 = 31, // Should be never used
// Apost
CELL_SAIL_PARAMETER_ENABLE_APOST_SRC = 32,
// File I/O Interface
CELL_SAIL_PARAMETER_FS = 33,
CELL_SAIL_PARAMETER_IO_PPU_THREAD_STACK_SIZE = 34,
CELL_SAIL_PARAMETER_VIDEO_PERFORMANCE_POLICY = 35,
_CELL_SAIL_PARAMETER_TYPE_NUM_OF_ELEMENTS = 36, // Should be never used
CELL_SAIL_PARAMETER_SOURCE_PPU_THREAD_PRIORITY = CELL_SAIL_PARAMETER_IO_PPU_THREAD_PRIORITY,
CELL_SAIL_PARAMETER_DMUX_SPURS_TASK_PRIORITY = CELL_SAIL_PARAMETER_DMUX_SPURS_TASK_PRIORITIES, // Deprecated
CELL_SAIL_PARAMETER_VDEC_SPURS_TASK_PRIORITY = CELL_SAIL_PARAMETER_VDEC_SPURS_TASK_PRIORITIES, // Deprecated
CELL_SAIL_PARAMETER_ADEC_SPURS_TASK_PRIORITY = CELL_SAIL_PARAMETER_ADEC_SPURS_TASK_PRIORITIES, // Deprecated
CELL_SAIL_PARAMETER_VPOST_SPURS_TASK_PRIORITY = CELL_SAIL_PARAMETER_VPOST_SPURS_TASK_PRIORITIES, // Deprecated
};
// Media states
enum
{
CELL_SAIL_MEDIA_STATE_FINE = 0,
CELL_SAIL_MEDIA_STATE_BAD = 1,
CELL_SAIL_MEDIA_STATE_LOST = 2,
};
// Stream Types
enum
{
CELL_SAIL_STREAM_PAMF = 0,
CELL_SAIL_STREAM_MP4 = 1,
CELL_SAIL_STREAM_AVI = 2,
CELL_SAIL_STREAM_UNSPECIFIED = -1,
};
// Sync Types
enum
{
CELL_SAIL_SYNC_MODE_REPEAT = 1 << 0,
CELL_SAIL_SYNC_MODE_SKIP = 1 << 1,
};
// Flags
enum {
CELL_SAIL_AVISF_DISABLED = 0x00000001,
CELL_SAIL_AVIF_HASINDEX = 0x00000010,
CELL_SAIL_AVIF_MUSTUSEINDEX = 0x00000020,
CELL_SAIL_AVIF_ISINTERLEAVED = 0x00000100,
CELL_SAIL_AVIF_WASCAPTUREFILE = 0x00010000,
CELL_SAIL_AVISF_VIDEO_PALCHANGES = 0x00010000,
CELL_SAIL_AVIF_COPYRIGHTED = 0x00020000,
CELL_SAIL_AVIF_TRUSTCKTYPE = 0x00000800, // Open-DML only
};
// Wave types
enum
{
CELL_SAIL_WAVE_FORMAT_PCM = 0x0001,
CELL_SAIL_WAVE_FORMAT_MPEG = 0x0050,
CELL_SAIL_WAVE_FORMAT_MPEGLAYER3 = 0x0055,
CELL_SAIL_WAVE_FORMAT_AC3 = 0x2000,
CELL_SAIL_WAVE_FORMAT_UNSPECIFIED = 0xFFFF,
};
// MPEG Layers
enum
{
CELL_SAIL_ACM_MPEG_LAYER1 = 0x0001,
CELL_SAIL_ACM_MPEG_LAYER2 = 0x0002,
CELL_SAIL_ACM_MPEG_LAYER3 = 0x0004,
};
// MPEG Modes
enum
{
CELL_SAIL_ACM_MPEG_STEREO = 0x0001,
CELL_SAIL_ACM_MPEG_JOINTSTEREO = 0x0002,
CELL_SAIL_ACM_MPEG_DUALCHANNEL = 0x0004,
CELL_SAIL_ACM_MPEG_SINGLECHANNEL = 0x0008,
};
// MPEG Flags
enum
{
CELL_SAIL_ACM_MPEG_PRIVATEBIT = 0x0001,
CELL_SAIL_ACM_MPEG_COPYRIGHT = 0x0002,
CELL_SAIL_ACM_MPEG_ORIGINALHOME = 0x0004,
CELL_SAIL_ACM_MPEG_PROTECTIONBIT = 0x0008,
CELL_SAIL_ACM_MPEG_ID_MPEG1 = 0x0010,
};
// MPEG Layer 3 Flags
enum
{
CELL_SAIL_MPEGLAYER3_ID_UNKNOWN = 0,
CELL_SAIL_MPEGLAYER3_ID_MPEG = 1,
CELL_SAIL_MPEGLAYER3_ID_CONSTANTFRAMESIZE = 2,
CELL_SAIL_MPEGLAYER3_FLAG_PADDING_ISO = 0x00000000,
CELL_SAIL_MPEGLAYER3_FLAG_PADDING_ON = 0x00000001,
CELL_SAIL_MPEGLAYER3_FLAG_PADDING_OFF = 0x00000002,
};
// ES Types
enum
{
CELL_SAIL_ES_AUDIO = 0,
CELL_SAIL_ES_VIDEO = 1,
CELL_SAIL_ES_USER = 2,
};
// Audio Coding Types
enum
{
CELL_SAIL_AUDIO_CODING_UNSPECIFIED = -1,
CELL_SAIL_AUDIO_CODING_LPCM_FLOAT32 = 1,
};
enum
{
CELL_SAIL_AUDIO_CHNUM_UNSPECIFIED = -1,
CELL_SAIL_AUDIO_CH_NUM_UNSPECIFIED = -1,
CELL_SAIL_AUDIO_AUSAMPLE_UNSPECIFIED = -1,
CELL_SAIL_AUDIO_SAMPLE_NUM_UNSPECIFIED = -1,
};
enum
{
CELL_SAIL_AUDIO_FS_32000HZ = 32000,
CELL_SAIL_AUDIO_FS_44100HZ = 44100,
CELL_SAIL_AUDIO_FS_48000HZ = 48000,
CELL_SAIL_AUDIO_FS_96000HZ = 96000,
CELL_SAIL_AUDIO_FS_88200HZ = 88200,
CELL_SAIL_AUDIO_FS_64000HZ = 64000,
//CELL_SAIL_AUDIO_FS_48000HZ = 48000,
//CELL_SAIL_AUDIO_FS_44100HZ = 44100,
//CELL_SAIL_AUDIO_FS_32000HZ = 32000,
CELL_SAIL_AUDIO_FS_24000HZ = 24000,
CELL_SAIL_AUDIO_FS_22050HZ = 22050,
CELL_SAIL_AUDIO_FS_16000HZ = 16000,
CELL_SAIL_AUDIO_FS_12000HZ = 12000,
CELL_SAIL_AUDIO_FS_11025HZ = 11025,
CELL_SAIL_AUDIO_FS_8000HZ = 8000,
CELL_SAIL_AUDIO_FS_7350HZ = 7350,
CELL_SAIL_AUDIO_FS_192000HZ = 192000,
//CELL_SAIL_AUDIO_FS_11024HZ = 11025,
CELL_SAIL_AUDIO_FS_UNSPECIFIED = -1,
};
enum
{
CELL_SAIL_AUDIO_CH_LAYOUT_UNDEFINED = 0,
// monoral
CELL_SAIL_AUDIO_CH_LAYOUT_1CH = 1,
// 1. Front Left
// 2. Front Right
CELL_SAIL_AUDIO_CH_LAYOUT_2CH_LR = 2,
// 1. Front Left
// 2. Front Center
// 3. Front Right
// for m4aac ac3
CELL_SAIL_AUDIO_CH_LAYOUT_3CH_LCR = 3,
// 1. Front Left
// 2. Front Center
// 3. Surround
// for m4aac ac3
CELL_SAIL_AUDIO_CH_LAYOUT_3CH_LRc = 4,
// 1. Front Left
// 2. Front Center
// 3. Front Right
// 4. Surround
// for m4aac ac3
CELL_SAIL_AUDIO_CH_LAYOUT_4CH_LCRc = 5,
// 1. Front Left
// 2. Front Right
// 3. Surround Left
// 4. Surround Right
// for m4aac
CELL_SAIL_AUDIO_CH_LAYOUT_4CH_LRlr = 6,
// 1. Front Left
// 2. Front Center
// 3. Front Right
// 4. Surround Left
// 5. Surround Right
// for m4aac
CELL_SAIL_AUDIO_CH_LAYOUT_5CH_LCRlr = 7,
// 1. Front Left
// 2. Front Center
// 3. Front Right
// 4. Surround Left
// 5. Surround Right
// 6. LFE
// for lpcm ac3 m4aac
CELL_SAIL_AUDIO_CH_LAYOUT_6CH_LCRlrE = 8,
// 1. Front Left
// 2. Front Center
// 3. Front Right
// 4. Back Left
// 5. Back Right
// 6. LFE
// for at3plus
CELL_SAIL_AUDIO_CH_LAYOUT_6CH_LCRxyE = 9,
// 1. Front Left
// 2. Front Center
// 3. Front Right
// 4. Back Left
// 5. Back Right
// 6. Back Center
// 7. LFE
// (for at3plus)
CELL_SAIL_AUDIO_CH_LAYOUT_7CH_LCRxycE = 10,
// 1. Front Left
// 2. Front Center
// 3. Front Right
// 4. LFE
// 5. Surround Left
// 6. Surround Right
// 7. Back Left (Left-Extend)
// 8. Back Right (Right-Extend)
// for lpcm at3plus
CELL_SAIL_AUDIO_CH_LAYOUT_8CH_LRCElrxy = 11,
CELL_SAIL_AUDIO_CH_LAYOUT_2CH_DUAL = 12,
CELL_SAIL_AUDIO_CH_LAYOUT_UNSPECIFIED = -1,
};
// Video Codings
enum
{
CELL_SAIL_VIDEO_CODING_UNSPECIFIED = -1,
CELL_SAIL_VIDEO_CODING_ARGB_INTERLEAVED = 0,
CELL_SAIL_VIDEO_CODING_RGBA_INTERLEAVED = 1,
CELL_SAIL_VIDEO_CODING_YUV422_U_Y0_V_Y1 = 2,
CELL_SAIL_VIDEO_CODING_YUV420_PLANAR = 3,
// Suported by cellCamera
CELL_SAIL_VIDEO_CODING_YUV422_Y0_U_Y1_V = 4,
CELL_SAIL_VIDEO_CODING_YUV422_V_Y1_U_Y0 = 9,
CELL_SAIL_VIDEO_CODING_YUV422_Y1_V_Y0_U = 10,
CELL_SAIL_VIDEO_CODING_JPEG = 11,
CELL_SAIL_VIDEO_CODING_RAW8_BAYER_BGGR = 12,
_CELL_SAIL_VIDEO_CODING_TYPE_NUM_OF_ELEMENTS = 13,
CELL_SAIL_VIDEO_CODING_UYVY422_INTERLEAVED = 2,
CELL_SAIL_VIDEO_CODING_YUYV422_INTERLEAVED = 4,
CELL_SAIL_VIDEO_CODING_VYUY422_REVERSE_INTERLEAVED = 9,
CELL_SAIL_VIDEO_CODING_RAW8_BAYER_GRBG = 12,
};
// Video Color Types
enum
{
CELL_SAIL_VIDEO_COLOR_MATRIX_UNSPECIFIED = -1,
CELL_SAIL_VIDEO_COLOR_MATRIX_BT601 = 0,
CELL_SAIL_VIDEO_COLOR_MATRIX_BT709 = 1,
_CELL_SAIL_VIDEO_COLOR_MATRIX_TYPE_NUM_OF_ELEMENTS = 2,
};
// Video Scan Types
enum
{
CELL_SAIL_VIDEO_SCAN_UNSPECIFIED = -1,
CELL_SAIL_VIDEO_SCAN_PROGRESSIVE = 0,
CELL_SAIL_VIDEO_SCAN_INTERLACE = 1,
_CELL_SAIL_VIDEO_SCAN_TYPE_NUM_OF_ELEMENTS = 2,
};
// Framerates
enum
{
CELL_SAIL_VIDEO_FRAME_RATE_UNSPECIFIED = -1,
CELL_SAIL_VIDEO_FRAME_RATE_24000_1001HZ = 0,
CELL_SAIL_VIDEO_FRAME_RATE_24HZ = 1,
CELL_SAIL_VIDEO_FRAME_RATE_25HZ = 2,
CELL_SAIL_VIDEO_FRAME_RATE_30000_1001HZ = 3,
CELL_SAIL_VIDEO_FRAME_RATE_30HZ = 4,
CELL_SAIL_VIDEO_FRAME_RATE_50HZ = 5,
CELL_SAIL_VIDEO_FRAME_RATE_60000_1001HZ = 6,
CELL_SAIL_VIDEO_FRAME_RATE_60HZ = 7,
_CELL_SAIL_VIDEO_FRAME_RATE_TYPE_NUM_OF_ELEMENTS = 8,
};
// Aspect Ratios
enum
{
CELL_SAIL_VIDEO_ASPECT_RATIO_UNSPECIFIED = -1,
CELL_SAIL_VIDEO_ASPECT_RATIO_1_1 = 1, // 1920x1080 1280x720
CELL_SAIL_VIDEO_ASPECT_RATIO_12_11 = 2, // 720x576 normal
CELL_SAIL_VIDEO_ASPECT_RATIO_10_11 = 3, // 720x480 normal
CELL_SAIL_VIDEO_ASPECT_RATIO_16_11 = 4, // 720x576 wide
CELL_SAIL_VIDEO_ASPECT_RATIO_40_33 = 5, // 720x480 wide
CELL_SAIL_VIDEO_ASPECT_RATIO_4_3 = 14, // 1440x1080
};
enum
{
CELL_SAIL_VIDEO_WIDTH_UNSPECIFIED = -1,
CELL_SAIL_VIDEO_HEIGHT_UNSPECIFIED = -1,
CELL_SAIL_VIDEO_PITCH_UNSPECIFIED = -1,
CELL_SAIL_VIDEO_BITS_PER_COLOR_UNSPECIFIED = -1,
CELL_SAIL_VIDEO_ALPHA_UNSPECIFIED = -1,
};
// Color Ranges
enum
{
CELL_SAIL_VIDEO_COLOR_RANGE_UNSPECIFIED = -1,
CELL_SAIL_VIDEO_COLOR_RANGE_LIMITED = 1,
CELL_SAIL_VIDEO_COLOR_RANGE_FULL = 0,
};
enum
{
CELL_SAIL_START_NOT_SPECIFIED = 0,
CELL_SAIL_START_NORMAL = 1 << 0, //1
CELL_SAIL_START_TIME_SCALE = 1 << 2, //4
CELL_SAIL_START_EP_SKIP = 1 << 4, //16
CELL_SAIL_START_EP_SKIP_REVERSE = 1 << 5, //32
CELL_SAIL_START_FRAME_STEP = 1 << 6, //64
};
// Seek Types
enum
{
CELL_SAIL_SEEK_NOT_SPECIFIED = 0,
CELL_SAIL_SEEK_ABSOLUTE_BYTE_POSITION = 1 << 0, // For PAMF
CELL_SAIL_SEEK_RELATIVE_BYTE_POSITION = 1 << 1, // Not implemented
CELL_SAIL_SEEK_ABSOLUTE_TIME_POSITION = 1 << 4, // MP4, AVI
CELL_SAIL_SEEK_CURRENT_POSITION = 1 << 6,
CELL_SAIL_SEEK_MP4_SCALE_AND_TIME = 1 << 4, // For MP4, obsolete
};
// Terminus Types
enum
{
CELL_SAIL_TERMINUS_NOT_SPECIFIED = 0,
CELL_SAIL_TERMINUS_EOS = 1 << 0,
CELL_SAIL_TERMINUS_ABSOLUTE_BYTE_POSITION = 1 << 1, // For PAMF
CELL_SAIL_TERMINUS_RELATIVE_BYTE_POSITION = 1 << 2, // Mot implemented
CELL_SAIL_TERMINUS_ABSOLUTE_TIME_POSITION = 1 << 5, // For MP4, AVI
CELL_SAIL_TERMINUS_MP4_SCALE_AND_TIME = 1 << 5, // For MP4, obsolete
CELL_SAIL_TERMINUS_MP4_SCALE_ANT_TIME = 1 << 5, // For MP4, here because of a typo
};
// Start Flag Types
enum
{
CELL_SAIL_START_FLAG_NOT_SPECIFIED = 0,
CELL_SAIL_START_FLAG_UNFLUSH = 1 << 0,
CELL_SAIL_START_FLAG_PAUSE_BEGIN = 1 << 1,
CELL_SAIL_START_FLAG_PAUSE_END = 1 << 2,
CELL_SAIL_START_FLAG_COMPLETE_STREAM = 1 << 3,
CELL_SAIL_START_FLAG_STICKY = 1 << 4,
CELL_SAIL_START_FLAG_PAUSE = 1 << 1, // Obsolete
};
enum
{
_CELL_SAIL_SYNC_SHIFT_NUM = 8,
// Buffering
CELL_SAIL_SYNC_UNDERFLOW = 1,
// = 2, Reserved
// Sync Status
CELL_SAIL_SYNC_ON_TIME = 1 << 2,
CELL_SAIL_SYNC_MAYBE_ON_TIME = 2 << 2,
CELL_SAIL_SYNC_EARLY = 3 << 2,
CELL_SAIL_SYNC_LATE = 4 << 2,
CELL_SAIL_SYNC_NO_SYNC = 5 << 2,
CELL_SAIL_SYNC_NO_PTS = 6 << 2,
CELL_SAIL_SYNC_NOT_READY = 7 << 2,
CELL_SAIL_SYNC_DISABLED = 8 << 2,
CELL_SAIL_SYNC_PAUSED = 9 << 2,
CELL_SAIL_SYNC_DISABLED_PAUSED = 10 << 2,
CELL_SAIL_SYNC_MUTED = 11 << 2,
CELL_SAIL_SYNC_DONE = 12 << 2,
// = 13 << 2, Reserved
// = 14 << 2, Reserved
// = 15 << 2, Reserved
//CELL_SAIL_SYNC_FIRST_FRAME = 64,
//CELL_SAIL_SYNC_LAST_FRAME = 128,
// Frame Status
CELL_SAIL_SYNC_NO_FRAME = 0,
CELL_SAIL_SYNC_REPEATED = 1 << _CELL_SAIL_SYNC_SHIFT_NUM,
CELL_SAIL_SYNC_NEXT = 2 << _CELL_SAIL_SYNC_SHIFT_NUM,
CELL_SAIL_SYNC_SKIPPED_ONE = 3 << _CELL_SAIL_SYNC_SHIFT_NUM,
};
enum
{
CELL_SAIL_EVENT_RECORDER_CALL_COMPLETED = 2,
CELL_SAIL_EVENT_RECORDER_STATE_CHANGED = 3,
};
enum
{
CELL_SAIL_VIDEO_FRAME_RATE_100HZ = 8,
CELL_SAIL_VIDEO_FRAME_RATE_120000_1001HZ = 9,
CELL_SAIL_VIDEO_FRAME_RATE_120HZ = 10,
};
enum
{
CELL_SAIL_GRAPHICS_ADAPTER_FIELD_TOP = 0,
CELL_SAIL_GRAPHICS_ADAPTER_FIELD_BOTTOM = 1,
CELL_SAIL_GRAPHICS_ADAPTER_FIELD_DONT_CARE = 2,
};
enum
{
CELL_SAIL_SOURCE_SEEK_ABSOLUTE_BYTE_POSITION = 1 << 0,
};
enum
{
CELL_SAIL_SOURCE_CAPABILITY_NONE = 0,
CELL_SAIL_SOURCE_CAPABILITY_SEEK_ABSOLUTE_BYTE_POSITION = 1 << 0,
CELL_SAIL_SOURCE_CAPABILITY_PAUSE = 1 << 4,
CELL_SAIL_SOURCE_CAPABILITY_GAPLESS = 1 << 5,
CELL_SAIL_SOURCE_CAPABILITY_EOS = 1 << 6,
CELL_SAIL_SOURCE_CAPABILITY_SEEK_ABSOLUTE_TIME_POSITION = 1 << 7,
};
struct CellSailAudioFormat
{
s8 coding;
s8 chNum;
be_t<s16> sampleNum;
be_t<s32> fs;
be_t<s32> chLayout;
be_t<s32> reserved0; // Specify both -1
be_t<s64> reserved1;
};
struct CellSailAudioFrameInfo
{
be_t<u32> pPcm;
be_t<s32> status;
be_t<u64> pts;
be_t<u64> reserved; // Specify 0
};
struct CellSailVideoFormat
{
s8 coding;
s8 scan;
s8 bitsPerColor;
s8 frameRate;
be_t<s16> width;
be_t<s16> height;
be_t<s32> pitch;
be_t<s32> alpha;
s8 colorMatrix;
s8 aspectRatio;
s8 colorRange;
s8 reserved1; // Specify all three -1
be_t<s32> reserved2;
be_t<s64> reserved3;
};
struct CellSailVideoFrameInfo
{
be_t<u32> pPic;
be_t<s32> status;
be_t<u64> pts;
be_t<u64> reserved; // Specify both 0
be_t<u16> interval;
u8 structure;
s8 repeatNum;
u8 reserved2[4];
};
struct CellSailSourceBufferItem
{
u8 pBuf;
be_t<u32> size;
be_t<u32> sessionId;
be_t<u32> reserved; // Specify 0
};
struct CellSailSourceStartCommand
{
be_t<u64> startFlags;
be_t<s64> startArg;
be_t<s64> lengthArg;
be_t<u64> optionalArg0;
be_t<u64> optionalArg1;
};
struct CellSailSourceStreamingProfile
{
be_t<u32> reserved0; // Specify 0
be_t<u32> numItems;
be_t<u32> maxBitrate;
be_t<u32> reserved1; // Specify 0
be_t<u64> duration;
be_t<u64> streamSize;
};
union CellSailEvent
{
struct
{
be_t<u32> major;
be_t<u32> minor;
}
u32x2;
be_t<u64> value;
};
template<typename T, typename>
struct ppu_gpr_cast_impl;
template<>
struct ppu_gpr_cast_impl<CellSailEvent, void>
{
static inline u64 to(const CellSailEvent& event)
{
return event.value;
}
};
using CellSailMemAllocatorFuncAlloc = vm::ptr<void>(vm::ptr<void> pArg, u32 boundary, u32 size);
using CellSailMemAllocatorFuncFree = void(vm::ptr<void> pArg, u32 boundary, vm::ptr<void> pMemory);
using CellSailSoundAdapterFuncMakeup = s32(vm::ptr<void> pArg);
using CellSailSoundAdapterFuncCleanup = s32(vm::ptr<void> pArg);
using CellSailSoundAdapterFuncFormatChanged = void(vm::ptr<void> pArg, vm::ptr<CellSailAudioFormat> pFormat, u32 sessionId);
using CellSailGraphicsAdapterFuncMakeup = s32(vm::ptr<void> pArg);
using CellSailGraphicsAdapterFuncCleanup = s32(vm::ptr<void> pArg);
using CellSailGraphicsAdapterFuncFormatChanged = void(vm::ptr<void> pArg, vm::ptr<CellSailVideoFormat> pFormat, u32 sessionId);
using CellSailGraphicsAdapterFuncAllocFrame = s32(vm::ptr<void> pArg, u32 size, s32 num, vm::pptr<u8> ppFrame);
using CellSailGraphicsAdapterFuncFreeFrame = s32(vm::ptr<void> pArg, s32 num, vm::pptr<u8> ppFrame);
using CellSailSourceFuncMakeup = s32(vm::ptr<void> pArg, vm::cptr<char> pProtocolNames);
using CellSailSourceFuncCleanup = s32(vm::ptr<void> pArg);
using CellSailSourceFuncOpen = void(vm::ptr<void> pArg, s32 streamType, vm::ptr<void> pMediaInfo, vm::cptr<char> pUri, vm::ptr<CellSailSourceStreamingProfile> pProfile);
using CellSailSourceFuncClose = void(vm::ptr<void> pArg);
using CellSailSourceFuncStart = void(vm::ptr<void> pArg, vm::ptr<CellSailSourceStartCommand> pCommand, u32 sessionId);
using CellSailSourceFuncStop = void(vm::ptr<void> pArg);
using CellSailSourceFuncCancel = void(vm::ptr<void> pArg);
using CellSailSourceFuncCheckout = s32(vm::ptr<void> pArg, vm::pptr<CellSailSourceBufferItem> ppItem);
using CellSailSourceFuncCheckin = s32(vm::ptr<void> pArg, vm::ptr<CellSailSourceBufferItem> pItem);
using CellSailSourceFuncClear = s32(vm::ptr<void> pArg);
using CellSailSourceFuncRead = s32(vm::ptr<void> pArg, s32 streamType, vm::ptr<void> pMediaInfo, vm::cptr<char> pUri, u64 offset, vm::ptr<u8> pBuf, u32 size, vm::ptr<u64> pTotalSize);
using CellSailSourceFuncReadSync = s32(vm::ptr<void> pArg, s32 streamType, vm::ptr<void> pMediaInfo, vm::cptr<char> pUri, u64 offset, vm::ptr<u8> pBuf, u32 size, vm::ptr<u64> pTotalSize);
using CellSailSourceFuncGetCapabilities = s32(vm::ptr<void> pArg, s32 streamType, vm::ptr<void> pMediaInfo, vm::cptr<char> pUri, vm::ptr<u64> pCapabilities);
using CellSailSourceFuncInquireCapability = s32(vm::ptr<void> pArg, s32 streamType, vm::ptr<void> pMediaInfo, vm::cptr<char> pUri, vm::ptr<CellSailSourceStartCommand> pCommand);
using CellSailSourceCheckFuncError = void(vm::ptr<void> pArg, vm::cptr<char> pMsg, s32 line);
using CellSailFsFuncOpen = s32(vm::cptr<char> pPath, s32 flag, vm::ptr<s32> pFd, vm::ptr<void> pArg, u64 size);
using CellSailFsFuncOpenSecond = s32(vm::cptr<char> pPath, s32 flag, s32 fd, vm::ptr<void> pArg, u64 size);
using CellSailFsFuncClose = s32(s32 fd);
using CellSailFsFuncFstat = s32(s32 fd, vm::ptr<struct CellFstat> pStat);
using CellSailFsFuncRead = s32(s32 fd, vm::ptr<void> pBuf, u64 numBytes, vm::ptr<u64> pNumRead);
using CellSailFsFuncLseek = s32(s32 fd, s64 offset, s32 whence, vm::ptr<u64> pPosition);
using CellSailFsFuncCancel = s32(s32 fd);
using CellSailRendererAudioFuncMakeup = s32(vm::ptr<void> pArg);
using CellSailRendererAudioFuncCleanup = s32(vm::ptr<void> pArg);
using CellSailRendererAudioFuncOpen = void(vm::ptr<void> pArg, vm::ptr<CellSailAudioFormat> pInfo, u32 frameNum);
using CellSailRendererAudioFuncClose = void(vm::ptr<void> pArg);
using CellSailRendererAudioFuncStart = void(vm::ptr<void> pArg, b8 buffering);
using CellSailRendererAudioFuncStop = void(vm::ptr<void> pArg, b8 flush);
using CellSailRendererAudioFuncCancel = void(vm::ptr<void> pArg);
using CellSailRendererAudioFuncCheckout = s32(vm::ptr<void> pArg, vm::pptr<CellSailAudioFrameInfo> ppInfo);
using CellSailRendererAudioFuncCheckin = s32(vm::ptr<void> pArg, vm::ptr<CellSailAudioFrameInfo> pInfo);
using CellSailRendererVideoFuncMakeup = s32(vm::ptr<void> pArg);
using CellSailRendererVideoFuncCleanup = s32(vm::ptr<void> pArg);
using CellSailRendererVideoFuncOpen = void(vm::ptr<void> pArg, vm::ptr<CellSailVideoFormat> pInfo, u32 frameNum, u32 minFrameNum);
using CellSailRendererVideoFuncClose = void(vm::ptr<void> pArg);
using CellSailRendererVideoFuncStart = void(vm::ptr<void> pArg, b8 buffering);
using CellSailRendererVideoFuncStop = void(vm::ptr<void> pArg, b8 flush, b8 keepRendering);
using CellSailRendererVideoFuncCancel = void(vm::ptr<void> pArg);
using CellSailRendererVideoFuncCheckout = s32(vm::ptr<void> pArg, vm::pptr<CellSailVideoFrameInfo> ppInfo);
using CellSailRendererVideoFuncCheckin = s32(vm::ptr<void> pArg, vm::ptr<CellSailVideoFrameInfo> pInfo);
using CellSailPlayerFuncNotified = void(vm::ptr<void> pArg, CellSailEvent event, u64 arg0, u64 arg1);
struct CellSailMemAllocatorFuncs
{
vm::ptr<CellSailMemAllocatorFuncAlloc> pAlloc;
vm::ptr<CellSailMemAllocatorFuncFree> pFree;
};
struct CellSailMemAllocator
{
vm::bptr<CellSailMemAllocatorFuncs> callbacks;
be_t<u32> pArg;
};
struct CellSailFuture
{
be_t<u32> mutex_id;
be_t<u32> cond_id;
volatile be_t<u32> flags;
be_t<s32> result;
be_t<u64> userParam;
};
struct CellSailSoundAdapterFuncs
{
vm::bptr<CellSailSoundAdapterFuncMakeup> pMakeup;
vm::bptr<CellSailSoundAdapterFuncCleanup> pCleanup;
vm::bptr<CellSailSoundAdapterFuncFormatChanged> pFormatChanged;
};
struct CellSailSoundFrameInfo
{
be_t<u32> pBuffer;
be_t<u32> sessionId;
be_t<u32> tag;
be_t<s32> status;
be_t<u64> pts;
};
struct CellSailSoundAdapter
{
bool initialized;
bool registered;
vm::ptr<CellSailSoundAdapterFuncMakeup> pMakeup;
vm::ptr<CellSailSoundAdapterFuncCleanup> pCleanup;
vm::ptr<CellSailSoundAdapterFuncFormatChanged> pFormatChanged;
vm::ptr<void> arg;
be_t<u32> index;
CellSailAudioFormat format;
};
CHECK_MAX_SIZE(CellSailSoundAdapter, 0x100);
struct CellSailGraphicsAdapterFuncs
{
vm::bptr<CellSailGraphicsAdapterFuncMakeup> pMakeup;
vm::bptr<CellSailGraphicsAdapterFuncCleanup> pCleanup;
vm::bptr<CellSailGraphicsAdapterFuncFormatChanged> pFormatChanged;
vm::bptr<CellSailGraphicsAdapterFuncAllocFrame> pAlloc;
vm::bptr<CellSailGraphicsAdapterFuncFreeFrame> pFree;
};
struct CellSailGraphicsFrameInfo
{
be_t<u32> pBuffer;
be_t<u32> sessionId;
be_t<u32> tag;
be_t<s32> status;
be_t<u64> pts;
};
struct CellSailGraphicsAdapter
{
bool initialized;
bool registered;
vm::ptr<CellSailGraphicsAdapterFuncMakeup> pMakeup;
vm::ptr<CellSailGraphicsAdapterFuncCleanup> pCleanup;
vm::ptr<CellSailGraphicsAdapterFuncFormatChanged> pFormatChanged;
vm::ptr<CellSailGraphicsAdapterFuncAllocFrame> pAlloc;
vm::ptr<CellSailGraphicsAdapterFuncFreeFrame> pFree;
vm::ptr<void> arg;
CellSailVideoFormat format;
be_t<s32> index;
};
CHECK_MAX_SIZE(CellSailGraphicsAdapter, 0x100);
struct CellSailAuInfo
{
be_t<u32> pAu;
be_t<u32> size;
be_t<s32> status;
be_t<u32> sessionId;
be_t<u64> pts;
be_t<u64> dts;
be_t<u64> reserved; // Specify 0
};
struct CellSailAuReceiver
{
be_t<u64> internalData[64];
};
struct CellSailRendererAudioFuncs
{
vm::bptr<CellSailRendererAudioFuncMakeup> pMakeup;
vm::bptr<CellSailRendererAudioFuncCleanup> pCleanup;
vm::bptr<CellSailRendererAudioFuncOpen> pOpen;
vm::bptr<CellSailRendererAudioFuncClose> pClose;
vm::bptr<CellSailRendererAudioFuncStart> pStart;
vm::bptr<CellSailRendererAudioFuncStop> pStop;
vm::bptr<CellSailRendererAudioFuncCancel> pCancel;
vm::bptr<CellSailRendererAudioFuncCheckout> pCheckout;
vm::bptr<CellSailRendererAudioFuncCheckin> pCheckin;
};
struct CellSailRendererAudioAttribute
{
be_t<u32> thisSize;
CellSailAudioFormat pPreferredFormat;
};
struct CellSailRendererAudio
{
be_t<u64> internalData[32];
};
struct CellSailRendererVideoFuncs
{
vm::bptr<CellSailRendererVideoFuncMakeup> pMakeup;
vm::bptr<CellSailRendererVideoFuncCleanup> pCleanup;
vm::bptr<CellSailRendererVideoFuncOpen> pOpen;
vm::bptr<CellSailRendererVideoFuncClose> pClose;
vm::bptr<CellSailRendererVideoFuncStart> pStart;
vm::bptr<CellSailRendererVideoFuncStop> pStop;
vm::bptr<CellSailRendererVideoFuncCancel> pCancel;
vm::bptr<CellSailRendererVideoFuncCheckout> pCheckout;
vm::bptr<CellSailRendererVideoFuncCheckin> pCheckin;
};
struct CellSailRendererVideoAttribute
{
be_t<u32> thisSize;
CellSailVideoFormat *pPreferredFormat;
};
struct CellSailRendererVideo
{
be_t<u64> internalData[32];
};
struct CellSailSourceFuncs
{
vm::bptr<CellSailSourceFuncMakeup> pMakeup;
vm::bptr<CellSailSourceFuncCleanup> pCleanup;
vm::bptr<CellSailSourceFuncOpen> pOpen;
vm::bptr<CellSailSourceFuncClose> pClose;
vm::bptr<CellSailSourceFuncStart> pStart;
vm::bptr<CellSailSourceFuncStop> pStop;
vm::bptr<CellSailSourceFuncCancel> pCancel;
vm::bptr<CellSailSourceFuncCheckout> pCheckout;
vm::bptr<CellSailSourceFuncCheckin> pCheckin;
vm::bptr<CellSailSourceFuncClear> pClear;
vm::bptr<CellSailSourceFuncRead> pRead;
vm::bptr<CellSailSourceFuncReadSync> pReadSync;
vm::bptr<CellSailSourceFuncGetCapabilities> pGetCapabilities;
vm::bptr<CellSailSourceFuncInquireCapability> pInquireCapability;
};
struct CellSailSource
{
be_t<u64> internalData[20];
};
struct CellSailSourceCheckStream
{
be_t<s32> streamType;
be_t<u32> pMediaInfo;
s8 pUri;
};
struct CellSailSourceCheckResource
{
CellSailSourceCheckStream ok;
CellSailSourceCheckStream readError;
CellSailSourceCheckStream openError;
CellSailSourceCheckStream startError;
CellSailSourceCheckStream runningError;
};
template <template <class T, usz A = alignof(T)> class be_t = ::be_t>
struct CellSailMp4DateTime
{
be_t<u16, 2> second;
be_t<u16> minute;
be_t<u16> hour;
be_t<u16> day;
be_t<u16> month;
be_t<u16> year;
be_t<u16> reserved0;
be_t<u16> reserved1;
};
struct CellSailMp4Movie
{
be_t<u64> internalData[16];
};
template <template <class T, usz A = alignof(T)> class be_t = ::be_t>
struct CellSailMp4MovieInfo
{
CellSailMp4DateTime<be_t> creationDateTime;
CellSailMp4DateTime<be_t> modificationDateTime;
be_t<u32> trackCount;
be_t<u32> movieTimeScale;
be_t<u32> movieDuration;
be_t<u32> reserved[16];
};
struct CellSailMp4Track
{
be_t<u64> internalData[6];
};
struct CellSailMp4TrackInfo
{
b8 isTrackEnabled;
u8 reserved0[3];
be_t<u32> trackId;
be_t<u64> trackDuration;
be_t<s16> layer;
be_t<s16> alternateGroup;
be_t<u16> reserved1[2];
be_t<u32> trackWidth;
be_t<u32> trackHeight;
be_t<u16> language;
be_t<u16> reserved2;
be_t<u16> mediaType;
be_t<u32> reserved3[3];
};
struct CellSailAviMovie
{
be_t<u64> internalData[16];
};
struct CellSailAviMovieInfo
{
be_t<u32> maxBytesPerSec;
be_t<u32> flags;
be_t<u32> reserved0;
be_t<u32> streams;
be_t<u32> suggestedBufferSize;
be_t<u32> width;
be_t<u32> height;
be_t<u32> scale;
be_t<u32> rate;
be_t<u32> length;
be_t<u32> reserved1;
be_t<u32> reserved2;
};
struct CellSailAviMainHeader
{
be_t<u32> microSecPerFrame;
be_t<u32> maxBytesPerSec;
be_t<u32> paddingGranularity;
be_t<u32> flags;
be_t<u32> totalFrames;
be_t<u32> initialFrames;
be_t<u32> streams;
be_t<u32> suggestedBufferSize;
be_t<u32> width;
be_t<u32> height;
be_t<u32> reserved[4];
};
struct CellSailAviExtendedHeader
{
be_t<u32> totalFrames;
};
struct CellSailAviStream
{
be_t<u64> internalData[2];
};
struct CellSailAviMediaType
{
be_t<u32> fccType;
be_t<u32> fccHandler;
union u {
struct audio {
be_t<u16> formatTag;
be_t<u16> reserved; // Specify 0
union u {
struct mpeg {
be_t<u16> headLayer; // Specify 0
be_t<u16> reserved; // Specify 0
};
};
};
struct video {
be_t<u32> compression;
be_t<u32> reserved; // Specify 0
};
};
};
struct CellSailAviStreamHeader
{
be_t<u32> fccType;
be_t<u32> fccHandler;
be_t<u32> flags;
be_t<u16> priority;
be_t<u32> initialFrames;
be_t<u32> scale;
be_t<u32> rate;
be_t<u32> start;
be_t<u32> length;
be_t<u32> suggestedBufferSize;
be_t<u32> quality;
be_t<u32> sampleSize;
struct frame {
be_t<u16> left;
be_t<u16> top;
be_t<u16> right;
be_t<u16> bottom;
};
};
struct CellSailBitmapInfoHeader
{
be_t<u32> size;
be_t<s32> width;
be_t<s32> height;
be_t<u16> planes;
be_t<u16> bitCount;
be_t<u32> compression;
be_t<u32> sizeImage;
be_t<s32> xPelsPerMeter;
be_t<s32> yPelsPerMeter;
be_t<u32> clrUsed;
be_t<u32> clrImportant;
};
struct CellSailWaveFormatEx
{
be_t<u16> formatTag;
be_t<u16> channels;
be_t<u32> samplesPerSec;
be_t<u32> avgBytesPerSec;
be_t<u16> blockAlign;
be_t<u16> bitsPerSample;
be_t<u16> cbSize;
};
struct CellSailMpeg1WaveFormat
{
CellSailWaveFormatEx wfx;
be_t<u16> headLayer;
be_t<u32> headBitrate;
be_t<u16> headMode;
be_t<u16> headModeExt;
be_t<u16> headEmphasis;
be_t<u16> headFlags;
be_t<u32> PTSLow;
be_t<u32> PTSHigh;
};
struct CellSailMpegLayer3WaveFormat
{
CellSailWaveFormatEx wfx;
be_t<u16> ID;
be_t<u32> flags;
be_t<u16> blockSize;
be_t<u16> framesPerBlock;
be_t<u16> codecDelay;
};
struct CellSailDescriptor
{
b8 autoSelection;
b8 registered;
be_t<s32> streamType;
be_t<u32> buffer;
be_t<u32> sp_;
};
CHECK_MAX_SIZE(CellSailDescriptor, 0x100);
struct CellSailStartCommand
{
be_t<u32> startType;
be_t<u32> seekType;
be_t<u32> terminusType;
be_t<u32> flags;
be_t<u32> startArg;
be_t<u32> reserved;
be_t<u64> seekArg;
be_t<u64> terminusArg;
};
struct CellSailFsReadFuncs
{
CellSailFsFuncOpen pOpen;
CellSailFsFuncOpenSecond pOpenSecond;
CellSailFsFuncClose pClose;
CellSailFsFuncFstat pFstat;
CellSailFsFuncRead pRead;
CellSailFsFuncLseek pLseek;
CellSailFsFuncCancel pCancel;
be_t<u32> reserved[2]; // Specify 0
};
struct CellSailFsRead
{
be_t<u32> capability;
CellSailFsReadFuncs funcs;
};
struct CellSailPlayerAttribute
{
be_t<s32> preset;
be_t<u32> maxAudioStreamNum;
be_t<u32> maxVideoStreamNum;
be_t<u32> maxUserStreamNum;
be_t<u32> queueDepth;
be_t<u32> reserved0; // All three specify 0
be_t<u32> reserved1;
be_t<u32> reserved2;
};
struct CellSailPlayerResource
{
be_t<u32> pSpurs;
be_t<u32> reserved0; // All three specify 0
be_t<u32> reserved1;
be_t<u32> reserved2;
};
struct CellSailPlayer
{
CellSailMemAllocator allocator;
vm::ptr<CellSailPlayerFuncNotified> callback;
vm::ptr<void> callbackArg;
CellSailPlayerAttribute attribute;
CellSailPlayerResource resource;
vm::ptr<CellSailStartCommand> playbackCommand;
s32 repeatMode;
s32 descriptors;
vm::ptr<CellSailDescriptor> registeredDescriptors[2];
bool paused;
bool booted;
vm::ptr<CellSailSoundAdapter> sAdapter;
vm::ptr<CellSailGraphicsAdapter> gAdapter;
// Attributes
be_t<s32> control_ppu_thread_priority;
be_t<s32> control_ppu_thread_stack_size;
be_t<s32> spurs_num_of_spus;
be_t<s32> spurs_spu_thread_priority;
be_t<s32> spurs_ppu_thread_priority;
b8 spurs_exit_if_no_work;
be_t<s32> io_ppu_thread_priority;
be_t<s32> io_ppu_thread_stack_size;
be_t<s32> dmux_ppu_thread_priority;
be_t<s32> dmux_num_of_spus;
be_t<u64> dmux_spurs_task_priorities;
be_t<s32> adec_ppu_thread_priority;
be_t<s32> adec_num_of_spus;
be_t<u64> adec_spurs_task_priorities;
b8 enable_apost_src;
be_t<s32> vdec_ppu_thread_priority;
be_t<s32> vdec_m2v_num_of_spus;
be_t<s32> vdec_avc_num_of_spus;
be_t<u64> vdec_spurs_task_priorities;
vm::ptr<CellVpostCtrlParam> enable_vpost;
be_t<s32> vpost_ppu_thread_priority;
be_t<s32> vpost_num_of_spus;
be_t<u64> vpost_spurs_task_priorities;
be_t<s32> graphics_adapter_buffer_release_delay;
be_t<s32> video_performance_policy;
b8 av_sync_es_audio;
b8 av_sync_es_video;
CellSailFsRead fs;
};
CHECK_MAX_SIZE(CellSailPlayer, 0x100);
inline static const char* ParameterCodeToName(s32 code)
{
switch (code)
{
case CELL_SAIL_PARAMETER_ENABLE_VPOST: return "ENABLE_VPOST";
case CELL_SAIL_PARAMETER_CONTROL_QUEUE_DEPTH: return "CONTROL_QUEUE_DEPTH";
case CELL_SAIL_PARAMETER_CONTROL_PPU_THREAD_PRIORITY: return "CONTROL_PPU_THREAD_PRIORITY";
case CELL_SAIL_PARAMETER_SPURS_NUM_OF_SPUS: return "SPURS_NUM_OF_SPUS";
case CELL_SAIL_PARAMETER_SPURS_SPU_THREAD_PRIORITY: return "SPURS_SPU_THREAD_PRIORITY";
case CELL_SAIL_PARAMETER_SPURS_PPU_THREAD_PRIORITY: return "SPURS_PPU_THREAD_PRIORITY";
case CELL_SAIL_PARAMETER_SPURS_EXIT_IF_NO_WORK: return "SPURS_EXIT_IF_NO_WORK";
case CELL_SAIL_PARAMETER_IO_PPU_THREAD_PRIORITY: return "IO_PPU_THREAD_PRIORITY";
case CELL_SAIL_PARAMETER_DMUX_PPU_THREAD_PRIORITY: return "DMUX_PPU_THREAD_PRIORITY";
case CELL_SAIL_PARAMETER_DMUX_SPU_THREAD_PRIORITY: return "DMUX_SPU_THREAD_PRIORITY";
case CELL_SAIL_PARAMETER_DMUX_NUM_OF_SPUS: return "DMUX_NUM_OF_SPUS";
case CELL_SAIL_PARAMETER_DMUX_SPURS_TASK_PRIORITIES: return "DMUX_SPURS_TASK_PRIORITIES";
case CELL_SAIL_PARAMETER_ADEC_PPU_THREAD_PRIORITY: return "ADEC_PPU_THREAD_PRIORITY";
case CELL_SAIL_PARAMETER_ADEC_SPU_THREAD_PRIORITY: return "ADEC_SPU_THREAD_PRIORITY";
case CELL_SAIL_PARAMETER_ADEC_NUM_OF_SPUS: return "ADEC_NUM_OF_SPUS";
case CELL_SAIL_PARAMETER_ADEC_SPURS_TASK_PRIORITIES: return "ADEC_SPURS_TASK_PRIORITIES";
case CELL_SAIL_PARAMETER_VDEC_PPU_THREAD_PRIORITY: return "VDEC_PPU_THREAD_PRIORITY";
case CELL_SAIL_PARAMETER_VDEC_SPU_THREAD_PRIORITY: return "VDEC_SPU_THREAD_PRIORITY";
case CELL_SAIL_PARAMETER_VDEC_M2V_NUM_OF_SPUS: return "VDEC_M2V_NUM_OF_SPUS";
case CELL_SAIL_PARAMETER_VDEC_AVC_NUM_OF_SPUS: return "VDEC_AVC_NUM_OF_SPUS";
case CELL_SAIL_PARAMETER_VDEC_SPURS_TASK_PRIORITIES: return "VDEC_SPURS_TASK_PRIORITIES";
case CELL_SAIL_PARAMETER_VPOST_PPU_THREAD_PRIORITY: return "VPOST_PPU_THREAD_PRIORITY";
case CELL_SAIL_PARAMETER_VPOST_SPU_THREAD_PRIORITY: return "VPOST_SPU_THREAD_PRIORITY";
case CELL_SAIL_PARAMETER_VPOST_NUM_OF_SPUS: return "VPOST_NUM_OF_SPUS";
case CELL_SAIL_PARAMETER_VPOST_SPURS_TASK_PRIORITIES: return "VPOST_SPURS_TASK_PRIORITIES";
case CELL_SAIL_PARAMETER_GRAPHICS_ADAPTER_BUFFER_RELEASE_DELAY: return "GRAPHICS_ADAPTER_BUFFER_RELEASE_DELAY";
case CELL_SAIL_PARAMETER_AV_SYNC_ES_AUDIO: return "AV_SYNC_ES_AUDIO";
case CELL_SAIL_PARAMETER_AV_SYNC_ES_VIDEO: return "AV_SYNC_ES_VIDEO";
case CELL_SAIL_PARAMETER_AV_SYNC_ES_USER: return "AV_SYNC_ES_USER";
case CELL_SAIL_PARAMETER_CONTROL_PPU_THREAD_STACK_SIZE: return "CONTROL_PPU_THREAD_STACK_SIZE";
case CELL_SAIL_PARAMETER_RESERVED0_: return "RESERVED0_";
case CELL_SAIL_PARAMETER_RESERVED1: return "RESERVED1";
case CELL_SAIL_PARAMETER_ENABLE_APOST_SRC: return "ENABLE_APOST_SRC";
case CELL_SAIL_PARAMETER_FS: return "FS";
case CELL_SAIL_PARAMETER_IO_PPU_THREAD_STACK_SIZE: return "IO_PPU_THREAD_STACK_SIZE";
case CELL_SAIL_PARAMETER_VIDEO_PERFORMANCE_POLICY: return "VIDEO_PERFORMANCE_POLICY";
case _CELL_SAIL_PARAMETER_TYPE_NUM_OF_ELEMENTS: return "TYPE_NUM_OF_ELEMENTS";
default: return "???";
}
}
| 38,708
|
C++
|
.h
| 1,133
| 32.321271
| 187
| 0.699912
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,846
|
cellSubDisplay.h
|
RPCS3_rpcs3/rpcs3/Emu/Cell/Modules/cellSubDisplay.h
|
#pragma once
// Return Codes
enum CellSubDisplayError : u32
{
CELL_SUBDISPLAY_ERROR_OUT_OF_MEMORY = 0x80029851,
CELL_SUBDISPLAY_ERROR_FATAL = 0x80029852,
CELL_SUBDISPLAY_ERROR_NOT_FOUND = 0x80029853,
CELL_SUBDISPLAY_ERROR_INVALID_VALUE = 0x80029854,
CELL_SUBDISPLAY_ERROR_NOT_INITIALIZED = 0x80029855,
CELL_SUBDISPLAY_ERROR_NOT_SUPPORTED = 0x80029856,
CELL_SUBDISPLAY_ERROR_SET_SAMPLE = 0x80029860,
CELL_SUBDISPLAY_ERROR_AUDIOOUT_IS_BUSY = 0x80029861,
CELL_SUBDISPLAY_ERROR_ZERO_REGISTERED = 0x80029813, // = CELL_REMOTEPLAY_ERROR_ZERO_REGISTERED
};
// Different constants
enum
{
CELL_SUBDISPLAY_STATUS_JOIN = 1,
CELL_SUBDISPLAY_STATUS_LEAVE = 2,
CELL_SUBDISPLAY_STATUS_FATALERROR = 3,
CELL_SUBDISPLAY_VERSION_0001 = 1,
CELL_SUBDISPLAY_VERSION_0002 = 2,
CELL_SUBDISPLAY_VERSION_0003 = 3,
CELL_SUBDISPLAY_MODE_REMOTEPLAY = 1,
CELL_SUBDISPLAY_VIDEO_FORMAT_A8R8G8B8 = 1,
CELL_SUBDISPLAY_VIDEO_FORMAT_R8G8B8A8 = 2,
CELL_SUBDISPLAY_VIDEO_FORMAT_YUV420 = 3,
CELL_SUBDISPLAY_VIDEO_ASPECT_RATIO_16_9 = 0,
CELL_SUBDISPLAY_VIDEO_ASPECT_RATIO_4_3 = 1,
CELL_SUBDISPLAY_VIDEO_MODE_SETDATA = 0,
CELL_SUBDISPLAY_VIDEO_MODE_CAPTURE = 1,
CELL_SUBDISPLAY_AUDIO_MODE_SETDATA = 0,
CELL_SUBDISPLAY_AUDIO_MODE_CAPTURE = 1,
CELL_SUBDISPLAY_0001_MEMORY_CONTAINER_SIZE = 8 * 1024 * 1024,
CELL_SUBDISPLAY_0002_MEMORY_CONTAINER_SIZE = 10 * 1024 * 1024,
CELL_SUBDISPLAY_0003_MEMORY_CONTAINER_SIZE = 10 * 1024 * 1024,
CELL_SUBDISPLAY_0003_WIDTH = 864,
CELL_SUBDISPLAY_0003_PITCH = 864,
CELL_SUBDISPLAY_0003_HEIGHT = 480,
CELL_SUBDISPLAY_NICKNAME_LEN = 256,
CELL_SUBDISPLAY_PSPID_LEN = 16,
};
// Touch
enum
{
CELL_SUBDISPLAY_TOUCH_STATUS_NONE = 0,
CELL_SUBDISPLAY_TOUCH_STATUS_PRESS = 1,
CELL_SUBDISPLAY_TOUCH_STATUS_RELEASE = 2,
CELL_SUBDISPLAY_TOUCH_STATUS_MOVE = 3,
CELL_SUBDISPLAY_TOUCH_STATUS_ABORT = 4,
CELL_SUBDISPLAY_TOUCH_MAX_TOUCH_INFO = 6,
};
struct CellSubDisplayVideoParam
{
be_t<s32> format;
be_t<s32> width;
be_t<s32> height;
be_t<s32> pitch;
be_t<s32> aspectRatio;
be_t<s32> videoMode;
};
struct CellSubDisplayAudioParam
{
be_t<s32> ch;
be_t<s32> audioMode;
};
struct CellSubDisplayParam
{
be_t<s32> version;
be_t<s32> mode;
be_t<s32> nGroup;
be_t<s32> nPeer;
CellSubDisplayVideoParam videoParam;
CellSubDisplayAudioParam audioParam;
};
struct CellSubDisplayPSPId
{
char data[CELL_SUBDISPLAY_PSPID_LEN];
};
struct CellSubDisplayNickname
{
char data[CELL_SUBDISPLAY_NICKNAME_LEN];
};
struct CellSubDisplayPeerInfo
{
be_t<u64> sessionId;
be_t<u32> portNo;
CellSubDisplayPSPId pspId;
CellSubDisplayNickname pspNickname;
};
struct CellSubDisplayTouchInfo
{
u8 status;
u8 force;
be_t<u16> x;
be_t<u16> y;
};
using CellSubDisplayHandler = void(s32 cbMsg, u64 cbParam, vm::ptr<void> userdata);
| 3,027
|
C++
|
.h
| 98
| 29.030612
| 96
| 0.708391
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,847
|
cellRtc.h
|
RPCS3_rpcs3/rpcs3/Emu/Cell/Modules/cellRtc.h
|
#pragma once
#include "Emu/Memory/vm_ptr.h"
#include "Emu/Cell/ErrorCodes.h"
// Return Codes
enum CellRtcError
{
CELL_RTC_ERROR_NOT_INITIALIZED = 0x80010601,
CELL_RTC_ERROR_INVALID_POINTER = 0x80010602,
CELL_RTC_ERROR_INVALID_VALUE = 0x80010603,
CELL_RTC_ERROR_INVALID_ARG = 0x80010604,
CELL_RTC_ERROR_NOT_SUPPORTED = 0x80010605,
CELL_RTC_ERROR_NO_CLOCK = 0x80010606,
CELL_RTC_ERROR_BAD_PARSE = 0x80010607,
CELL_RTC_ERROR_INVALID_YEAR = 0x80010621,
CELL_RTC_ERROR_INVALID_MONTH = 0x80010622,
CELL_RTC_ERROR_INVALID_DAY = 0x80010623,
CELL_RTC_ERROR_INVALID_HOUR = 0x80010624,
CELL_RTC_ERROR_INVALID_MINUTE = 0x80010625,
CELL_RTC_ERROR_INVALID_SECOND = 0x80010626,
CELL_RTC_ERROR_INVALID_MICROSECOND = 0x80010627,
};
struct CellRtcTick
{
be_t<u64> tick;
};
struct CellRtcDateTime
{
be_t<u16> year; // 1 to 9999
be_t<u16> month; // 1 to 12
be_t<u16> day; // 1 to 31
be_t<u16> hour; // 0 to 23
be_t<u16> minute; // 0 to 59
be_t<u16> second; // 0 to 59
be_t<u32> microsecond; // 0 to 999999
};
constexpr u64 RTC_MAGIC_OFFSET = 62135596800000000ull; // 1970-01-01 00:00:00.000000
constexpr u64 RTC_FILETIME_OFFSET = 50491123200000000ull; // 1601-01-01 00:00:00.000000
constexpr u64 RTC_SYSTEM_TIME_MIN = 63082281600000000ull; // 2000-01-01 00:00:00.000000
constexpr u64 RTC_SYSTEM_TIME_MAX = 66238041599999999ull; // 2099-12-31 23:59:59.999999
constexpr u32 DAYS_IN_400_YEARS = 365 * 400 + 97;
constexpr u16 DAYS_IN_100_YEARS = 365 * 100 + 24;
constexpr u16 DAYS_IN_4_YEARS = 365 * 4 + 1;
constexpr std::array<u8, 12> DAYS_IN_MONTH = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
constexpr std::array<u8, 12> DAYS_IN_MONTH_LEAP = { 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
constexpr std::array<u16, 13> MONTH_OFFSET = { 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, umax };
constexpr std::array<u16, 13> MONTH_OFFSET_LEAP = { 0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335, umax };
constexpr std::array<std::string_view, 7> WEEKDAY_NAMES = { "sunday", "monday", "tuesday", "wednesday", "thursday", "friday", "saturday" };
constexpr std::array<std::string_view, 12> MONTH_NAMES = { "january", "february", "march", "april", "may", "june", "july", "august", "september", "october", "november", "december" };
constexpr std::array<std::string_view, 70> TIME_ZONE_NAMES = { "gmt", "est", "edt", "cst", "cdt", "mst", "mdt", "pst", "pdt", "nzdt", "nzst", "idle", "nzt", "aesst", "acsst", "cadt", "sadt", "aest", "east", "gst", "ligt", "acst", "sast", "cast", "awsst", "jst", "kst", "wdt", "mt", "awst", "cct", "wadt", "wst", "jt", "wast", "it", "bt", "eetdst", "eet", "cetdst", "fwt", "ist", "mest", "metdst", "sst", "bst", "cet", "dnt", "fst", "met", "mewt", "mez", "nor", "set", "swt", "wetdst", "wet", "wat", "ndt", "adt", "nft", "nst", "ast", "ydt", "hdt", "yst", "ahst", "cat", "nt", "idlw" };
constexpr std::array<s8, 70> TIME_ZONE_VALUES = { 0, -10, -8, -12, -10, -14, -12, -16, -14, 26, 24, 24, 24, 22, 21, 21, 21, 20, 20, 20, 20, 19, 19, 19, 18, 18, 18, 18, 17, 16, 16, 16, 16, 15, 14, 7, 6, 6, 4, 4, 4, 4, 4, 4, 4, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, -2, -3, -6, -5, -5, -8, -16, -18, -18, -20, -20, -22, -24 }; // In units of 30 minutes
error_code cellRtcTickAddMinutes(ppu_thread& ppu, vm::ptr<CellRtcTick> pTick0, vm::cptr<CellRtcTick> pTick1, s64 lAdd);
error_code cellRtcSetTick(ppu_thread& ppu, vm::ptr<CellRtcDateTime> pTime, vm::cptr<CellRtcTick> pTick);
constexpr u32 cellRtcGetTickResolution();
error_code cellRtcCheckValid(vm::cptr<CellRtcDateTime> pTime);
s32 cellRtcGetDayOfWeek(s32 year, s32 month, s32 day);
error_code cellRtcGetTick(ppu_thread& ppu, vm::cptr<CellRtcDateTime> pTime, vm::ptr<CellRtcTick> pTick);
error_code cellRtcGetCurrentTick(ppu_thread& ppu, vm::ptr<CellRtcTick> pTick);
CellRtcDateTime tick_to_date_time(u64 tick);
u64 date_time_to_tick(CellRtcDateTime date_time);
| 4,276
|
C++
|
.h
| 59
| 70.898305
| 611
| 0.603329
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,848
|
cellSearch.h
|
RPCS3_rpcs3/rpcs3/Emu/Cell/Modules/cellSearch.h
|
#pragma once
#include "Emu/Memory/vm_ptr.h"
// Error Codes
enum CellSearchError : u32
{
CELL_SEARCH_CANCELED = 1,
CELL_SEARCH_ERROR_PARAM = 0x8002C801,
CELL_SEARCH_ERROR_BUSY = 0x8002C802,
CELL_SEARCH_ERROR_NO_MEMORY = 0x8002C803,
CELL_SEARCH_ERROR_UNKNOWN_MODE = 0x8002C804,
CELL_SEARCH_ERROR_ALREADY_INITIALIZED = 0x8002C805,
CELL_SEARCH_ERROR_NOT_INITIALIZED = 0x8002C806,
CELL_SEARCH_ERROR_FINALIZING = 0x8002C807,
CELL_SEARCH_ERROR_NOT_SUPPORTED_SEARCH = 0x8002C808,
CELL_SEARCH_ERROR_CONTENT_OBSOLETE = 0x8002C809,
CELL_SEARCH_ERROR_CONTENT_NOT_FOUND = 0x8002C80A,
CELL_SEARCH_ERROR_NOT_LIST = 0x8002C80B,
CELL_SEARCH_ERROR_OUT_OF_RANGE = 0x8002C80C,
CELL_SEARCH_ERROR_INVALID_SEARCHID = 0x8002C80D,
CELL_SEARCH_ERROR_ALREADY_GOT_RESULT = 0x8002C80E,
CELL_SEARCH_ERROR_NOT_SUPPORTED_CONTEXT = 0x8002C80F,
CELL_SEARCH_ERROR_INVALID_CONTENTTYPE = 0x8002C810,
CELL_SEARCH_ERROR_DRM = 0x8002C811,
CELL_SEARCH_ERROR_TAG = 0x8002C812,
CELL_SEARCH_ERROR_GENERIC = 0x8002C8FF,
};
// Constants
enum
{
CELL_SEARCH_CONTENT_ID_SIZE = 16,
CELL_SEARCH_TITLE_LEN_MAX = 384,
CELL_SEARCH_TAG_NUM_MAX = 6,
CELL_SEARCH_TAG_LEN_MAX = 63,
CELL_SEARCH_PATH_LEN_MAX = 63,
CELL_SEARCH_MTOPTION_LEN_MAX = 63,
CELL_SEARCH_DEVELOPERDATA_LEN_MAX = 64,
CELL_SEARCH_GAMECOMMENT_SIZE_MAX = 1024,
CELL_SEARCH_CONTENT_BUFFER_SIZE_MAX = 2048,
};
// Sort keys
enum CellSearchSortKey : s32
{
CELL_SEARCH_SORTKEY_NONE = 0,
CELL_SEARCH_SORTKEY_DEFAULT = 1,
CELL_SEARCH_SORTKEY_TITLE = 2,
CELL_SEARCH_SORTKEY_ALBUMTITLE = 3,
CELL_SEARCH_SORTKEY_GENRENAME = 4,
CELL_SEARCH_SORTKEY_ARTISTNAME = 5,
CELL_SEARCH_SORTKEY_IMPORTEDDATE = 6,
CELL_SEARCH_SORTKEY_TRACKNUMBER = 7,
CELL_SEARCH_SORTKEY_TAKENDATE = 8,
CELL_SEARCH_SORTKEY_USERDEFINED = 9,
CELL_SEARCH_SORTKEY_MODIFIEDDATE = 10,
};
// Sort order
enum CellSearchSortOrder : s32
{
CELL_SEARCH_SORTORDER_NONE = 0,
CELL_SEARCH_SORTORDER_ASCENDING = 1,
CELL_SEARCH_SORTORDER_DESCENDING = 2,
};
// Content types
enum CellSearchContentType : s32
{
CELL_SEARCH_CONTENTTYPE_NONE = 0,
CELL_SEARCH_CONTENTTYPE_MUSIC = 1,
CELL_SEARCH_CONTENTTYPE_MUSICLIST = 2,
CELL_SEARCH_CONTENTTYPE_PHOTO = 3,
CELL_SEARCH_CONTENTTYPE_PHOTOLIST = 4,
CELL_SEARCH_CONTENTTYPE_VIDEO = 5,
CELL_SEARCH_CONTENTTYPE_VIDEOLIST = 6,
CELL_SEARCH_CONTENTTYPE_SCENE = 7,
};
// Codecs
enum CellSearchCodec : s32
{
CELL_SEARCH_CODEC_UNKNOWN = 0,
CELL_SEARCH_CODEC_MPEG2 = 1,
CELL_SEARCH_CODEC_MPEG4 = 2,
CELL_SEARCH_CODEC_AVC = 3,
CELL_SEARCH_CODEC_MPEG1 = 4,
CELL_SEARCH_CODEC_AT3 = 5,
CELL_SEARCH_CODEC_AT3P = 6,
CELL_SEARCH_CODEC_ATALL = 7,
CELL_SEARCH_CODEC_MP3 = 8,
CELL_SEARCH_CODEC_AAC = 9,
CELL_SEARCH_CODEC_LPCM = 10,
CELL_SEARCH_CODEC_WAV = 11,
CELL_SEARCH_CODEC_WMA = 12,
CELL_SEARCH_CODEC_JPEG = 13,
CELL_SEARCH_CODEC_PNG = 14,
CELL_SEARCH_CODEC_TIFF = 15,
CELL_SEARCH_CODEC_BMP = 16,
CELL_SEARCH_CODEC_GIF = 17,
CELL_SEARCH_CODEC_MPEG2_TS = 18,
CELL_SEARCH_CODEC_DSD = 19,
CELL_SEARCH_CODEC_AC3 = 20,
CELL_SEARCH_CODEC_MPEG1_LAYER1 = 21,
CELL_SEARCH_CODEC_MPEG1_LAYER2 = 22,
CELL_SEARCH_CODEC_MPEG1_LAYER3 = 23,
CELL_SEARCH_CODEC_MPEG2_LAYER1 = 24,
CELL_SEARCH_CODEC_MPEG2_LAYER2 = 25,
CELL_SEARCH_CODEC_MPEG2_LAYER3 = 26,
CELL_SEARCH_CODEC_MOTIONJPEG = 27,
CELL_SEARCH_CODEC_MPO = 28,
};
// Scene types
enum CellSearchSceneType : s32
{
CELL_SEARCH_SCENETYPE_NONE = 0,
CELL_SEARCH_SCENETYPE_CHAPTER = 1,
CELL_SEARCH_SCENETYPE_CLIP_HIGHLIGHT = 2,
CELL_SEARCH_SCENETYPE_CLIP_USER = 3,
};
// List types
enum CellSearchListType : s32
{
CELL_SEARCH_LISTTYPE_NONE = 0,
CELL_SEARCH_LISTTYPE_MUSIC_ALBUM = 1,
CELL_SEARCH_LISTTYPE_MUSIC_GENRE = 2,
CELL_SEARCH_LISTTYPE_MUSIC_ARTIST = 3,
CELL_SEARCH_LISTTYPE_PHOTO_YEAR = 4,
CELL_SEARCH_LISTTYPE_PHOTO_MONTH = 5,
CELL_SEARCH_LISTTYPE_PHOTO_ALBUM = 6,
CELL_SEARCH_LISTTYPE_PHOTO_PLAYLIST = 7,
CELL_SEARCH_LISTTYPE_VIDEO_ALBUM = 8,
CELL_SEARCH_LISTTYPE_MUSIC_PLAYLIST = 9,
};
// Content status
enum CellSearchContentStatus : s32
{
CELL_SEARCH_CONTENTSTATUS_NONE,
CELL_SEARCH_CONTENTSTATUS_AVAILABLE,
CELL_SEARCH_CONTENTSTATUS_NOT_SUPPORTED,
CELL_SEARCH_CONTENTSTATUS_BROKEN,
};
// Search orientation
enum CellSearchOrientation : s32
{
CELL_SEARCH_ORIENTATION_UNKNOWN = 0,
CELL_SEARCH_ORIENTATION_TOP_LEFT,
CELL_SEARCH_ORIENTATION_TOP_RIGHT,
CELL_SEARCH_ORIENTATION_BOTTOM_RIGHT,
CELL_SEARCH_ORIENTATION_BOTTOM_LEFT,
};
// Search modes
enum CellSearchMode : s32
{
CELL_SEARCH_MODE_NORMAL = 0,
};
// Search events
enum CellSearchEvent : s32
{
CELL_SEARCH_EVENT_NOTIFICATION = 0,
CELL_SEARCH_EVENT_INITIALIZE_RESULT,
CELL_SEARCH_EVENT_FINALIZE_RESULT,
CELL_SEARCH_EVENT_LISTSEARCH_RESULT,
CELL_SEARCH_EVENT_CONTENTSEARCH_INLIST_RESULT,
CELL_SEARCH_EVENT_CONTENTSEARCH_RESULT,
CELL_SEARCH_EVENT_SCENESEARCH_INVIDEO_RESULT,
CELL_SEARCH_EVENT_SCENESEARCH_RESULT,
};
enum CellSearchListSearchType : s32
{
CELL_SEARCH_LISTSEARCHTYPE_NONE = 0,
CELL_SEARCH_LISTSEARCHTYPE_MUSIC_ALBUM,
CELL_SEARCH_LISTSEARCHTYPE_MUSIC_GENRE,
CELL_SEARCH_LISTSEARCHTYPE_MUSIC_ARTIST,
CELL_SEARCH_LISTSEARCHTYPE_PHOTO_YEAR,
CELL_SEARCH_LISTSEARCHTYPE_PHOTO_MONTH,
CELL_SEARCH_LISTSEARCHTYPE_PHOTO_ALBUM,
CELL_SEARCH_LISTSEARCHTYPE_PHOTO_PLAYLIST,
CELL_SEARCH_LISTSEARCHTYPE_VIDEO_ALBUM,
CELL_SEARCH_LISTSEARCHTYPE_MUSIC_PLAYLIST,
};
enum CellSearchContentSearchType : s32
{
CELL_SEARCH_CONTENTSEARCHTYPE_NONE = 0,
CELL_SEARCH_CONTENTSEARCHTYPE_MUSIC_ALL,
CELL_SEARCH_CONTENTSEARCHTYPE_PHOTO_ALL,
CELL_SEARCH_CONTENTSEARCHTYPE_VIDEO_ALL,
};
enum CellSearchSceneSearchType : s32
{
CELL_SEARCH_SCENESEARCHTYPE_NONE = 0,
CELL_SEARCH_SCENESEARCHTYPE_CHAPTER,
CELL_SEARCH_SCENESEARCHTYPE_CLIP_HIGHLIGHT,
CELL_SEARCH_SCENESEARCHTYPE_CLIP_USER,
CELL_SEARCH_SCENESEARCHTYPE_CLIP,
CELL_SEARCH_SCENESEARCHTYPE_ALL,
};
enum CellSearchRepeatMode : s32
{
CELL_SEARCH_REPEATMODE_NONE = 0,
CELL_SEARCH_REPEATMODE_REPEAT1,
CELL_SEARCH_REPEATMODE_ALL,
CELL_SEARCH_REPEATMODE_NOREPEAT1,
};
enum CellSearchContextOption : s32
{
CELL_SEARCH_CONTEXTOPTION_NONE = 0,
CELL_SEARCH_CONTEXTOPTION_SHUFFLE,
};
enum CellSearchSharableType : s32
{
CELL_SEARCH_SHARABLETYPE_PROHIBITED = 0,
CELL_SEARCH_SHARABLETYPE_PERMITTED,
};
using CellSearchId = s32;
using CellSearchSystemCallback = void(CellSearchEvent event, s32 result, vm::cptr<void> param, vm::ptr<void> userData);
struct CellSearchContentId
{
char data[CELL_SEARCH_CONTENT_ID_SIZE];
};
struct CellSearchResultParam
{
be_t<CellSearchId> searchId;
be_t<u32> resultNum;
};
struct CellSearchMusicListInfo
{
be_t<s32> listType; // CellSearchListType
be_t<u32> numOfItems;
be_t<s64> duration;
char title[CELL_SEARCH_TITLE_LEN_MAX + 1];
char reserved[3];
char artistName[CELL_SEARCH_TITLE_LEN_MAX + 1];
char reserved2[3];
};
struct CellSearchPhotoListInfo
{
be_t<s32> listType; // CellSearchListType
be_t<u32> numOfItems;
char title[CELL_SEARCH_TITLE_LEN_MAX + 1];
char reserved[3];
};
struct CellSearchVideoListInfo
{
be_t<s32> listType; // CellSearchListType
be_t<u32> numOfItems;
be_t<s64> duration;
char title[CELL_SEARCH_TITLE_LEN_MAX + 1];
char reserved[3];
};
struct CellSearchMusicInfo
{
be_t<s64> duration;
be_t<s64> size;
be_t<s64> importedDate;
be_t<s64> lastPlayedDate;
be_t<s32> releasedYear;
be_t<s32> trackNumber;
be_t<s32> bitrate;
be_t<s32> samplingRate;
be_t<s32> quantizationBitrate;
be_t<s32> playCount;
be_t<s32> drmEncrypted;
be_t<s32> codec; // CellSearchCodec
be_t<s32> status; // CellSearchContentStatus
char diskNumber[8];
char title[CELL_SEARCH_TITLE_LEN_MAX + 1];
char reserved[3];
char albumTitle[CELL_SEARCH_TITLE_LEN_MAX + 1];
char reserved2[3];
char artistName[CELL_SEARCH_TITLE_LEN_MAX + 1];
char reserved3[3];
char genreName[CELL_SEARCH_TITLE_LEN_MAX + 1];
char reserved4[3];
};
struct CellSearchPhotoInfo
{
be_t<s64> size;
be_t<s64> importedDate;
be_t<s64> takenDate;
be_t<s32> width;
be_t<s32> height;
be_t<s32> orientation; // CellSearchOrientation
be_t<s32> codec; // CellSearchCodec
be_t<s32> status; // CellSearchContentStatus
char title[CELL_SEARCH_TITLE_LEN_MAX + 1];
char reserved[3];
char albumTitle[CELL_SEARCH_TITLE_LEN_MAX + 1];
char reserved2[3];
};
struct CellSearchVideoInfo
{
be_t<s64> duration;
be_t<s64> size;
be_t<s64> importedDate;
be_t<s64> takenDate;
be_t<s32> videoBitrate;
be_t<s32> audioBitrate;
be_t<s32> playCount;
be_t<s32> drmEncrypted;
be_t<s32> videoCodec; // CellSearchCodec
be_t<s32> audioCodec; // CellSearchCodec
be_t<s32> status; // CellSearchContentStatus
char title[CELL_SEARCH_TITLE_LEN_MAX + 1];
char reserved[3];
char albumTitle[CELL_SEARCH_TITLE_LEN_MAX + 1];
char reserved2[3];
};
struct CellSearchVideoSceneInfo
{
be_t<s32> sceneType; // CellSearchSceneType
be_t<s64> startTime_ms;
be_t<s64> endTime_ms;
CellSearchContentId videoId;
char title[CELL_SEARCH_TITLE_LEN_MAX + 1];
char reserved[3];
char tags[CELL_SEARCH_TAG_NUM_MAX][CELL_SEARCH_TAG_LEN_MAX];
};
struct CellSearchContentInfoPath
{
char contentPath[CELL_SEARCH_PATH_LEN_MAX + 1];
char thumbnailPath[CELL_SEARCH_PATH_LEN_MAX + 1];
};
struct CellSearchContentInfoPathMovieThumb
{
char movieThumbnailPath[CELL_SEARCH_PATH_LEN_MAX + 1];
char movieThumbnailOption[CELL_SEARCH_MTOPTION_LEN_MAX + 1];
};
struct CellSearchTimeInfo
{
be_t<s64> takenDate;
be_t<s64> importedDate;
be_t<s64> modifiedDate;
};
| 9,856
|
C++
|
.h
| 328
| 28.27439
| 119
| 0.734836
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,849
|
sceNpUtil.h
|
RPCS3_rpcs3/rpcs3/Emu/Cell/Modules/sceNpUtil.h
|
#pragma once
enum
{
SCE_NP_UTIL_BANDWIDTH_TEST_STATUS_NONE = 0,
SCE_NP_UTIL_BANDWIDTH_TEST_STATUS_RUNNING = 1,
SCE_NP_UTIL_BANDWIDTH_TEST_STATUS_FINISHED = 2
};
struct SceNpUtilBandwidthTestResult
{
be_t<f64> upload_bps;
be_t<f64> download_bps;
be_t<s32> result;
s8 padding[4];
};
| 290
|
C++
|
.h
| 14
| 19.071429
| 47
| 0.759124
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,850
|
cellSpudll.h
|
RPCS3_rpcs3/rpcs3/Emu/Cell/Modules/cellSpudll.h
|
#pragma once
#include "Emu/Memory/vm_ptr.h"
enum CellSpudllError : u32
{
CELL_SPUDLL_ERROR_INVAL = 0x80410602,
CELL_SPUDLL_ERROR_STAT = 0x8041060f,
CELL_SPUDLL_ERROR_ALIGN = 0x80410610,
CELL_SPUDLL_ERROR_NULL_POINTER = 0x80410611,
CELL_SPUDLL_ERROR_SRCH = 0x80410605,
CELL_SPUDLL_ERROR_UNDEF = 0x80410612,
CELL_SPUDLL_ERROR_FATAL = 0x80410613,
};
struct CellSpudllHandleConfig
{
be_t<u32> mode;
be_t<u32> dmaTag;
be_t<u32> numMaxReferred;
be_t<u32> numMaxDepend;
vm::bptr<void> unresolvedSymbolValueForFunc;
vm::bptr<void> unresolvedSymbolValueForObject;
vm::bptr<void> unresolvedSymbolValueForOther;
be_t<u32> __reserved__[9];
};
| 693
|
C++
|
.h
| 23
| 28.347826
| 47
| 0.731634
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,851
|
libmixer.h
|
RPCS3_rpcs3/rpcs3/Emu/Cell/Modules/libmixer.h
|
#pragma once
#include "Emu/Memory/vm_ptr.h"
// Error Codes
enum CellLibmixerError : u32
{
CELL_LIBMIXER_ERROR_NOT_INITIALIZED = 0x80310002,
CELL_LIBMIXER_ERROR_INVALID_PARAMATER = 0x80310003,
CELL_LIBMIXER_ERROR_NO_MEMORY = 0x80310005,
CELL_LIBMIXER_ERROR_ALREADY_EXIST = 0x80310006,
CELL_LIBMIXER_ERROR_FULL = 0x80310007,
CELL_LIBMIXER_ERROR_NOT_EXIST = 0x80310008,
CELL_LIBMIXER_ERROR_TYPE_MISMATCH = 0x80310009,
CELL_LIBMIXER_ERROR_NOT_FOUND = 0x8031000a,
};
enum
{
CELL_SURBUS_LEFT = 0,
CELL_SURBUS_RIGHT = 1,
CELL_SURBUS_CENTER = 2,
CELL_SURBUS_LFE = 3,
CELL_SURBUS_LEFT_SUR = 4,
CELL_SURBUS_RIGHT_SUR = 5,
CELL_SURBUS_LEFT_EXT = 6,
CELL_SURBUS_RIGHT_EXT = 7,
CELL_SURBUS_REVERB_LEFT = 8,
CELL_SURBUS_REVERB_RIGHT = 9,
CELL_SURBUS_REVERB_LEFT_SUR = 10,
CELL_SURBUS_REVERB_RIGHT_SUR = 11,
};
enum
{
CELL_SURMIXER_PARAM_TOTALLEVEL_LINEAR = 8,
CELL_SURMIXER_PARAM_REVERBLEVEL_LINEAR = 9,
CELL_SURMIXER_PARAM_TOTALMUTE = 12,
CELL_SURMIXER_PARAM_TOTALLEVEL = 40, // in dB
CELL_SURMIXER_PARAM_REVERBLEVEL = 41, // in dB
};
static const float CELL_SURMIXER_CONT_MUTEON = 1.0;
static const float CELL_SURMIXER_CONT_MUTEOFF = 0.0;
enum
{
CELL_SURMIXER_CONT_DBSWITCHON = 1,
CELL_SURMIXER_CONT_DBSWITCHOFF = 0,
CELL_SURMIXER_CONT_PAUSE_OFF = 0,
CELL_SURMIXER_CONT_PAUSE_ON = 1,
CELL_SURMIXER_CONT_PAUSE_ON_IMMEDIATE = 2,
};
enum
{
CELL_SURMIXER_CHSTRIP_TYPE1A = 1,
CELL_SURMIXER_CHSTRIP_TYPE2A = 2,
CELL_SURMIXER_CHSTRIP_TYPE6A = 3,
CELL_SURMIXER_CHSTRIP_TYPE8A = 4,
CELL_SURMIXER_CH1PARAM_LEVEL = 0,
CELL_SURMIXER_CH1PARAM_EXPRESSIONLEVEL = 1,
CELL_SURMIXER_CH1PARAM_CENTERLEVEL = 2,
CELL_SURMIXER_CH1PARAM_REVERBSENDLEVEL = 3,
CELL_SURMIXER_CH1PARAM_MUTE = 4,
CELL_SURMIXER_CH1PARAM_REVSENDPOSITION = 5,
CELL_SURMIXER_CH1PARAM_POSITION = 6,
CELL_SURMIXER_CH2PARAM_LEVEL = 0,
CELL_SURMIXER_CH2PARAM_EXPRESSIONLEVEL = 1,
CELL_SURMIXER_CH2PARAM_CENTERLEVEL = 2,
CELL_SURMIXER_CH2PARAM_REVERBSENDLEVEL = 3,
CELL_SURMIXER_CH2PARAM_MUTE = 4,
CELL_SURMIXER_CH2PARAM_REVSENDPOSITION = 5,
CELL_SURMIXER_CH2PARAM_POSITION = 6,
CELL_SURMIXER_CH6PARAM_LEVEL = 0,
CELL_SURMIXER_CH6PARAM_EXPRESSIONLEVEL = 1,
CELL_SURMIXER_CH6PARAM_REVERBSENDLEVEL = 2,
CELL_SURMIXER_CH6PARAM_CENTER_REVERBSENDLEVEL = 3,
CELL_SURMIXER_CH6PARAM_MUTE = 4,
CELL_SURMIXER_CH8PARAM_LEVEL = 0,
CELL_SURMIXER_CH8PARAM_EXPRESSIONLEVEL = 1,
CELL_SURMIXER_CH8PARAM_REVERBSENDLEVEL = 2,
CELL_SURMIXER_CH8PARAM_CENTER_REVERBSENDLEVEL = 3,
CELL_SURMIXER_CH8PARAM_MUTE = 4,
CELL_SURMIXER_CH1CONT_MUTE_OFF = 0,
CELL_SURMIXER_CH1CONT_MUTE_ON = 1,
CELL_SURMIXER_CH2CONT_MUTE_OFF = 0,
CELL_SURMIXER_CH2CONT_MUTE_ON = 1,
CELL_SURMIXER_CH6CONT_MUTE_OFF = 0,
CELL_SURMIXER_CH6CONT_MUTE_ON = 1,
CELL_SURMIXER_CH8CONT_MUTE_OFF = 0,
CELL_SURMIXER_CH8CONT_MUTE_ON = 1,
};
enum
{
CELL_SSPLAYER_ONESHOT = 0,
CELL_SSPLAYER_ONESHOT_CONT = 2,
CELL_SSPLAYER_LOOP_ON = 16,
CELL_SSPLAYER_STATE_ERROR = 0xffffffff,
CELL_SSPLAYER_STATE_NOTREADY = 0x88888888,
CELL_SSPLAYER_STATE_OFF = 0x00,
CELL_SSPLAYER_STATE_PAUSE = 0x01,
CELL_SSPLAYER_STATE_CLOSING = 0x08,
CELL_SSPLAYER_STATE_ON = 0x20,
};
using CellSurMixerNotifyCallbackFunction = s32(vm::ptr<void> arg, u32 counter, u32 samples);
struct CellSSPlayerConfig
{
be_t<u32> channels;
be_t<u32> outputMode;
};
struct CellSSPlayerWaveParam
{
be_t<u32> addr;
be_t<s32> format;
be_t<u32> samples;
be_t<u32> loopStartOffset;
be_t<u32> startOffset;
};
struct CellSSPlayerCommonParam
{
be_t<u32> loopMode;
be_t<u32> attackMode;
};
struct CellSurMixerPosition
{
be_t<float> x;
be_t<float> y;
be_t<float> z;
};
struct CellSSPlayerRuntimeInfo
{
be_t<float> level;
be_t<float> speed;
CellSurMixerPosition position;
};
struct CellSurMixerConfig
{
be_t<s32> priority;
be_t<u32> chStrips1;
be_t<u32> chStrips2;
be_t<u32> chStrips6;
be_t<u32> chStrips8;
};
struct CellSurMixerChStripParam
{
be_t<u32> param;
be_t<u32> attribute_addr;
be_t<s32> dBSwitch;
be_t<float> floatVal;
be_t<s32> intVal;
};
| 4,034
|
C++
|
.h
| 145
| 25.972414
| 92
| 0.7597
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,852
|
cellVoice.h
|
RPCS3_rpcs3/rpcs3/Emu/Cell/Modules/cellVoice.h
|
#pragma once
#include <unordered_map>
#include <deque>
// libvoice = 0x80310801 - 0x803108ff
// libvoice version 100
// Error Codes
enum CellVoiceError : u32
{
CELL_VOICE_ERROR_ADDRESS_INVALID = 0x8031080a,
CELL_VOICE_ERROR_ARGUMENT_INVALID = 0x80310805,
CELL_VOICE_ERROR_CONTAINER_INVALID = 0x80310806,
CELL_VOICE_ERROR_DEVICE_NOT_PRESENT = 0x80310812,
CELL_VOICE_ERROR_EVENT_DISPATCH = 0x80310811,
CELL_VOICE_ERROR_EVENT_QUEUE = 0x8031080f,
CELL_VOICE_ERROR_GENERAL = 0x80310803,
CELL_VOICE_ERROR_LIBVOICE_INITIALIZED = 0x80310802,
CELL_VOICE_ERROR_LIBVOICE_NOT_INIT = 0x80310801,
CELL_VOICE_ERROR_NOT_IMPLEMENTED = 0x80310809,
CELL_VOICE_ERROR_PORT_INVALID = 0x80310804,
CELL_VOICE_ERROR_RESOURCE_INSUFFICIENT = 0x80310808,
CELL_VOICE_ERROR_SERVICE_ATTACHED = 0x8031080c,
CELL_VOICE_ERROR_SERVICE_DETACHED = 0x8031080b,
CELL_VOICE_ERROR_SERVICE_HANDLE = 0x80310810,
CELL_VOICE_ERROR_SERVICE_NOT_FOUND = 0x8031080d,
CELL_VOICE_ERROR_SHAREDMEMORY = 0x8031080e,
CELL_VOICE_ERROR_TOPOLOGY = 0x80310807,
};
enum CellVoiceAppType : u32
{
CELLVOICE_APPTYPE_GAME_1MB = 1 << 29
};
enum CellVoiceBitRate : u32
{
CELLVOICE_BITRATE_NULL = ~0u,
CELLVOICE_BITRATE_3850 = 3850,
CELLVOICE_BITRATE_4650 = 4650,
CELLVOICE_BITRATE_5700 = 5700,
CELLVOICE_BITRATE_7300 = 7300,
CELLVOICE_BITRATE_14400 = 14400,
CELLVOICE_BITRATE_16000 = 16000,
CELLVOICE_BITRATE_22533 = 22533,
};
enum CellVoiceEventType : u32
{
CELLVOICE_EVENT_DATA_ERROR = 1 << 0,
CELLVOICE_EVENT_PORT_ATTACHED = 1 << 1,
CELLVOICE_EVENT_PORT_DETACHED = 1 << 2,
CELLVOICE_EVENT_SERVICE_ATTACHED = 1 << 3,
CELLVOICE_EVENT_SERVICE_DETACHED = 1 << 4,
CELLVOICE_EVENT_PORT_WEAK_ATTACHED = 1 << 5,
CELLVOICE_EVENT_PORT_WEAK_DETACHED = 1 << 6,
};
enum CellVoicePcmDataType : u32
{
CELLVOICE_PCM_NULL = ~0u,
CELLVOICE_PCM_FLOAT = 0,
CELLVOICE_PCM_FLOAT_LITTLE_ENDIAN = 1,
CELLVOICE_PCM_SHORT = 2,
CELLVOICE_PCM_SHORT_LITTLE_ENDIAN = 3,
CELLVOICE_PCM_INTEGER = 4,
CELLVOICE_PCM_INTEGER_LITTLE_ENDIAN = 5,
};
enum CellVoicePortAttr : u32
{
CELLVOICE_ATTR_ENERGY_LEVEL = 1000,
CELLVOICE_ATTR_VAD = 1001,
CELLVOICE_ATTR_DTX = 1002,
CELLVOICE_ATTR_AUTO_RESAMPLE = 1003,
CELLVOICE_ATTR_LATENCY = 1004,
CELLVOICE_ATTR_SILENCE_THRESHOLD = 1005,
};
enum CellVoicePortState : u32
{
CELLVOICE_PORTSTATE_NULL = ~0u,
CELLVOICE_PORTSTATE_IDLE = 0,
CELLVOICE_PORTSTATE_READY = 1,
CELLVOICE_PORTSTATE_BUFFERING = 2,
CELLVOICE_PORTSTATE_RUNNING = 3,
};
enum CellVoicePortType : u32
{
CELLVOICE_PORTTYPE_NULL = ~0u,
CELLVOICE_PORTTYPE_IN_MIC = 0,
CELLVOICE_PORTTYPE_IN_PCMAUDIO = 1,
CELLVOICE_PORTTYPE_IN_VOICE = 2,
CELLVOICE_PORTTYPE_OUT_PCMAUDIO = 3,
CELLVOICE_PORTTYPE_OUT_VOICE = 4,
CELLVOICE_PORTTYPE_OUT_SECONDARY = 5,
};
enum CellVoiceSamplingRate : u32
{
CELLVOICE_SAMPLINGRATE_NULL = ~0u,
CELLVOICE_SAMPLINGRATE_16000 = 16000,
};
enum CellVoiceVersionCheck : u32
{
CELLVOICE_VERSION_100 = 100
};
// Definitions
enum
{
CELLVOICE_MAX_IN_VOICE_PORT = 32,
CELLVOICE_MAX_OUT_VOICE_PORT = 4,
CELLVOICE_GAME_1MB_MAX_IN_VOICE_PORT = 8,
CELLVOICE_GAME_1MB_MAX_OUT_VOICE_PORT = 2,
CELLVOICE_MAX_PORT = 128,
CELLVOICE_INVALID_PORT_ID = 0xff,
};
struct CellVoiceBasePortInfo // aligned(64)
{
be_t<CellVoicePortType> portType;
be_t<CellVoicePortState> state;
be_t<u16> numEdge;
vm::bptr<u32> pEdge;
be_t<u32> numByte;
be_t<u32> frameSize;
};
struct CellVoiceInitParam // aligned(32)
{
be_t<CellVoiceEventType> eventMask;
be_t<CellVoiceVersionCheck> version;
be_t<s32> appType;
u8 reserved[32 - sizeof(s32) * 3];
};
struct CellVoicePCMFormat
{
u8 numChannels;
u8 sampleAlignment;
be_t<CellVoicePcmDataType> dataType;
be_t<CellVoiceSamplingRate> sampleRate;
};
struct CellVoicePortParam // aligned(64)
{
be_t<CellVoicePortType> portType;
be_t<u16> threshold;
be_t<u16> bMute;
be_t<f32> volume;
union
{
struct
{
be_t<CellVoiceBitRate> bitrate;
} voice;
struct
{
be_t<u32> bufSize;
CellVoicePCMFormat format;
} pcmaudio;
struct
{
be_t<u32> playerId;
} device;
};
};
struct CellVoiceStartParam // aligned(32)
{
be_t<u32> container;
u8 reserved[32 - sizeof(s32) * 1];
};
struct voice_manager
{
struct port_t
{
s32 state = CELLVOICE_PORTSTATE_NULL;
CellVoicePortParam info;
ENABLE_BITWISE_SERIALIZATION;
};
// See cellVoiceCreatePort
u8 id_ctr = 0;
// For cellVoiceSetNotifyEventQueue
u32 port_source = 0;
std::unordered_map<u16, port_t> ports;
std::unordered_map<u64, std::deque<u64>> queue_keys;
bool voice_service_started = false;
port_t* access_port(u32 id)
{
// Upper 16 bits are ignored
auto pos = ports.find(static_cast<u16>(id));
if (pos == ports.end())
{
return nullptr;
}
return &pos->second;
}
void reset();
shared_mutex mtx;
atomic_t<bool> is_init{ false };
SAVESTATE_INIT_POS(17);
voice_manager() = default;
voice_manager(utils::serial& ar) { save(ar); }
void save(utils::serial& ar);
};
| 5,253
|
C++
|
.h
| 192
| 25.364583
| 53
| 0.703696
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,853
|
sceNp2.h
|
RPCS3_rpcs3/rpcs3/Emu/Cell/Modules/sceNp2.h
|
#pragma once
#include "sceNp.h"
#include "Emu/Memory/vm_ptr.h"
// Error codes
enum SceNpMatching2Error : u32
{
// NP Matching 2 Utility
SCE_NP_MATCHING2_ERROR_OUT_OF_MEMORY = 0x80022301,
SCE_NP_MATCHING2_ERROR_ALREADY_INITIALIZED = 0x80022302,
SCE_NP_MATCHING2_ERROR_NOT_INITIALIZED = 0x80022303,
SCE_NP_MATCHING2_ERROR_CONTEXT_MAX = 0x80022304,
SCE_NP_MATCHING2_ERROR_CONTEXT_ALREADY_EXISTS = 0x80022305,
SCE_NP_MATCHING2_ERROR_CONTEXT_NOT_FOUND = 0x80022306,
SCE_NP_MATCHING2_ERROR_CONTEXT_ALREADY_STARTED = 0x80022307,
SCE_NP_MATCHING2_ERROR_CONTEXT_NOT_STARTED = 0x80022308,
SCE_NP_MATCHING2_ERROR_SERVER_NOT_FOUND = 0x80022309,
SCE_NP_MATCHING2_ERROR_INVALID_ARGUMENT = 0x8002230a,
SCE_NP_MATCHING2_ERROR_INVALID_CONTEXT_ID = 0x8002230b,
SCE_NP_MATCHING2_ERROR_INVALID_SERVER_ID = 0x8002230c,
SCE_NP_MATCHING2_ERROR_INVALID_WORLD_ID = 0x8002230d,
SCE_NP_MATCHING2_ERROR_INVALID_LOBBY_ID = 0x8002230e,
SCE_NP_MATCHING2_ERROR_INVALID_ROOM_ID = 0x8002230f,
SCE_NP_MATCHING2_ERROR_INVALID_MEMBER_ID = 0x80022310,
SCE_NP_MATCHING2_ERROR_INVALID_ATTRIBUTE_ID = 0x80022311,
SCE_NP_MATCHING2_ERROR_INVALID_CASTTYPE = 0x80022312,
SCE_NP_MATCHING2_ERROR_INVALID_SORT_METHOD = 0x80022313,
SCE_NP_MATCHING2_ERROR_INVALID_MAX_SLOT = 0x80022314,
SCE_NP_MATCHING2_ERROR_INVALID_MATCHING_SPACE = 0x80022316,
SCE_NP_MATCHING2_ERROR_INVALID_BLOCK_KICK_FLAG = 0x80022318,
SCE_NP_MATCHING2_ERROR_INVALID_MESSAGE_TARGET = 0x80022319,
SCE_NP_MATCHING2_ERROR_RANGE_FILTER_MAX = 0x8002231a,
SCE_NP_MATCHING2_ERROR_INSUFFICIENT_BUFFER = 0x8002231b,
SCE_NP_MATCHING2_ERROR_DESTINATION_DISAPPEARED = 0x8002231c,
SCE_NP_MATCHING2_ERROR_REQUEST_TIMEOUT = 0x8002231d,
SCE_NP_MATCHING2_ERROR_INVALID_ALIGNMENT = 0x8002231e,
SCE_NP_MATCHING2_ERROR_REQUEST_CB_QUEUE_OVERFLOW = 0x8002231f,
SCE_NP_MATCHING2_ERROR_EVENT_CB_QUEUE_OVERFLOW = 0x80022320,
SCE_NP_MATCHING2_ERROR_MSG_CB_QUEUE_OVERFLOW = 0x80022321,
SCE_NP_MATCHING2_ERROR_CONNECTION_CLOSED_BY_SERVER = 0x80022322,
SCE_NP_MATCHING2_ERROR_SSL_VERIFY_FAILED = 0x80022323,
SCE_NP_MATCHING2_ERROR_SSL_HANDSHAKE = 0x80022324,
SCE_NP_MATCHING2_ERROR_SSL_SEND = 0x80022325,
SCE_NP_MATCHING2_ERROR_SSL_RECV = 0x80022326,
SCE_NP_MATCHING2_ERROR_JOINED_SESSION_MAX = 0x80022327,
SCE_NP_MATCHING2_ERROR_ALREADY_JOINED = 0x80022328,
SCE_NP_MATCHING2_ERROR_INVALID_SESSION_TYPE = 0x80022329,
SCE_NP_MATCHING2_ERROR_CLAN_LOBBY_NOT_EXIST = 0x8002232a,
SCE_NP_MATCHING2_ERROR_NP_SIGNED_OUT = 0x8002232b,
SCE_NP_MATCHING2_ERROR_CONTEXT_UNAVAILABLE = 0x8002232c,
SCE_NP_MATCHING2_ERROR_SERVER_NOT_AVAILABLE = 0x8002232d,
SCE_NP_MATCHING2_ERROR_NOT_ALLOWED = 0x8002232e,
SCE_NP_MATCHING2_ERROR_ABORTED = 0x8002232f,
SCE_NP_MATCHING2_ERROR_REQUEST_NOT_FOUND = 0x80022330,
SCE_NP_MATCHING2_ERROR_SESSION_DESTROYED = 0x80022331,
SCE_NP_MATCHING2_ERROR_CONTEXT_STOPPED = 0x80022332,
SCE_NP_MATCHING2_ERROR_INVALID_REQUEST_PARAMETER = 0x80022333,
SCE_NP_MATCHING2_ERROR_NOT_NP_SIGN_IN = 0x80022334,
SCE_NP_MATCHING2_ERROR_ROOM_NOT_FOUND = 0x80022335,
SCE_NP_MATCHING2_ERROR_ROOM_MEMBER_NOT_FOUND = 0x80022336,
SCE_NP_MATCHING2_ERROR_LOBBY_NOT_FOUND = 0x80022337,
SCE_NP_MATCHING2_ERROR_LOBBY_MEMBER_NOT_FOUND = 0x80022338,
SCE_NP_MATCHING2_ERROR_EVENT_DATA_NOT_FOUND = 0x80022339,
SCE_NP_MATCHING2_ERROR_KEEPALIVE_TIMEOUT = 0x8002233a,
SCE_NP_MATCHING2_ERROR_TIMEOUT_TOO_SHORT = 0x8002233b,
SCE_NP_MATCHING2_ERROR_TIMEDOUT = 0x8002233c,
SCE_NP_MATCHING2_ERROR_CREATE_HEAP = 0x8002233d,
SCE_NP_MATCHING2_ERROR_INVALID_ATTRIBUTE_SIZE = 0x8002233e,
SCE_NP_MATCHING2_ERROR_CANNOT_ABORT = 0x8002233f,
SCE_NP_MATCHING2_RESOLVER_ERROR_NO_DNS_SERVER = 0x800223a2,
SCE_NP_MATCHING2_RESOLVER_ERROR_INVALID_PACKET = 0x800223ad,
SCE_NP_MATCHING2_RESOLVER_ERROR_TIMEOUT = 0x800223b0,
SCE_NP_MATCHING2_RESOLVER_ERROR_NO_RECORD = 0x800223b1,
SCE_NP_MATCHING2_RESOLVER_ERROR_RES_PACKET_FORMAT = 0x800223b2,
SCE_NP_MATCHING2_RESOLVER_ERROR_RES_SERVER_FAILURE = 0x800223b3,
SCE_NP_MATCHING2_RESOLVER_ERROR_NO_HOST = 0x800223b4,
SCE_NP_MATCHING2_RESOLVER_ERROR_RES_NOT_IMPLEMENTED = 0x800223b5,
SCE_NP_MATCHING2_RESOLVER_ERROR_RES_SERVER_REFUSED = 0x800223b6,
SCE_NP_MATCHING2_RESOLVER_ERROR_RESP_TRUNCATED = 0x800223bc,
SCE_NP_MATCHING2_SERVER_ERROR_BAD_REQUEST = 0x80022b01,
SCE_NP_MATCHING2_SERVER_ERROR_SERVICE_UNAVAILABLE = 0x80022b02,
SCE_NP_MATCHING2_SERVER_ERROR_BUSY = 0x80022b03,
SCE_NP_MATCHING2_SERVER_ERROR_END_OF_SERVICE = 0x80022b04,
SCE_NP_MATCHING2_SERVER_ERROR_INTERNAL_SERVER_ERROR = 0x80022b05,
SCE_NP_MATCHING2_SERVER_ERROR_PLAYER_BANNED = 0x80022b06,
SCE_NP_MATCHING2_SERVER_ERROR_FORBIDDEN = 0x80022b07,
SCE_NP_MATCHING2_SERVER_ERROR_BLOCKED = 0x80022b08,
SCE_NP_MATCHING2_SERVER_ERROR_UNSUPPORTED_NP_ENV = 0x80022b09,
SCE_NP_MATCHING2_SERVER_ERROR_INVALID_TICKET = 0x80022b0a,
SCE_NP_MATCHING2_SERVER_ERROR_INVALID_SIGNATURE = 0x80022b0b,
SCE_NP_MATCHING2_SERVER_ERROR_EXPIRED_TICKET = 0x80022b0c,
SCE_NP_MATCHING2_SERVER_ERROR_ENTITLEMENT_REQUIRED = 0x80022b0d,
SCE_NP_MATCHING2_SERVER_ERROR_NO_SUCH_CONTEXT = 0x80022b0e,
SCE_NP_MATCHING2_SERVER_ERROR_CLOSED = 0x80022b0f,
SCE_NP_MATCHING2_SERVER_ERROR_NO_SUCH_TITLE = 0x80022b10,
SCE_NP_MATCHING2_SERVER_ERROR_NO_SUCH_WORLD = 0x80022b11,
SCE_NP_MATCHING2_SERVER_ERROR_NO_SUCH_LOBBY = 0x80022b12,
SCE_NP_MATCHING2_SERVER_ERROR_NO_SUCH_ROOM = 0x80022b13,
SCE_NP_MATCHING2_SERVER_ERROR_NO_SUCH_LOBBY_INSTANCE = 0x80022b14,
SCE_NP_MATCHING2_SERVER_ERROR_NO_SUCH_ROOM_INSTANCE = 0x80022b15,
SCE_NP_MATCHING2_SERVER_ERROR_PASSWORD_MISMATCH = 0x80022b17,
SCE_NP_MATCHING2_SERVER_ERROR_LOBBY_FULL = 0x80022b18,
SCE_NP_MATCHING2_SERVER_ERROR_ROOM_FULL = 0x80022b19,
SCE_NP_MATCHING2_SERVER_ERROR_GROUP_FULL = 0x80022b1b,
SCE_NP_MATCHING2_SERVER_ERROR_NO_SUCH_USER = 0x80022b1c,
SCE_NP_MATCHING2_SERVER_ERROR_TITLE_PASSPHRASE_MISMATCH = 0x80022b1e,
SCE_NP_MATCHING2_SERVER_ERROR_DUPLICATE_LOBBY = 0x80022b25,
SCE_NP_MATCHING2_SERVER_ERROR_DUPLICATE_ROOM = 0x80022b26,
SCE_NP_MATCHING2_SERVER_ERROR_NO_JOIN_GROUP_LABEL = 0x80022b29,
SCE_NP_MATCHING2_SERVER_ERROR_NO_SUCH_GROUP = 0x80022b2a,
SCE_NP_MATCHING2_SERVER_ERROR_NO_PASSWORD = 0x80022b2b,
SCE_NP_MATCHING2_SERVER_ERROR_MAX_OVER_SLOT_GROUP = 0x80022b2c,
SCE_NP_MATCHING2_SERVER_ERROR_MAX_OVER_PASSWORD_MASK = 0x80022b2d,
SCE_NP_MATCHING2_SERVER_ERROR_DUPLICATE_GROUP_LABEL = 0x80022b2e,
SCE_NP_MATCHING2_SERVER_ERROR_REQUEST_OVERFLOW = 0x80022b2f,
SCE_NP_MATCHING2_SERVER_ERROR_ALREADY_JOINED = 0x80022b30,
SCE_NP_MATCHING2_SERVER_ERROR_NAT_TYPE_MISMATCH = 0x80022b31,
SCE_NP_MATCHING2_SERVER_ERROR_ROOM_INCONSISTENCY = 0x80022b32,
// SCE_NP_MATCHING2_NET_ERRNO_BASE = 0x800224XX,
// SCE_NP_MATCHING2_NET_H_ERRNO_BASE = 0x800225XX,
};
// Constants for matching functions and structures
enum
{
SCE_NP_MATCHING2_ALLOWED_USER_MAX = 100,
SCE_NP_MATCHING2_BLOCKED_USER_MAX = 100,
SCE_NP_MATCHING2_CHAT_MSG_MAX_SIZE = 1024,
SCE_NP_MATCHING2_BIN_MSG_MAX_SIZE = 1024,
SCE_NP_MATCHING2_GROUP_LABEL_SIZE = 8,
SCE_NP_MATCHING2_INVITATION_OPTION_DATA_MAX_SIZE = 32,
SCE_NP_MATCHING2_INVITATION_TARGET_SESSION_MAX = 2,
SCE_NP_MATCHING2_LOBBY_MEMBER_DATA_INTERNAL_LIST_MAX = 256,
SCE_NP_MATCHING2_LOBBY_MEMBER_DATA_INTERNAL_EXTENDED_DATA_LIST_MAX = 64,
SCE_NP_MATCHING2_LOBBY_BIN_ATTR_INTERNAL_NUM = 2,
SCE_NP_MATCHING2_LOBBYMEMBER_BIN_ATTR_INTERNAL_NUM = 1,
SCE_NP_MATCHING2_LOBBYMEMBER_BIN_ATTR_INTERNAL_MAX_SIZE = 64,
SCE_NP_MATCHING2_LOBBY_MAX_SLOT = 256,
SCE_NP_MATCHING2_PRESENCE_OPTION_DATA_SIZE = 16,
SCE_NP_MATCHING2_RANGE_FILTER_START_INDEX_MIN = 1,
SCE_NP_MATCHING2_RANGE_FILTER_MAX = 20,
SCE_NP_MATCHING2_ROOM_MAX_SLOT = 64,
SCE_NP_MATCHING2_ROOM_GROUP_ID_MAX = 15,
SCE_NP_MATCHING2_ROOM_BIN_ATTR_EXTERNAL_NUM = 2,
SCE_NP_MATCHING2_ROOM_BIN_ATTR_EXTERNAL_MAX_SIZE = 256,
SCE_NP_MATCHING2_ROOM_BIN_ATTR_INTERNAL_NUM = 2,
SCE_NP_MATCHING2_ROOM_BIN_ATTR_INTERNAL_MAX_SIZE = 256,
SCE_NP_MATCHING2_ROOM_SEARCHABLE_INT_ATTR_EXTERNAL_NUM = 8,
SCE_NP_MATCHING2_ROOM_SEARCHABLE_BIN_ATTR_EXTERNAL_NUM = 1,
SCE_NP_MATCHING2_ROOM_SEARCHABLE_BIN_ATTR_EXTERNAL_MAX_SIZE = 64,
SCE_NP_MATCHING2_ROOMMEMBER_BIN_ATTR_INTERNAL_NUM = 1,
SCE_NP_MATCHING2_ROOMMEMBER_BIN_ATTR_INTERNAL_MAX_SIZE = 64,
SCE_NP_MATCHING2_SESSION_PASSWORD_SIZE = 8,
SCE_NP_MATCHING2_USER_BIN_ATTR_NUM = 1,
SCE_NP_MATCHING2_USER_BIN_ATTR_MAX_SIZE = 128,
SCE_NP_MATCHING2_GET_USER_INFO_LIST_NPID_NUM_MAX = 25,
SCE_NP_MATCHING2_GET_ROOM_DATA_EXTERNAL_LIST_ROOM_NUM_MAX = 20,
SCE_NP_MATCHING2_EVENT_DATA_MAX_SIZE_GetServerInfo = 4,
SCE_NP_MATCHING2_EVENT_DATA_MAX_SIZE_GetWorldInfoList = 3848,
SCE_NP_MATCHING2_EVENT_DATA_MAX_SIZE_GetRoomMemberDataExternalList = 15624,
SCE_NP_MATCHING2_EVENT_DATA_MAX_SIZE_GetRoomDataExternalList = 25768,
SCE_NP_MATCHING2_EVENT_DATA_MAX_SIZE_GetLobbyInfoList = 1296,
SCE_NP_MATCHING2_EVENT_DATA_MAX_SIZE_GetUserInfoList = 17604,
SCE_NP_MATCHING2_EVENT_DATA_MAX_SIZE_CreateJoinRoom = 25224,
SCE_NP_MATCHING2_EVENT_DATA_MAX_SIZE_JoinRoom = 25224,
SCE_NP_MATCHING2_EVENT_DATA_MAX_SIZE_SearchRoom = 25776,
SCE_NP_MATCHING2_EVENT_DATA_MAX_SIZE_SendRoomChatMessage = 1,
SCE_NP_MATCHING2_EVENT_DATA_MAX_SIZE_GetRoomDataInternal = 25224,
SCE_NP_MATCHING2_EVENT_DATA_MAX_SIZE_GetRoomMemberDataInternal = 372,
SCE_NP_MATCHING2_EVENT_DATA_MAX_SIZE_JoinLobby = 1124,
SCE_NP_MATCHING2_EVENT_DATA_MAX_SIZE_SendLobbyChatMessage = 1,
SCE_NP_MATCHING2_EVENT_DATA_MAX_SIZE_GetLobbyMemberDataInternal = 672,
SCE_NP_MATCHING2_EVENT_DATA_MAX_SIZE_GetLobbyMemberDataInternalList = 42760,
SCE_NP_MATCHING2_EVENT_DATA_MAX_SIZE_SignalingGetPingInfo = 40,
SCE_NP_MATCHING2_EVENT_DATA_MAX_SIZE_RoomMemberUpdateInfo = 396,
SCE_NP_MATCHING2_EVENT_DATA_MAX_SIZE_RoomUpdateInfo = 28,
SCE_NP_MATCHING2_EVENT_DATA_MAX_SIZE_RoomOwnerUpdateInfo = 40,
SCE_NP_MATCHING2_EVENT_DATA_MAX_SIZE_RoomDataInternalUpdateInfo = 26208,
SCE_NP_MATCHING2_EVENT_DATA_MAX_SIZE_RoomMemberDataInternalUpdateInfo = 493,
SCE_NP_MATCHING2_EVENT_DATA_MAX_SIZE_SignalingOptParamUpdateInfo = 8,
SCE_NP_MATCHING2_EVENT_DATA_MAX_SIZE_RoomMessageInfo = 1407,
SCE_NP_MATCHING2_EVENT_DATA_MAX_SIZE_LobbyMemberUpdateInfo = 696,
SCE_NP_MATCHING2_EVENT_DATA_MAX_SIZE_LobbyUpdateInfo = 8,
SCE_NP_MATCHING2_EVENT_DATA_MAX_SIZE_LobbyMemberDataInternalUpdateInfo = 472,
SCE_NP_MATCHING2_EVENT_DATA_MAX_SIZE_LobbyMessageInfo = 1790,
SCE_NP_MATCHING2_EVENT_DATA_MAX_SIZE_LobbyInvitationInfo = 870,
};
enum
{
SCE_NP_MATCHING2_MAX_SIZE_RoomDataExternal = 1288,
SCE_NP_MATCHING2_MAX_SIZE_RoomMemberDataInternal = 368,
SCE_NP_MATCHING2_MAX_SIZE_LobbyMemberDataInternal = 668,
SCE_NP_MATCHING2_MAX_SIZE_LobbyMemberDataInternal_NoExtendedData = 80,
SCE_NP_MATCHING2_MAX_SIZE_UserInfo = 704,
};
enum
{
SCE_NP_MATCHING2_TITLE_PASSPHRASE_SIZE = 128
};
// Comparison operator specified as the search condition
enum
{
SCE_NP_MATCHING2_OPERATOR_EQ = 1,
SCE_NP_MATCHING2_OPERATOR_NE = 2,
SCE_NP_MATCHING2_OPERATOR_LT = 3,
SCE_NP_MATCHING2_OPERATOR_LE = 4,
SCE_NP_MATCHING2_OPERATOR_GT = 5,
SCE_NP_MATCHING2_OPERATOR_GE = 6,
};
// Message cast type
enum
{
SCE_NP_MATCHING2_CASTTYPE_BROADCAST = 1,
SCE_NP_MATCHING2_CASTTYPE_UNICAST = 2,
SCE_NP_MATCHING2_CASTTYPE_MULTICAST = 3,
SCE_NP_MATCHING2_CASTTYPE_MULTICAST_TEAM = 4,
};
// Session type
enum
{
SCE_NP_MATCHING2_SESSION_TYPE_LOBBY = 1,
SCE_NP_MATCHING2_SESSION_TYPE_ROOM = 2,
};
// Signaling type
enum
{
SCE_NP_MATCHING2_SIGNALING_TYPE_NONE = 0,
SCE_NP_MATCHING2_SIGNALING_TYPE_MESH = 1,
SCE_NP_MATCHING2_SIGNALING_TYPE_STAR = 2,
};
enum
{
SCE_NP_MATCHING2_SIGNALING_FLAG_MANUAL_MODE = 0x01
};
// Event cause
enum
{
SCE_NP_MATCHING2_EVENT_CAUSE_LEAVE_ACTION = 1,
SCE_NP_MATCHING2_EVENT_CAUSE_KICKOUT_ACTION = 2,
SCE_NP_MATCHING2_EVENT_CAUSE_GRANT_OWNER_ACTION = 3,
SCE_NP_MATCHING2_EVENT_CAUSE_SERVER_OPERATION = 4,
SCE_NP_MATCHING2_EVENT_CAUSE_MEMBER_DISAPPEARED = 5,
SCE_NP_MATCHING2_EVENT_CAUSE_SERVER_INTERNAL = 6,
SCE_NP_MATCHING2_EVENT_CAUSE_CONNECTION_ERROR = 7,
SCE_NP_MATCHING2_EVENT_CAUSE_NP_SIGNED_OUT = 8,
SCE_NP_MATCHING2_EVENT_CAUSE_SYSTEM_ERROR = 9,
SCE_NP_MATCHING2_EVENT_CAUSE_CONTEXT_ERROR = 10,
SCE_NP_MATCHING2_EVENT_CAUSE_CONTEXT_ACTION = 11,
};
// Server status
enum
{
SCE_NP_MATCHING2_SERVER_STATUS_AVAILABLE = 1,
SCE_NP_MATCHING2_SERVER_STATUS_UNAVAILABLE = 2,
SCE_NP_MATCHING2_SERVER_STATUS_BUSY = 3,
SCE_NP_MATCHING2_SERVER_STATUS_MAINTENANCE = 4,
};
// Member role
enum
{
SCE_NP_MATCHING2_ROLE_MEMBER = 1,
SCE_NP_MATCHING2_ROLE_OWNER = 2,
};
// Status of kicked-out member with regards to rejoining
enum
{
SCE_NP_MATCHING2_BLOCKKICKFLAG_OK = 0,
SCE_NP_MATCHING2_BLOCKKICKFLAG_NG = 1,
};
// Sort method
enum
{
SCE_NP_MATCHING2_SORT_METHOD_JOIN_DATE = 0,
SCE_NP_MATCHING2_SORT_METHOD_SLOT_NUMBER = 1,
};
// Context options (matching)
enum
{
SCE_NP_MATCHING2_CONTEXT_OPTION_USE_ONLINENAME = 0x01,
SCE_NP_MATCHING2_CONTEXT_OPTION_USE_AVATARURL = 0x02,
};
// User information acquisition option
enum
{
SCE_NP_MATCHING2_GET_USER_INFO_LIST_OPTION_WITH_ONLINENAME = 0x01,
SCE_NP_MATCHING2_GET_USER_INFO_LIST_OPTION_WITH_AVATARURL = 0x02,
};
// Room search options
enum
{
SCE_NP_MATCHING2_SEARCH_ROOM_OPTION_WITH_NPID = 0x01,
SCE_NP_MATCHING2_SEARCH_ROOM_OPTION_WITH_ONLINENAME = 0x02,
SCE_NP_MATCHING2_SEARCH_ROOM_OPTION_WITH_AVATARURL = 0x04,
SCE_NP_MATCHING2_SEARCH_ROOM_OPTION_NAT_TYPE_FILTER = 0x08,
SCE_NP_MATCHING2_SEARCH_ROOM_OPTION_RANDOM = 0x10,
};
// Send options
enum
{
SCE_NP_MATCHING2_SEND_MSG_OPTION_WITH_NPID = 0x01,
SCE_NP_MATCHING2_SEND_MSG_OPTION_WITH_ONLINENAME = 0x02,
SCE_NP_MATCHING2_SEND_MSG_OPTION_WITH_AVATARURL = 0x04,
};
enum
{
SCE_NP_MATCHING2_ROOM_ALLOWED_USER_MAX = 100,
SCE_NP_MATCHING2_ROOM_BLOCKED_USER_MAX = 100,
};
// Flag-type lobby attribute
enum
{
SCE_NP_MATCHING2_LOBBY_FLAG_ATTR_PERMANENT = 0x80000000,
SCE_NP_MATCHING2_LOBBY_FLAG_ATTR_CLAN = 0x40000000,
SCE_NP_MATCHING2_LOBBY_FLAG_ATTR_MEMBER_NOTIFICATION = 0x20000000,
};
// Attribute ID of lobby member internal binary attribute
enum
{
SCE_NP_MATCHING2_LOBBYMEMBER_BIN_ATTR_INTERNAL_1_ID = 0x0039,
};
// Flag-type room attribute
enum
{
SCE_NP_MATCHING2_ROOM_FLAG_ATTR_OWNER_AUTO_GRANT = 0x80000000,
SCE_NP_MATCHING2_ROOM_FLAG_ATTR_CLOSED = 0x40000000,
SCE_NP_MATCHING2_ROOM_FLAG_ATTR_FULL = 0x20000000,
SCE_NP_MATCHING2_ROOM_FLAG_ATTR_HIDDEN = 0x10000000,
SCE_NP_MATCHING2_ROOM_FLAG_ATTR_NAT_TYPE_RESTRICTION = 0x04000000,
SCE_NP_MATCHING2_ROOM_FLAG_ATTR_PROHIBITIVE_MODE = 0x02000000,
};
// Flah-type room member attribute
enum
{
SCE_NP_MATCHING2_LOBBYMEMBER_FLAG_ATTR_OWNER = 0x80000000,
SCE_NP_MATCHING2_ROOMMEMBER_FLAG_ATTR_OWNER = 0x80000000,
};
// ID of external room search integer attribute
enum
{
SCE_NP_MATCHING2_ROOM_SEARCHABLE_INT_ATTR_EXTERNAL_1_ID = 0x004c,
SCE_NP_MATCHING2_ROOM_SEARCHABLE_INT_ATTR_EXTERNAL_2_ID = 0x004d,
SCE_NP_MATCHING2_ROOM_SEARCHABLE_INT_ATTR_EXTERNAL_3_ID = 0x004e,
SCE_NP_MATCHING2_ROOM_SEARCHABLE_INT_ATTR_EXTERNAL_4_ID = 0x004f,
SCE_NP_MATCHING2_ROOM_SEARCHABLE_INT_ATTR_EXTERNAL_5_ID = 0x0050,
SCE_NP_MATCHING2_ROOM_SEARCHABLE_INT_ATTR_EXTERNAL_6_ID = 0x0051,
SCE_NP_MATCHING2_ROOM_SEARCHABLE_INT_ATTR_EXTERNAL_7_ID = 0x0052,
SCE_NP_MATCHING2_ROOM_SEARCHABLE_INT_ATTR_EXTERNAL_8_ID = 0x0053,
};
// ID of external room search binary attribute
enum
{
SCE_NP_MATCHING2_ROOM_SEARCHABLE_BIN_ATTR_EXTERNAL_1_ID = 0x0054,
};
// ID of external room binary attribute
enum
{
SCE_NP_MATCHING2_ROOM_BIN_ATTR_EXTERNAL_1_ID = 0x0055,
SCE_NP_MATCHING2_ROOM_BIN_ATTR_EXTERNAL_2_ID = 0x0056,
};
// ID of internal lobby binary attribute
enum
{
SCE_NP_MATCHING2_LOBBY_BIN_ATTR_INTERNAL_1_ID = 0x0037,
SCE_NP_MATCHING2_LOBBY_BIN_ATTR_INTERNAL_2_ID = 0x0038,
};
// ID of internal room binary attribute
enum
{
SCE_NP_MATCHING2_ROOM_BIN_ATTR_INTERNAL_1_ID = 0x0057,
SCE_NP_MATCHING2_ROOM_BIN_ATTR_INTERNAL_2_ID = 0x0058,
};
// ID of internal room member binary attribute
enum
{
SCE_NP_MATCHING2_ROOMMEMBER_BIN_ATTR_INTERNAL_1_ID = 0x0059,
};
// Attribute ID of user binary attribute
enum
{
SCE_NP_MATCHING2_USER_BIN_ATTR_1_ID = 0x005f,
};
// Event of request functions
enum
{
SCE_NP_MATCHING2_REQUEST_EVENT_GetServerInfo = 0x0001,
SCE_NP_MATCHING2_REQUEST_EVENT_GetWorldInfoList = 0x0002,
SCE_NP_MATCHING2_REQUEST_EVENT_GetRoomMemberDataExternalList = 0x0003,
SCE_NP_MATCHING2_REQUEST_EVENT_SetRoomDataExternal = 0x0004,
SCE_NP_MATCHING2_REQUEST_EVENT_GetRoomDataExternalList = 0x0005,
SCE_NP_MATCHING2_REQUEST_EVENT_GetLobbyInfoList = 0x0006,
SCE_NP_MATCHING2_REQUEST_EVENT_SetUserInfo = 0x0007,
SCE_NP_MATCHING2_REQUEST_EVENT_GetUserInfoList = 0x0008,
SCE_NP_MATCHING2_REQUEST_EVENT_CreateServerContext = 0x0009,
SCE_NP_MATCHING2_REQUEST_EVENT_DeleteServerContext = 0x000a,
SCE_NP_MATCHING2_REQUEST_EVENT_CreateJoinRoom = 0x0101,
SCE_NP_MATCHING2_REQUEST_EVENT_JoinRoom = 0x0102,
SCE_NP_MATCHING2_REQUEST_EVENT_LeaveRoom = 0x0103,
SCE_NP_MATCHING2_REQUEST_EVENT_GrantRoomOwner = 0x0104,
SCE_NP_MATCHING2_REQUEST_EVENT_KickoutRoomMember = 0x0105,
SCE_NP_MATCHING2_REQUEST_EVENT_SearchRoom = 0x0106,
SCE_NP_MATCHING2_REQUEST_EVENT_SendRoomChatMessage = 0x0107,
SCE_NP_MATCHING2_REQUEST_EVENT_SendRoomMessage = 0x0108,
SCE_NP_MATCHING2_REQUEST_EVENT_SetRoomDataInternal = 0x0109,
SCE_NP_MATCHING2_REQUEST_EVENT_GetRoomDataInternal = 0x010a,
SCE_NP_MATCHING2_REQUEST_EVENT_SetRoomMemberDataInternal = 0x010b,
SCE_NP_MATCHING2_REQUEST_EVENT_GetRoomMemberDataInternal = 0x010c,
SCE_NP_MATCHING2_REQUEST_EVENT_SetSignalingOptParam = 0x010d,
SCE_NP_MATCHING2_REQUEST_EVENT_JoinLobby = 0x0201,
SCE_NP_MATCHING2_REQUEST_EVENT_LeaveLobby = 0x0202,
SCE_NP_MATCHING2_REQUEST_EVENT_SendLobbyChatMessage = 0x0203,
SCE_NP_MATCHING2_REQUEST_EVENT_SendLobbyInvitation = 0x0204,
SCE_NP_MATCHING2_REQUEST_EVENT_SetLobbyMemberDataInternal = 0x0205,
SCE_NP_MATCHING2_REQUEST_EVENT_GetLobbyMemberDataInternal = 0x0206,
SCE_NP_MATCHING2_REQUEST_EVENT_GetLobbyMemberDataInternalList = 0x0207,
SCE_NP_MATCHING2_REQUEST_EVENT_SignalingGetPingInfo = 0x0e01,
};
// Room event
enum
{
SCE_NP_MATCHING2_ROOM_EVENT_MemberJoined = 0x1101,
SCE_NP_MATCHING2_ROOM_EVENT_MemberLeft = 0x1102,
SCE_NP_MATCHING2_ROOM_EVENT_Kickedout = 0x1103,
SCE_NP_MATCHING2_ROOM_EVENT_RoomDestroyed = 0x1104,
SCE_NP_MATCHING2_ROOM_EVENT_RoomOwnerChanged = 0x1105,
SCE_NP_MATCHING2_ROOM_EVENT_UpdatedRoomDataInternal = 0x1106,
SCE_NP_MATCHING2_ROOM_EVENT_UpdatedRoomMemberDataInternal = 0x1107,
SCE_NP_MATCHING2_ROOM_EVENT_UpdatedSignalingOptParam = 0x1108,
};
// Room message event
enum
{
SCE_NP_MATCHING2_ROOM_MSG_EVENT_ChatMessage = 0x2101,
SCE_NP_MATCHING2_ROOM_MSG_EVENT_Message = 0x2102,
};
// Lobby event
enum
{
SCE_NP_MATCHING2_LOBBY_EVENT_MemberJoined = 0x3201,
SCE_NP_MATCHING2_LOBBY_EVENT_MemberLeft = 0x3202,
SCE_NP_MATCHING2_LOBBY_EVENT_LobbyDestroyed = 0x3203,
SCE_NP_MATCHING2_LOBBY_EVENT_UpdatedLobbyMemberDataInternal = 0x3204,
};
// Lobby message event
enum
{
SCE_NP_MATCHING2_LOBBY_MSG_EVENT_ChatMessage = 0x4201,
SCE_NP_MATCHING2_LOBBY_MSG_EVENT_Invitation = 0x4202,
};
// Signaling event
enum
{
SCE_NP_MATCHING2_SIGNALING_EVENT_Dead = 0x5101,
SCE_NP_MATCHING2_SIGNALING_EVENT_Established = 0x5102,
SCE_NP_MATCHING2_SIGNALING_EVENT_NetInfoResult = 0x5103,
};
// Context event
enum
{
SCE_NP_MATCHING2_CONTEXT_EVENT_StartOver = 0x6f01,
SCE_NP_MATCHING2_CONTEXT_EVENT_Start = 0x6f02,
SCE_NP_MATCHING2_CONTEXT_EVENT_Stop = 0x6f03,
};
enum
{
SCE_NP_MATCHING2_SIGNALING_NETINFO_NAT_STATUS_UNKNOWN = 0,
SCE_NP_MATCHING2_SIGNALING_NETINFO_NAT_STATUS_TYPE = 1,
SCE_NP_MATCHING2_SIGNALING_NETINFO_NAT_STATUS_TYPE2 = 2,
SCE_NP_MATCHING2_SIGNALING_NETINFO_NAT_STATUS_TYPE3 = 3,
};
typedef u16 SceNpMatching2ServerId;
typedef u32 SceNpMatching2WorldId;
typedef u16 SceNpMatching2WorldNumber;
typedef u64 SceNpMatching2LobbyId;
typedef u16 SceNpMatching2LobbyNumber;
typedef u16 SceNpMatching2LobbyMemberId;
typedef u64 SceNpMatching2RoomId;
typedef u16 SceNpMatching2RoomNumber;
typedef u16 SceNpMatching2RoomMemberId;
typedef u8 SceNpMatching2RoomGroupId;
typedef u8 SceNpMatching2TeamId;
typedef u16 SceNpMatching2ContextId;
typedef u32 SceNpMatching2RequestId;
typedef u16 SceNpMatching2AttributeId;
typedef u32 SceNpMatching2FlagAttr;
typedef u8 SceNpMatching2NatType;
typedef u8 SceNpMatching2Operator;
typedef u8 SceNpMatching2CastType;
typedef u8 SceNpMatching2SessionType;
typedef u8 SceNpMatching2SignalingType;
typedef u8 SceNpMatching2SignalingFlag;
typedef u8 SceNpMatching2EventCause;
typedef u8 SceNpMatching2ServerStatus;
typedef u8 SceNpMatching2Role;
typedef u8 SceNpMatching2BlockKickFlag;
typedef u64 SceNpMatching2RoomPasswordSlotMask;
typedef u64 SceNpMatching2RoomJoinedSlotMask;
typedef u16 SceNpMatching2Event;
typedef u32 SceNpMatching2EventKey;
typedef u32 SceNpMatching2SignalingRequestId;
typedef SceNpCommunicationPassphrase SceNpMatching2TitlePassphrase;
// Request callback function
using SceNpMatching2RequestCallback = void(SceNpMatching2ContextId ctxId, SceNpMatching2RequestId reqId, SceNpMatching2Event event, SceNpMatching2EventKey eventKey,
s32 errorCode, u32 dataSize, vm::ptr<void> arg);
using SceNpMatching2RoomEventCallback = void(SceNpMatching2ContextId ctxId, SceNpMatching2RoomId roomId, SceNpMatching2Event event, SceNpMatching2EventKey eventKey,
s32 errorCode, u32 dataSize, vm::ptr<void> arg);
using SceNpMatching2RoomMessageCallback = void(SceNpMatching2ContextId ctxId, SceNpMatching2RoomId roomId, SceNpMatching2RoomMemberId srcMemberId, SceNpMatching2Event event,
SceNpMatching2EventKey eventKey, s32 errorCode, u32 dataSize, vm::ptr<void> arg);
using SceNpMatching2LobbyEventCallback = void(SceNpMatching2ContextId ctxId, SceNpMatching2LobbyId lobbyId, SceNpMatching2Event event, SceNpMatching2EventKey eventKey,
s32 errorCode, u32 dataSize, vm::ptr<void> arg);
using SceNpMatching2LobbyMessageCallback = void(SceNpMatching2ContextId ctxId, SceNpMatching2LobbyId lobbyId, SceNpMatching2LobbyMemberId srcMemberId, SceNpMatching2Event event,
SceNpMatching2EventKey eventKey, s32 errorCode, u32 dataSize, vm::ptr<void> arg);
using SceNpMatching2SignalingCallback = void(SceNpMatching2ContextId ctxId, SceNpMatching2RoomId roomId, SceNpMatching2RoomMemberId peerMemberId, SceNpMatching2Event event,
s32 errorCode, vm::ptr<void> arg);
using SceNpMatching2ContextCallback = void(SceNpMatching2ContextId ctxId, SceNpMatching2Event event, SceNpMatching2EventCause eventCause, s32 errorCode, vm::ptr<void> arg);
// Session password
struct SceNpMatching2SessionPassword
{
u8 data[SCE_NP_MATCHING2_SESSION_PASSWORD_SIZE];
};
// Optional presence data
struct SceNpMatching2PresenceOptionData
{
u8 data[SCE_NP_MATCHING2_PRESENCE_OPTION_DATA_SIZE];
be_t<u32> length;
};
// Integer-type attribute
struct SceNpMatching2IntAttr
{
be_t<SceNpMatching2AttributeId> id;
u8 padding[2];
be_t<u32> num;
};
// Binary-type attribute
struct SceNpMatching2BinAttr
{
be_t<SceNpMatching2AttributeId> id;
u8 padding[2];
vm::bptr<u8> ptr;
be_t<u32> size;
};
// Range filter
struct SceNpMatching2RangeFilter
{
be_t<u32> startIndex;
be_t<u32> max;
};
// Integer-type search condition
struct SceNpMatching2IntSearchFilter
{
SceNpMatching2Operator searchOperator;
u8 padding[3];
SceNpMatching2IntAttr attr;
};
// Binary-type search condition
struct SceNpMatching2BinSearchFilter
{
SceNpMatching2Operator searchOperator;
u8 padding[3];
SceNpMatching2BinAttr attr;
};
// Range of result
struct SceNpMatching2Range
{
be_t<u32> startIndex;
be_t<u32> total;
be_t<u32> size;
};
// Session information about a session joined by the user
struct SceNpMatching2JoinedSessionInfo
{
u8 sessionType;
u8 padding1[1];
be_t<SceNpMatching2ServerId> serverId;
be_t<SceNpMatching2WorldId> worldId;
be_t<SceNpMatching2LobbyId> lobbyId;
be_t<SceNpMatching2RoomId> roomId;
CellRtcTick joinDate;
};
// User information
struct SceNpMatching2UserInfo
{
vm::bptr<SceNpMatching2UserInfo> next;
SceNpUserInfo2 userInfo;
vm::bptr<SceNpMatching2BinAttr> userBinAttr;
be_t<u32> userBinAttrNum;
SceNpMatching2JoinedSessionInfo joinedSessionInfo;
be_t<u32> joinedSessionInfoNum;
};
// Server
struct SceNpMatching2Server
{
be_t<SceNpMatching2ServerId> serverId;
SceNpMatching2ServerStatus status;
u8 padding[1];
};
// World
struct SceNpMatching2World
{
be_t<SceNpMatching2WorldId> worldId;
be_t<u32> numOfLobby;
be_t<u32> maxNumOfTotalLobbyMember;
be_t<u32> curNumOfTotalLobbyMember;
be_t<u32> curNumOfRoom;
be_t<u32> curNumOfTotalRoomMember;
b8 withEntitlementId;
SceNpEntitlementId entitlementId;
u8 padding[3];
};
// Lobby member internal binary attribute
struct SceNpMatching2LobbyMemberBinAttrInternal
{
CellRtcTick updateDate;
SceNpMatching2BinAttr data;
u8 padding[4];
};
// Lobby-internal lobby member information
struct SceNpMatching2LobbyMemberDataInternal
{
vm::bptr<SceNpMatching2LobbyMemberDataInternal> next;
SceNpUserInfo2 userInfo;
CellRtcTick joinDate;
be_t<SceNpMatching2LobbyMemberId> memberId;
u8 padding[2];
be_t<SceNpMatching2FlagAttr> flagAttr;
vm::bptr<SceNpMatching2JoinedSessionInfo> joinedSessionInfo;
be_t<u32> joinedSessionInfoNum;
vm::bptr<SceNpMatching2LobbyMemberBinAttrInternal> lobbyMemberBinAttrInternal;
be_t<u32> lobbyMemberBinAttrInternalNum; // Unsigned ints are be_t<u32> not uint, right?
};
// Lobby member ID list
struct SceNpMatching2LobbyMemberIdList
{
be_t<SceNpMatching2LobbyMemberId> memberId;
be_t<u32> memberIdNum;
be_t<SceNpMatching2LobbyMemberId> me;
u8 padding[6];
};
// Lobby-internal binary attribute
struct SceNpMatching2LobbyBinAttrInternal
{
CellRtcTick updateDate;
be_t<SceNpMatching2LobbyMemberId> updateMemberId;
u8 padding[2];
SceNpMatching2BinAttr data;
};
// Lobby-external lobby information
struct SceNpMatching2LobbyDataExternal
{
vm::bptr<SceNpMatching2LobbyDataExternal> next;
be_t<SceNpMatching2ServerId> serverId;
u8 padding1[2];
be_t<SceNpMatching2WorldId> worldId;
u8 padding2[4];
be_t<SceNpMatching2LobbyId > lobbyId;
be_t<u32> maxSlot;
be_t<u32> curMemberNum;
be_t<u32> flagAttr;
vm::bptr<SceNpMatching2IntAttr> lobbySearchableIntAttrExternal;
be_t<u32> lobbySearchableIntAttrExternalNum;
vm::bptr<SceNpMatching2BinAttr> lobbySearchableBinAttrExternal;
be_t<u32> lobbySearchableBinAttrExternalNum;
vm::bptr<SceNpMatching2BinAttr> lobbyBinAttrExternal;
be_t<u32> lobbyBinAttrExternalNum;
u8 padding3[4];
};
// Lobby-internal lobby information
struct SceNpMatching2LobbyDataInternal
{
be_t<SceNpMatching2ServerId> serverId;
u8 padding1[2];
be_t<SceNpMatching2WorldId> worldId;
be_t<SceNpMatching2LobbyId> lobbyId;
be_t<u32> maxSlot;
SceNpMatching2LobbyMemberIdList memberIdList;
be_t<SceNpMatching2FlagAttr> flagAttr;
vm::bptr<SceNpMatching2LobbyBinAttrInternal> lobbyBinAttrInternal;
be_t<u32> lobbyBinAttrInternalNum;
};
// Lobby message transmission destination
union SceNpMatching2LobbyMessageDestination
{
be_t<SceNpMatching2LobbyMemberId> unicastTarget;
struct multicastTarget
{
vm::bptr<SceNpMatching2LobbyMemberId> memberId;
be_t<u32> memberIdNum;
};
};
// Group label
struct SceNpMatching2GroupLabel
{
u8 data[SCE_NP_MATCHING2_GROUP_LABEL_SIZE];
};
// Set groups in a room
struct SceNpMatching2RoomGroupConfig
{
be_t<u32> slotNum;
b8 withLabel;
SceNpMatching2GroupLabel label;
b8 withPassword;
u8 padding[2];
};
// Set group password
struct SceNpMatching2RoomGroupPasswordConfig
{
SceNpMatching2RoomGroupId groupId;
b8 withPassword;
u8 padding[1];
};
// Group (of slots in a room)
struct SceNpMatching2RoomGroup
{
SceNpMatching2RoomGroupId groupId;
b8 withPassword;
b8 withLabel;
u8 padding[1];
SceNpMatching2GroupLabel label;
be_t<u32> slotNum;
be_t<u32> curGroupMemberNum;
};
// Internal room member binary attribute
struct SceNpMatching2RoomMemberBinAttrInternal
{
CellRtcTick updateDate;
SceNpMatching2BinAttr data;
u8 padding[4];
};
// External room member data
struct SceNpMatching2RoomMemberDataExternal
{
vm::bptr<SceNpMatching2RoomMemberDataExternal> next;
SceNpUserInfo2 userInfo;
CellRtcTick joinDate;
SceNpMatching2Role role;
u8 padding[7];
};
// Internal room member data
struct SceNpMatching2RoomMemberDataInternal
{
vm::bptr<SceNpMatching2RoomMemberDataInternal> next;
SceNpUserInfo2 userInfo;
CellRtcTick joinDate;
be_t<SceNpMatching2RoomMemberId> memberId;
SceNpMatching2TeamId teamId;
u8 padding1[1];
vm::bptr<SceNpMatching2RoomGroup> roomGroup;
SceNpMatching2NatType natType;
u8 padding2[3];
be_t<SceNpMatching2FlagAttr> flagAttr;
vm::bptr<SceNpMatching2RoomMemberBinAttrInternal> roomMemberBinAttrInternal;
be_t<u32> roomMemberBinAttrInternalNum;
};
// Internal room member data list
struct SceNpMatching2RoomMemberDataInternalList
{
vm::bptr<SceNpMatching2RoomMemberDataInternal> members;
be_t<u32> membersNum;
vm::bptr<SceNpMatching2RoomMemberDataInternal> me;
vm::bptr<SceNpMatching2RoomMemberDataInternal> owner;
};
// Internal room binary attribute
struct SceNpMatching2RoomBinAttrInternal
{
CellRtcTick updateDate;
be_t<SceNpMatching2RoomMemberId> updateMemberId;
u8 padding[2];
SceNpMatching2BinAttr data;
};
// External room data
struct SceNpMatching2RoomDataExternal
{
vm::bptr<SceNpMatching2RoomDataExternal> next;
be_t<SceNpMatching2ServerId> serverId;
u8 padding1[2];
be_t<SceNpMatching2WorldId> worldId;
be_t<u16> publicSlotNum;
be_t<u16> privateSlotNum;
be_t<SceNpMatching2LobbyId> lobbyId;
be_t<SceNpMatching2RoomId> roomId;
be_t<u16> openPublicSlotNum;
be_t<u16> maxSlot;
be_t<u16> openPrivateSlotNum;
be_t<u16> curMemberNum;
be_t<SceNpMatching2RoomPasswordSlotMask> passwordSlotMask;
vm::bptr<SceNpUserInfo2> owner;
vm::bptr<SceNpMatching2RoomGroup> roomGroup;
be_t<u32> roomGroupNum;
be_t<u32> flagAttr;
vm::bptr<SceNpMatching2IntAttr> roomSearchableIntAttrExternal;
be_t<u32> roomSearchableIntAttrExternalNum;
vm::bptr<SceNpMatching2BinAttr> roomSearchableBinAttrExternal;
be_t<u32> roomSearchableBinAttrExternalNum;
vm::bptr<SceNpMatching2BinAttr> roomBinAttrExternal;
be_t<u32> roomBinAttrExternalNum;
};
// Internal room data
struct SceNpMatching2RoomDataInternal
{
be_t<SceNpMatching2ServerId> serverId;
u8 padding1[2];
be_t<SceNpMatching2WorldId> worldId;
be_t<SceNpMatching2LobbyId> lobbyId;
be_t<SceNpMatching2RoomId> roomId;
be_t<SceNpMatching2RoomPasswordSlotMask> passwordSlotMask;
be_t<u32> maxSlot;
SceNpMatching2RoomMemberDataInternalList memberList;
vm::bptr<SceNpMatching2RoomGroup> roomGroup;
be_t<u32> roomGroupNum;
be_t<SceNpMatching2FlagAttr> flagAttr;
vm::bptr<SceNpMatching2RoomBinAttrInternal> roomBinAttrInternal;
be_t<u32> roomBinAttrInternalNum;
};
// Room message recipient
union SceNpMatching2RoomMessageDestination
{
be_t<SceNpMatching2RoomMemberId> unicastTarget;
struct multicastTarget
{
vm::bptr<SceNpMatching2RoomMemberId> memberId;
be_t<u32> memberIdNum;
} multicastTarget;
SceNpMatching2TeamId multicastTargetTeamId;
};
// Invitation data
struct SceNpMatching2InvitationData
{
vm::bptr<SceNpMatching2JoinedSessionInfo> targetSession;
be_t<u32> targetSessionNum;
vm::bptr<void> optData;
be_t<u32> optDataLen;
};
// Signaling option parameter
struct SceNpMatching2SignalingOptParam
{
SceNpMatching2SignalingType type;
SceNpMatching2SignalingFlag flag;
be_t<SceNpMatching2RoomMemberId> hubMemberId;
u8 reserved2[4];
};
// Option parameters for requests
struct SceNpMatching2RequestOptParam
{
vm::bptr<SceNpMatching2RequestCallback> cbFunc;
vm::bptr<void> cbFuncArg;
be_t<u32> timeout;
be_t<u16> appReqId;
u8 padding[2];
};
// Room slot information
struct SceNpMatching2RoomSlotInfo
{
be_t<SceNpMatching2RoomId> roomId;
be_t<SceNpMatching2RoomJoinedSlotMask> joinedSlotMask;
be_t<SceNpMatching2RoomPasswordSlotMask> passwordSlotMask;
be_t<u16> publicSlotNum;
be_t<u16> privateSlotNum;
be_t<u16> openPublicSlotNum;
be_t<u16> openPrivateSlotNum;
};
// Server data request parameter
struct SceNpMatching2GetServerInfoRequest
{
be_t<SceNpMatching2ServerId> serverId;
};
// Server data request response data
struct SceNpMatching2GetServerInfoResponse
{
SceNpMatching2Server server;
};
// Request parameter for creating a server context
struct SceNpMatching2CreateServerContextRequest
{
be_t<SceNpMatching2ServerId> serverId;
};
// Request parameter for deleting a server context
struct SceNpMatching2DeleteServerContextRequest
{
be_t<SceNpMatching2ServerId> serverId;
};
// World data list request parameter
struct SceNpMatching2GetWorldInfoListRequest
{
be_t<SceNpMatching2ServerId> serverId;
};
// World data list request response data
struct SceNpMatching2GetWorldInfoListResponse
{
vm::bptr<SceNpMatching2World> world;
be_t<u32> worldNum;
};
// User information setting request parameter
struct SceNpMatching2SetUserInfoRequest
{
be_t<SceNpMatching2ServerId> serverId;
u8 padding[2];
vm::bptr<SceNpMatching2BinAttr> userBinAttr;
be_t<u32> userBinAttrNum;
};
// User information list acquisition request parameter
struct SceNpMatching2GetUserInfoListRequest
{
be_t<SceNpMatching2ServerId> serverId;
u8 padding[2];
vm::bptr<SceNpId> npId;
be_t<u32> npIdNum;
vm::bptr<SceNpMatching2AttributeId> attrId;
be_t<u32> attrIdNum;
be_t<s32> option; // int should be be_t<s32>, right?
};
// User information list acquisition response data
struct SceNpMatching2GetUserInfoListResponse
{
vm::bptr<SceNpMatching2UserInfo> userInfo;
be_t<u32> userInfoNum;
};
// External room member data list request parameter
struct SceNpMatching2GetRoomMemberDataExternalListRequest
{
be_t<SceNpMatching2RoomId> roomId;
};
// External room member data list request response data
struct SceNpMatching2GetRoomMemberDataExternalListResponse
{
vm::bptr<SceNpMatching2RoomMemberDataExternal> roomMemberDataExternal;
be_t<u32> roomMemberDataExternalNum;
};
// External room data configuration request parameters
struct SceNpMatching2SetRoomDataExternalRequest
{
be_t<SceNpMatching2RoomId> roomId;
vm::bptr<SceNpMatching2IntAttr> roomSearchableIntAttrExternal;
be_t<u32> roomSearchableIntAttrExternalNum;
vm::bptr<SceNpMatching2BinAttr> roomSearchableBinAttrExternal;
be_t<u32> roomSearchableBinAttrExternalNum;
vm::bptr<SceNpMatching2BinAttr> roomBinAttrExternal;
be_t<u32> roomBinAttrExternalNum;
};
// External room data list request parameters
struct SceNpMatching2GetRoomDataExternalListRequest
{
vm::bptr<SceNpMatching2RoomId> roomId;
be_t<u32> roomIdNum;
vm::bcptr<SceNpMatching2AttributeId> attrId;
be_t<u32> attrIdNum;
};
// External room data list request response data
struct SceNpMatching2GetRoomDataExternalListResponse
{
vm::bptr<SceNpMatching2RoomDataExternal> roomDataExternal;
be_t<u32> roomDataExternalNum;
};
// Create-and-join room request parameters
struct SceNpMatching2CreateJoinRoomRequest
{
be_t<SceNpMatching2WorldId> worldId;
u8 padding1[4];
be_t<SceNpMatching2LobbyId> lobbyId;
be_t<u32> maxSlot;
be_t<u32> flagAttr;
vm::bptr<SceNpMatching2BinAttr> roomBinAttrInternal;
be_t<u32> roomBinAttrInternalNum;
vm::bptr<SceNpMatching2IntAttr> roomSearchableIntAttrExternal;
be_t<u32> roomSearchableIntAttrExternalNum;
vm::bptr<SceNpMatching2BinAttr> roomSearchableBinAttrExternal;
be_t<u32> roomSearchableBinAttrExternalNum;
vm::bptr<SceNpMatching2BinAttr> roomBinAttrExternal;
be_t<u32> roomBinAttrExternalNum;
vm::bptr<SceNpMatching2SessionPassword> roomPassword;
vm::bptr<SceNpMatching2RoomGroupConfig> groupConfig;
be_t<u32> groupConfigNum;
vm::bptr<SceNpMatching2RoomPasswordSlotMask> passwordSlotMask;
vm::bptr<SceNpId> allowedUser;
be_t<u32> allowedUserNum;
vm::bptr<SceNpId> blockedUser;
be_t<u32> blockedUserNum;
vm::bptr<SceNpMatching2GroupLabel> joinRoomGroupLabel;
vm::bptr<SceNpMatching2BinAttr> roomMemberBinAttrInternal;
be_t<u32> roomMemberBinAttrInternalNum;
SceNpMatching2TeamId teamId;
u8 padding2[3];
vm::bptr<SceNpMatching2SignalingOptParam> sigOptParam;
u8 padding3[4];
};
// Create-and-join room request response data
struct SceNpMatching2CreateJoinRoomResponse
{
vm::bptr<SceNpMatching2RoomDataInternal> roomDataInternal;
};
// Join room request parameters
struct SceNpMatching2JoinRoomRequest
{
be_t<SceNpMatching2RoomId> roomId;
vm::bptr<SceNpMatching2SessionPassword> roomPassword;
vm::bptr<SceNpMatching2GroupLabel> joinRoomGroupLabel;
vm::bptr<SceNpMatching2BinAttr> roomMemberBinAttrInternal;
be_t<u32> roomMemberBinAttrInternalNum;
SceNpMatching2PresenceOptionData optData;
SceNpMatching2TeamId teamId;
u8 padding[3];
};
// Join room request response data
struct SceNpMatching2JoinRoomResponse
{
vm::bptr<SceNpMatching2RoomDataInternal> roomDataInternal;
};
// Leave room request parameters
struct SceNpMatching2LeaveRoomRequest
{
be_t<SceNpMatching2RoomId> roomId;
SceNpMatching2PresenceOptionData optData;
u8 padding[4];
};
// Room ownership grant request parameters
struct SceNpMatching2GrantRoomOwnerRequest
{
be_t<SceNpMatching2RoomId> roomId;
be_t<SceNpMatching2RoomMemberId> newOwner;
u8 padding[2];
SceNpMatching2PresenceOptionData optData;
};
// Kickout request parameters
struct SceNpMatching2KickoutRoomMemberRequest
{
be_t<SceNpMatching2RoomId> roomId;
be_t<SceNpMatching2RoomMemberId> target;
SceNpMatching2BlockKickFlag blockKickFlag;
u8 padding[1];
SceNpMatching2PresenceOptionData optData;
};
// Room search parameters
struct SceNpMatching2SearchRoomRequest
{
be_t<s32> option;
be_t<SceNpMatching2WorldId> worldId;
be_t<SceNpMatching2LobbyId> lobbyId;
SceNpMatching2RangeFilter rangeFilter;
be_t<SceNpMatching2FlagAttr> flagFilter;
be_t<SceNpMatching2FlagAttr> flagAttr;
vm::bptr<SceNpMatching2IntSearchFilter> intFilter;
be_t<u32> intFilterNum;
vm::bptr<SceNpMatching2BinSearchFilter> binFilter;
be_t<u32> binFilterNum;
vm::bptr<SceNpMatching2AttributeId> attrId;
be_t<u32> attrIdNum;
};
// Room search response data
struct SceNpMatching2SearchRoomResponse
{
SceNpMatching2Range range;
vm::bptr<SceNpMatching2RoomDataExternal> roomDataExternal;
};
// Room message send request parameters
struct SceNpMatching2SendRoomMessageRequest
{
be_t<SceNpMatching2RoomId> roomId;
SceNpMatching2CastType castType;
u8 padding[3];
SceNpMatching2RoomMessageDestination dst;
vm::bcptr<void> msg;
be_t<u32> msgLen;
be_t<s32> option;
};
// Room chat message send request parameters
struct SceNpMatching2SendRoomChatMessageRequest
{
be_t<SceNpMatching2RoomId> roomId;
SceNpMatching2CastType castType;
u8 padding[3];
SceNpMatching2RoomMessageDestination dst;
vm::bcptr<void> msg;
be_t<u32> msgLen;
be_t<s32> option;
};
// Room chat message send request response data
struct SceNpMatching2SendRoomChatMessageResponse
{
b8 filtered;
};
// Internal room data configuration request parameters
struct SceNpMatching2SetRoomDataInternalRequest
{
be_t<SceNpMatching2RoomId> roomId;
be_t<SceNpMatching2FlagAttr> flagFilter;
be_t<SceNpMatching2FlagAttr> flagAttr;
vm::bptr<SceNpMatching2BinAttr> roomBinAttrInternal;
be_t<u32> roomBinAttrInternalNum;
vm::bptr<SceNpMatching2RoomGroupPasswordConfig> passwordConfig;
be_t<u32> passwordConfigNum;
vm::bptr<SceNpMatching2RoomPasswordSlotMask> passwordSlotMask;
vm::bptr<SceNpMatching2RoomMemberId> ownerPrivilegeRank;
be_t<u32> ownerPrivilegeRankNum;
u8 padding[4];
};
// Internal room data request parameters
struct SceNpMatching2GetRoomDataInternalRequest
{
be_t<SceNpMatching2RoomId> roomId;
vm::bcptr<SceNpMatching2AttributeId> attrId;
be_t<u32> attrIdNum;
};
// Internal room data request response data
struct SceNpMatching2GetRoomDataInternalResponse
{
vm::bptr<SceNpMatching2RoomDataInternal> roomDataInternal;
};
// Internal room member data configuration request parameters
struct SceNpMatching2SetRoomMemberDataInternalRequest
{
be_t<SceNpMatching2RoomId> roomId;
be_t<SceNpMatching2RoomMemberId> memberId;
SceNpMatching2TeamId teamId;
u8 padding[5];
be_t<SceNpMatching2FlagAttr> flagFilter;
be_t<SceNpMatching2FlagAttr> flagAttr;
vm::bptr<SceNpMatching2BinAttr> roomMemberBinAttrInternal;
be_t<u32> roomMemberBinAttrInternalNum;
};
// Internal room member data request parameters
struct SceNpMatching2GetRoomMemberDataInternalRequest
{
be_t<SceNpMatching2RoomId> roomId;
be_t<SceNpMatching2RoomMemberId> memberId;
u8 padding[6];
vm::bcptr<SceNpMatching2AttributeId> attrId;
be_t<u32> attrIdNum;
};
// Internal room member data request response data
struct SceNpMatching2GetRoomMemberDataInternalResponse
{
vm::bptr<SceNpMatching2RoomMemberDataInternal> roomMemberDataInternal;
};
// Signaling option parameter setting request parameter
struct SceNpMatching2SetSignalingOptParamRequest
{
be_t<SceNpMatching2RoomId> roomId;
SceNpMatching2SignalingOptParam sigOptParam;
};
// Lobby information list acquisition request parameter
struct SceNpMatching2GetLobbyInfoListRequest
{
be_t<SceNpMatching2WorldId> worldId;
SceNpMatching2RangeFilter rangeFilter;
vm::bptr<SceNpMatching2AttributeId> attrId;
be_t<u32> attrIdNum;
};
// Lobby information list acquisition response data
struct SceNpMatching2GetLobbyInfoListResponse
{
SceNpMatching2Range range;
vm::bptr<SceNpMatching2LobbyDataExternal> lobbyDataExternal;
};
// Lobby joining request parameter
struct SceNpMatching2JoinLobbyRequest
{
be_t<SceNpMatching2LobbyId> lobbyId;
vm::bptr<SceNpMatching2JoinedSessionInfo> joinedSessionInfo;
be_t<u32> joinedSessionInfoNum;
vm::bptr<SceNpMatching2BinAttr> lobbyMemberBinAttrInternal;
be_t<u32> lobbyMemberBinAttrInternalNum;
SceNpMatching2PresenceOptionData optData;
u8 padding[4];
};
// Lobby joining response data
struct SceNpMatching2JoinLobbyResponse
{
vm::bptr<SceNpMatching2LobbyDataInternal> lobbyDataInternal;
};
// Lobby leaving request parameter
struct SceNpMatching2LeaveLobbyRequest
{
be_t<SceNpMatching2LobbyId> lobbyId;
SceNpMatching2PresenceOptionData optData;
u8 padding[4];
};
// Lobby chat message sending request parameter
struct SceNpMatching2SendLobbyChatMessageRequest
{
be_t<SceNpMatching2LobbyId> lobbyId;
SceNpMatching2CastType castType;
u8 padding[3];
SceNpMatching2LobbyMessageDestination dst;
vm::bcptr<void> msg;
be_t<u32> msgLen;
be_t<s32> option;
};
// Lobby chat message sending response data
struct SceNpMatching2SendLobbyChatMessageResponse
{
b8 filtered;
};
// Lobby invitation message sending request parameter
struct SceNpMatching2SendLobbyInvitationRequest
{
be_t<SceNpMatching2LobbyId> lobbyId;
SceNpMatching2CastType castType;
u8 padding[3];
SceNpMatching2LobbyMessageDestination dst;
SceNpMatching2InvitationData invitationData;
be_t<s32> option;
};
// Lobby-internal lobby member information setting request parameter
struct SceNpMatching2SetLobbyMemberDataInternalRequest
{
be_t<SceNpMatching2LobbyId> lobbyId;
be_t<SceNpMatching2LobbyMemberId> memberId;
u8 padding1[2];
be_t<SceNpMatching2FlagAttr> flagFilter;
be_t<SceNpMatching2FlagAttr> flagAttr;
vm::bptr<SceNpMatching2JoinedSessionInfo> joinedSessionInfo;
be_t<u32> joinedSessionInfoNum;
vm::bptr<SceNpMatching2BinAttr> lobbyMemberBinAttrInternal;
be_t<u32> lobbyMemberBinAttrInternalNum;
u8 padding2[4];
};
// Lobby-internal lobby member information acquisition request parameter
struct SceNpMatching2GetLobbyMemberDataInternalRequest
{
be_t<SceNpMatching2LobbyId> lobbyId;
be_t<SceNpMatching2LobbyMemberId> memberId;
u8 padding[6];
vm::bcptr<SceNpMatching2AttributeId> attrId;
be_t<u32> attrIdNum;
};
// Lobby-internal lobby member information acquisition response data
struct SceNpMatching2GetLobbyMemberDataInternalResponse
{
vm::bptr<SceNpMatching2LobbyMemberDataInternal> lobbyMemberDataInternal;
};
// Request parameters for obtaining a list of lobby-internal lobby member information
struct SceNpMatching2GetLobbyMemberDataInternalListRequest
{
be_t<SceNpMatching2LobbyId> lobbyId;
vm::bptr<SceNpMatching2LobbyMemberId> memberId;
be_t<u32> memberIdNum;
vm::bcptr<SceNpMatching2AttributeId> attrId;
be_t<u32> attrIdNum;
b8 extendedData;
u8 padding[7];
};
// Reponse data for obtaining a list of lobby-internal lobby member information
struct SceNpMatching2GetLobbyMemberDataInternalListResponse
{
vm::bptr<SceNpMatching2LobbyMemberDataInternal> lobbyMemberDataInternal;
be_t<u32> lobbyMemberDataInternalNum;
};
// Request parameters for obtaining Ping information
struct SceNpMatching2SignalingGetPingInfoRequest
{
be_t<SceNpMatching2RoomId> roomId;
u8 reserved[16];
};
// Response data for obtaining Ping information
struct SceNpMatching2SignalingGetPingInfoResponse
{
be_t<SceNpMatching2ServerId> serverId;
u8 padding1[2];
be_t<SceNpMatching2WorldId> worldId;
be_t<SceNpMatching2RoomId> roomId;
be_t<u32> rtt;
u8 reserved[20];
};
// Join request parameters for room in prohibitive mode
struct SceNpMatching2JoinProhibitiveRoomRequest
{
SceNpMatching2JoinRoomRequest joinParam;
vm::bptr<SceNpId> blockedUser;
be_t<u32> blockedUserNum;
};
// Room member update information
struct SceNpMatching2RoomMemberUpdateInfo
{
vm::bptr<SceNpMatching2RoomMemberDataInternal> roomMemberDataInternal;
SceNpMatching2EventCause eventCause;
u8 padding[3];
SceNpMatching2PresenceOptionData optData;
};
// Room owner update information
struct SceNpMatching2RoomOwnerUpdateInfo
{
be_t<SceNpMatching2RoomMemberId> prevOwner;
be_t<SceNpMatching2RoomMemberId> newOwner;
SceNpMatching2EventCause eventCause;
u8 padding[3];
vm::bptr<SceNpMatching2SessionPassword> roomPassword;
SceNpMatching2PresenceOptionData optData;
};
// Room update information
struct SceNpMatching2RoomUpdateInfo
{
SceNpMatching2EventCause eventCause;
u8 padding[3];
be_t<s32> errorCode;
SceNpMatching2PresenceOptionData optData;
};
// Internal room data update information
struct SceNpMatching2RoomDataInternalUpdateInfo
{
vm::bptr<SceNpMatching2RoomDataInternal> newRoomDataInternal;
vm::bptr<SceNpMatching2FlagAttr> newFlagAttr;
vm::bptr<SceNpMatching2FlagAttr> prevFlagAttr;
vm::bptr<SceNpMatching2RoomPasswordSlotMask> newRoomPasswordSlotMask;
vm::bptr<SceNpMatching2RoomPasswordSlotMask> prevRoomPasswordSlotMask;
vm::bpptr<SceNpMatching2RoomGroup> newRoomGroup;
be_t<u32> newRoomGroupNum;
vm::bpptr<SceNpMatching2RoomBinAttrInternal> newRoomBinAttrInternal;
be_t<u32> newRoomBinAttrInternalNum;
};
// Internal room member data update information
struct SceNpMatching2RoomMemberDataInternalUpdateInfo
{
vm::bptr<SceNpMatching2RoomMemberDataInternal> newRoomMemberDataInternal;
vm::bptr<SceNpMatching2FlagAttr> newFlagAttr;
vm::bptr<SceNpMatching2FlagAttr> prevFlagAttr;
vm::bptr<SceNpMatching2TeamId> newTeamId;
vm::bpptr<SceNpMatching2RoomMemberBinAttrInternal> newRoomMemberBinAttrInternal;
be_t<u32> newRoomMemberBinAttrInternalNum;
};
// Room message information
struct SceNpMatching2RoomMessageInfo
{
b8 filtered;
SceNpMatching2CastType castType;
u8 padding[2];
vm::bptr<SceNpMatching2RoomMessageDestination> dst;
vm::bptr<SceNpUserInfo2> srcMember;
vm::bptr<void> msg;
be_t<u32> msgLen;
};
// Lobby member update information
struct SceNpMatching2LobbyMemberUpdateInfo
{
vm::bptr<SceNpMatching2LobbyMemberDataInternal> lobbyMemberDataInternal;
SceNpMatching2EventCause eventCause;
u8 padding[3];
SceNpMatching2PresenceOptionData optData;
};
// Lobby update information
struct SceNpMatching2LobbyUpdateInfo
{
SceNpMatching2EventCause eventCause;
u8 padding[3];
be_t<s32> errorCode;
};
// Lobby-internal lobby member information update information
struct SceNpMatching2LobbyMemberDataInternalUpdateInfo
{
be_t<SceNpMatching2LobbyMemberId> memberId;
u8 padding[2];
SceNpId npId;
be_t<SceNpMatching2FlagAttr> flagFilter;
be_t<SceNpMatching2FlagAttr> newFlagAttr;
SceNpMatching2JoinedSessionInfo newJoinedSessionInfo;
be_t<u32> newJoinedSessionInfoNum;
vm::bptr<SceNpMatching2LobbyMemberBinAttrInternal> newLobbyMemberBinAttrInternal;
be_t<u32> newLobbyMemberBinAttrInternalNum;
};
// Lobby message information
struct SceNpMatching2LobbyMessageInfo
{
b8 filtered;
SceNpMatching2CastType castType;
u8 padding[2];
vm::bptr<SceNpMatching2LobbyMessageDestination> dst;
vm::bptr<SceNpUserInfo2> srcMember;
vm::bcptr<void> msg;
be_t<u32> msgLen;
};
// Lobby invitation message information
struct SceNpMatching2LobbyInvitationInfo
{
SceNpMatching2CastType castType;
u8 padding[3];
vm::bptr<SceNpMatching2LobbyMessageDestination> dst;
vm::bptr<SceNpUserInfo2> srcMember;
SceNpMatching2InvitationData invitationData;
};
// Update information of the signaling option parameter
struct SceNpMatching2SignalingOptParamUpdateInfo
{
SceNpMatching2SignalingOptParam newSignalingOptParam;
};
// Matching2 utility intilization parameters
struct SceNpMatching2UtilityInitParam
{
be_t<u32> containerId;
be_t<u32> requestCbQueueLen;
be_t<u32> sessionEventCbQueueLen;
be_t<u32> sessionMsgCbQueueLen;
u8 reserved[16];
};
// Matching2 memory information
struct SceNpMatching2MemoryInfo
{
be_t<u32> totalMemSize;
be_t<u32> curMemUsage;
be_t<u32> maxMemUsage;
u8 reserved[12];
};
// Matching2 information on the event data queues in the system
struct SceNpMatching2CbQueueInfo
{
be_t<u32> requestCbQueueLen;
be_t<u32> curRequestCbQueueLen;
be_t<u32> maxRequestCbQueueLen;
be_t<u32> sessionEventCbQueueLen;
be_t<u32> curSessionEventCbQueueLen;
be_t<u32> maxSessionEventCbQueueLen;
be_t<u32> sessionMsgCbQueueLen;
be_t<u32> curSessionMsgCbQueueLen;
be_t<u32> maxSessionMsgCbQueueLen;
u8 reserved[12];
};
struct SceNpMatching2SignalingNetInfo
{
be_t<u32> size;
be_t<u32> localAddr;
be_t<u32> mappedAddr;
be_t<u32> natStatus;
};
// NP OAuth Errors
enum SceNpOauthError : u32
{
SCE_NP_OAUTH_ERROR_UNKNOWN = 0x80025f01,
SCE_NP_OAUTH_ERROR_ALREADY_INITIALIZED = 0x80025f02,
SCE_NP_OAUTH_ERROR_NOT_INITIALIZED = 0x80025f03,
SCE_NP_OAUTH_ERROR_INVALID_ARGUMENT = 0x80025f04,
SCE_NP_OAUTH_ERROR_OUT_OF_MEMORY = 0x80025f05,
SCE_NP_OAUTH_ERROR_OUT_OF_BUFFER = 0x80025f06,
SCE_NP_OAUTH_ERROR_BAD_RESPONSE = 0x80025f07,
SCE_NP_OAUTH_ERROR_ABORTED = 0x80025f08,
SCE_NP_OAUTH_ERROR_SIGNED_OUT = 0x80025f09,
SCE_NP_OAUTH_ERROR_REQUEST_NOT_FOUND = 0x80025f0a,
SCE_NP_OAUTH_ERROR_SSL_ERR_CN_CHECK = 0x80025f0b,
SCE_NP_OAUTH_ERROR_SSL_ERR_UNKNOWN_CA = 0x80025f0c,
SCE_NP_OAUTH_ERROR_SSL_ERR_NOT_AFTER_CHECK = 0x80025f0d,
SCE_NP_OAUTH_ERROR_SSL_ERR_NOT_BEFORE_CHECK = 0x80025f0e,
SCE_NP_OAUTH_ERROR_SSL_ERR_INVALID_CERT = 0x80025f0f,
SCE_NP_OAUTH_ERROR_SSL_ERR_INTERNAL = 0x80025f10,
SCE_NP_OAUTH_ERROR_REQUEST_MAX = 0x80025f11,
SCE_NP_OAUTH_SERVER_ERROR_BANNED_CONSOLE = 0x80025d14,
SCE_NP_OAUTH_SERVER_ERROR_INVALID_LOGIN = 0x82e00014,
SCE_NP_OAUTH_SERVER_ERROR_INACTIVE_ACCOUNT = 0x82e0001b,
SCE_NP_OAUTH_SERVER_ERROR_SUSPENDED_ACCOUNT = 0x82e0001c,
SCE_NP_OAUTH_SERVER_ERROR_SUSPENDED_DEVICE = 0x82e0001d,
SCE_NP_OAUTH_SERVER_ERROR_PASSWORD_EXPIRED = 0x82e00064,
SCE_NP_OAUTH_SERVER_ERROR_TOSUA_MUST_BE_RE_ACCEPTED = 0x82e00067,
SCE_NP_OAUTH_SERVER_ERROR_TOSUA_MUST_BE_RE_ACCEPTED_FOR_SUBACCOUNT = 0x82e01042,
SCE_NP_OAUTH_SERVER_ERROR_BANNED_ACCOUNT = 0x82e01050,
SCE_NP_OAUTH_SERVER_ERROR_SERVICE_END = 0x82e1019a,
SCE_NP_OAUTH_SERVER_ERROR_SERVICE_UNAVAILABLE = 0x82e101f7,
};
typedef s32 SceNpAuthOAuthRequestId;
enum
{
SCE_NP_AUTHORIZATION_CODE_MAX_LEN = 128,
SCE_NP_CLIENT_ID_MAX_LEN = 128,
};
struct SceNpClientId
{
char id[SCE_NP_CLIENT_ID_MAX_LEN + 1];
u8 padding[7];
};
struct SceNpAuthorizationCode
{
char code[SCE_NP_AUTHORIZATION_CODE_MAX_LEN + 1];
u8 padding[7];
};
struct SceNpAuthGetAuthorizationCodeParameter
{
be_t<u32> size;
vm::bcptr<SceNpClientId> pClientId;
vm::bcptr<char> pScope;
};
| 55,116
|
C++
|
.h
| 1,471
| 35.724677
| 177
| 0.766877
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,854
|
cellSpurs.h
|
RPCS3_rpcs3/rpcs3/Emu/Cell/Modules/cellSpurs.h
|
#pragma once
#include "cellSync.h"
#include "util/v128.hpp"
struct CellSpurs;
struct CellSpursTaskset;
// Core return codes.
enum CellSpursCoreError : u32
{
CELL_SPURS_CORE_ERROR_AGAIN = 0x80410701,
CELL_SPURS_CORE_ERROR_INVAL = 0x80410702,
CELL_SPURS_CORE_ERROR_NOMEM = 0x80410704,
CELL_SPURS_CORE_ERROR_SRCH = 0x80410705,
CELL_SPURS_CORE_ERROR_PERM = 0x80410709,
CELL_SPURS_CORE_ERROR_BUSY = 0x8041070A,
CELL_SPURS_CORE_ERROR_STAT = 0x8041070F,
CELL_SPURS_CORE_ERROR_ALIGN = 0x80410710,
CELL_SPURS_CORE_ERROR_NULL_POINTER = 0x80410711,
};
//
enum CellSpursPolicyModuleError : u32
{
CELL_SPURS_POLICY_MODULE_ERROR_AGAIN = 0x80410801,
CELL_SPURS_POLICY_MODULE_ERROR_INVAL = 0x80410802,
CELL_SPURS_POLICY_MODULE_ERROR_NOSYS = 0x80410803,
CELL_SPURS_POLICY_MODULE_ERROR_NOMEM = 0x80410804,
CELL_SPURS_POLICY_MODULE_ERROR_SRCH = 0x80410805,
CELL_SPURS_POLICY_MODULE_ERROR_NOENT = 0x80410806,
CELL_SPURS_POLICY_MODULE_ERROR_NOEXEC = 0x80410807,
CELL_SPURS_POLICY_MODULE_ERROR_DEADLK = 0x80410808,
CELL_SPURS_POLICY_MODULE_ERROR_PERM = 0x80410809,
CELL_SPURS_POLICY_MODULE_ERROR_BUSY = 0x8041080A,
CELL_SPURS_POLICY_MODULE_ERROR_ABORT = 0x8041080C,
CELL_SPURS_POLICY_MODULE_ERROR_FAULT = 0x8041080D,
CELL_SPURS_POLICY_MODULE_ERROR_CHILD = 0x8041080E,
CELL_SPURS_POLICY_MODULE_ERROR_STAT = 0x8041080F,
CELL_SPURS_POLICY_MODULE_ERROR_ALIGN = 0x80410810,
CELL_SPURS_POLICY_MODULE_ERROR_NULL_POINTER = 0x80410811,
};
// Task return codes.
enum CellSpursTaskError : u32
{
CELL_SPURS_TASK_ERROR_AGAIN = 0x80410901,
CELL_SPURS_TASK_ERROR_INVAL = 0x80410902,
CELL_SPURS_TASK_ERROR_NOSYS = 0x80410903,
CELL_SPURS_TASK_ERROR_NOMEM = 0x80410904,
CELL_SPURS_TASK_ERROR_SRCH = 0x80410905,
CELL_SPURS_TASK_ERROR_NOEXEC = 0x80410907,
CELL_SPURS_TASK_ERROR_PERM = 0x80410909,
CELL_SPURS_TASK_ERROR_BUSY = 0x8041090A,
CELL_SPURS_TASK_ERROR_FAULT = 0x8041090D,
CELL_SPURS_TASK_ERROR_ALIGN = 0x80410910,
CELL_SPURS_TASK_ERROR_STAT = 0x8041090F,
CELL_SPURS_TASK_ERROR_NULL_POINTER = 0x80410911,
CELL_SPURS_TASK_ERROR_FATAL = 0x80410914,
CELL_SPURS_TASK_ERROR_SHUTDOWN = 0x80410920,
};
enum CellSpursJobError : u32
{
CELL_SPURS_JOB_ERROR_AGAIN = 0x80410A01,
CELL_SPURS_JOB_ERROR_INVAL = 0x80410A02,
CELL_SPURS_JOB_ERROR_NOSYS = 0x80410A03,
CELL_SPURS_JOB_ERROR_NOMEM = 0x80410A04,
CELL_SPURS_JOB_ERROR_SRCH = 0x80410A05,
CELL_SPURS_JOB_ERROR_NOENT = 0x80410A06,
CELL_SPURS_JOB_ERROR_NOEXEC = 0x80410A07,
CELL_SPURS_JOB_ERROR_DEADLK = 0x80410A08,
CELL_SPURS_JOB_ERROR_PERM = 0x80410A09,
CELL_SPURS_JOB_ERROR_BUSY = 0x80410A0A,
CELL_SPURS_JOB_ERROR_JOB_DESCRIPTOR = 0x80410A0B,
CELL_SPURS_JOB_ERROR_JOB_DESCRIPTOR_SIZE = 0x80410A0C,
CELL_SPURS_JOB_ERROR_FAULT = 0x80410A0D,
CELL_SPURS_JOB_ERROR_CHILD = 0x80410A0E,
CELL_SPURS_JOB_ERROR_STAT = 0x80410A0F,
CELL_SPURS_JOB_ERROR_ALIGN = 0x80410A10,
CELL_SPURS_JOB_ERROR_NULL_POINTER = 0x80410A11,
CELL_SPURS_JOB_ERROR_MEMORY_CORRUPTED = 0x80410A12,
CELL_SPURS_JOB_ERROR_MEMORY_SIZE = 0x80410A17,
CELL_SPURS_JOB_ERROR_UNKNOWN_COMMAND = 0x80410A18,
CELL_SPURS_JOB_ERROR_JOBLIST_ALIGNMENT = 0x80410A19,
CELL_SPURS_JOB_ERROR_JOB_ALIGNMENT = 0x80410A1a,
CELL_SPURS_JOB_ERROR_CALL_OVERFLOW = 0x80410A1b,
CELL_SPURS_JOB_ERROR_ABORT = 0x80410A1c,
CELL_SPURS_JOB_ERROR_DMALIST_ELEMENT = 0x80410A1d,
CELL_SPURS_JOB_ERROR_NUM_CACHE = 0x80410A1e,
CELL_SPURS_JOB_ERROR_INVALID_BINARY = 0x80410A1f,
};
// SPURS defines.
enum SPURSKernelInterfaces : u32
{
CELL_SPURS_MAX_SPU = 8,
CELL_SPURS_MAX_WORKLOAD = 16,
CELL_SPURS_MAX_WORKLOAD2 = 32,
CELL_SPURS_SYS_SERVICE_WORKLOAD_ID = 32,
CELL_SPURS_MAX_PRIORITY = 16,
CELL_SPURS_NAME_MAX_LENGTH = 15,
CELL_SPURS_SIZE = 4096,
CELL_SPURS_SIZE2 = 8192,
CELL_SPURS_INTERRUPT_VECTOR = 0x0,
CELL_SPURS_LOCK_LINE = 0x80,
CELL_SPURS_KERNEL_DMA_TAG_ID = 31,
CELL_SPURS_KERNEL1_ENTRY_ADDR = 0x818,
CELL_SPURS_KERNEL2_ENTRY_ADDR = 0x848,
CELL_SPURS_KERNEL1_EXIT_ADDR = 0x808,
CELL_SPURS_KERNEL2_EXIT_ADDR = 0x838,
CELL_SPURS_KERNEL1_SELECT_WORKLOAD_ADDR = 0x290,
CELL_SPURS_KERNEL2_SELECT_WORKLOAD_ADDR = 0x290,
};
enum RangeofEventQueuePortNumbers
{
CELL_SPURS_STATIC_PORT_RANGE_BOTTOM = 15,
CELL_SPURS_DYNAMIC_PORT_RANGE_TOP = 16,
CELL_SPURS_DYNAMIC_PORT_RANGE_BOTTOM = 63,
};
enum SpursAttrFlags : u32
{
SAF_NONE = 0x00000000,
SAF_EXIT_IF_NO_WORK = 0x00000001,
SAF_UNKNOWN_FLAG_30 = 0x00000002,
SAF_SECOND_VERSION = 0x00000004,
SAF_UNKNOWN_FLAG_9 = 0x00400000,
SAF_UNKNOWN_FLAG_8 = 0x00800000,
SAF_UNKNOWN_FLAG_7 = 0x01000000,
SAF_SYSTEM_WORKLOAD_ENABLED = 0x02000000,
SAF_SPU_PRINTF_ENABLED = 0x10000000,
SAF_SPU_TGT_EXCLUSIVE_NON_CONTEXT = 0x20000000,
SAF_SPU_MEMORY_CONTAINER_SET = 0x40000000,
SAF_UNKNOWN_FLAG_0 = 0x80000000,
};
enum SpursFlags1 : u8
{
SF1_NONE = 0x00,
SF1_32_WORKLOADS = 0x40,
SF1_EXIT_IF_NO_WORK = 0x80,
};
enum SpursWorkloadState : u8
{
// Workload states
SPURS_WKL_STATE_NON_EXISTENT = 0,
SPURS_WKL_STATE_PREPARING = 1,
SPURS_WKL_STATE_RUNNABLE = 2,
SPURS_WKL_STATE_SHUTTING_DOWN = 3,
SPURS_WKL_STATE_REMOVABLE = 4,
SPURS_WKL_STATE_INVALID = 5,
};
enum SpursImgAddrConstants : u32
{
// Image addresses
SPURS_IMG_ADDR_SYS_SRV_WORKLOAD = 0x100,
SPURS_IMG_ADDR_TASKSET_PM = 0x200,
};
enum SpursWorkloadGUIDs : u64
{
// GUID
SPURS_GUID_SYS_WKL = 0x1BB841BF38F89D33ull,
SPURS_GUID_TASKSET_PM = 0x836E915B2E654143ull,
};
enum CellSpursModulePollStatus
{
CELL_SPURS_MODULE_POLL_STATUS_READYCOUNT = 1,
CELL_SPURS_MODULE_POLL_STATUS_SIGNAL = 2,
CELL_SPURS_MODULE_POLL_STATUS_FLAG = 4
};
enum SpursTraceConstants
{
// Trace tag types
CELL_SPURS_TRACE_TAG_KERNEL = 0x20,
CELL_SPURS_TRACE_TAG_SERVICE = 0x21,
CELL_SPURS_TRACE_TAG_TASK = 0x22,
CELL_SPURS_TRACE_TAG_JOB = 0x23,
CELL_SPURS_TRACE_TAG_OVIS = 0x24,
CELL_SPURS_TRACE_TAG_LOAD = 0x2a,
CELL_SPURS_TRACE_TAG_MAP = 0x2b,
CELL_SPURS_TRACE_TAG_START = 0x2c,
CELL_SPURS_TRACE_TAG_STOP = 0x2d,
CELL_SPURS_TRACE_TAG_USER = 0x2e,
CELL_SPURS_TRACE_TAG_GUID = 0x2f,
// Service incident
CELL_SPURS_TRACE_SERVICE_INIT = 0x01,
CELL_SPURS_TRACE_SERVICE_WAIT = 0x02,
CELL_SPURS_TRACE_SERVICE_EXIT = 0x03,
// Task incident
CELL_SPURS_TRACE_TASK_DISPATCH = 0x01,
CELL_SPURS_TRACE_TASK_YIELD = 0x03,
CELL_SPURS_TRACE_TASK_WAIT = 0x04,
CELL_SPURS_TRACE_TASK_EXIT = 0x05,
// Trace mode flags
CELL_SPURS_TRACE_MODE_FLAG_WRAP_BUFFER = 0x1,
CELL_SPURS_TRACE_MODE_FLAG_SYNCHRONOUS_START_STOP = 0x2,
CELL_SPURS_TRACE_MODE_FLAG_MASK = 0x3,
};
// SPURS task constants
enum SpursTaskConstants
{
CELL_SPURS_MAX_TASK = 128,
CELL_SPURS_TASK_TOP = 0x3000,
CELL_SPURS_TASK_BOTTOM = 0x40000,
CELL_SPURS_MAX_TASK_NAME_LENGTH = 32,
CELL_SPURS_TASK_ATTRIBUTE_REVISION = 1,
CELL_SPURS_TASKSET_ATTRIBUTE_REVISION = 1,
CELL_SPURS_TASK_EXECUTION_CONTEXT_SIZE = 1024,
CELL_SPURS_TASKSET_PM_ENTRY_ADDR = 0xA00,
CELL_SPURS_TASKSET_PM_SYSCALL_ADDR = 0xA70,
// Task syscall numbers
CELL_SPURS_TASK_SYSCALL_EXIT = 0,
CELL_SPURS_TASK_SYSCALL_YIELD = 1,
CELL_SPURS_TASK_SYSCALL_WAIT_SIGNAL = 2,
CELL_SPURS_TASK_SYSCALL_POLL = 3,
CELL_SPURS_TASK_SYSCALL_RECV_WKL_FLAG = 4,
// Task poll status
CELL_SPURS_TASK_POLL_FOUND_TASK = 1,
CELL_SPURS_TASK_POLL_FOUND_WORKLOAD = 2,
};
enum CellSpursEventFlagWaitMode
{
CELL_SPURS_EVENT_FLAG_OR = 0,
CELL_SPURS_EVENT_FLAG_AND = 1,
CELL_SPURS_EVENT_FLAG_WAIT_MODE_LAST = CELL_SPURS_EVENT_FLAG_AND,
};
enum CellSpursEventFlagClearMode
{
CELL_SPURS_EVENT_FLAG_CLEAR_AUTO = 0,
CELL_SPURS_EVENT_FLAG_CLEAR_MANUAL = 1,
CELL_SPURS_EVENT_FLAG_CLEAR_LAST = CELL_SPURS_EVENT_FLAG_CLEAR_MANUAL,
};
enum CellSpursEventFlagDirection
{
CELL_SPURS_EVENT_FLAG_SPU2SPU,
CELL_SPURS_EVENT_FLAG_SPU2PPU,
CELL_SPURS_EVENT_FLAG_PPU2SPU,
CELL_SPURS_EVENT_FLAG_ANY2ANY,
CELL_SPURS_EVENT_FLAG_LAST = CELL_SPURS_EVENT_FLAG_ANY2ANY,
};
enum CellSpursJobOpcode : u64
{
CELL_SPURS_JOB_OPCODE_NOP = 0,
CELL_SPURS_JOB_OPCODE_RESET_PC = 1,
CELL_SPURS_JOB_OPCODE_SYNC = 2 | (0 << 3),
CELL_SPURS_JOB_OPCODE_LWSYNC = 2 | (2 << 3),
CELL_SPURS_JOB_OPCODE_SYNC_LABEL = 2 | (1 << 3),
CELL_SPURS_JOB_OPCODE_LWSYNC_LABEL = 2 | (3 << 3),
CELL_SPURS_JOB_OPCODE_NEXT = 3,
CELL_SPURS_JOB_OPCODE_CALL = 4,
CELL_SPURS_JOB_OPCODE_FLUSH = 5,
CELL_SPURS_JOB_OPCODE_JOBLIST = 6,
CELL_SPURS_JOB_OPCODE_ABORT = 7 | (0 << 3),
CELL_SPURS_JOB_OPCODE_GUARD = 7 | (1 << 3),
CELL_SPURS_JOB_OPCODE_SET_LABEL = 7 | (2 << 3),
CELL_SPURS_JOB_OPCODE_RET = 7 | (14 << 3),
CELL_SPURS_JOB_OPCODE_END = 7 | (15 << 3),
CELL_SPURS_JOB_OPCODE_JTS = 0x800000000ull | CELL_SPURS_JOB_OPCODE_LWSYNC,
};
enum CellSpursJobChainRevision : u32
{
CELL_SPURS_JOB_REVISION_0 = 0,
CELL_SPURS_JOB_REVISION_1 = 1,
CELL_SPURS_JOB_REVISION_2 = 2,
CELL_SPURS_JOB_REVISION_3 = 3,
};
// Event flag constants
enum SpursEventFlagConstants
{
CELL_SPURS_EVENT_FLAG_MAX_WAIT_SLOTS = 16,
CELL_SPURS_EVENT_FLAG_INVALID_SPU_PORT = 0xFF,
};
struct alignas(16) CellSpursWorkloadFlag
{
be_t<u64> unused0;
be_t<u32> unused1;
atomic_be_t<u32> flag;
};
CHECK_SIZE_ALIGN(CellSpursWorkloadFlag, 16, 16);
struct CellSpursInfo
{
be_t<s32> nSpus; // 0x00
be_t<s32> spuThreadGroupPriority; // 0x04
be_t<s32> ppuThreadPriority; // 0x08
b8 exitIfNoWork; // 0x0C
b8 spurs2; // 0x0D
u8 padding24[2]; // 0x0E
vm::bptr<void> traceBuffer; // 0x10
be_t<u32> padding32; // 0x14
be_t<u64> traceBufferSize; // 0x18
be_t<u32> traceMode; // 0x20
be_t<u32> spuThreadGroup; // 0x24
be_t<u32> spuThreads[8]; // 0x28
be_t<u64> spursHandlerThread0; // 0x48
be_t<u64> spursHandlerThread1; // 0x50
char namePrefix[16]; // 0x58
be_t<u32> namePrefixLength; // 0x68
be_t<u32> deadlineMissCounter; // 0x6C
be_t<u32> deadlineMeetCounter; // 0x70
u8 padding[164]; // 0x74
};
CHECK_SIZE(CellSpursInfo, 280);
struct alignas(8) CellSpursAttribute
{
be_t<u32> revision; // 0x0
be_t<u32> sdkVersion; // 0x4
be_t<u32> nSpus; // 0x8
be_t<s32> spuPriority; // 0xC
be_t<s32> ppuPriority; // 0x10
b8 exitIfNoWork; // 0x14
char prefix[15]; // 0x15 (not a NTS)
be_t<u32> prefixSize; // 0x24
be_t<u32> flags; // 0x28 (SpursAttrFlags)
be_t<u32> container; // 0x2C
be_t<u32> unk0; // 0x30
be_t<u32> unk1; // 0x34
u8 swlPriority[8]; // 0x38
be_t<u32> swlMaxSpu; // 0x40
be_t<u32> swlIsPreem; // 0x44
u8 padding[440];
};
CHECK_SIZE_ALIGN(CellSpursAttribute, 512, 8);
using CellSpursShutdownCompletionEventHook = void(vm::ptr<CellSpurs> spurs, u32 wid, vm::ptr<void> arg);
struct alignas(16) CellSpursTraceInfo
{
be_t<u32> spuThread[8]; // 0x00
be_t<u32> count[8]; // 0x20
be_t<u32> spuThreadGroup; // 0x40
be_t<u32> numSpus; // 0x44
u8 padding[56];
};
CHECK_SIZE_ALIGN(CellSpursTraceInfo, 128, 16);
struct CellSpursTraceHeader
{
u8 tag;
u8 length;
u8 spu;
u8 workload;
be_t<u32> time;
};
struct CellSpursTraceControlData
{
be_t<u32> incident;
be_t<u32> reserved;
};
struct CellSpursTraceServiceData
{
be_t<u32> incident;
be_t<u32> reserved;
};
struct CellSpursTraceTaskData
{
be_t<u32> incident;
be_t<u32> taskId;
};
struct CellSpursTraceJobData
{
u8 reserved[3];
u8 binLSAhigh8;
be_t<u32> jobDescriptor;
};
struct CellSpursTraceLoadData
{
be_t<u32> ea;
be_t<u16> ls;
be_t<u16> size;
};
struct CellSpursTraceMapData
{
be_t<u32> offset;
be_t<u16> ls;
be_t<u16> size;
};
struct CellSpursTraceStartData
{
char _module[4];
be_t<u16> level;
be_t<u16> ls;
};
struct alignas(16) CellSpursTracePacket
{
CellSpursTraceHeader header;
union
{
CellSpursTraceControlData control;
CellSpursTraceServiceData service;
CellSpursTraceTaskData task;
CellSpursTraceJobData job;
CellSpursTraceLoadData load;
CellSpursTraceMapData map;
CellSpursTraceStartData start;
be_t<u64> stop;
be_t<u64> user;
be_t<u64> guid;
be_t<u64> raw;
}
data;
};
CHECK_SIZE_ALIGN(CellSpursTracePacket, 16, 16);
struct CellSpursJobChain;
struct CellSpursExceptionInfo;
using CellSpursJobChainExceptionEventHandler = void(vm::ptr<CellSpurs> spurs, vm::ptr<CellSpursJobChain> jobChain, vm::cptr<CellSpursExceptionInfo> info
, vm::cptr<void> eaJobBinary, u32 lsAddrJobBinary, vm::ptr<void> arg);
struct alignas(128) CellSpursJobChain
{
vm::bcptr<u64, u64> pc; // 0x00
vm::bcptr<u64, u64> linkRegister[3]; // 0x08
u8 unk0[0x3]; // 0x20
b8 isHalted; // 0x23
b8 autoReadyCount; // 0x24
u8 unk1[0x3]; // 0x25
u8 initSpuCount; // 0x28
u8 unk5; // 0x29
u8 tag1; // 0x2A
u8 tag2; // 0x2B
u8 val2C; // 0x2C
u8 jmVer; // 0x2D
u8 val2E; // 0x2E
u8 val2F; // 0x2F
atomic_be_t<u64> urgentCmds[4]; // 0x30
u8 unk2[0x20]; // 0x50
atomic_be_t<u16> maxGrabbedJob; // 0x70
be_t<u16> sizeJobDescriptor; // 0x72
be_t<u32> workloadId; // 0x74
vm::bptr<CellSpurs, u64> spurs; // 0x78
be_t<s32> error; // 0x80
be_t<u32> unk3; // 0x84
vm::bptr<void, u64> cause; // 0x88
be_t<u32> sdkVer; // 0x90
u8 jobMemoryCheck; // 0x94 (unlike Attribute::jobMmeoryCheck it is not a boolean but a bitset it seems)
u8 unk4[0x3]; // 0x95
vm::bptr<CellSpursJobChainExceptionEventHandler, u64> exceptionEventHandler; // 0x98
vm::bptr<void, u64> exceptionEventHandlerArgument; // 0xA0
u8 unk6[0x100 - 0xA8];
};
struct alignas(128) CellSpursJobChain_x00
{
vm::bcptr<u64, u64> pc; // 0x00
vm::bcptr<u64, u64> linkRegister[3]; // 0x08
u8 unk0[0x3]; // 0x20
b8 isHalted; // 0x23
b8 autoReadyCount; // 0x24
u8 unk1[0x3]; // 0x25
u8 initSpuCount; // 0x28
u8 unk5; // 0x29
u8 tag1; // 0x2A
u8 tag2; // 0x2B
u8 val2C; // 0x2C
u8 jmVer; // 0x2D
u8 val2E; // 0x2E
u8 val2F; // 0x2F
be_t<u64> urgentCmds[4]; // 0x30
u8 unk2[0x20]; // 0x50
be_t<u16> maxGrabbedJob; // 0x70
be_t<u16> sizeJobDescriptor; // 0x72
be_t<u32> workloadId; // 0x74
vm::bptr<CellSpurs, u64> spurs; // 0x78
};
struct CellSpursJobChainInfo
{
be_t<u64> urgentCommandSlot[4]; // 0x00
vm::bcptr<u64> programCounter; // 0x20
vm::bcptr<u64> linkRegister[3]; // 0x24
vm::bcptr<void> cause; // 0x30
be_t<u32> statusCode; // 0x34
be_t<u32> maxSizeJobDescriptor; // 0x38
be_t<u32> idWorkload; // 0x3C
b8 autoReadyCount; // 0x40
b8 isHalted; // 0x41
b8 isFixedMemAlloc; // 0x42
u8 padding8; // 0x43
u16 maxGrabbedJob; // 0x44
u16 padding16; // 0x46
vm::bcptr<char> name; // 0x48
vm::bptr<CellSpursJobChainExceptionEventHandler> exceptionEventHandler; // 0x4C
vm::bptr<void> exceptionEventHandlerArgument; // 0x50
};
struct alignas(8) CellSpursJobChainAttribute
{
be_t<u32> jmVer; // 0x00
be_t<u32> sdkVer; // 0x04
vm::bcptr<u64> jobChainEntry; // 0x08
be_t<u16> sizeJobDescriptor; // 0x0C
be_t<u16> maxGrabbedJob; // 0x0E
u8 priorities[8]; // 0x10
be_t<u32> maxContention; // 0x18
b8 autoSpuCount; // 0x1C
u8 padding[3]; // 0x1D
be_t<u32> tag1; // 0x20
be_t<u32> tag2; // 0x24
b8 isFixedMemAlloc; // 0x28
u8 padding1[3]; // 0x29
be_t<u32> maxSizeJobDescriptor; // 0x2C
be_t<u32> initSpuCount; // 0x30
be_t<u32> haltOnError; // 0x34
vm::bcptr<char> name; // 0x38
b8 jobMemoryCheck; // 0x3C
};
struct CellSpursWorkloadInfo
{
be_t<u64> data; // 0x00
u8 priority[8]; // 0x08
vm::bcptr<void> policyModule; // 0x10
be_t<u32> sizePolicyModule; // 0x14
vm::bcptr<char> nameClass; // 0x18
vm::bcptr<char> nameInstance; // 0x1C
u8 contention; // 0x20
u8 minContention; // 0x21
u8 maxContention; // 0x22
u8 readyCount; // 0x23
u8 idleSpuRequest; // 0x24
u8 hasSignal; // 0x25
u8 padding[2]; // 0x26
vm::bptr<void> shutdownCompletionEventHook; // 0x28
vm::bptr<void> shutdownCompletionEventHookArgument; // 0x2C
};
struct alignas(128) CellSpursJobGuard
{
atomic_be_t<u32> ncount0; // 0x00
be_t<u32> ncount1; // 0x04
vm::bptr<CellSpursJobChain> jobChain; // 0x0C
be_t<u32> unk0;
be_t<u32> requestSpuCount; // 0x10
be_t<u32> unk1[3];
be_t<u32> autoReset; // 0x20
be_t<u32> unk2[3];
be_t<u32> zero; // 0x30
u8 unk3[0x80 - 0x34];
};
CHECK_SIZE_ALIGN(CellSpursJobGuard, 128, 128);
struct alignas(128) CellSpursJobGuard_x00
{
be_t<u32> ncount0; // 0x00
be_t<u32> ncount1; // 0x04
vm::bptr<CellSpursJobChain> jobChain; // 0x0C
be_t<u32> unk0;
be_t<u32> requestSpuCount; // 0x10
be_t<u32> unk1[3];
be_t<u32> autoReset; // 0x20
be_t<u32> unk2[3];
be_t<u32> zero; // 0x30
u8 unk3[0x80 - 0x34];
};
CHECK_SIZE_ALIGN(CellSpursJobGuard_x00, 128, 128);
// Core CellSpurs structures
struct alignas(128) CellSpurs
{
struct _sub_str1
{
u8 unk0[0x20]; // 0x00 - SPU exception handler 0x08 - SPU exception handler args
be_t<u64> sem; // 0x20
atomic_be_t<u32> x28; // 0x28
be_t<u32> x2C; // 0x2C
vm::bptr<CellSpursShutdownCompletionEventHook, u64> hook; // 0x30
vm::bptr<void, u64> hookArg; // 0x38
u8 unk2[0x40];
};
CHECK_SIZE(_sub_str1, 128);
struct EventPortMux;
using EventHandlerCallback = void(vm::ptr<EventPortMux>, u64 data);
struct EventHandlerListNode
{
vm::bptr<EventHandlerListNode, u64> next;
be_t<u64> data;
vm::bptr<EventHandlerCallback, u64> handler;
};
struct EventPortMux
{
atomic_be_t<u32> reqPending; // 0x00
be_t<u32> spuPort; // 0x04
be_t<u32> x08; // 0x08
be_t<u32> x0C; // 0x0C
be_t<u64> eventPort; // 0x10
atomic_t<vm::bptr<EventHandlerListNode, u64>> handlerList; // 0x18
u8 x20[0x80 - 0x20]; // 0x20
};
CHECK_SIZE(EventPortMux, 128);
struct WorkloadInfo
{
vm::bcptr<void, u64> addr; // 0x00 Address of the executable
be_t<u64> arg; // 0x08 Argument
be_t<u32> size; // 0x10 Size of the executable
atomic_t<u8> uniqueId; // 0x14 Unique id of the workload. It is the same for all workloads with the same addr.
u8 pad[3];
union
{
atomic_t<u64> prio64;
u8 priority[8]; // 0x18 Priority of the workload on each SPU
};
};
CHECK_SIZE(WorkloadInfo, 32);
struct _sub_str4
{
vm::bcptr<char, u64> nameClass;
vm::bcptr<char, u64> nameInstance;
};
atomic_t<u8> wklReadyCount1[0x10]; // 0x00 Number of SPUs requested by each workload (0..15 wids).
atomic_t<u8> wklIdleSpuCountOrReadyCount2[0x10]; // 0x10 SPURS1: Number of idle SPUs requested by each workload (0..15 wids). SPURS2: Number of SPUs requested by each workload (16..31 wids).
u8 wklCurrentContention[0x10]; // 0x20 Number of SPUs used by each workload. SPURS1: index = wid. SPURS2: packed 4-bit data, index = wid % 16, internal index = wid / 16.
u8 wklPendingContention[0x10]; // 0x30 Number of SPUs that are pending to context switch to the workload. SPURS1: index = wid. SPURS2: packed 4-bit data, index = wid % 16, internal index = wid / 16.
u8 wklMinContention[0x10]; // 0x40 Min SPUs required for each workload. SPURS1: index = wid. SPURS2: Unused.
atomic_t<u8> wklMaxContention[0x10]; // 0x50 Max SPUs that may be allocated to each workload. SPURS1: index = wid. SPURS2: packed 4-bit data, index = wid % 16, internal index = wid / 16.
CellSpursWorkloadFlag wklFlag; // 0x60
atomic_be_t<u16> wklSignal1; // 0x70 Bitset for 0..15 wids
atomic_t<u8> sysSrvMessage; // 0x72
u8 spuIdling; // 0x73
u8 flags1; // 0x74 Type is SpursFlags1
u8 sysSrvTraceControl; // 0x75
u8 nSpus; // 0x76
atomic_t<u8> wklFlagReceiver; // 0x77
atomic_be_t<u16> wklSignal2; // 0x78 Bitset for 16..32 wids
u8 x7A[6]; // 0x7A
atomic_t<SpursWorkloadState> wklState1[0x10]; // 0x80
u8 wklStatus1[0x10]; // 0x90
atomic_t<u8> wklEvent1[0x10]; // 0xA0
atomic_be_t<u32> wklEnabled; // 0xB0
atomic_be_t<u32> wklMskB; // 0xB4 - System service - Available module id
u32 xB8; // 0xB8
u8 sysSrvExitBarrier; // 0xBC
atomic_t<u8> sysSrvMsgUpdateWorkload; // 0xBD
u8 xBE; // 0xBE
u8 sysSrvMsgTerminate; // 0xBF
u8 sysSrvPreemptWklId[8]; // 0xC0 Id of the workload that was preempted by the system workload on each SPU
u8 sysSrvOnSpu; // 0xC8
u8 spuPort; // 0xC9
u8 xCA; // 0xCA
u8 xCB; // 0xCB
struct SrvTraceSyncVar
{
u8 sysSrvTraceInitialised; // 0xCC
u8 sysSrvNotifyUpdateTraceComplete; // 0xCD
u8 sysSrvMsgUpdateTrace; // 0xCE
u8 xCF;
};
atomic_t<SrvTraceSyncVar> sysSrvTrace; // 0xCC
atomic_t<SpursWorkloadState> wklState2[0x10]; // 0xD0
u8 wklStatus2[0x10]; // 0xE0
atomic_t<u8> wklEvent2[0x10]; // 0xF0
_sub_str1 wklF1[0x10]; // 0x100
vm::bptr<CellSpursTraceInfo, u64> traceBuffer; // 0x900
be_t<u32> traceStartIndex[6]; // 0x908
u8 unknown7[0x948 - 0x920]; // 0x920
be_t<u64> traceDataSize; // 0x948
be_t<u32> traceMode; // 0x950
u8 unknown8[0x980 - 0x954]; // 0x954
be_t<u64> semPrv; // 0x980
be_t<u32> unk11; // 0x988
be_t<u32> unk12; // 0x98C
be_t<u64> unk13; // 0x990
u8 unknown4[0xB00 - 0x998];
WorkloadInfo wklInfo1[0x10]; // 0xB00
WorkloadInfo wklInfoSysSrv; // 0xD00
be_t<u64> ppu0; // 0xD20 Handler thread
be_t<u64> ppu1; // 0xD28
be_t<u32> spuTG; // 0xD30 SPU thread group
be_t<u32> spus[8]; // 0xD34
u8 unknown3[0xD5C - 0xD54];
be_t<u32> eventQueue; // 0xD5C
be_t<u32> eventPort; // 0xD60
atomic_t<u8> handlerDirty; // 0xD64
atomic_t<u8> handlerWaiting; // 0xD65
atomic_t<u8> handlerExiting; // 0xD66
u8 xD67; // 0xD67
atomic_be_t<u32> enableEH; // 0xD68
be_t<u32> exception; // 0xD6C
sys_spu_image spuImg; // 0xD70
be_t<u32> flags; // 0xD80
be_t<s32> spuPriority; // 0xD84
be_t<u32> ppuPriority; // 0xD88
char prefix[0x0f]; // 0xD8C
u8 prefixSize; // 0xD9B
be_t<u32> unk5; // 0xD9C
be_t<u32> revision; // 0xDA0
be_t<u32> sdkVersion; // 0xDA4
atomic_be_t<u64> spuPortBits; // 0xDA8
sys_lwmutex_t mutex; // 0xDB0
sys_lwcond_t cond; // 0xDC8
u8 unknown9[0xE00 - 0xDD0];
_sub_str4 wklH1[0x10]; // 0xE00
EventPortMux eventPortMux; // 0xF00
atomic_be_t<u64> globalSpuExceptionHandler; // 0xF80
be_t<u64> globalSpuExceptionHandlerArgs; // 0xF88
u8 unknown6[0x1000 - 0xF90];
WorkloadInfo wklInfo2[0x10]; // 0x1000
_sub_str1 wklF2[0x10]; // 0x1200
_sub_str4 wklH2[0x10]; // 0x1A00
u8 unknown_[0x2000 - 0x1B00];
u32 max_workloads() const
{
return (flags1 & SF1_32_WORKLOADS ? CELL_SPURS_MAX_WORKLOAD2 : CELL_SPURS_MAX_WORKLOAD);
}
atomic_t<SpursWorkloadState>& wklState(u32 wid)
{
if (wid & 0x10)
{
return wklState2[wid & 0xf];
}
else
{
return wklState1[wid & 0xf];
}
}
u8 wklStatus(u32 wid) const
{
if (wid & 0x10)
{
return atomic_storage<u8>::load(wklStatus2[wid & 0xf]);
}
else
{
return atomic_storage<u8>::load(wklStatus1[wid & 0xf]);
}
}
atomic_t<u8>& wklEvent(u32 wid)
{
if (wid & 0x10)
{
return wklEvent2[wid & 0xf];
}
else
{
return wklEvent1[wid & 0xf];
}
}
atomic_t<u8>& readyCount(u32 wid)
{
if (wid < 0x10)
{
return wklReadyCount1[wid & 0xf];
}
else
{
return wklIdleSpuCountOrReadyCount2[wid & 0xf];
}
}
_sub_str1& wklSyncInfo(u32 wid)
{
if (wid & 0x10)
{
return wklF2[wid & 0xf];
}
else
{
return wklF1[wid & 0xf];
}
}
_sub_str4& wklName(u32 wid)
{
if (wid & 0x10)
{
return wklH2[wid & 0xf];
}
else
{
return wklH1[wid & 0xf];
}
}
WorkloadInfo& wklInfo(u32 wid)
{
if (wid & 0x10)
{
return wklInfo2[wid & 0xf];
}
else
{
return wklInfo1[wid & 0xf];
}
}
};
CHECK_SIZE_ALIGN(CellSpurs, 0x2000, 128);
using CellSpurs2 = CellSpurs;
struct CellSpursExceptionInfo
{
be_t<u32> spu_thread;
be_t<u32> spu_npc;
be_t<u32> cause;
be_t<u64> option;
};
// Exception handler
using CellSpursGlobalExceptionEventHandler = void(vm::ptr<CellSpurs> spurs, vm::cptr<CellSpursExceptionInfo> info, u32 id, vm::ptr<void> arg);
struct CellSpursWorkloadAttribute
{
be_t<u32> revision;
be_t<u32> sdkVersion;
vm::bcptr<void> pm;
be_t<u32> size;
be_t<u64> data;
u8 priority[8];
be_t<u32> minContention;
be_t<u32> maxContention;
vm::bcptr<char> nameClass;
vm::bcptr<char> nameInstance;
vm::bptr<CellSpursShutdownCompletionEventHook> hook;
vm::bptr<void> hookArg;
u8 padding[456];
};
CHECK_SIZE_ALIGN(CellSpursWorkloadAttribute, 512, 8);
struct alignas(128) CellSpursEventFlag
{
struct ControlSyncVar
{
be_t<u16> events; // 0x00 Event bits
be_t<u16> spuTaskPendingRecv; // 0x02 A bit is set to 1 when the condition of the SPU task using the slot are met and back to 0 when the SPU task unblocks
be_t<u16> ppuWaitMask; // 0x04 Wait mask for blocked PPU thread
u8 ppuWaitSlotAndMode; // 0x06 Top 4 bits: Wait slot number of the blocked PPU threads, Bottom 4 bits: Wait mode of the blocked PPU thread
u8 ppuPendingRecv; // 0x07 Set to 1 when the blocked PPU thread's conditions are met and back to 0 when the PPU thread is unblocked
};
union
{
atomic_t<ControlSyncVar> ctrl; // 0x00
atomic_be_t<u16> events; // 0x00
};
be_t<u16> spuTaskUsedWaitSlots; // 0x08 A bit is set to 1 if the wait slot corresponding to the bit is used by an SPU task and 0 otherwise
be_t<u16> spuTaskWaitMode; // 0x0A A bit is set to 1 if the wait mode for the SPU task corresponding to the bit is AND and 0 otherwise
u8 spuPort; // 0x0C
u8 isIwl; // 0x0D
u8 direction; // 0x0E
u8 clearMode; // 0x0F
be_t<u16> spuTaskWaitMask[16]; // 0x10 Wait mask for blocked SPU tasks
be_t<u16> pendingRecvTaskEvents[16]; // 0x30 The value of event flag when the wait condition for the thread/task was met
u8 waitingTaskId[16]; // 0x50 Task id of waiting SPU threads
u8 waitingTaskWklId[16]; // 0x60 Workload id of waiting SPU threads
be_t<u64> addr; // 0x70
be_t<u32> eventPortId; // 0x78
be_t<u32> eventQueueId; // 0x7C
};
CHECK_SIZE_ALIGN(CellSpursEventFlag, 128, 128);
struct alignas(128) CellSpursEventFlag_x00
{
struct alignas(8) ControlSyncVar
{
be_t<u16> events; // 0x00 Event bits
be_t<u16> spuTaskPendingRecv; // 0x02 A bit is set to 1 when the condition of the SPU task using the slot are met and back to 0 when the SPU task unblocks
be_t<u16> ppuWaitMask; // 0x04 Wait mask for blocked PPU thread
u8 ppuWaitSlotAndMode; // 0x06 Top 4 bits: Wait slot number of the blocked PPU threads, Bottom 4 bits: Wait mode of the blocked PPU thread
u8 ppuPendingRecv; // 0x07 Set to 1 when the blocked PPU thread's conditions are met and back to 0 when the PPU thread is unblocked
};
ControlSyncVar ctrl; // 0x00
be_t<u16> spuTaskUsedWaitSlots; // 0x08 A bit is set to 1 if the wait slot corresponding to the bit is used by an SPU task and 0 otherwise
be_t<u16> spuTaskWaitMode; // 0x0A A bit is set to 1 if the wait mode for the SPU task corresponding to the bit is AND and 0 otherwise
u8 spuPort; // 0x0C
u8 isIwl; // 0x0D
u8 direction; // 0x0E
u8 clearMode; // 0x0F
be_t<u16> spuTaskWaitMask[16]; // 0x10 Wait mask for blocked SPU tasks
be_t<u16> pendingRecvTaskEvents[16]; // 0x30 The value of event flag when the wait condition for the thread/task was met
u8 waitingTaskId[16]; // 0x50 Task id of waiting SPU threads
u8 waitingTaskWklId[16]; // 0x60 Workload id of waiting SPU threads
be_t<u64> addr; // 0x70
be_t<u32> eventPortId; // 0x78
be_t<u32> eventQueueId; // 0x7C
};
using CellSpursLFQueue = CellSyncLFQueue;
union CellSpursTaskArgument
{
be_t<u32> _u32[4];
be_t<u64> _u64[2];
};
union CellSpursTaskLsPattern
{
be_t<u32> _u32[4];
be_t<u64> _u64[2];
};
struct alignas(16) CellSpursTaskAttribute
{
u8 reserved[256];
};
CHECK_SIZE_ALIGN(CellSpursTaskAttribute, 256, 16);
struct alignas(16) CellSpursTaskAttribute2
{
be_t<u32> revision;
be_t<u32> sizeContext;
be_t<u64> eaContext;
CellSpursTaskLsPattern lsPattern;
vm::bcptr<char> name;
u8 reserved[220];
};
CHECK_SIZE_ALIGN(CellSpursTaskAttribute2, 256, 16);
// Exception handler
using CellSpursTasksetExceptionEventHandler = void(vm::ptr<CellSpurs> spurs, vm::ptr<CellSpursTaskset> taskset, u32 idTask, vm::cptr<CellSpursExceptionInfo> info, vm::ptr<void> arg);
struct alignas(128) CellSpursTaskExitCode
{
u8 skip[128];
};
CHECK_SIZE_ALIGN(CellSpursTaskExitCode, 128, 128);
struct CellSpursTaskInfo
{
CellSpursTaskLsPattern lsPattern;
CellSpursTaskArgument argument;
vm::bptr<void> eaElf;
vm::bptr<void> eaContext;
be_t<u32> sizeContext;
u8 state;
u8 hasSignal;
u8 padding[2];
vm::bcptr<CellSpursTaskExitCode> eaTaskExitCode;
u8 guid[8];
u8 reserved[12];
};
CHECK_SIZE(CellSpursTaskInfo, 72);
struct CellSpursTasksetInfo
{
CellSpursTaskInfo taskInfo[CELL_SPURS_MAX_TASK];
be_t<u64> argument;
be_t<u32> idWorkload;
be_t<u32> idLastScheduledTask;
vm::bcptr<char> name;
vm::bptr<CellSpursTasksetExceptionEventHandler> exceptionEventHandler;
vm::bptr<void> exceptionEventHandlerArgument;
be_t<u32> sizeTaskset;
u8 reserved[112];
};
CHECK_SIZE(CellSpursTasksetInfo, 9360);
struct alignas(8) CellSpursTasksetAttribute
{
be_t<u32> revision; // 0x00
be_t<u32> sdk_version; // 0x04
be_t<u64> args; // 0x08
u8 priority[8]; // 0x10
be_t<u32> max_contention; // 0x18
vm::bcptr<char> name; // 0x1C
be_t<u32> taskset_size; // 0x20
be_t<s32> enable_clear_ls; // 0x24
u8 reserved[472];
};
CHECK_SIZE_ALIGN(CellSpursTasksetAttribute, 512, 8);
struct alignas(128) CellSpursTaskset
{
struct TaskInfo
{
CellSpursTaskArgument args; // 0x00
vm::bcptr<void, u64> elf; // 0x10
be_t<u64> context_save_storage_and_alloc_ls_blocks; // 0x18 This is (context_save_storage_addr | allocated_ls_blocks)
CellSpursTaskLsPattern ls_pattern; // 0x20
};
CHECK_SIZE(TaskInfo, 48);
struct atomic_tasks_bitset
{
atomic_be_t<u32> values[4];
u32 get_bit(u32 bit) const
{
return values[bit / 32] & ((1u << 31) >> (bit % 32));
}
};
atomic_tasks_bitset running; // 0x00
atomic_tasks_bitset ready; // 0x10
atomic_tasks_bitset pending_ready; // 0x20
atomic_tasks_bitset enabled; // 0x30
atomic_tasks_bitset signalled; // 0x40
atomic_tasks_bitset waiting; // 0x50
vm::bptr<CellSpurs, u64> spurs; // 0x60
be_t<u64> args; // 0x68
u8 enable_clear_ls; // 0x70
u8 x71; // 0x71
u8 wkl_flag_wait_task; // 0x72
u8 last_scheduled_task; // 0x73
be_t<u32> wid; // 0x74
be_t<u64> x78; // 0x78
TaskInfo task_info[128]; // 0x80
vm::bptr<CellSpursTasksetExceptionEventHandler, u64> exception_handler; // 0x1880
vm::bptr<u64, u64> exception_handler_arg; // 0x1888
be_t<u32> size; // 0x1890
u32 unk2; // 0x1894
u32 event_flag_id1; // 0x1898
u32 event_flag_id2; // 0x189C
u8 unk3[0x60]; // 0x18A0
};
CHECK_SIZE_ALIGN(CellSpursTaskset, 128 * 50, 128);
struct alignas(128) spurs_taskset_signal_op
{
be_t<u32> running[4]; // 0x00
be_t<u32> ready[4]; // 0x10
be_t<u32> pending_ready[4]; // 0x20
be_t<u32> enabled[4]; // 0x30
be_t<u32> signalled[4]; // 0x40
be_t<u32> waiting[4]; // 0x50
vm::bptr<CellSpurs, u64> spurs; // 0x60
be_t<u64> args; // 0x68
u8 enable_clear_ls; // 0x70
u8 x71; // 0x71
u8 wkl_flag_wait_task; // 0x72
u8 last_scheduled_task; // 0x73
be_t<u32> wid; // 0x74
be_t<u64> x78; // 0x78
};
struct alignas(128) spurs_wkl_state_op
{
SpursWorkloadState wklState1[0x10]; // 0x00
u8 wklStatus1[0x10]; // 0x10
u8 wklEvent1[0x10]; // 0x20
be_t<u32> wklEnabled; // 0x30
be_t<u32> wklMskB; // 0x34
u8 uns[0x5]; // 0x38
u8 sysSrvMsgUpdateWorkload; // 0x3D
u8 uns2[0x12]; // 0x3E
SpursWorkloadState wklState2[0x10]; // 0x50
u8 wklStatus2[0x10]; // 0x60
u8 wklEvent2[0x10]; // 0x70
};
struct alignas(128) CellSpursTaskset2
{
struct TaskInfo
{
CellSpursTaskArgument args;
vm::bptr<u64, u64> elf_addr;
vm::bptr<u64, u64> context_save_storage; // This is (context_save_storage_addr | allocated_ls_blocks)
CellSpursTaskLsPattern ls_pattern;
};
CHECK_SIZE(TaskInfo, 48);
be_t<u32> running_set[4]; // 0x00
be_t<u32> ready_set[4]; // 0x10
be_t<u32> ready2_set[4]; // 0x20 - TODO: Find out what this is
be_t<u32> enabled_set[4]; // 0x30
be_t<u32> signal_received_set[4]; // 0x40
be_t<u32> waiting_set[4]; // 0x50
vm::bptr<CellSpurs, u64> spurs; // 0x60
be_t<u64> args; // 0x68
u8 enable_clear_ls; // 0x70
u8 x71; // 0x71
u8 x72; // 0x72
u8 last_scheduled_task; // 0x73
be_t<u32> wid; // 0x74
be_t<u64> x78; // 0x78
TaskInfo task_info[128]; // 0x80
vm::bptr<u64, u64> exception_handler; // 0x1880
vm::bptr<u64, u64> exception_handler_arg; // 0x1888
be_t<u32> size; // 0x1890
u32 unk2; // 0x1894
u32 event_flag_id1; // 0x1898
u32 event_flag_id2; // 0x189C
u8 unk3[0x1980 - 0x18A0]; // 0x18A0
be_t<v128> task_exit_code[128]; // 0x1980
u8 unk4[0x2900 - 0x2180]; // 0x2180
};
CHECK_SIZE_ALIGN(CellSpursTaskset2, 128 * 82, 128);
struct alignas(16) CellSpursTaskNameBuffer
{
char taskName[CELL_SPURS_MAX_TASK][CELL_SPURS_MAX_TASK_NAME_LENGTH];
};
struct alignas(8) CellSpursTasksetAttribute2
{
be_t<u32> revision; // 0x00
vm::bcptr<char> name; // 0x04
be_t<u64> args; // 0x08
u8 priority[8]; // 0x10
be_t<u32> max_contention; // 0x18
be_t<s32> enable_clear_ls; // 0x1C
vm::bptr<CellSpursTaskNameBuffer> task_name_buffer; // 0x20
u8 reserved[472];
};
CHECK_SIZE_ALIGN(CellSpursTasksetAttribute2, 512, 8);
struct alignas(16) CellSpursTaskBinInfo
{
be_t<u64> eaElf;
be_t<u32> sizeContext;
be_t<u32> reserved;
CellSpursTaskLsPattern lsPattern;
};
struct alignas(128) CellSpursBarrier
{
be_t<u32> zero; // 0x00
be_t<u32> remained; // 0x04
u8 unk0[0x34 - 0x8];
vm::bptr<CellSpursTaskset> taskset; // 0x34
u8 unk1[0x80 - 0x38];
};
CHECK_SIZE_ALIGN(CellSpursBarrier, 128, 128);
// The SPURS kernel context. This resides at 0x100 of the LS.
struct SpursKernelContext
{
u8 tempArea[0x80]; // 0x100
u8 wklLocContention[0x10]; // 0x180
u8 wklLocPendingContention[0x10]; // 0x190
u8 priority[0x10]; // 0x1A0
u8 x1B0[0x10]; // 0x1B0
vm::bptr<CellSpurs, u64> spurs; // 0x1C0
be_t<u32> spuNum; // 0x1C8
be_t<u32> dmaTagId; // 0x1CC
vm::bcptr<void, u64> wklCurrentAddr; // 0x1D0
be_t<u32> wklCurrentUniqueId; // 0x1D8
be_t<u32> wklCurrentId; // 0x1DC
be_t<u32> exitToKernelAddr; // 0x1E0
be_t<u32> selectWorkloadAddr; // 0x1E4
u8 moduleId[2]; // 0x1E8
u8 sysSrvInitialised; // 0x1EA
u8 spuIdling; // 0x1EB
be_t<u16> wklRunnable1; // 0x1EC
be_t<u16> wklRunnable2; // 0x1EE
be_t<u32> x1F0; // 0x1F0
be_t<u32> x1F4; // 0x1F4
be_t<u32> x1F8; // 0x1F8
be_t<u32> x1FC; // 0x1FC
be_t<u32> x200; // 0x200
be_t<u32> x204; // 0x204
be_t<u32> x208; // 0x208
be_t<u32> x20C; // 0x20C
be_t<u64> traceBuffer; // 0x210
be_t<u32> traceMsgCount; // 0x218
be_t<u32> traceMaxCount; // 0x21C
u8 wklUniqueId[0x10]; // 0x220
u8 x230[0x280 - 0x230]; // 0x230
be_t<u32> guid[4]; // 0x280
};
CHECK_SIZE(SpursKernelContext, 0x190);
// The SPURS taskset policy module context. This resides at 0x2700 of the LS.
struct SpursTasksetContext
{
u8 tempAreaTaskset[0x80]; // 0x2700
u8 tempAreaTaskInfo[0x30]; // 0x2780
be_t<u64> x27B0; // 0x27B0
vm::bptr<CellSpursTaskset, u64> taskset; // 0x27B8
be_t<u32> kernelMgmtAddr; // 0x27C0
be_t<u32> syscallAddr; // 0x27C4
be_t<u32> x27C8; // 0x27C8
be_t<u32> spuNum; // 0x27CC
be_t<u32> dmaTagId; // 0x27D0
be_t<u32> taskId; // 0x27D4
u8 x27D8[0x2840 - 0x27D8]; // 0x27D8
u8 moduleId[16]; // 0x2840
u8 stackArea[0x2C80 - 0x2850]; // 0x2850
be_t<v128> savedContextLr; // 0x2C80
be_t<v128> savedContextSp; // 0x2C90
be_t<v128> savedContextR80ToR127[48]; // 0x2CA0
be_t<v128> savedContextFpscr; // 0x2FA0
be_t<u32> savedWriteTagGroupQueryMask; // 0x2FB0
be_t<u32> savedSpuWriteEventMask; // 0x2FB4
be_t<u32> tasksetMgmtAddr; // 0x2FB8
be_t<u32> guidAddr; // 0x2FBC
be_t<u64> x2FC0; // 0x2FC0
be_t<u64> x2FC8; // 0x2FC8
be_t<u32> taskExitCode; // 0x2FD0
be_t<u32> x2FD4; // 0x2FD4
u8 x2FD8[0x3000 - 0x2FD8]; // 0x2FD8
};
CHECK_SIZE(SpursTasksetContext, 0x900);
struct SpursJobChainContext
{
u8 tempAreaJobChain[0x80]; // 0x4A00
u8 unk0[3]; // 0x4A80
b8 unkFlag0; // 0x4A83
u8 unk1[0x10]; // 0x4A84
vm::bptr<CellSpursJobChain> jobChain; // 0x4A94
// TODO
};
class SpursModuleExit
{
};
| 47,148
|
C++
|
.h
| 1,139
| 39.355575
| 220
| 0.536756
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,855
|
libsnd3.h
|
RPCS3_rpcs3/rpcs3/Emu/Cell/Modules/libsnd3.h
|
#pragma once
#include "Emu/Memory/vm_ptr.h"
// Error Codes
enum CellSnd3Error : u32
{
CELL_SND3_ERROR_PARAM = 0x80310301,
CELL_SND3_ERROR_CREATE_MUTEX = 0x80310302,
CELL_SND3_ERROR_SYNTH = 0x80310303,
CELL_SND3_ERROR_ALREADY = 0x80310304,
CELL_SND3_ERROR_NOTINIT = 0x80310305,
CELL_SND3_ERROR_SMFFULL = 0x80310306,
CELL_SND3_ERROR_HD3ID = 0x80310307,
CELL_SND3_ERROR_SMF = 0x80310308,
CELL_SND3_ERROR_SMFCTX = 0x80310309,
CELL_SND3_ERROR_FORMAT = 0x8031030a,
CELL_SND3_ERROR_SMFID = 0x8031030b,
CELL_SND3_ERROR_SOUNDDATAFULL = 0x8031030c,
CELL_SND3_ERROR_VOICENUM = 0x8031030d,
CELL_SND3_ERROR_RESERVEDVOICE = 0x8031030e,
CELL_SND3_ERROR_REQUESTQUEFULL = 0x8031030f,
CELL_SND3_ERROR_OUTPUTMODE = 0x80310310,
};
struct CellSnd3KeyOnParam
{
u8 vel;
u8 pan;
u8 panEx;
be_t<s32> addPitch;
};
struct CellSnd3VoiceBitCtx
{
be_t<u32> core[4];
};
struct CellSnd3DataCtx
{
s8 system[32];
};
struct CellSnd3SmfCtx
{
s8 system[352];
};
struct CellSnd3RequestQueueCtx
{
vm::bptr<void> frontQueue;
be_t<u32> frontQueueSize;
vm::bptr<void> rearQueue;
be_t<u32> rearQueueSize;
};
| 1,197
|
C++
|
.h
| 48
| 23.229167
| 45
| 0.71366
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,856
|
cellOskDialog.h
|
RPCS3_rpcs3/rpcs3/Emu/Cell/Modules/cellOskDialog.h
|
#pragma once
#include "util/types.hpp"
#include "util/atomic.hpp"
#include "util/init_mutex.hpp"
#include "Utilities/mutex.h"
#include "Emu/Memory/vm_ptr.h"
#include <string>
#include <functional>
// error codes
enum CellOskDialogError : u32
{
CELL_OSKDIALOG_ERROR_IME_ALREADY_IN_USE = 0x8002b501,
CELL_OSKDIALOG_ERROR_GET_SIZE_ERROR = 0x8002b502,
CELL_OSKDIALOG_ERROR_UNKNOWN = 0x8002b503,
CELL_OSKDIALOG_ERROR_PARAM = 0x8002b504,
};
// OSK status for the callback
enum
{
CELL_SYSUTIL_OSKDIALOG_LOADED = 0x0502,
CELL_SYSUTIL_OSKDIALOG_FINISHED = 0x0503,
CELL_SYSUTIL_OSKDIALOG_UNLOADED = 0x0504,
CELL_SYSUTIL_OSKDIALOG_INPUT_ENTERED = 0x0505,
CELL_SYSUTIL_OSKDIALOG_INPUT_CANCELED = 0x0506,
CELL_SYSUTIL_OSKDIALOG_INPUT_DEVICE_CHANGED = 0x0507,
CELL_SYSUTIL_OSKDIALOG_DISPLAY_CHANGED = 0x0508,
};
enum CellOskDialogInputFieldResult
{
CELL_OSKDIALOG_INPUT_FIELD_RESULT_OK = 0,
CELL_OSKDIALOG_INPUT_FIELD_RESULT_CANCELED = 1,
CELL_OSKDIALOG_INPUT_FIELD_RESULT_ABORT = 2,
CELL_OSKDIALOG_INPUT_FIELD_RESULT_NO_INPUT_TEXT = 3,
};
enum CellOskDialogInitialKeyLayout
{
CELL_OSKDIALOG_INITIAL_PANEL_LAYOUT_SYSTEM = 0,
CELL_OSKDIALOG_INITIAL_PANEL_LAYOUT_10KEY = 1,
CELL_OSKDIALOG_INITIAL_PANEL_LAYOUT_FULLKEY = 2,
};
enum CellOskDialogInputDevice
{
CELL_OSKDIALOG_INPUT_DEVICE_PAD = 0,
CELL_OSKDIALOG_INPUT_DEVICE_KEYBOARD = 1,
};
enum CellOskDialogContinuousMode
{
CELL_OSKDIALOG_CONTINUOUS_MODE_NONE = 0,
CELL_OSKDIALOG_CONTINUOUS_MODE_REMAIN_OPEN = 1,
CELL_OSKDIALOG_CONTINUOUS_MODE_HIDE = 2,
CELL_OSKDIALOG_CONTINUOUS_MODE_SHOW = 3,
};
enum CellOskDialogDisplayStatus
{
CELL_OSKDIALOG_DISPLAY_STATUS_HIDE = 0,
CELL_OSKDIALOG_DISPLAY_STATUS_SHOW = 1,
};
enum CellOskDialogFilterCallbackReturnValue
{
CELL_OSKDIALOG_NOT_CHANGE = 0,
CELL_OSKDIALOG_CHANGE_WORD = 1,
};
enum CellOskDialogActionValue
{
CELL_OSKDIALOG_CHANGE_NO_EVENT = 0,
CELL_OSKDIALOG_CHANGE_EVENT_CANCEL = 1,
CELL_OSKDIALOG_CHANGE_WORDS_INPUT = 3,
CELL_OSKDIALOG_CHANGE_WORDS_INSERT = 4,
CELL_OSKDIALOG_CHANGE_WORDS_REPLACE_ALL = 6,
};
enum CellOskDialogFinishReason
{
CELL_OSKDIALOG_CLOSE_CONFIRM = 0,
CELL_OSKDIALOG_CLOSE_CANCEL = 1,
};
enum CellOskDialogFinishReasonFake // Helper. Must be negative values.
{
FAKE_CELL_OSKDIALOG_CLOSE_ABORT = -1,
FAKE_CELL_OSKDIALOG_CLOSE_TERMINATE = -2,
};
enum CellOskDialogType
{
CELL_OSKDIALOG_TYPE_SINGLELINE_OSK = 0,
CELL_OSKDIALOG_TYPE_MULTILINE_OSK = 1,
CELL_OSKDIALOG_TYPE_FULL_KEYBOARD_SINGLELINE_OSK = 2,
CELL_OSKDIALOG_TYPE_FULL_KEYBOARD_MULTILINE_OSK = 3,
CELL_OSKDIALOG_TYPE_SEPARATE_SINGLELINE_TEXT_WINDOW = 4,
CELL_OSKDIALOG_TYPE_SEPARATE_MULTILINE_TEXT_WINDOW = 5,
CELL_OSKDIALOG_TYPE_SEPARATE_INPUT_PANEL_WINDOW = 6,
CELL_OSKDIALOG_TYPE_SEPARATE_FULL_KEYBOARD_INPUT_PANEL_WINDOW = 7,
CELL_OSKDIALOG_TYPE_SEPARATE_CANDIDATE_WINDOW = 8,
};
enum
{
CELL_OSKDIALOG_STRING_SIZE = 512, // Theroretical maximum for osk input, games can specify a lower limit
};
enum
{
CELL_OSKDIALOG_PANELMODE_DEFAULT = 0x00000000,
CELL_OSKDIALOG_PANELMODE_GERMAN = 0x00000001,
CELL_OSKDIALOG_PANELMODE_ENGLISH = 0x00000002,
CELL_OSKDIALOG_PANELMODE_SPANISH = 0x00000004,
CELL_OSKDIALOG_PANELMODE_FRENCH = 0x00000008,
CELL_OSKDIALOG_PANELMODE_ITALIAN = 0x00000010,
CELL_OSKDIALOG_PANELMODE_DUTCH = 0x00000020,
CELL_OSKDIALOG_PANELMODE_PORTUGUESE = 0x00000040,
CELL_OSKDIALOG_PANELMODE_RUSSIAN = 0x00000080,
CELL_OSKDIALOG_PANELMODE_JAPANESE = 0x00000100,
CELL_OSKDIALOG_PANELMODE_DEFAULT_NO_JAPANESE = 0x00000200,
CELL_OSKDIALOG_PANELMODE_POLISH = 0x00000400,
CELL_OSKDIALOG_PANELMODE_KOREAN = 0x00001000,
CELL_OSKDIALOG_PANELMODE_TURKEY = 0x00002000,
CELL_OSKDIALOG_PANELMODE_TRADITIONAL_CHINESE = 0x00004000,
CELL_OSKDIALOG_PANELMODE_SIMPLIFIED_CHINESE = 0x00008000,
CELL_OSKDIALOG_PANELMODE_PORTUGUESE_BRAZIL = 0x00010000,
CELL_OSKDIALOG_PANELMODE_DANISH = 0x00020000,
CELL_OSKDIALOG_PANELMODE_SWEDISH = 0x00040000,
CELL_OSKDIALOG_PANELMODE_NORWEGIAN = 0x00080000,
CELL_OSKDIALOG_PANELMODE_FINNISH = 0x00100000,
CELL_OSKDIALOG_PANELMODE_JAPANESE_HIRAGANA = 0x00200000,
CELL_OSKDIALOG_PANELMODE_JAPANESE_KATAKANA = 0x00400000,
CELL_OSKDIALOG_PANELMODE_ALPHABET_FULL_WIDTH = 0x00800000,
CELL_OSKDIALOG_PANELMODE_ALPHABET = 0x01000000,
CELL_OSKDIALOG_PANELMODE_LATIN = 0x02000000,
CELL_OSKDIALOG_PANELMODE_NUMERAL_FULL_WIDTH = 0x04000000,
CELL_OSKDIALOG_PANELMODE_NUMERAL = 0x08000000,
CELL_OSKDIALOG_PANELMODE_URL = 0x10000000,
CELL_OSKDIALOG_PANELMODE_PASSWORD = 0x20000000
};
enum
{
CELL_OSKDIALOG_LAYOUTMODE_X_ALIGN_LEFT = 0x00000200,
CELL_OSKDIALOG_LAYOUTMODE_X_ALIGN_CENTER = 0x00000400,
CELL_OSKDIALOG_LAYOUTMODE_X_ALIGN_RIGHT = 0x00000800,
CELL_OSKDIALOG_LAYOUTMODE_Y_ALIGN_TOP = 0x00001000,
CELL_OSKDIALOG_LAYOUTMODE_Y_ALIGN_CENTER = 0x00002000,
CELL_OSKDIALOG_LAYOUTMODE_Y_ALIGN_BOTTOM = 0x00004000
};
enum
{
CELL_OSKDIALOG_NO_SPACE = 0x00000001,
CELL_OSKDIALOG_NO_RETURN = 0x00000002,
CELL_OSKDIALOG_NO_INPUT_ANALOG = 0x00000008,
CELL_OSKDIALOG_NO_STARTUP_EFFECT = 0x00001000,
};
enum
{
CELL_OSKDIALOG_10KEY_PANEL = 0x00000001,
CELL_OSKDIALOG_FULLKEY_PANEL = 0x00000002
};
enum
{
CELL_OSKDIALOG_DEVICE_MASK_PAD = 0x000000ff
};
enum
{
CELL_OSKDIALOG_EVENT_HOOK_TYPE_FUNCTION_KEY = 0x00000001,
CELL_OSKDIALOG_EVENT_HOOK_TYPE_ASCII_KEY = 0x00000002,
CELL_OSKDIALOG_EVENT_HOOK_TYPE_ONLY_MODIFIER = 0x00000004
};
static const f32 CELL_OSKDIALOG_SCALE_MIN = 0.80f;
static const f32 CELL_OSKDIALOG_SCALE_MAX = 1.05f;
struct CellOskDialogInputFieldInfo
{
vm::bptr<u16> message;
vm::bptr<u16> init_text;
be_t<u32> limit_length;
};
struct CellOskDialogPoint
{
be_t<f32> x;
be_t<f32> y;
};
struct CellOskDialogParam
{
be_t<u32> allowOskPanelFlg;
be_t<u32> firstViewPanel;
CellOskDialogPoint controlPoint;
be_t<s32> prohibitFlgs;
};
// Actual input data
struct CellOskDialogCallbackReturnParam
{
be_t<s32> result; // CellOskDialogInputFieldResult
be_t<s32> numCharsResultString;
vm::bptr<u16> pResultString;
};
struct CellOskDialogLayoutInfo
{
be_t<s32> layoutMode;
CellOskDialogPoint position;
};
struct CellOskDialogSeparateWindowOption
{
be_t<u32> continuousMode; // CellOskDialogContinuousMode
be_t<s32> deviceMask;
be_t<s32> inputFieldWindowWidth;
be_t<f32> inputFieldBackgroundTrans;
vm::bptr<CellOskDialogLayoutInfo> inputFieldLayoutInfo;
vm::bptr<CellOskDialogLayoutInfo> inputPanelLayoutInfo;
vm::bptr<void> reserved;
};
struct CellOskDialogKeyMessage
{
be_t<u32> led;
be_t<u32> mkey;
be_t<u16> keycode;
};
struct CellOskDialogImeDictionaryInfo
{
be_t<u32> targetLanguage;
vm::bcptr<char> dictionaryPath;
};
using cellOskDialogConfirmWordFilterCallback = int(vm::ptr<u16> pConfirmString, s32 wordLength);
using cellOskDialogHardwareKeyboardEventHookCallback = class b8(vm::ptr<CellOskDialogKeyMessage> keyMessage, vm::ptr<u32> action, vm::ptr<void> pActionInfo);
using cellOskDialogForceFinishCallback = class b8();
struct osk_window_layout
{
u32 layout_mode = CELL_OSKDIALOG_LAYOUTMODE_X_ALIGN_LEFT | CELL_OSKDIALOG_LAYOUTMODE_Y_ALIGN_TOP;
u32 x_align = CELL_OSKDIALOG_LAYOUTMODE_X_ALIGN_LEFT;
u32 y_align = CELL_OSKDIALOG_LAYOUTMODE_Y_ALIGN_TOP;
f32 x_offset = 0.0f;
f32 y_offset = 0.0f;
std::string to_string() const
{
return fmt::format("{ layout_mode=0x%x, x_align=0x%x, y_align=0x%x, x_offset=%.2f, y_offset=%.2f }", layout_mode, x_align, y_align, x_offset, y_offset);
}
};
enum class OskDialogState
{
Unloaded,
Open,
Abort,
Closed
};
class OskDialogBase
{
public:
struct color
{
f32 r = 1.0f;
f32 g = 1.0f;
f32 b = 1.0f;
f32 a = 1.0f;
};
struct osk_params
{
std::string title;
std::u16string message;
char16_t* init_text = nullptr;
u32 charlimit = 0;
u32 prohibit_flags = 0;
u32 panel_flag = 0;
u32 support_language = 0;
u32 first_view_panel = 0;
osk_window_layout layout{};
osk_window_layout input_layout{}; // Only used with separate windows
osk_window_layout panel_layout{}; // Only used with separate windows
u32 input_field_window_width = 0; // Only used with separate windows
f32 input_field_background_transparency = 1.0f; // Only used with separate windows
f32 initial_scale = 1.0f;
color base_color{};
bool dimmer_enabled = false;
bool use_separate_windows = false;
bool intercept_input = false;
};
virtual void Create(const osk_params& params) = 0;
virtual void Clear(bool clear_all_data) = 0;
virtual void Insert(const std::u16string& text) = 0;
virtual void SetText(const std::u16string& text) = 0;
// Closes the dialog.
// Set status to CELL_OSKDIALOG_CLOSE_CONFIRM or CELL_OSKDIALOG_CLOSE_CANCEL for user input.
// Set status to -1 if closed by the game or system.
// Set status to -2 if terminated by the system.
virtual void Close(s32 status) = 0;
virtual ~OskDialogBase() {};
std::function<void(s32 status)> on_osk_close;
std::function<void(CellOskDialogKeyMessage key_message)> on_osk_key_input_entered;
atomic_t<OskDialogState> state{ OskDialogState::Unloaded };
atomic_t<CellOskDialogContinuousMode> continuous_mode{ CELL_OSKDIALOG_CONTINUOUS_MODE_NONE };
atomic_t<CellOskDialogInputDevice> input_device{ CELL_OSKDIALOG_INPUT_DEVICE_PAD }; // The current input device.
atomic_t<bool> pad_input_enabled{ true }; // Determines if the OSK consumes the device's input.
atomic_t<bool> mouse_input_enabled{ true }; // Determines if the OSK consumes the device's input.
atomic_t<bool> keyboard_input_enabled{ true }; // Determines if the OSK consumes the device's input.
atomic_t<bool> ignore_device_events{ false }; // Determines if the OSK ignores device events.
atomic_t<CellOskDialogInputFieldResult> osk_input_result{ CellOskDialogInputFieldResult::CELL_OSKDIALOG_INPUT_FIELD_RESULT_OK };
std::array<char16_t, CELL_OSKDIALOG_STRING_SIZE> osk_text{};
};
struct osk_info
{
std::shared_ptr<OskDialogBase> dlg;
std::array<char16_t, CELL_OSKDIALOG_STRING_SIZE> valid_text{}; // The string that's going to be served to the game.
shared_mutex text_mtx;
atomic_t<bool> use_separate_windows = false;
atomic_t<bool> lock_ext_input_device = false;
atomic_t<u32> device_mask = 0; // OSK ignores input from the specified devices. 0 means all devices can influence the OSK
atomic_t<u32> input_field_window_width = 0;
atomic_t<f32> input_field_background_transparency = 1.0f;
osk_window_layout input_field_layout_info{};
osk_window_layout input_panel_layout_info{};
atomic_t<u32> key_layout_options = CELL_OSKDIALOG_10KEY_PANEL;
atomic_t<CellOskDialogInitialKeyLayout> initial_key_layout = CELL_OSKDIALOG_INITIAL_PANEL_LAYOUT_SYSTEM; // TODO: use
atomic_t<CellOskDialogInputDevice> initial_input_device = CELL_OSKDIALOG_INPUT_DEVICE_PAD; // OSK at first only receives input from the initial device
atomic_t<bool> clipboard_enabled = false; // For copy and paste
atomic_t<bool> half_byte_kana_enabled = false;
atomic_t<u32> supported_languages = 0; // Used to enable non-default languages in the OSK
atomic_t<bool> dimmer_enabled = true;
atomic_t<OskDialogBase::color> base_color = OskDialogBase::color{ 0.2f, 0.2f, 0.2f, 1.0f };
atomic_t<bool> pointer_enabled = false;
atomic_t<f32> pointer_x = 0.0f;
atomic_t<f32> pointer_y = 0.0f;
atomic_t<f32> initial_scale = 1.0f;
osk_window_layout layout = {};
atomic_t<CellOskDialogContinuousMode> osk_continuous_mode = CELL_OSKDIALOG_CONTINUOUS_MODE_NONE;
atomic_t<u32> last_dialog_state = CELL_SYSUTIL_OSKDIALOG_UNLOADED; // Used for continuous seperate window dialog
atomic_t<vm::ptr<cellOskDialogConfirmWordFilterCallback>> osk_confirm_callback{};
atomic_t<vm::ptr<cellOskDialogForceFinishCallback>> osk_force_finish_callback{};
atomic_t<vm::ptr<cellOskDialogHardwareKeyboardEventHookCallback>> osk_hardware_keyboard_event_hook_callback{};
atomic_t<u16> hook_event_mode{0};
stx::init_mutex init;
void reset();
// Align horizontally
static u32 get_aligned_x(u32 layout_mode);
// Align vertically
static u32 get_aligned_y(u32 layout_mode);
};
| 12,290
|
C++
|
.h
| 326
| 35.800613
| 157
| 0.758606
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,857
|
cellSysutilAvc.h
|
RPCS3_rpcs3/rpcs3/Emu/Cell/Modules/cellSysutilAvc.h
|
#pragma once
#include "Emu/Cell/Modules/sceNp.h"
enum CellAvcError : u32
{
CELL_AVC_ERROR_UNKNOWN = 0x8002b701,
CELL_AVC_ERROR_NOT_SUPPORTED = 0x8002b702,
CELL_AVC_ERROR_NOT_INITIALIZED = 0x8002b703,
CELL_AVC_ERROR_ALREADY_INITIALIZED = 0x8002b704,
CELL_AVC_ERROR_INVALID_ARGUMENT = 0x8002b705,
CELL_AVC_ERROR_OUT_OF_MEMORY = 0x8002b706,
CELL_AVC_ERROR_BAD_ID = 0x8002b707,
CELL_AVC_ERROR_INVALID_STATUS = 0x8002b70a,
CELL_AVC_ERROR_TIMEOUT = 0x8002b70b,
CELL_AVC_ERROR_NO_SESSION = 0x8002b70d,
CELL_AVC_ERROR_INCOMPATIBLE_PROTOCOL = 0x8002b70e,
CELL_AVC_ERROR_PEER_UNREACHABLE = 0x8002b710,
};
enum CellSysutilAvcTransitionType : u32
{
CELL_SYSUTIL_AVC_TRANSITION_LINEAR = 0x00000000,
CELL_SYSUTIL_AVC_TRANSITION_SLOWDOWN = 0x00000001,
CELL_SYSUTIL_AVC_TRANSITION_FASTUP = 0x00000002,
CELL_SYSUTIL_AVC_TRANSITION_ANGULAR = 0x00000003,
CELL_SYSUTIL_AVC_TRANSITION_EXPONENT = 0x00000004,
CELL_SYSUTIL_AVC_TRANSITION_NONE = 0xffffffff
};
enum CellSysutilAvcWindowZorderMode : u32
{
CELL_SYSUTIL_AVC_ZORDER_FORWARD_MOST = 0x00000002,
CELL_SYSUTIL_AVC_ZORDER_BEHIND_MOST = 0x00000003,
};
enum : u32
{
CELL_AVC_REQUEST_ID_SYSTEM_EVENT = 0x00000000,
CELL_SYSUTIL_AVC_VIDEO_MEMORY_SIZE = 26 * 1024 * 1024,
CELL_SYSUTIL_AVC_VOICE_MEMORY_SIZE = 8 * 1024 * 1024,
CELL_SYSUTIL_AVC_EXTRA_MEMORY_SIZE_FOR_SHARING_VIDEO_BUFFER = 2 * 1024 * 1024,
CELL_SYSUTIL_AVC_OPTION_PARAM_VERSION = 100,
};
enum CellSysutilAvcEvent : u32
{
CELL_AVC_EVENT_LOAD_SUCCEEDED = 0x00000001,
CELL_AVC_EVENT_LOAD_FAILED = 0x00000002,
CELL_AVC_EVENT_UNLOAD_SUCCEEDED = 0x00000003,
CELL_AVC_EVENT_UNLOAD_FAILED = 0x00000004,
CELL_AVC_EVENT_JOIN_SUCCEEDED = 0x00000005,
CELL_AVC_EVENT_JOIN_FAILED = 0x00000006,
CELL_AVC_EVENT_BYE_SUCCEEDED = 0x00000007,
CELL_AVC_EVENT_BYE_FAILED = 0x00000008,
CELL_AVC_EVENT_SYSTEM_NEW_MEMBER_JOINED = 0x10000001,
CELL_AVC_EVENT_SYSTEM_MEMBER_LEFT = 0x10000002,
CELL_AVC_EVENT_SYSTEM_SESSION_ESTABLISHED = 0x10000003,
CELL_AVC_EVENT_SYSTEM_SESSION_CANNOT_ESTABLISHED = 0x10000004,
CELL_AVC_EVENT_SYSTEM_SESSION_DISCONNECTED = 0x10000005,
CELL_AVC_EVENT_SYSTEM_VOICE_DETECTED = 0x10000006,
CELL_AVC_EVENT_SYSTEM_MIC_DETECTED = 0x10000007,
CELL_AVC_EVENT_SYSTEM_CAMERA_DETECTED = 0x10000008,
};
enum CellSysUtilAvcEventParam : u64
{
CELL_AVC_EVENT_PARAM_ERROR_UNKNOWN = 0x00000001,
CELL_AVC_EVENT_PARAM_ERROR_NOT_SUPPORTED = 0x00000002,
CELL_AVC_EVENT_PARAM_ERROR_INVALID_ARGUMENT = 0x00000003,
CELL_AVC_EVENT_PARAM_ERROR_OUT_OF_MEMORY = 0x00000004,
CELL_AVC_EVENT_PARAM_ERROR_INVALID_STATUS = 0x00000005,
CELL_AVC_EVENT_PARAM_ERROR_TIMEOUT = 0x00000006,
CELL_AVC_EVENT_PARAM_ERROR_CONTEXT_DOES_NOT_EXIST = 0x00000007,
CELL_AVC_EVENT_PARAM_ERROR_ROOM_DOES_NOT_EXIST = 0x00000008,
CELL_AVC_EVENT_PARAM_ERROR_MEDIA_MISMATCHED = 0x00000009,
CELL_AVC_EVENT_PARAM_ERROR_MEMBER_EXCEEDED = 0x0000000A,
CELL_AVC_EVENT_PARAM_ERROR_MASTER_LEFT = 0x0000000B,
CELL_AVC_EVENT_PARAM_ERROR_NETWORK_ERROR = 0x0000000C,
CELL_AVC_EVENT_PARAM_ERROR_INCOMPATIBLE_PROTOCOL = 0x0000000D,
};
enum CellSysUtilAvcAttribute : u32
{
CELL_SYSUTIL_AVC_ATTRIBUTE_DEFAULT_TRANSITION_TYPE = 0x00000001,
CELL_SYSUTIL_AVC_ATTRIBUTE_DEFAULT_TRANSITION_DURATION = 0x00000002,
CELL_SYSUTIL_AVC_ATTRIBUTE_DEFAULT_INITIAL_SHOW_STATUS = 0x00000003,
CELL_SYSUTIL_AVC_ATTRIBUTE_VOICE_DETECT_EVENT_TYPE = 0x00000004,
CELL_SYSUTIL_AVC_ATTRIBUTE_VOICE_DETECT_INTERVAL_TIME = 0x00000005,
CELL_SYSUTIL_AVC_ATTRIBUTE_VOICE_DETECT_SIGNAL_LEVEL = 0x00000006,
CELL_SYSUTIL_AVC_ATTRIBUTE_ROOM_PRIVILEGE_TYPE = 0x00000007,
CELL_SYSUTIL_AVC_ATTRIBUTE_VIDEO_MAX_BITRATE = 0x00000008,
};
enum CellSysutilAvcLayoutMode : u32
{
CELL_SYSUTIL_AVC_LAYOUT_LEFT = 0x00000000,
CELL_SYSUTIL_AVC_LAYOUT_RIGHT = 0x00000001,
CELL_SYSUTIL_AVC_LAYOUT_TOP = 0x00000002,
CELL_SYSUTIL_AVC_LAYOUT_BOTTOM = 0x00000003,
};
enum CellSysUtilAvcMediaType : u32
{
CELL_SYSUTIL_AVC_VOICE_CHAT = 0x00000001,
CELL_SYSUTIL_AVC_VIDEO_CHAT = 0x00000002,
};
enum CellSysutilAvcRoomPrivilegeType : u32
{
CELL_SYSUTIL_AVC_ROOM_PRIVILEGE_TYPE_NO_AUTO_GRANT = 0x00000000,
CELL_SYSUTIL_AVC_ROOM_PRIVILEGE_TYPE_AUTO_GRANT = 0x00000001
};
enum CellSysUtilAvcVideoQuality : u32
{
CELL_SYSUTIL_AVC_VIDEO_QUALITY_DEFAULT = 0x00000001
};
enum CellSysutilAvcVoiceDetectEventType : u32
{
CELL_SYSUTIL_AVC_VOICE_DETECT_EVENT_TYPE_SIGNAL = 0x00000001,
CELL_SYSUTIL_AVC_VOICE_DETECT_EVENT_TYPE_SPEAK = 0x00000002
};
enum CellSysutilAvcVoiceDetectSpeakData : u32
{
CELL_SYSUTIL_AVC_VOICE_DETECT_DATA_SPEAK_STOP = 0x00000000,
CELL_SYSUTIL_AVC_VOICE_DETECT_DATA_SPEAK_START = 0x00000001
};
enum CellSysUtilAvcVoiceQuality : u32
{
CELL_SYSUTIL_AVC_VOICE_QUALITY_DEFAULT = 0x00000001
};
struct CellSysutilAvcOptionParam
{
be_t<s32> avcOptionParamVersion;
b8 sharingVideoBuffer;
be_t<s32> maxPlayers; // Not in FW 1.70
};
struct CellSysutilAvcVoiceDetectData
{
SceNpId npid;
be_t<s32> data;
};
typedef u32 CellSysutilAvcRequestId;
using CellSysutilAvcCallback = void(CellSysutilAvcRequestId request_id, CellSysutilAvcEvent event_id, CellSysUtilAvcEventParam event_param, vm::ptr<void> userdata);
| 5,479
|
C++
|
.h
| 133
| 39.421053
| 164
| 0.745304
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,858
|
cellPamf.h
|
RPCS3_rpcs3/rpcs3/Emu/Cell/Modules/cellPamf.h
|
#pragma once
#include "Emu/Memory/vm_ptr.h"
// Error Codes
enum CellPamfError : u32
{
CELL_PAMF_ERROR_STREAM_NOT_FOUND = 0x80610501,
CELL_PAMF_ERROR_INVALID_PAMF = 0x80610502,
CELL_PAMF_ERROR_INVALID_ARG = 0x80610503,
CELL_PAMF_ERROR_UNKNOWN_TYPE = 0x80610504,
CELL_PAMF_ERROR_UNSUPPORTED_VERSION = 0x80610505,
CELL_PAMF_ERROR_UNKNOWN_STREAM = 0x80610506,
CELL_PAMF_ERROR_EP_NOT_FOUND = 0x80610507,
CELL_PAMF_ERROR_NOT_AVAILABLE = 0x80610508,
};
// PamfReaderInitialize Attribute Flags
enum
{
CELL_PAMF_ATTRIBUTE_VERIFY_ON = 1,
CELL_PAMF_ATTRIBUTE_MINIMUM_HEADER = 2,
};
enum CellPamfStreamType
{
CELL_PAMF_STREAM_TYPE_AVC = 0,
CELL_PAMF_STREAM_TYPE_M2V = 1,
CELL_PAMF_STREAM_TYPE_ATRAC3PLUS = 2,
CELL_PAMF_STREAM_TYPE_PAMF_LPCM = 3,
CELL_PAMF_STREAM_TYPE_AC3 = 4,
CELL_PAMF_STREAM_TYPE_USER_DATA = 5,
CELL_PAMF_STREAM_TYPE_PSMF_AVC = 6,
CELL_PAMF_STREAM_TYPE_PSMF_ATRAC3PLUS = 7,
CELL_PAMF_STREAM_TYPE_PSMF_LPCM = 8,
CELL_PAMF_STREAM_TYPE_PSMF_USER_DATA = 9,
CELL_PAMF_STREAM_TYPE_VIDEO = 20,
CELL_PAMF_STREAM_TYPE_AUDIO = 21,
CELL_PAMF_STREAM_TYPE_UNK = 22,
};
enum PamfStreamCodingType : u8
{
PAMF_STREAM_CODING_TYPE_M2V = 0x02,
PAMF_STREAM_CODING_TYPE_AVC = 0x1b,
PAMF_STREAM_CODING_TYPE_PAMF_LPCM = 0x80,
PAMF_STREAM_CODING_TYPE_AC3 = 0x81,
PAMF_STREAM_CODING_TYPE_ATRAC3PLUS = 0xdc,
PAMF_STREAM_CODING_TYPE_USER_DATA = 0xdd,
PAMF_STREAM_CODING_TYPE_PSMF = 0xff,
};
enum
{
CELL_PAMF_FS_48kHz = 1,
};
enum
{
CELL_PAMF_BIT_LENGTH_16 = 1,
CELL_PAMF_BIT_LENGTH_24 = 3,
};
enum
{
CELL_PAMF_AVC_PROFILE_MAIN = 77,
CELL_PAMF_AVC_PROFILE_HIGH = 100,
};
enum
{
CELL_PAMF_AVC_LEVEL_2P1 = 21,
CELL_PAMF_AVC_LEVEL_3P0 = 30,
CELL_PAMF_AVC_LEVEL_3P1 = 31,
CELL_PAMF_AVC_LEVEL_3P2 = 32,
CELL_PAMF_AVC_LEVEL_4P1 = 41,
CELL_PAMF_AVC_LEVEL_4P2 = 42,
};
enum
{
CELL_PAMF_AVC_FRC_24000DIV1001 = 0,
CELL_PAMF_AVC_FRC_24 = 1,
CELL_PAMF_AVC_FRC_25 = 2,
CELL_PAMF_AVC_FRC_30000DIV1001 = 3,
CELL_PAMF_AVC_FRC_30 = 4,
CELL_PAMF_AVC_FRC_50 = 5,
CELL_PAMF_AVC_FRC_60000DIV1001 = 6,
};
enum
{
CELL_PAMF_M2V_MP_ML = 1,
CELL_PAMF_M2V_MP_H14 = 2,
CELL_PAMF_M2V_MP_HL = 3,
CELL_PAMF_M2V_UNKNOWN = 255,
};
enum
{
CELL_PAMF_M2V_FRC_24000DIV1001 = 1,
CELL_PAMF_M2V_FRC_24 = 2,
CELL_PAMF_M2V_FRC_25 = 3,
CELL_PAMF_M2V_FRC_30000DIV1001 = 4,
CELL_PAMF_M2V_FRC_30 = 5,
CELL_PAMF_M2V_FRC_50 = 6,
CELL_PAMF_M2V_FRC_60000DIV1001 = 7,
};
enum
{
CELL_PAMF_ASPECT_RATIO_1_1 = 1,
CELL_PAMF_ASPECT_RATIO_12_11 = 2,
CELL_PAMF_ASPECT_RATIO_10_11 = 3,
CELL_PAMF_ASPECT_RATIO_16_11 = 4,
CELL_PAMF_ASPECT_RATIO_40_33 = 5,
CELL_PAMF_ASPECT_RATIO_4_3 = 14,
};
enum
{
CELL_PAMF_COLOUR_PRIMARIES_ITR_R_BT_709 = 1,
CELL_PAMF_COLOUR_PRIMARIES_UNSPECIFIED = 2,
CELL_PAMF_COLOUR_PRIMARIES_ITU_R_BT_470_SYS_M = 4,
CELL_PAMF_COLOUR_PRIMARIES_ITU_R_BT_470_SYS_BG = 5,
CELL_PAMF_COLOUR_PRIMARIES_SMPTE_170_M = 6,
CELL_PAMF_COLOUR_PRIMARIES_SMPTE_240_M = 7,
CELL_PAMF_COLOUR_PRIMARIES_GENERIC_FILM = 8,
};
enum
{
CELL_PAMF_TRANSFER_CHARACTERISTICS_ITU_R_BT_709 = 1,
CELL_PAMF_TRANSFER_CHARACTERISTICS_UNSPECIFIED = 2,
CELL_PAMF_TRANSFER_CHARACTERISTICS_ITU_R_BT_470_SYS_M = 4,
CELL_PAMF_TRANSFER_CHARACTERISTICS_ITU_R_BT_470_SYS_BG = 5,
CELL_PAMF_TRANSFER_CHARACTERISTICS_SMPTE_170_M = 6,
CELL_PAMF_TRANSFER_CHARACTERISTICS_SMPTE_240_M = 7,
CELL_PAMF_TRANSFER_CHARACTERISTICS_LINEAR = 8,
CELL_PAMF_TRANSFER_CHARACTERISTICS_LOG_100_1 = 9,
CELL_PAMF_TRANSFER_CHARACTERISTICS_LOG_316_1 = 10,
};
enum
{
CELL_PAMF_MATRIX_GBR = 0,
CELL_PAMF_MATRIX_ITU_R_BT_709 = 1,
CELL_PAMF_MATRIX_UNSPECIFIED = 2,
CELL_PAMF_MATRIX_FCC = 4,
CELL_PAMF_MATRIX_ITU_R_BT_470_SYS_BG = 5,
CELL_PAMF_MATRIX_SMPTE_170_M = 6,
CELL_PAMF_MATRIX_SMPTE_240_M = 7,
CELL_PAMF_MATRIX_YCGCO = 8,
};
// Timestamp information (time in increments of 90 kHz)
struct CellCodecTimeStamp
{
be_t<u32> upper;
be_t<u32> lower;
};
constexpr u32 CODEC_TS_INVALID = umax;
// Entry point information
struct CellPamfEp
{
be_t<u32> indexN;
be_t<u32> nThRefPictureOffset;
CellCodecTimeStamp pts;
be_t<u64> rpnOffset;
};
struct CellPamfEpUnk // Speculative name, only used in two undocumented functions
{
CellPamfEp ep;
be_t<u64> nextRpnOffset;
};
CHECK_SIZE(CellPamfEpUnk, 0x20);
// Entry point iterator
struct CellPamfEpIterator
{
b8 isPamf;
be_t<u32> index;
be_t<u32> num;
vm::bcptr<void> pCur;
};
struct CellCodecEsFilterId
{
be_t<u32> filterIdMajor;
be_t<u32> filterIdMinor;
be_t<u32> supplementalInfo1;
be_t<u32> supplementalInfo2;
};
// AVC (MPEG4 AVC Video) Specific Information
struct CellPamfAvcInfo
{
u8 profileIdc;
u8 levelIdc;
u8 frameMbsOnlyFlag;
u8 videoSignalInfoFlag;
u8 frameRateInfo;
u8 aspectRatioIdc;
be_t<u16> sarWidth;
be_t<u16> sarHeight;
be_t<u16> horizontalSize;
be_t<u16> verticalSize;
be_t<u16> frameCropLeftOffset;
be_t<u16> frameCropRightOffset;
be_t<u16> frameCropTopOffset;
be_t<u16> frameCropBottomOffset;
u8 videoFormat;
u8 videoFullRangeFlag;
u8 colourPrimaries;
u8 transferCharacteristics;
u8 matrixCoefficients;
u8 entropyCodingModeFlag;
u8 deblockingFilterFlag;
u8 minNumSlicePerPictureIdc;
u8 nfwIdc;
u8 maxMeanBitrate;
};
CHECK_SIZE(CellPamfAvcInfo, 0x20);
// M2V (MPEG2 Video) Specific Information
struct CellPamfM2vInfo
{
u8 profileAndLevelIndication;
u8 progressiveSequence;
u8 videoSignalInfoFlag;
u8 frameRateInfo;
u8 aspectRatioIdc;
be_t<u16> sarWidth;
be_t<u16> sarHeight;
be_t<u16> horizontalSize;
be_t<u16> verticalSize;
be_t<u16> horizontalSizeValue;
be_t<u16> verticalSizeValue;
u8 videoFormat;
u8 videoFullRangeFlag;
u8 colourPrimaries;
u8 transferCharacteristics;
u8 matrixCoefficients;
};
CHECK_SIZE(CellPamfM2vInfo, 0x18);
// ATRAC3+ Audio Specific Information
struct CellPamfAtrac3plusInfo
{
be_t<u32> samplingFrequency;
u8 numberOfChannels;
};
CHECK_SIZE(CellPamfAtrac3plusInfo, 8);
// AC3 Audio Specific Information
struct CellPamfAc3Info
{
be_t<u32> samplingFrequency;
u8 numberOfChannels;
};
CHECK_SIZE(CellPamfAc3Info, 8);
// LPCM Audio Specific Information
struct CellPamfLpcmInfo
{
be_t<u32> samplingFrequency;
u8 numberOfChannels;
be_t<u16> bitsPerSample;
};
CHECK_SIZE(CellPamfLpcmInfo, 8);
// PAMF file structs, everything here is not aligned (LLE uses exclusively u8 pointers)
struct PamfStreamHeader
{
u8 stream_coding_type;
u8 reserved[3];
u8 stream_id;
u8 private_stream_id; // for streams multiplexed as private data streams (stream_id == 0xbd)
be_t<u16, 1> p_std_buffer; // 2 bits: unused ??? "00", 1 bit: P_STD_buffer_scale, 13 bits: P_STD_buffer_size
be_t<u32, 1> ep_offset; // offset of EP section in header
be_t<u32, 1> ep_num; // count of EPs
union
{
u8 data[32]; // specific info
// AVC specific information
struct
{
u8 profileIdc;
u8 levelIdc;
u8 x2; // contains frameMbsOnlyFlag, videoSignalInfoFlag, frameRateInfo
u8 aspectRatioIdc;
be_t<u16, 1> sarWidth;
be_t<u16, 1> sarHeight;
u8 reserved1;
u8 horizontalSize; // divided by 16
u8 reserved2;
u8 verticalSize; // divided by 16
be_t<u16, 1> frameCropLeftOffset;
be_t<u16, 1> frameCropRightOffset;
be_t<u16, 1> frameCropTopOffset;
be_t<u16, 1> frameCropBottomOffset;
u8 x14; // contains videoFormat and videoFullRangeFlag
u8 colourPrimaries;
u8 transferCharacteristics;
u8 matrixCoefficients;
u8 x18; // contains entropyCodingModeFlag, deblockingFilterFlag, minNumSlicePerPictureIdc, nfwIdc
u8 maxMeanBitrate;
}
AVC;
// M2V specific information
struct
{
s8 x0; // contains profileAndLevelIndication
u8 x1; // not used
u8 x2; // contains progressiveSequence, videoSignalInfoFlag, frameRateInfo
u8 aspectRatioIdc;
be_t<u16, 1> sarWidth;
be_t<u16, 1> sarHeight;
u8 reserved1;
u8 horizontalSize; // in units of 16 pixels
u8 reserved2;
u8 verticalSize; // in units of 16 pixels
be_t<u16, 1> horizontalSizeValue;
be_t<u16, 1> verticalSizeValue;
be_t<u32, 1> x10; // not used
u8 x14; // contains videoFormat and videoFullRangeFlag
u8 colourPrimaries;
u8 transferCharacteristics;
u8 matrixCoefficients;
}
M2V;
// Audio specific information
struct
{
be_t<u16, 1> unknown; // 0
u8 channels; // number of channels (1, 2, 6, 8)
u8 freq; // 1 (always 48000)
u8 bps; // LPCM only
}
audio;
};
};
CHECK_SIZE_ALIGN(PamfStreamHeader, 48, 1);
struct PamfGroup
{
be_t<u32, 1> size; // doesn't include this field
u8 reserved;
u8 stream_num; // same value as in PamfSequenceInfo
PamfStreamHeader streams;
};
CHECK_SIZE_ALIGN(PamfGroup, 6 + sizeof(PamfStreamHeader), 1);
struct PamfGroupingPeriod
{
be_t<u32, 1> size; // doesn't include this field
be_t<u16, 1> start_pts_high; // always 0, greatest valid pts is UINT32_MAX
be_t<u32, 1> start_pts_low; // same value as in PamfSequenceInfo, since there is only one PamfGroupingPeriod
be_t<u16, 1> end_pts_high; // unused due to bug
be_t<u32, 1> end_pts_low; // same value as in PamfSequenceInfo, since there is only one PamfGroupingPeriod
u8 reserved;
u8 group_num; // always 1
PamfGroup groups;
};
CHECK_SIZE_ALIGN(PamfGroupingPeriod, 0x12 + sizeof(PamfGroup), 1);
struct PamfSequenceInfo
{
be_t<u32, 1> size; // doesn't include this field
be_t<u16, 1> reserved1;
be_t<u16, 1> start_pts_high; // always 0, greatest valid pts is UINT32_MAX
be_t<u32, 1> start_pts_low; // Presentation Time Stamp (start)
be_t<u16, 1> end_pts_high; // always 0, greatest valid pts is UINT32_MAX
be_t<u32, 1> end_pts_low; // Presentation Time Stamp (end)
be_t<u32, 1> mux_rate_bound; // multiplex bitrate in units of 50 bytes per second
be_t<u32, 1> std_delay_bound; // buffer delay in units of 1/90000 seconds
be_t<u32, 1> total_stream_num; // across all groups; since there is always only one group, this is equal stream_count in PamfGroup
u8 reserved2;
u8 grouping_period_num; // always 1
PamfGroupingPeriod grouping_periods;
};
CHECK_SIZE_ALIGN(PamfSequenceInfo, 0x20 + sizeof(PamfGroupingPeriod), 1);
struct PamfHeader
{
be_t<u32, 1> magic; // "PAMF"
be_t<u32, 1> version; // "0040" or "0041"
be_t<u32, 1> header_size; // in units of 2048 bytes
be_t<u32, 1> data_size; // in units of 2048 bytes
be_t<u32, 1> psmf_marks_offset; // always 0
be_t<u32, 1> psmf_marks_size; // always 0
be_t<u32, 1> unk_offset; // always 0
be_t<u32, 1> unk_size; // always 0
u8 reserved[0x30];
PamfSequenceInfo seq_info;
};
CHECK_SIZE_ALIGN(PamfHeader, 0x50 + sizeof(PamfSequenceInfo), 1);
struct PamfEpHeader
{
be_t<u16, 1> value0; // 2 bits: indexN, 1 bit: unused, 13 bits: nThRefPictureOffset in units of 2048 bytes
be_t<u16, 1> pts_high; // always 0, greatest valid pts is UINT32_MAX
be_t<u32, 1> pts_low;
be_t<u32, 1> rpnOffset; // in units of 2048 bytes
};
CHECK_SIZE_ALIGN(PamfEpHeader, 12, 1);
// PSMF specific
struct PsmfStreamHeader
{
u8 stream_id;
u8 private_stream_id; // for streams multiplexed as private data streams (stream_id == 0xbd)
be_t<u16, 1> p_std_buffer; // 2 bits: unused ??? "00", 1 bit: P_STD_buffer_scale, 13 bits: P_STD_buffer_size
be_t<u32, 1> ep_offset; // offset of EP section in header
be_t<u32, 1> ep_num; // count of EPs
union
{
// Video specific information
struct
{
u8 horizontalSize; // in units of 16 pixels
u8 verticalSize; // in units of 16 pixels
}
video;
// Audio specific information
struct
{
be_t<u16, 1> unknown; // 0
u8 channelConfiguration; // 1 = mono, 2 = stereo
u8 samplingFrequency; // 2 = 44.1kHz
}
audio;
};
};
CHECK_SIZE_ALIGN(PsmfStreamHeader, 0x10, 1);
struct PsmfGroup
{
be_t<u32, 1> size; // doesn't include this field
u8 reserved;
u8 stream_num; // same value as in PsmfSequenceInfo
PsmfStreamHeader streams;
};
CHECK_SIZE_ALIGN(PsmfGroup, 6 + sizeof(PsmfStreamHeader), 1);
struct PsmfGroupingPeriod
{
be_t<u32, 1> size; // doesn't include this field
be_t<u16, 1> start_pts_high; // always 0, greatest valid pts is UINT32_MAX
be_t<u32, 1> start_pts_low; // same value as in PsmfSequenceInfo, since there is only one PsmfGroupingPeriod
be_t<u16, 1> end_pts_high; // unused due to bug
be_t<u32, 1> end_pts_low; // same value as in PsmfSequenceInfo, since there is only one PsmfGroupingPeriod
u8 reserved;
u8 group_num; // always 1
PsmfGroup groups;
};
CHECK_SIZE_ALIGN(PsmfGroupingPeriod, 0x12 + sizeof(PsmfGroup), 1);
struct PsmfSequenceInfo
{
be_t<u32, 1> size; // doesn't include this field
be_t<u16, 1> start_pts_high; // always 0, greatest valid pts is UINT32_MAX
be_t<u32, 1> start_pts_low; // Presentation Time Stamp (start)
be_t<u16, 1> end_pts_high; // always 0, greatest valid pts is UINT32_MAX
be_t<u32, 1> end_pts_low; // Presentation Time Stamp (end)
be_t<u32, 1> mux_rate_bound; // multiplex bitrate in units of 50 bytes per second
be_t<u32, 1> std_delay_bound; // buffer delay in units of 1/90000 seconds
u8 total_stream_num; // across all groups; since there is always only one group, this is equal stream_count in PsmfGroup
u8 grouping_period_num; // always 1
PsmfGroupingPeriod grouping_periods;
};
CHECK_SIZE_ALIGN(PsmfSequenceInfo, 0x1a + sizeof(PsmfGroupingPeriod), 1);
struct PsmfHeader
{
be_t<u32, 1> magic; // "PSMF"
be_t<u32, 1> version; // "0012", "0013", "0014" or "0015"
be_t<u32, 1> header_size; // not scaled, unlike PAMF
be_t<u32, 1> data_size; // not scaled, unlike PAMF
be_t<u32, 1> psmf_marks_offset;
be_t<u32, 1> psmf_marks_size;
be_t<u32, 1> unk[2];
u8 reserved[0x30];
PsmfSequenceInfo seq_info;
};
CHECK_SIZE_ALIGN(PsmfHeader, 0x50 + sizeof(PsmfSequenceInfo), 1);
struct PsmfEpHeader
{
be_t<u16, 1> value0; // 2 bits: indexN, 2 bits: unused, 11 bits: nThRefPictureOffset in units of 1024 bytes, 1 bit: pts_high
be_t<u32, 1> pts_low;
be_t<u32, 1> rpnOffset; // in units of 2048 bytes
};
CHECK_SIZE_ALIGN(PsmfEpHeader, 10, 1);
struct CellPamfReader
{
be_t<u64> headerSize;
be_t<u64> dataSize;
be_t<u32> attribute;
be_t<u16> isPsmf;
be_t<u16> version;
be_t<u32> currentGroupingPeriodIndex;
be_t<u32> currentGroupIndex;
be_t<u32> currentStreamIndex;
union
{
struct
{
vm::bcptr<PamfHeader> header;
vm::bcptr<PamfSequenceInfo> sequenceInfo;
vm::bcptr<PamfGroupingPeriod> currentGroupingPeriod;
vm::bcptr<PamfGroup> currentGroup;
vm::bcptr<PamfStreamHeader> currentStream;
}
pamf;
struct
{
vm::bcptr<PsmfHeader> header;
vm::bcptr<PsmfSequenceInfo> sequenceInfo;
vm::bcptr<PsmfGroupingPeriod> currentGroupingPeriod;
vm::bcptr<PsmfGroup> currentGroup;
vm::bcptr<PsmfStreamHeader> currentStream;
}
psmf;
};
u32 reserved[18];
};
CHECK_SIZE(CellPamfReader, 128);
error_code cellPamfReaderInitialize(vm::ptr<CellPamfReader> pSelf, vm::cptr<PamfHeader> pAddr, u64 fileSize, u32 attribute);
#include <mutex>
#include <condition_variable>
extern const std::function<bool()> SQUEUE_ALWAYS_EXIT;
extern const std::function<bool()> SQUEUE_NEVER_EXIT;
bool squeue_test_exit();
// TODO: eliminate this boolshit
template<typename T, u32 sq_size = 256>
class squeue_t
{
struct squeue_sync_var_t
{
struct
{
u32 position : 31;
u32 pop_lock : 1;
};
struct
{
u32 count : 31;
u32 push_lock : 1;
};
};
atomic_t<squeue_sync_var_t> m_sync;
mutable std::mutex m_rcv_mutex;
mutable std::mutex m_wcv_mutex;
mutable std::condition_variable m_rcv;
mutable std::condition_variable m_wcv;
T m_data[sq_size];
enum squeue_sync_var_result : u32
{
SQSVR_OK = 0,
SQSVR_LOCKED = 1,
SQSVR_FAILED = 2,
};
public:
squeue_t()
: m_sync(squeue_sync_var_t{})
{
}
static u32 get_max_size()
{
return sq_size;
}
bool is_full() const
{
return m_sync.load().count == sq_size;
}
bool push(const T& data, const std::function<bool()>& test_exit)
{
u32 pos = 0;
while (u32 res = m_sync.atomic_op([&pos](squeue_sync_var_t& sync) -> u32
{
ensure(sync.count <= sq_size);
ensure(sync.position < sq_size);
if (sync.push_lock)
{
return SQSVR_LOCKED;
}
if (sync.count == sq_size)
{
return SQSVR_FAILED;
}
sync.push_lock = 1;
pos = sync.position + sync.count;
return SQSVR_OK;
}))
{
if (res == SQSVR_FAILED && (test_exit() || squeue_test_exit()))
{
return false;
}
std::unique_lock<std::mutex> wcv_lock(m_wcv_mutex);
m_wcv.wait_for(wcv_lock, std::chrono::milliseconds(1));
}
m_data[pos >= sq_size ? pos - sq_size : pos] = data;
m_sync.atomic_op([](squeue_sync_var_t& sync)
{
ensure(sync.count <= sq_size);
ensure(sync.position < sq_size);
ensure(!!sync.push_lock);
sync.push_lock = 0;
sync.count++;
});
m_rcv.notify_one();
m_wcv.notify_one();
return true;
}
bool push(const T& data, const volatile bool* do_exit)
{
return push(data, [do_exit]() { return do_exit && *do_exit; });
}
bool push(const T& data)
{
return push(data, SQUEUE_NEVER_EXIT);
}
bool try_push(const T& data)
{
return push(data, SQUEUE_ALWAYS_EXIT);
}
bool pop(T& data, const std::function<bool()>& test_exit)
{
u32 pos = 0;
while (u32 res = m_sync.atomic_op([&pos](squeue_sync_var_t& sync) -> u32
{
ensure(sync.count <= sq_size);
ensure(sync.position < sq_size);
if (!sync.count)
{
return SQSVR_FAILED;
}
if (sync.pop_lock)
{
return SQSVR_LOCKED;
}
sync.pop_lock = 1;
pos = sync.position;
return SQSVR_OK;
}))
{
if (res == SQSVR_FAILED && (test_exit() || squeue_test_exit()))
{
return false;
}
std::unique_lock<std::mutex> rcv_lock(m_rcv_mutex);
m_rcv.wait_for(rcv_lock, std::chrono::milliseconds(1));
}
data = m_data[pos];
m_sync.atomic_op([](squeue_sync_var_t& sync)
{
ensure(sync.count <= sq_size);
ensure(sync.position < sq_size);
ensure(!!sync.pop_lock);
sync.pop_lock = 0;
sync.position++;
sync.count--;
if (sync.position == sq_size)
{
sync.position = 0;
}
});
m_rcv.notify_one();
m_wcv.notify_one();
return true;
}
bool pop(T& data, const volatile bool* do_exit)
{
return pop(data, [do_exit]() { return do_exit && *do_exit; });
}
bool pop(T& data)
{
return pop(data, SQUEUE_NEVER_EXIT);
}
bool try_pop(T& data)
{
return pop(data, SQUEUE_ALWAYS_EXIT);
}
bool peek(T& data, u32 start_pos, const std::function<bool()>& test_exit)
{
ensure(start_pos < sq_size);
u32 pos = 0;
while (u32 res = m_sync.atomic_op([&pos, start_pos](squeue_sync_var_t& sync) -> u32
{
ensure(sync.count <= sq_size);
ensure(sync.position < sq_size);
if (sync.count <= start_pos)
{
return SQSVR_FAILED;
}
if (sync.pop_lock)
{
return SQSVR_LOCKED;
}
sync.pop_lock = 1;
pos = sync.position + start_pos;
return SQSVR_OK;
}))
{
if (res == SQSVR_FAILED && (test_exit() || squeue_test_exit()))
{
return false;
}
std::unique_lock<std::mutex> rcv_lock(m_rcv_mutex);
m_rcv.wait_for(rcv_lock, std::chrono::milliseconds(1));
}
data = m_data[pos >= sq_size ? pos - sq_size : pos];
m_sync.atomic_op([](squeue_sync_var_t& sync)
{
ensure(sync.count <= sq_size);
ensure(sync.position < sq_size);
ensure(!!sync.pop_lock);
sync.pop_lock = 0;
});
m_rcv.notify_one();
return true;
}
bool peek(T& data, u32 start_pos, const volatile bool* do_exit)
{
return peek(data, start_pos, [do_exit]() { return do_exit && *do_exit; });
}
bool peek(T& data, u32 start_pos = 0)
{
return peek(data, start_pos, SQUEUE_NEVER_EXIT);
}
bool try_peek(T& data, u32 start_pos = 0)
{
return peek(data, start_pos, SQUEUE_ALWAYS_EXIT);
}
class squeue_data_t
{
T* const m_data;
const u32 m_pos;
const u32 m_count;
squeue_data_t(T* data, u32 pos, u32 count)
: m_data(data)
, m_pos(pos)
, m_count(count)
{
}
public:
T& operator [] (u32 index)
{
ensure(index < m_count);
index += m_pos;
index = index < sq_size ? index : index - sq_size;
return m_data[index];
}
};
void process(void(*proc)(squeue_data_t data))
{
u32 pos, count;
while (m_sync.atomic_op([&pos, &count](squeue_sync_var_t& sync) -> u32
{
ensure(sync.count <= sq_size);
ensure(sync.position < sq_size);
if (sync.pop_lock || sync.push_lock)
{
return SQSVR_LOCKED;
}
pos = sync.position;
count = sync.count;
sync.pop_lock = 1;
sync.push_lock = 1;
return SQSVR_OK;
}))
{
std::unique_lock<std::mutex> rcv_lock(m_rcv_mutex);
m_rcv.wait_for(rcv_lock, std::chrono::milliseconds(1));
}
proc(squeue_data_t(m_data, pos, count));
m_sync.atomic_op([](squeue_sync_var_t& sync)
{
ensure(sync.count <= sq_size);
ensure(sync.position < sq_size);
ensure(!!sync.pop_lock);
ensure(!!sync.push_lock);
sync.pop_lock = 0;
sync.push_lock = 0;
});
m_wcv.notify_one();
m_rcv.notify_one();
}
void clear()
{
while (m_sync.atomic_op([](squeue_sync_var_t& sync) -> u32
{
ensure(sync.count <= sq_size);
ensure(sync.position < sq_size);
if (sync.pop_lock || sync.push_lock)
{
return SQSVR_LOCKED;
}
sync.pop_lock = 1;
sync.push_lock = 1;
return SQSVR_OK;
}))
{
std::unique_lock<std::mutex> rcv_lock(m_rcv_mutex);
m_rcv.wait_for(rcv_lock, std::chrono::milliseconds(1));
}
m_sync.exchange({});
m_wcv.notify_one();
m_rcv.notify_one();
}
};
| 21,677
|
C++
|
.h
| 777
| 25.277992
| 131
| 0.68957
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,859
|
cellGame.h
|
RPCS3_rpcs3/rpcs3/Emu/Cell/Modules/cellGame.h
|
#pragma once
#include "Emu/Memory/vm_ptr.h"
// Return Codes
enum
{
CELL_GAME_RET_OK = 0,
CELL_GAME_RET_CANCEL = 1,
CELL_GAME_RET_NONE = 2,
};
enum CellGameError : u32
{
CELL_GAME_ERROR_NOTFOUND = 0x8002cb04,
CELL_GAME_ERROR_BROKEN = 0x8002cb05,
CELL_GAME_ERROR_INTERNAL = 0x8002cb06,
CELL_GAME_ERROR_PARAM = 0x8002cb07,
CELL_GAME_ERROR_NOAPP = 0x8002cb08,
CELL_GAME_ERROR_ACCESS_ERROR = 0x8002cb09,
CELL_GAME_ERROR_NOSPACE = 0x8002cb20,
CELL_GAME_ERROR_NOTSUPPORTED = 0x8002cb21,
CELL_GAME_ERROR_FAILURE = 0x8002cb22,
CELL_GAME_ERROR_BUSY = 0x8002cb23,
CELL_GAME_ERROR_IN_SHUTDOWN = 0x8002cb24,
CELL_GAME_ERROR_INVALID_ID = 0x8002cb25,
CELL_GAME_ERROR_EXIST = 0x8002cb26,
CELL_GAME_ERROR_NOTPATCH = 0x8002cb27,
CELL_GAME_ERROR_INVALID_THEME_FILE = 0x8002cb28,
CELL_GAME_ERROR_BOOTPATH = 0x8002cb50,
};
enum CellGameDataError : u32
{
CELL_GAMEDATA_ERROR_CBRESULT = 0x8002b601,
CELL_GAMEDATA_ERROR_ACCESS_ERROR = 0x8002b602,
CELL_GAMEDATA_ERROR_INTERNAL = 0x8002b603,
CELL_GAMEDATA_ERROR_PARAM = 0x8002b604,
CELL_GAMEDATA_ERROR_NOSPACE = 0x8002b605,
CELL_GAMEDATA_ERROR_BROKEN = 0x8002b606,
CELL_GAMEDATA_ERROR_FAILURE = 0x8002b607,
};
enum CellDiscGameError : u32
{
CELL_DISCGAME_ERROR_INTERNAL = 0x8002bd01,
CELL_DISCGAME_ERROR_NOT_DISCBOOT = 0x8002bd02,
CELL_DISCGAME_ERROR_PARAM = 0x8002bd03,
};
// Definitions
enum
{
CELL_GAME_PATH_MAX = 128,
CELL_GAME_DIRNAME_SIZE = 32,
CELL_GAME_HDDGAMEPATH_SIZE = 128,
CELL_GAME_THEMEFILENAME_SIZE = 48,
CELL_GAME_SYSP_LANGUAGE_NUM = 20,
CELL_GAME_SYSP_TITLE_SIZE = 128,
CELL_GAME_SYSP_TITLEID_SIZE = 10,
CELL_GAME_SYSP_VERSION_SIZE = 6,
CELL_GAME_SYSP_PS3_SYSTEM_VER_SIZE = 8,
CELL_GAME_SYSP_APP_VER_SIZE = 6,
CELL_GAME_GAMETYPE_SYS = 0,
CELL_GAME_GAMETYPE_DISC = 1,
CELL_GAME_GAMETYPE_HDD = 2,
CELL_GAME_GAMETYPE_GAMEDATA = 3,
CELL_GAME_GAMETYPE_HOME = 4,
CELL_GAME_SIZEKB_NOTCALC = -1,
CELL_GAME_THEMEINSTALL_BUFSIZE_MIN = 4096,
CELL_GAME_ATTRIBUTE_PATCH = 0x1,
CELL_GAME_ATTRIBUTE_APP_HOME = 0x2,
CELL_GAME_ATTRIBUTE_DEBUG = 0x4,
CELL_GAME_ATTRIBUTE_XMBBUY = 0x8,
CELL_GAME_ATTRIBUTE_COMMERCE2_BROWSER = 0x10,
CELL_GAME_ATTRIBUTE_INVITE_MESSAGE = 0x20,
CELL_GAME_ATTRIBUTE_CUSTOM_DATA_MESSAGE = 0x40,
CELL_GAME_ATTRIBUTE_WEB_BROWSER = 0x100,
CELL_GAME_THEME_OPTION_NONE = 0x0,
CELL_GAME_THEME_OPTION_APPLY = 0x1,
CELL_GAME_DISCTYPE_OTHER = 0,
CELL_GAME_DISCTYPE_PS3 = 1,
CELL_GAME_DISCTYPE_PS2 = 2,
};
//Parameter IDs of PARAM.SFO
enum
{
//Integers
CELL_GAME_PARAMID_PARENTAL_LEVEL = 102,
CELL_GAME_PARAMID_RESOLUTION = 103,
CELL_GAME_PARAMID_SOUND_FORMAT = 104,
//Strings
CELL_GAME_PARAMID_TITLE = 0,
CELL_GAME_PARAMID_TITLE_DEFAULT = 1,
CELL_GAME_PARAMID_TITLE_JAPANESE = 2,
CELL_GAME_PARAMID_TITLE_ENGLISH = 3,
CELL_GAME_PARAMID_TITLE_FRENCH = 4,
CELL_GAME_PARAMID_TITLE_SPANISH = 5,
CELL_GAME_PARAMID_TITLE_GERMAN = 6,
CELL_GAME_PARAMID_TITLE_ITALIAN = 7,
CELL_GAME_PARAMID_TITLE_DUTCH = 8,
CELL_GAME_PARAMID_TITLE_PORTUGUESE = 9,
CELL_GAME_PARAMID_TITLE_RUSSIAN = 10,
CELL_GAME_PARAMID_TITLE_KOREAN = 11,
CELL_GAME_PARAMID_TITLE_CHINESE_T = 12,
CELL_GAME_PARAMID_TITLE_CHINESE_S = 13,
CELL_GAME_PARAMID_TITLE_FINNISH = 14,
CELL_GAME_PARAMID_TITLE_SWEDISH = 15,
CELL_GAME_PARAMID_TITLE_DANISH = 16,
CELL_GAME_PARAMID_TITLE_NORWEGIAN = 17,
CELL_GAME_PARAMID_TITLE_POLISH = 18,
CELL_GAME_PARAMID_TITLE_PORTUGUESE_BRAZIL = 19, // FW 4.00
CELL_GAME_PARAMID_TITLE_ENGLISH_UK = 20, // FW 4.00
CELL_GAME_PARAMID_TITLE_TURKISH = 21, // FW 4.30
CELL_GAME_PARAMID_TITLE_ID = 100,
CELL_GAME_PARAMID_VERSION = 101,
CELL_GAME_PARAMID_PS3_SYSTEM_VER = 105,
CELL_GAME_PARAMID_APP_VER = 106,
};
//Error dialog types
enum
{
CELL_GAME_ERRDIALOG_BROKEN_GAMEDATA = 0,
CELL_GAME_ERRDIALOG_BROKEN_HDDGAME = 1,
CELL_GAME_ERRDIALOG_NOSPACE = 2,
CELL_GAME_ERRDIALOG_BROKEN_EXIT_GAMEDATA = 100,
CELL_GAME_ERRDIALOG_BROKEN_EXIT_HDDGAME = 101,
CELL_GAME_ERRDIALOG_NOSPACE_EXIT = 102,
};
enum // CellGameResolution
{
CELL_GAME_RESOLUTION_480 = 0x01,
CELL_GAME_RESOLUTION_576 = 0x02,
CELL_GAME_RESOLUTION_720 = 0x04,
CELL_GAME_RESOLUTION_1080 = 0x08,
CELL_GAME_RESOLUTION_480SQ = 0x10,
CELL_GAME_RESOLUTION_576SQ = 0x20,
};
enum // CellGameSoundFormat
{
CELL_GAME_SOUNDFORMAT_2LPCM = 0x01,
CELL_GAME_SOUNDFORMAT_51LPCM = 0x04,
CELL_GAME_SOUNDFORMAT_71LPCM = 0x10,
CELL_GAME_SOUNDFORMAT_51DDENC = 0x102,
CELL_GAME_SOUNDFORMAT_51DTSENC = 0x202,
};
struct CellGameContentSize
{
be_t<s32> hddFreeSizeKB;
be_t<s32> sizeKB;
be_t<s32> sysSizeKB;
};
struct CellGameSetInitParams
{
char title[CELL_GAME_SYSP_TITLE_SIZE];
char titleId[CELL_GAME_SYSP_TITLEID_SIZE];
char reserved0[2];
char version[CELL_GAME_SYSP_VERSION_SIZE];
char reserved1[66];
};
struct CellGameDataCBResult
{
be_t<s32> result;
be_t<s32> errNeedSizeKB;
vm::bptr<char> invalidMsg;
vm::bptr<void> reserved;
};
enum // old consts
{
CELL_GAMEDATA_CBRESULT_OK_CANCEL = 1,
CELL_GAMEDATA_CBRESULT_OK = 0,
CELL_GAMEDATA_CBRESULT_ERR_NOSPACE = -1,
CELL_GAMEDATA_CBRESULT_ERR_BROKEN = -3,
CELL_GAMEDATA_CBRESULT_ERR_NODATA = -4,
CELL_GAMEDATA_CBRESULT_ERR_INVALID = -5,
CELL_GAMEDATA_RET_OK = 0,
CELL_GAMEDATA_RET_CANCEL = 1,
CELL_GAMEDATA_ATTR_NORMAL = 0,
CELL_GAMEDATA_VERSION_CURRENT = 0,
CELL_GAMEDATA_INVALIDMSG_MAX = 256,
CELL_GAMEDATA_PATH_MAX = 1055,
CELL_GAMEDATA_DIRNAME_SIZE = 32,
CELL_GAMEDATA_SIZEKB_NOTCALC = -1,
CELL_GAMEDATA_SYSP_LANGUAGE_NUM = 20,
CELL_GAMEDATA_SYSP_TITLE_SIZE = 128,
CELL_GAMEDATA_SYSP_TITLEID_SIZE = 10,
CELL_GAMEDATA_SYSP_VERSION_SIZE = 6,
CELL_GAMEDATA_ISNEWDATA_NO = 0,
CELL_GAMEDATA_ISNEWDATA_YES = 1,
CELL_GAMEDATA_ERRDIALOG_NONE = 0,
CELL_GAMEDATA_ERRDIALOG_ALWAYS = 1,
CELL_DISCGAME_SYSP_TITLEID_SIZE=10,
};
enum
{
TITLEID_SFO_ENTRY_SIZE = 16, // This is the true length on PS3 (TODO: Fix in more places)
};
struct CellGameDataSystemFileParam
{
char title[CELL_GAMEDATA_SYSP_TITLE_SIZE];
char titleLang[CELL_GAMEDATA_SYSP_LANGUAGE_NUM][CELL_GAMEDATA_SYSP_TITLE_SIZE];
char titleId[CELL_GAMEDATA_SYSP_TITLEID_SIZE];
char reserved0[2];
char dataVersion[CELL_GAMEDATA_SYSP_VERSION_SIZE];
char reserved1[2];
be_t<u32> parentalLevel;
be_t<u32> attribute;
be_t<u32> resolution; // cellHddGameCheck member: GD doesn't have this value
be_t<u32> soundFormat; // cellHddGameCheck member: GD doesn't have this value
char reserved2[248];
};
struct CellDiscGameSystemFileParam
{
char titleId[CELL_DISCGAME_SYSP_TITLEID_SIZE];
char reserved0[2];
be_t<u32> parentalLevel;
char reserved1[16];
};
struct CellGameDataStatGet
{
be_t<s32> hddFreeSizeKB;
be_t<u32> isNewData;
char contentInfoPath[CELL_GAMEDATA_PATH_MAX];
char gameDataPath[CELL_GAMEDATA_PATH_MAX];
char reserved0[2];
be_t<s64> st_atime_;
be_t<s64> st_mtime_;
be_t<s64> st_ctime_;
CellGameDataSystemFileParam getParam;
be_t<s32> sizeKB;
be_t<s32> sysSizeKB;
char reserved1[68];
};
struct CellGameDataStatSet
{
vm::bptr<CellGameDataSystemFileParam> setParam;
be_t<u32> reserved;
};
typedef void(CellGameDataStatCallback)(vm::ptr<CellGameDataCBResult> cbResult, vm::ptr<CellGameDataStatGet> get, vm::ptr<CellGameDataStatSet> set);
// cellSysutil: cellHddGame
enum CellHddGameError : u32
{
CELL_HDDGAME_ERROR_CBRESULT = 0x8002ba01,
CELL_HDDGAME_ERROR_ACCESS_ERROR = 0x8002ba02,
CELL_HDDGAME_ERROR_INTERNAL = 0x8002ba03,
CELL_HDDGAME_ERROR_PARAM = 0x8002ba04,
CELL_HDDGAME_ERROR_NOSPACE = 0x8002ba05,
CELL_HDDGAME_ERROR_BROKEN = 0x8002ba06,
CELL_HDDGAME_ERROR_FAILURE = 0x8002ba07,
};
enum
{
// Return Codes
CELL_HDDGAME_RET_OK = 0,
CELL_HDDGAME_RET_CANCEL = 1,
// Callback Result
CELL_HDDGAME_CBRESULT_OK_CANCEL = 1,
CELL_HDDGAME_CBRESULT_OK = 0,
CELL_HDDGAME_CBRESULT_ERR_NOSPACE = -1,
CELL_HDDGAME_CBRESULT_ERR_BROKEN = -3,
CELL_HDDGAME_CBRESULT_ERR_NODATA = -4,
CELL_HDDGAME_CBRESULT_ERR_INVALID = -5,
// Character Strings
CELL_HDDGAME_INVALIDMSG_MAX = 256,
CELL_HDDGAME_PATH_MAX = 1055,
CELL_HDDGAME_SYSP_TITLE_SIZE = 128,
CELL_HDDGAME_SYSP_TITLEID_SIZE = 10,
CELL_HDDGAME_SYSP_VERSION_SIZE = 6,
CELL_HDDGAME_SYSP_SYSTEMVER_SIZE = 8,
// HDD Directory exists
CELL_HDDGAME_ISNEWDATA_EXIST = 0,
CELL_HDDGAME_ISNEWDATA_NODIR = 1,
// Languages
CELL_HDDGAME_SYSP_LANGUAGE_NUM = 20,
// Stat Get
CELL_HDDGAME_SIZEKB_NOTCALC = -1,
};
using CellHddGameStatGet = CellGameDataStatGet;
using CellHddGameStatSet = CellGameDataStatSet;
using CellHddGameSystemFileParam = CellGameDataSystemFileParam;
using CellHddGameCBResult = CellGameDataCBResult;
typedef void(CellHddGameStatCallback)(vm::ptr<CellHddGameCBResult> cbResult, vm::ptr<CellHddGameStatGet> get, vm::ptr<CellHddGameStatSet> set);
typedef s32(CellGameThemeInstallCallback)(u32 fileOffset, u32 readSize, vm::ptr<void> buf);
typedef void(CellGameDiscEjectCallback)();
typedef void(CellGameDiscInsertCallback)(u32 discType, vm::ptr<char> titleId);
using CellDiscGameDiscEjectCallback = CellGameDiscEjectCallback;
using CellDiscGameDiscInsertCallback = CellGameDiscInsertCallback;
struct disc_change_manager
{
disc_change_manager();
virtual ~disc_change_manager();
std::mutex mtx;
atomic_t<bool> is_inserting = false;
vm::ptr<CellGameDiscEjectCallback> eject_callback = vm::null;
vm::ptr<CellGameDiscInsertCallback> insert_callback = vm::null;
enum class eject_state
{
unknown,
inserted,
ejected,
busy
};
atomic_t<eject_state> state = eject_state::unknown;
error_code register_callbacks(vm::ptr<CellGameDiscEjectCallback> func_eject, vm::ptr<CellGameDiscInsertCallback> func_insert);
error_code unregister_callbacks();
void eject_disc();
void insert_disc(u32 disc_type, std::string title_id);
};
| 10,404
|
C++
|
.h
| 302
| 32.536424
| 147
| 0.70988
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,860
|
cellFont.h
|
RPCS3_rpcs3/rpcs3/Emu/Cell/Modules/cellFont.h
|
#pragma once
#include "Emu/Memory/vm_ptr.h"
// Error codes
enum CellFontError : u32
{
CELL_FONT_ERROR_FATAL = 0x80540001,
CELL_FONT_ERROR_INVALID_PARAMETER = 0x80540002,
CELL_FONT_ERROR_UNINITIALIZED = 0x80540003,
CELL_FONT_ERROR_INITIALIZE_FAILED = 0x80540004,
CELL_FONT_ERROR_INVALID_CACHE_BUFFER = 0x80540005,
CELL_FONT_ERROR_ALREADY_INITIALIZED = 0x80540006,
CELL_FONT_ERROR_ALLOCATION_FAILED = 0x80540007,
CELL_FONT_ERROR_NO_SUPPORT_FONTSET = 0x80540008,
CELL_FONT_ERROR_OPEN_FAILED = 0x80540009,
CELL_FONT_ERROR_READ_FAILED = 0x8054000a,
CELL_FONT_ERROR_FONT_OPEN_FAILED = 0x8054000b,
CELL_FONT_ERROR_FONT_NOT_FOUND = 0x8054000c,
CELL_FONT_ERROR_FONT_OPEN_MAX = 0x8054000d,
CELL_FONT_ERROR_FONT_CLOSE_FAILED = 0x8054000e,
CELL_FONT_ERROR_ALREADY_OPENED = 0x8054000f,
CELL_FONT_ERROR_NO_SUPPORT_FUNCTION = 0x80540010,
CELL_FONT_ERROR_NO_SUPPORT_CODE = 0x80540011,
CELL_FONT_ERROR_NO_SUPPORT_GLYPH = 0x80540012,
CELL_FONT_ERROR_BUFFER_SIZE_NOT_ENOUGH = 0x80540016,
CELL_FONT_ERROR_RENDERER_ALREADY_BIND = 0x80540020,
CELL_FONT_ERROR_RENDERER_UNBIND = 0x80540021,
CELL_FONT_ERROR_RENDERER_INVALID = 0x80540022,
CELL_FONT_ERROR_RENDERER_ALLOCATION_FAILED = 0x80540023,
CELL_FONT_ERROR_ENOUGH_RENDERING_BUFFER = 0x80540024,
CELL_FONT_ERROR_NO_SUPPORT_SURFACE = 0x80540040,
};
// Font Set Types
enum
{
CELL_FONT_TYPE_RODIN_SANS_SERIF_LATIN = 0x00000000,
CELL_FONT_TYPE_RODIN_SANS_SERIF_LIGHT_LATIN = 0x00000001,
CELL_FONT_TYPE_RODIN_SANS_SERIF_BOLD_LATIN = 0x00000002,
CELL_FONT_TYPE_RODIN_SANS_SERIF_LATIN2 = 0x00000018,
CELL_FONT_TYPE_RODIN_SANS_SERIF_LIGHT_LATIN2 = 0x00000019,
CELL_FONT_TYPE_RODIN_SANS_SERIF_BOLD_LATIN2 = 0x0000001a,
CELL_FONT_TYPE_MATISSE_SERIF_LATIN = 0x00000020,
CELL_FONT_TYPE_NEWRODIN_GOTHIC_JAPANESE = 0x00000008,
CELL_FONT_TYPE_NEWRODIN_GOTHIC_LIGHT_JAPANESE = 0x00000009,
CELL_FONT_TYPE_NEWRODIN_GOTHIC_BOLD_JAPANESE = 0x0000000a,
CELL_FONT_TYPE_YD_GOTHIC_KOREAN = 0x0000000c,
CELL_FONT_TYPE_SEURAT_MARU_GOTHIC_LATIN = 0x00000040,
CELL_FONT_TYPE_SEURAT_MARU_GOTHIC_LATIN2 = 0x00000041,
CELL_FONT_TYPE_VAGR_SANS_SERIF_ROUND = 0x00000043,
CELL_FONT_TYPE_VAGR_SANS_SERIF_ROUND_LATIN2 = 0x00000044,
CELL_FONT_TYPE_SEURAT_MARU_GOTHIC_JAPANESE = 0x00000048,
CELL_FONT_TYPE_NEWRODIN_GOTHIC_JP_SET = 0x00000100,
CELL_FONT_TYPE_NEWRODIN_GOTHIC_LATIN_SET = 0x00000101,
CELL_FONT_TYPE_NEWRODIN_GOTHIC_RODIN_SET = 0x00000104,
CELL_FONT_TYPE_NEWRODIN_GOTHIC_RODIN2_SET = 0x00000204,
CELL_FONT_TYPE_NEWRODIN_GOTHIC_YG_RODIN2_SET = 0x00000201,
CELL_FONT_TYPE_NEWRODIN_GOTHIC_YG_DFHEI5_SET = 0x00000108,
CELL_FONT_TYPE_NEWRODIN_GOTHIC_YG_DFHEI5_RODIN_SET = 0x00000109,
CELL_FONT_TYPE_NEWRODIN_GOTHIC_YG_DFHEI5_RODIN2_SET = 0x00000209,
CELL_FONT_TYPE_DFHEI5_GOTHIC_YG_NEWRODIN_TCH_SET = 0x0000010a,
CELL_FONT_TYPE_DFHEI5_GOTHIC_YG_NEWRODIN_RODIN_TCH_SET = 0x0000010b,
CELL_FONT_TYPE_DFHEI5_GOTHIC_YG_NEWRODIN_RODIN2_TCH_SET = 0x0000020b,
CELL_FONT_TYPE_DFHEI5_GOTHIC_YG_NEWRODIN_SCH_SET = 0x0000010c,
CELL_FONT_TYPE_DFHEI5_GOTHIC_YG_NEWRODIN_RODIN_SCH_SET = 0x0000010d,
CELL_FONT_TYPE_DFHEI5_GOTHIC_YG_NEWRODIN_RODIN2_SCH_SET = 0x0000020d,
CELL_FONT_TYPE_SEURAT_MARU_GOTHIC_RSANS_SET = 0x00300104,
CELL_FONT_TYPE_SEURAT_CAPIE_MARU_GOTHIC_RSANS_SET = 0x00300105,
CELL_FONT_TYPE_SEURAT_CAPIE_MARU_GOTHIC_JP_SET = 0x00300107,
CELL_FONT_TYPE_SEURAT_MARU_GOTHIC_YG_DFHEI5_RSANS_SET = 0x00300109,
CELL_FONT_TYPE_SEURAT_CAPIE_MARU_GOTHIC_YG_DFHEI5_RSANS_SET = 0x0030010F,
CELL_FONT_TYPE_VAGR_SEURAT_CAPIE_MARU_GOTHIC_RSANS_SET = 0x00300124,
CELL_FONT_TYPE_VAGR_SEURAT_CAPIE_MARU_GOTHIC_YG_DFHEI5_RSANS_SET = 0x00300129,
CELL_FONT_TYPE_NEWRODIN_GOTHIC_YG_LIGHT_SET = 0x00040100,
CELL_FONT_TYPE_NEWRODIN_GOTHIC_YG_RODIN_LIGHT_SET = 0x00040101,
CELL_FONT_TYPE_NEWRODIN_GOTHIC_YG_RODIN2_LIGHT_SET = 0x00040201,
CELL_FONT_TYPE_NEWRODIN_GOTHIC_RODIN_LIGHT_SET = 0x00040104,
CELL_FONT_TYPE_NEWRODIN_GOTHIC_RODIN2_LIGHT_SET = 0x00040204,
CELL_FONT_TYPE_NEWRODIN_GOTHIC_YG_BOLD_SET = 0x00070100,
CELL_FONT_TYPE_NEWRODIN_GOTHIC_YG_RODIN_BOLD_SET = 0x00070101,
CELL_FONT_TYPE_NEWRODIN_GOTHIC_YG_RODIN2_BOLD_SET = 0x00070201,
CELL_FONT_TYPE_NEWRODIN_GOTHIC_RODIN_BOLD_SET = 0x00070104,
CELL_FONT_TYPE_NEWRODIN_GOTHIC_RODIN2_BOLD_SET = 0x00070204,
CELL_FONT_TYPE_SEURAT_MARU_GOTHIC_RSANS2_SET = 0x00300204,
CELL_FONT_TYPE_SEURAT_CAPIE_MARU_GOTHIC_RSANS2_SET = 0x00300205,
CELL_FONT_TYPE_SEURAT_MARU_GOTHIC_YG_DFHEI5_RSANS2_SET = 0x00300209,
CELL_FONT_TYPE_SEURAT_CAPIE_MARU_GOTHIC_YG_DFHEI5_RSANS2_SET = 0x0030020F,
CELL_FONT_TYPE_SEURAT_CAPIE_MARU_GOTHIC_YG_DFHEI5_VAGR2_SET = 0x00300229,
CELL_FONT_TYPE_SEURAT_CAPIE_MARU_GOTHIC_VAGR2_SET = 0x00300224,
};
enum
{
CELL_FONT_LIBRARY_TYPE_NONE = 0
};
enum
{
CELL_FONT_MAP_FONT = 0,
CELL_FONT_MAP_UNICODE = 1,
};
enum
{
CELL_FONT_OPEN_MODE_DEFAULT = 0,
CELL_FONT_OPEN_MODE_IGNORE_VERTICAL_METRICS = 1,
};
enum
{
CELL_FONT_GRAPHICS_DRAW_TYPE_MONO = 0,
CELL_FONT_GRAPHICS_DRAW_TYPE_COLOR = 1,
CELL_FONT_GRAPHICS_DRAW_TYPE_COLOR_REVERSE = 2,
};
//Custom enum to determine the origin of a CellFont object
enum
{
CELL_FONT_OPEN_FONTSET,
CELL_FONT_OPEN_FONT_FILE,
CELL_FONT_OPEN_FONT_INSTANCE,
CELL_FONT_OPEN_MEMORY,
};
constexpr f32 CELL_FONT_GLYPH_OUTLINE_CONTROL_DISTANCE_DEFAULT = 0.125f;
using CellFontMallocCallback = vm::ptr<void>(vm::ptr<void> arg, u32 size);
using CellFontFreeCallback = void(vm::ptr<void> arg, vm::ptr<void> ptr);
using CellFontReallocCallback = vm::ptr<void>(vm::ptr<void> arg, vm::ptr<void> p, u32 reallocSize);
using CellFontCallocCallback = vm::ptr<void>(vm::ptr<void> arg, u32 num, u32 size);
struct CellFontMemoryInterface
{
vm::bptr<void> arg;
vm::bptr<CellFontMallocCallback> malloc;
vm::bptr<CellFontFreeCallback> free;
vm::bptr<CellFontReallocCallback> realloc;
vm::bptr<CellFontCallocCallback> calloc;
};
struct CellFontEntry
{
be_t<u32> lock;
be_t<u32> uniqueId;
vm::bcptr<void> fontLib;
vm::bptr<void> fontH;
};
struct CellFontConfig
{
// FileCache
vm::bptr<u32> fc_buffer;
be_t<u32> fc_size;
be_t<u32> userFontEntryMax;
vm::bptr<CellFontEntry> userFontEntrys;
be_t<u32> flags;
};
struct CellFontLibrary
{
be_t<u32> libraryType;
be_t<u32> libraryVersion;
vm::bptr<u32> SystemClosed;
};
struct CellFontType
{
be_t<u32> type;
be_t<u32> map;
};
struct CellFontHorizontalLayout
{
be_t<f32> baseLineY;
be_t<f32> lineHeight;
be_t<f32> effectHeight;
};
struct CellFontVerticalLayout
{
be_t<f32> baseLineX;
be_t<f32> lineWidth;
be_t<f32> effectWidth;
};
struct CellFontVertexesGlyphSubHeader
{
be_t<u32> size;
be_t<f32> SystemReserved[11];
};
struct CellFontVertexesGlyphData
{
const be_t<u32> size;
vm::bptr<f32> SystemClosed;
};
struct CellFontVertexesGlyph
{
vm::bptr<CellFontVertexesGlyphData> data;
vm::bptr<CellFontVertexesGlyphSubHeader> subHeader;
};
struct CellFontGlyphMetrics
{
be_t<f32> width;
be_t<f32> height;
be_t<f32> h_bearingX;
be_t<f32> h_bearingY;
be_t<f32> h_advance;
be_t<f32> v_bearingX;
be_t<f32> v_bearingY;
be_t<f32> v_advance;
};
struct CellFontGlyphOutline
{
be_t<s16> contoursCount;
be_t<s16> pointsCount;
struct Point
{
be_t<f32> x;
be_t<f32> y;
};
vm::bptr<Point> points;
vm::bptr<u8> pointTags;
vm::bptr<u16> contourIndexs;
be_t<u32> flags;
vm::bptr<void> generateEnv;
};
using CellFontGetOutlineVertexCallback = vm::ptr<void>(vm::ptr<void> arg, s32 contourN, s32 vertexNumber, s32 vertexAttr, f32 x, f32 y);
struct CellFontGetOutlineVertexesIF
{
vm::bptr<CellFontGetOutlineVertexCallback> callback;
vm::bptr<void> arg;
};
struct CellFontGlyphBoundingBox
{
be_t<f32> min_x;
be_t<f32> min_y;
be_t<f32> max_x;
be_t<f32> max_y;
};
struct CellFontKerning
{
be_t<f32> offsetX;
be_t<f32> offsetY;
};
struct CellFontGlyphStyle
{
be_t<f32> scale_widthPixel;
be_t<f32> scale_heightPixel;
be_t<f32> effect_weight;
be_t<f32> effect_slant;
};
struct CellFontGlyph
{
be_t<u16> CF_type;
be_t<u16> type;
be_t<u32> size;
CellFontGlyphMetrics Metrics;
CellFontGlyphOutline Outline;
};
struct CellFontRenderSurface
{
vm::bptr<void> buffer;
be_t<s32> widthByte;
be_t<s32> pixelSizeByte;
be_t<s32> width;
be_t<s32> height;
// Scissor
be_t<u32> sc_x0;
be_t<u32> sc_y0;
be_t<u32> sc_x1;
be_t<u32> sc_y1;
};
struct CellFontImageTransInfo
{
vm::bptr<u8> image;
be_t<u32> imageWidthByte;
be_t<u32> imageWidth;
be_t<u32> imageHeight;
vm::bptr<void> surface;
be_t<u32> surfWidthByte;
};
struct CellFont
{
be_t<float> scale_x;
be_t<float> scale_y;
be_t<float> slant;
be_t<u32> renderer_addr;
be_t<u32> fontdata_addr;
be_t<u32> origin;
struct stbtt_fontinfo* stbfont;
// hack: don't place anything after pointer
};
struct CellFontRendererConfig
{
// Buffering Policy
vm::bptr<void> buffer;
be_t<u32> initSize;
be_t<u32> maxSize;
be_t<u32> expandSize;
be_t<u32> resetSize;
};
struct CellFontRenderer
{
vm::bptr<void> systemReserved[64];
};
struct CellFontGraphics
{
be_t<u32> graphicsType;
vm::bptr<uint32_t> SystemClosed;
};
struct CellFontGraphicsDrawContext
{
vm::bptr<void> SystemReserved[64];
};
| 9,639
|
C++
|
.h
| 297
| 30.632997
| 136
| 0.724416
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,861
|
cellMic.h
|
RPCS3_rpcs3/rpcs3/Emu/Cell/Modules/cellMic.h
|
#pragma once
#include "Utilities/Thread.h"
#include "Emu/Cell/timers.hpp"
#include "3rdparty/OpenAL/openal-soft/include/AL/alext.h"
// Error Codes
enum CellMicInError : u32
{
CELL_MICIN_ERROR_ALREADY_INIT = 0x80140101,
CELL_MICIN_ERROR_DEVICE = 0x80140102,
CELL_MICIN_ERROR_NOT_INIT = 0x80140103,
CELL_MICIN_ERROR_PARAM = 0x80140104,
CELL_MICIN_ERROR_PORT_FULL = 0x80140105,
CELL_MICIN_ERROR_ALREADY_OPEN = 0x80140106,
CELL_MICIN_ERROR_NOT_OPEN = 0x80140107,
CELL_MICIN_ERROR_NOT_RUN = 0x80140108,
CELL_MICIN_ERROR_TRANS_EVENT = 0x80140109,
CELL_MICIN_ERROR_OPEN = 0x8014010a,
CELL_MICIN_ERROR_SHAREDMEMORY = 0x8014010b,
CELL_MICIN_ERROR_MUTEX = 0x8014010c,
CELL_MICIN_ERROR_EVENT_QUEUE = 0x8014010d,
CELL_MICIN_ERROR_DEVICE_NOT_FOUND = 0x8014010e,
CELL_MICIN_ERROR_FATAL = 0x8014010f,
CELL_MICIN_ERROR_DEVICE_NOT_SUPPORT = 0x80140110,
// CELL_MICIN_ERROR_SYSTEM = CELL_MICIN_ERROR_DEVICE,
// CELL_MICIN_ERROR_SYSTEM_NOT_FOUND = CELL_MICIN_ERROR_DEVICE_NOT_FOUND,
// CELL_MICIN_ERROR_SYSTEM_NOT_SUPPORT = CELL_MICIN_ERROR_DEVICE_NOT_SUPPORT
};
enum CellMicInErrorDsp : u32
{
CELL_MICIN_ERROR_DSP = 0x80140200,
CELL_MICIN_ERROR_DSP_ASSERT = 0x80140201,
CELL_MICIN_ERROR_DSP_PATH = 0x80140202,
CELL_MICIN_ERROR_DSP_FILE = 0x80140203,
CELL_MICIN_ERROR_DSP_PARAM = 0x80140204,
CELL_MICIN_ERROR_DSP_MEMALLOC = 0x80140205,
CELL_MICIN_ERROR_DSP_POINTER = 0x80140206,
CELL_MICIN_ERROR_DSP_FUNC = 0x80140207,
CELL_MICIN_ERROR_DSP_MEM = 0x80140208,
CELL_MICIN_ERROR_DSP_ALIGN16 = 0x80140209,
CELL_MICIN_ERROR_DSP_ALIGN128 = 0x8014020a,
CELL_MICIN_ERROR_DSP_EAALIGN128 = 0x8014020b,
CELL_MICIN_ERROR_DSP_LIB_HANDLER = 0x80140216,
CELL_MICIN_ERROR_DSP_LIB_INPARAM = 0x80140217,
CELL_MICIN_ERROR_DSP_LIB_NOSPU = 0x80140218,
CELL_MICIN_ERROR_DSP_LIB_SAMPRATE = 0x80140219,
};
enum CellMicSignalState : u32
{
CELLMIC_SIGSTATE_LOCTALK = 0,
CELLMIC_SIGSTATE_FARTALK = 1,
CELLMIC_SIGSTATE_NSR = 3,
CELLMIC_SIGSTATE_AGC = 4,
CELLMIC_SIGSTATE_MICENG = 5,
CELLMIC_SIGSTATE_SPKENG = 6,
};
enum CellMicCommand
{
CELLMIC_INIT = 0,
CELLMIC_END,
CELLMIC_ATTACH,
CELLMIC_DETACH,
CELLMIC_SWITCH,
CELLMIC_DATA,
CELLMIC_OPEN,
CELLMIC_CLOSE,
CELLMIC_START,
CELLMIC_STOP,
CELLMIC_QUERY,
CELLMIC_CONFIG,
CELLMIC_CALLBACK,
CELLMIC_RESET,
CELLMIC_STATUS,
CELLMIC_IPC,
CELLMIC_CALLBACK2,
CELLMIC_WEAK,
CELLMIC_INIT2,
};
enum CellMicDeviceAttr : u32
{
CELLMIC_DEVATTR_LED = 9,
CELLMIC_DEVATTR_GAIN = 10,
CELLMIC_DEVATTR_VOLUME = 201,
CELLMIC_DEVATTR_AGC = 202,
CELLMIC_DEVATTR_CHANVOL = 301,
CELLMIC_DEVATTR_DSPTYPE = 302,
};
enum CellMicSignalAttr : u32
{
CELLMIC_SIGATTR_BKNGAIN = 0,
CELLMIC_SIGATTR_REVERB = 9,
CELLMIC_SIGATTR_AGCLEVEL = 26,
CELLMIC_SIGATTR_VOLUME = 301,
CELLMIC_SIGATTR_PITCHSHIFT = 331
};
enum CellMicSignalType : u8
{
CELLMIC_SIGTYPE_NULL = 0,
CELLMIC_SIGTYPE_DSP = 1,
CELLMIC_SIGTYPE_AUX = 2,
CELLMIC_SIGTYPE_RAW = 4,
};
enum CellMicType : s32
{
CELLMIC_TYPE_UNDEF = -1,
CELLMIC_TYPE_UNKNOWN = 0,
CELLMIC_TYPE_EYETOY1 = 1,
CELLMIC_TYPE_EYETOY2 = 2,
CELLMIC_TYPE_USBAUDIO = 3,
CELLMIC_TYPE_BLUETOOTH = 4,
CELLMIC_TYPE_A2DP = 5,
};
enum
{
CELL_MAX_MICS = 8,
MAX_MICS_PERMISSABLE = 4,
NullDeviceID = -1,
CELL_MIC_STARTFLAG_LATENCY_4 = 0x00000001,
CELL_MIC_STARTFLAG_LATENCY_2 = 0x00000002,
CELL_MIC_STARTFLAG_LATENCY_1 = 0x00000003,
};
enum : u64
{
SYSMICIN_KEYBASE = 0x8000CA7211071000ULL,
EQUEUE_KEY_MICIN_ACCESSPOINT = 0x8000CA7211072abcULL,
LIBMIC_KEYBASE = 0x8000000000000100ULL,
};
struct CellMicInputFormatI
{
u8 channelNum;
u8 subframeSize;
u8 bitResolution;
u8 dataType;
be_t<u32> sampleRate;
};
struct CellMicInputStream
{
be_t<u32> uiBufferBottom;
be_t<u32> uiBufferSize;
be_t<u32> uiBuffer;
};
struct CellMicInputDefinition
{
be_t<u32> uiDevId;
CellMicInputStream data;
CellMicInputFormatI aux_format;
CellMicInputFormatI raw_format;
CellMicInputFormatI sig_format;
};
struct CellMicStatus
{
be_t<s32> raw_samprate;
be_t<s32> dsp_samprate;
be_t<s32> dsp_volume;
be_t<s32> isStart;
be_t<s32> isOpen;
be_t<s32> local_voice;
be_t<s32> remote_voice;
be_t<f32> mic_energy;
be_t<f32> spk_energy;
};
// --- End of cell definitions ---
template <usz Size>
class simple_ringbuf
{
public:
simple_ringbuf()
{
m_container.resize(Size);
}
bool has_data() const
{
return m_used != 0;
}
u32 read_bytes(u8* buf, const u32 size)
{
const u32 to_read = size > m_used ? m_used : size;
if (!to_read)
return 0;
ensure(buf);
u8* data = m_container.data();
const u32 new_tail = m_tail + to_read;
if (new_tail >= Size)
{
const u32 first_chunk_size = Size - m_tail;
std::memcpy(buf, data + m_tail, first_chunk_size);
std::memcpy(buf + first_chunk_size, data, to_read - first_chunk_size);
m_tail = (new_tail - Size);
}
else
{
std::memcpy(buf, data + m_tail, to_read);
m_tail = new_tail;
}
m_used -= to_read;
return to_read;
}
void write_bytes(const u8* buf, const u32 size)
{
if (size == 0)
{
return;
}
ensure(size <= Size);
const u32 over_size = m_used + size;
if (over_size > Size)
{
m_tail += (over_size - Size);
if (m_tail > Size)
m_tail -= Size;
m_used = Size;
}
else
{
m_used = over_size;
}
u8* data = m_container.data();
const u32 new_head = m_head + size;
if (new_head >= Size)
{
const u32 first_chunk_size = Size - m_head;
std::memcpy(data + m_head, buf, first_chunk_size);
std::memcpy(data, buf + first_chunk_size, size - first_chunk_size);
m_head = (new_head - Size);
}
else
{
std::memcpy(data + m_head, buf, size);
m_head = new_head;
}
}
protected:
std::vector<u8> m_container;
u32 m_head = 0, m_tail = 0, m_used = 0;
};
class microphone_device
{
public:
microphone_device(microphone_handler type = microphone_handler::null);
void add_device(const std::string& name);
void set_registered(bool registered) { mic_registered = registered; };
error_code open_microphone(const u8 type, const u32 dsp_r, const u32 raw_r, const u8 channels = 2);
error_code close_microphone();
error_code start_microphone();
error_code stop_microphone();
std::string get_device_name() const { return devices.empty() ? "" : devices.front().name; }
void update_audio();
bool has_data() const;
bool is_registered() const { return mic_registered; }
bool is_opened() const { return mic_opened; }
bool is_started() const { return mic_started; }
u8 get_signal_types() const { return signal_types; }
constexpr u8 get_bit_resolution() const { return bit_resolution; }
u32 get_raw_samplingrate() const { return raw_samplingrate; }
u8 get_num_channels() const { return num_channels; }
u8 get_datatype() const
{
switch(device_type)
{
case microphone_handler::real_singstar:
case microphone_handler::singstar:
return 0; // LE
default:
return 1; // BE
}
}
u32 read_raw(u8* buf, u32 size) { return rbuf_raw.read_bytes(buf, size); }
u32 read_dsp(u8* buf, u32 size) { return rbuf_dsp.read_bytes(buf, size); }
// Microphone attributes
u32 attr_gain = 3; // 0 to 5. Default is 3.
u32 attr_volume = 145; // 0 to 241. Default is 145.
u32 attr_agc = 0; // 0 to 241. Default is 0.
std::array<u32, 2> attr_chanvol = {100, 100}; // 0 to 100. Default is ?.
u32 attr_led = 0;
u32 attr_dsptype = 0;
private:
template <u32 bytesize>
static inline void variable_byteswap(const void* src, void* dst);
inline u32 convert_16_bit_pcm_to_float(const std::vector<u8>& buffer, u32 num_bytes);
u32 capture_audio();
void get_data(const u32 num_samples);
void get_raw(const u32 num_samples);
void get_dsp(const u32 num_samples);
microphone_handler device_type = microphone_handler::null;
bool mic_registered = false;
bool mic_opened = false;
bool mic_started = false;
struct mic_device
{
std::string name;
ALCdevice* device = nullptr;
std::vector<u8> buf;
};
std::vector<mic_device> devices;
std::vector<u8> temp_buf;
std::vector<u8> float_buf;
// Sampling information provided at opening of mic
u32 raw_samplingrate = 48000;
u32 dsp_samplingrate = 48000;
u32 aux_samplingrate = 48000;
u8 num_channels = 2;
u8 signal_types = CELLMIC_SIGTYPE_NULL;
u32 sample_size = 0; // Determined at opening for internal use
static constexpr u8 bit_resolution = 16;
static constexpr usz inbuf_size = 400000; // Default value unknown
static constexpr usz float_buf_size = inbuf_size * (sizeof(f32) / sizeof(s16));
simple_ringbuf<inbuf_size> rbuf_raw;
simple_ringbuf<float_buf_size> rbuf_dsp;
simple_ringbuf<inbuf_size> rbuf_aux;
};
class mic_context
{
public:
void operator()();
void load_config_and_init();
void wake_up();
// Returns index of registered device
u32 register_device(const std::string& name);
void unregister_device(u32 dev_num);
bool check_device(u32 dev_num);
u64 event_queue_key = 0;
u64 event_queue_source = 0;
std::array<microphone_device, CELL_MAX_MICS> mic_list{};
shared_mutex mutex;
atomic_t<u8> init = 0;
static constexpr auto thread_name = "Microphone Thread"sv;
protected:
atomic_t<u32> wakey = 0;
// u32 signalStateLocalTalk = 9; // value is in range 0-10. 10 indicates talking, 0 indicating none.
// u32 signalStateFarTalk = 0; // value is in range 0-10. 10 indicates talking from far away, 0 indicating none.
// f32 signalStateNoiseSupression; // value is in decibels
// f32 signalStateGainControl;
// f32 signalStateMicSignalLevel; // value is in decibels
// f32 signalStateSpeakerSignalLevel; // value is in decibels
};
using mic_thread = named_thread<mic_context>;
| 9,936
|
C++
|
.h
| 335
| 27.39403
| 113
| 0.700409
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,862
|
sceNpTus.h
|
RPCS3_rpcs3/rpcs3/Emu/Cell/Modules/sceNpTus.h
|
#pragma once
#include "cellRtc.h"
#include "sceNp.h"
#include <map>
// Constants for TUS functions and structures
enum
{
SCE_NP_TUS_DATA_INFO_MAX_SIZE = 384,
SCE_NP_TUS_MAX_CTX_NUM = 32,
SCE_NP_TUS_MAX_SLOT_NUM_PER_TRANS = 64,
SCE_NP_TUS_MAX_USER_NUM_PER_TRANS = 101,
SCE_NP_TUS_MAX_SELECTED_FRIENDS_NUM = 100,
};
enum
{
SCE_NP_TUS_OPETYPE_EQUAL = 1,
SCE_NP_TUS_OPETYPE_NOT_EQUAL,
SCE_NP_TUS_OPETYPE_GREATER_THAN,
SCE_NP_TUS_OPETYPE_GREATER_OR_EQUAL,
SCE_NP_TUS_OPETYPE_LESS_THAN,
SCE_NP_TUS_OPETYPE_LESS_OR_EQUAL
};
enum
{
SCE_NP_TUS_VARIABLE_SORTTYPE_DESCENDING_DATE = 1,
SCE_NP_TUS_VARIABLE_SORTTYPE_ASCENDING_DATE,
SCE_NP_TUS_VARIABLE_SORTTYPE_DESCENDING_VALUE,
SCE_NP_TUS_VARIABLE_SORTTYPE_ASCENDING_VALUE
};
enum
{
SCE_NP_TUS_DATASTATUS_SORTTYPE_DESCENDING_DATE = 1,
SCE_NP_TUS_DATASTATUS_SORTTYPE_ASCENDING_DATE
};
enum SceNpTssStatusCodeType
{
SCE_NP_TSS_STATUS_TYPE_OK,
SCE_NP_TSS_STATUS_TYPE_PARTIAL,
SCE_NP_TSS_STATUS_TYPE_NOT_MODIFIED
};
enum SceNpTssIfType
{
SCE_NP_TSS_IFTYPE_IF_MODIFIED_SINCE,
SCE_NP_TSS_IFTYPE_IF_RANGE
};
using SceNpTssSlotId = s32;
using SceNpTusSlotId = s32;
using SceNpTusVirtualUserId = SceNpOnlineId;
// Structure for representing a TUS variable
struct SceNpTusVariable
{
SceNpId ownerId;
be_t<s32> hasData;
CellRtcTick lastChangedDate;
u8 pad[4];
SceNpId lastChangedAuthorId;
be_t<s64> variable;
be_t<s64> oldVariable;
u8 reserved[16];
};
// Structure for representing the accessory information of a TUS data
struct SceNpTusDataInfo
{
be_t<u32> infoSize;
u8 pad[4];
u8 data[SCE_NP_TUS_DATA_INFO_MAX_SIZE];
};
// Structure for respreseting the status of TUS data
struct SceNpTusDataStatus
{
SceNpId ownerId;
be_t<s32> hasData;
CellRtcTick lastChangedDate;
SceNpId lastChangedAuthorId;
vm::bptr<void> data;
be_t<u32> dataSize;
u8 pad[4];
SceNpTusDataInfo info;
};
struct SceNpTusAddAndGetVariableOptParam
{
be_t<u32> size;
vm::bptr<CellRtcTick> isLastChangedDate;
vm::bptr<SceNpId> isLastChangedAuthorId;
};
struct SceNpTusTryAndSetVariableOptParam
{
be_t<u32> size;
vm::bptr<CellRtcTick> isLastChangedDate;
vm::bptr<SceNpId> isLastChangedAuthorId;
vm::bptr<s64> compareValue;
};
struct SceNpTusSetDataOptParam
{
be_t<u32> size;
vm::bptr<CellRtcTick> isLastChangedDate;
vm::bptr<SceNpId> isLastChangedAuthorId;
};
struct SceNpTssDataStatus
{
CellRtcTick lastModified;
be_t<s32> statusCodeType;
be_t<u32> contentLength;
};
struct SceNpTssIfModifiedSinceParam
{
be_t<s32> ifType;
u8 padding[4];
CellRtcTick lastModified;
};
struct SceNpTssGetDataOptParam
{
be_t<u32> size;
vm::bptr<u64> offset;
vm::bptr<u64> lastByte;
vm::bptr<SceNpTssIfModifiedSinceParam> ifParam;
};
// fxm objects
struct sce_np_tus_transaction_context
{
s32 id = 0;
u32 timeout = 0;
bool abort = false;
};
struct sce_np_tus_title_context
{
std::map<s32 /*transaction_context_id*/, sce_np_tus_transaction_context> transaction_contexts;
};
struct sce_np_tus_manager
{
private:
s32 next_title_context_id = 1;
s32 next_transaction_context_id = 1;
std::map<s32 /*title_context_id*/, sce_np_tus_title_context> title_contexts;
public:
std::mutex mtx;
atomic_t<bool> is_initialized = false;
s32 add_title_context();
bool check_title_context_id(s32 titleCtxId);
bool remove_title_context_id(s32 titleCtxId);
sce_np_tus_title_context* get_title_context(s32 titleCtxId);
s32 add_transaction_context(s32 titleCtxId);
bool check_transaction_context_id(s32 transId);
bool remove_transaction_context_id(s32 transId);
sce_np_tus_transaction_context* get_transaction_context(s32 transId);
void terminate();
};
| 3,605
|
C++
|
.h
| 147
| 22.809524
| 95
| 0.785839
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,863
|
cellDmux.h
|
RPCS3_rpcs3/rpcs3/Emu/Cell/Modules/cellDmux.h
|
#pragma once
#include "Emu/Memory/vm_ptr.h"
// Error Codes
enum CellDmuxError :u32
{
CELL_DMUX_ERROR_ARG = 0x80610201,
CELL_DMUX_ERROR_SEQ = 0x80610202,
CELL_DMUX_ERROR_BUSY = 0x80610203,
CELL_DMUX_ERROR_EMPTY = 0x80610204,
CELL_DMUX_ERROR_FATAL = 0x80610205,
};
enum CellDmuxStreamType : s32
{
CELL_DMUX_STREAM_TYPE_UNDEF = 0,
CELL_DMUX_STREAM_TYPE_PAMF = 1,
CELL_DMUX_STREAM_TYPE_TERMINATOR = 2,
};
enum CellDmuxMsgType : s32
{
CELL_DMUX_MSG_TYPE_DEMUX_DONE = 0,
CELL_DMUX_MSG_TYPE_FATAL_ERR = 1,
CELL_DMUX_MSG_TYPE_PROG_END_CODE = 2,
};
enum CellDmuxEsMsgType : s32
{
CELL_DMUX_ES_MSG_TYPE_AU_FOUND = 0,
CELL_DMUX_ES_MSG_TYPE_FLUSH_DONE = 1,
};
enum CellDmuxPamfM2vLevel : s32
{
CELL_DMUX_PAMF_M2V_MP_LL = 0,
CELL_DMUX_PAMF_M2V_MP_ML,
CELL_DMUX_PAMF_M2V_MP_H14,
CELL_DMUX_PAMF_M2V_MP_HL,
};
enum CellDmuxPamfAvcLevel : s32
{
CELL_DMUX_PAMF_AVC_LEVEL_2P1 = 21,
CELL_DMUX_PAMF_AVC_LEVEL_3P0 = 30,
CELL_DMUX_PAMF_AVC_LEVEL_3P1 = 31,
CELL_DMUX_PAMF_AVC_LEVEL_3P2 = 32,
CELL_DMUX_PAMF_AVC_LEVEL_4P1 = 41,
CELL_DMUX_PAMF_AVC_LEVEL_4P2 = 42,
};
struct CellDmuxPamfAuSpecificInfoM2v
{
be_t<u32> reserved1;
};
struct CellDmuxPamfAuSpecificInfoAvc
{
be_t<u32> reserved1;
};
struct CellDmuxPamfAuSpecificInfoLpcm
{
u8 channelAssignmentInfo;
u8 samplingFreqInfo;
u8 bitsPerSample;
};
struct CellDmuxPamfAuSpecificInfoAc3
{
be_t<u32> reserved1;
};
struct CellDmuxPamfAuSpecificInfoAtrac3plus
{
be_t<u32> reserved1;
};
struct CellDmuxPamfAuSpecificInfoUserData
{
be_t<u32> reserved1;
};
struct CellDmuxPamfEsSpecificInfoM2v
{
be_t<u32> profileLevel;
};
struct CellDmuxPamfEsSpecificInfoAvc
{
be_t<u32> level;
};
struct CellDmuxPamfEsSpecificInfoLpcm
{
be_t<u32> samplingFreq;
be_t<u32> numOfChannels;
be_t<u32> bitsPerSample;
};
struct CellDmuxPamfEsSpecificInfoAc3
{
be_t<u32> reserved1;
};
struct CellDmuxPamfEsSpecificInfoAtrac3plus
{
be_t<u32> reserved1;
};
struct CellDmuxPamfEsSpecificInfoUserData
{
be_t<u32> reserved1;
};
enum CellDmuxPamfSamplingFrequency : s32
{
CELL_DMUX_PAMF_FS_48K = 48000,
};
enum CellDmuxPamfBitsPerSample : s32
{
CELL_DMUX_PAMF_BITS_PER_SAMPLE_16 = 16,
CELL_DMUX_PAMF_BITS_PER_SAMPLE_24 = 24,
};
enum CellDmuxPamfLpcmChannelAssignmentInfo : s32
{
CELL_DMUX_PAMF_LPCM_CH_M1 = 1,
CELL_DMUX_PAMF_LPCM_CH_LR = 3,
CELL_DMUX_PAMF_LPCM_CH_LRCLSRSLFE = 9,
CELL_DMUX_PAMF_LPCM_CH_LRCLSCS1CS2RSLFE = 11,
};
enum CellDmuxPamfLpcmFs : s32
{
CELL_DMUX_PAMF_LPCM_FS_48K = 1,
};
enum CellDmuxPamfLpcmBitsPerSamples : s32
{
CELL_DMUX_PAMF_LPCM_BITS_PER_SAMPLE_16 = 1,
CELL_DMUX_PAMF_LPCM_BITS_PER_SAMPLE_24 = 3,
};
struct CellDmuxMsg
{
be_t<s32> msgType; // CellDmuxMsgType
be_t<u64> supplementalInfo;
};
struct CellDmuxEsMsg
{
be_t<s32> msgType; // CellDmuxEsMsgType
be_t<u64> supplementalInfo;
};
struct CellDmuxType
{
be_t<s32> streamType; // CellDmuxStreamType
be_t<u32> reserved[2];
};
struct CellDmuxPamfSpecificInfo
{
be_t<u32> thisSize;
b8 programEndCodeCb;
};
struct CellDmuxType2
{
be_t<s32> streamType; // CellDmuxStreamType
be_t<u32> streamSpecificInfo;
};
struct CellDmuxResource
{
be_t<u32> memAddr;
be_t<u32> memSize;
be_t<u32> ppuThreadPriority;
be_t<u32> ppuThreadStackSize;
be_t<u32> spuThreadPriority;
be_t<u32> numOfSpus;
};
struct CellDmuxResourceEx
{
be_t<u32> memAddr;
be_t<u32> memSize;
be_t<u32> ppuThreadPriority;
be_t<u32> ppuThreadStackSize;
be_t<u32> spurs_addr;
u8 priority[8];
be_t<u32> maxContention;
};
/*
struct CellDmuxResource2Ex
{
b8 isResourceEx; //true
CellDmuxResourceEx resourceEx;
};
struct CellDmuxResource2NoEx
{
b8 isResourceEx; //false
CellDmuxResource resource;
};
*/
struct CellDmuxResource2
{
b8 isResourceEx;
be_t<u32> memAddr;
be_t<u32> memSize;
be_t<u32> ppuThreadPriority;
be_t<u32> ppuThreadStackSize;
be_t<u32> shit[4];
};
using CellDmuxCbMsg = u32(u32 demuxerHandle, vm::ptr<CellDmuxMsg> demuxerMsg, u32 cbArg);
struct CellDmuxCb
{
vm::bptr<CellDmuxCbMsg> cbMsgFunc;
be_t<u32> cbArg;
};
using CellDmuxCbEsMsg = u32(u32 demuxerHandle, u32 esHandle, vm::ptr<CellDmuxEsMsg> esMsg, u32 cbArg);
struct CellDmuxEsCb
{
vm::bptr<CellDmuxCbEsMsg> cbEsMsgFunc;
be_t<u32> cbArg;
};
struct CellDmuxAttr
{
be_t<u32> memSize;
be_t<u32> demuxerVerUpper;
be_t<u32> demuxerVerLower;
};
struct CellDmuxEsAttr
{
be_t<u32> memSize;
};
struct CellDmuxEsResource
{
be_t<u32> memAddr;
be_t<u32> memSize;
};
struct CellDmuxAuInfo
{
be_t<u32> auAddr;
be_t<u32> auSize;
be_t<u32> auMaxSize;
be_t<u64> userData;
be_t<u32> ptsUpper;
be_t<u32> ptsLower;
be_t<u32> dtsUpper;
be_t<u32> dtsLower;
};
struct CellDmuxAuInfoEx
{
be_t<u32> auAddr;
be_t<u32> auSize;
be_t<u32> reserved;
b8 isRap;
be_t<u64> userData;
CellCodecTimeStamp pts;
CellCodecTimeStamp dts;
};
| 4,758
|
C++
|
.h
| 234
| 18.692308
| 102
| 0.773265
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,864
|
cellFiber.h
|
RPCS3_rpcs3/rpcs3/Emu/Cell/Modules/cellFiber.h
|
#pragma once
#include "Emu/Memory/vm_ptr.h"
// Return Codes
enum CellFiberError : u32
{
CELL_FIBER_ERROR_AGAIN = 0x80760001, // Resource was temporarily unavailable
CELL_FIBER_ERROR_INVAL = 0x80760002, // Value of the argument is invalid
CELL_FIBER_ERROR_NOMEM = 0x80760004, // Insufficient memory
CELL_FIBER_ERROR_DEADLK = 0x80760008, // Execution of the operation will cause a deadlock
CELL_FIBER_ERROR_PERM = 0x80760009, // Executed operation is not permitted
CELL_FIBER_ERROR_BUSY = 0x8076000A, // The operation target is busy
CELL_FIBER_ERROR_ABORT = 0x8076000C, // The operation has been aborted
CELL_FIBER_ERROR_STAT = 0x8076000F, // State of the operation target is invalid
CELL_FIBER_ERROR_ALIGN = 0x80760010, // The alignment of the argument address is invalid
CELL_FIBER_ERROR_NULL_POINTER = 0x80760011, // Invalid NULL pointer is specified for the argument
CELL_FIBER_ERROR_NOSYSINIT = 0x80760020, // cellFiberPpuInitialize() has not been called
};
//
// CellFiberPpuScheduler
//
struct alignas(128) CellFiberPpuScheduler
{
u8 skip[512];
};
CHECK_SIZE_ALIGN(CellFiberPpuScheduler, 512, 128);
struct alignas(8) CellFiberPpuSchedulerAttribute
{
u8 privateHeader[16];
b8 autoCheckFlags;
b8 debuggerSupport;
u8 padding[2];
be_t<u32> autoCheckFlagsIntervalUsec;
u8 skip[232];
};
CHECK_SIZE_ALIGN(CellFiberPpuSchedulerAttribute, 256, 8);
//
// CellFiberPpu
//
struct alignas(128) CellFiberPpu
{
u8 skip[896];
};
CHECK_SIZE_ALIGN(CellFiberPpu, 896, 128);
typedef s32(CellFiberPpuEntry)(u64 arg);
typedef void(CellFiberPpuOnExitCallback)(u64 arg, s32 exitCode);
struct alignas(8) CellFiberPpuAttribute
{
u8 privateHeader[16];
char name[32];
vm::bptr<CellFiberPpuOnExitCallback> onExitCallback;
be_t<u32> __reserved0__;
be_t<u64> onExitCallbackArg;
be_t<u64> __reserved1__;
u8 skip[184];
};
CHECK_SIZE_ALIGN(CellFiberPpuAttribute, 256, 8);
//
// CellFiberPpuContext
//
struct alignas(16) CellFiberPpuContext
{
u8 skip[640];
};
CHECK_SIZE_ALIGN(CellFiberPpuContext, 640, 16);
typedef void(CellFiberPpuContextEntry)(u64 arg, vm::ptr<CellFiberPpuContext> fiberFrom);
struct alignas(8) CellFiberPpuContextAttribute
{
u8 privateHeader[16];
char name[32];
b8 debuggerSupport;
u8 skip[79];
};
CHECK_SIZE_ALIGN(CellFiberPpuContextAttribute, 128, 8);
struct CellFiberPpuContextExecutionOption;
typedef vm::ptr<CellFiberPpuContext>(CellFiberPpuSchedulerCallback)(u64 arg0, u64 arg1);
//
// CellFiberPpuUtilWorkerControl
//
struct alignas(128) CellFiberPpuUtilWorkerControl
{
u8 skip[768];
};
CHECK_SIZE_ALIGN(CellFiberPpuUtilWorkerControl, 768, 128);
struct alignas(8) CellFiberPpuUtilWorkerControlAttribute
{
CellFiberPpuSchedulerAttribute scheduler;
be_t<u64> privateHeader[2];
u8 __reserved__[112];
};
CHECK_SIZE_ALIGN(CellFiberPpuUtilWorkerControlAttribute, 384, 8);
| 2,893
|
C++
|
.h
| 90
| 30.466667
| 98
| 0.779618
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,865
|
sceNpCommerce2.h
|
RPCS3_rpcs3/rpcs3/Emu/Cell/Modules/sceNpCommerce2.h
|
#pragma once
#include "cellRtc.h"
// Return codes
enum SceNpCommerce2Error
{
SCE_NP_COMMERCE2_ERROR_NOT_INITIALIZED = 0x80023001,
SCE_NP_COMMERCE2_ERROR_ALREADY_INITIALIZED = 0x80023002,
SCE_NP_COMMERCE2_ERROR_INVALID_ARGUMENT = 0x80023003,
SCE_NP_COMMERCE2_ERROR_UNSUPPORTED_VERSION = 0x80023004,
SCE_NP_COMMERCE2_ERROR_CTX_MAX = 0x80023005,
SCE_NP_COMMERCE2_ERROR_INVALID_INDEX = 0x80023006,
SCE_NP_COMMERCE2_ERROR_INVALID_SKUID = 0x80023007,
SCE_NP_COMMERCE2_ERROR_INVALID_SKU_NUM = 0x80023008,
SCE_NP_COMMERCE2_ERROR_INVALID_MEMORY_CONTAINER = 0x80023009,
SCE_NP_COMMERCE2_ERROR_INSUFFICIENT_MEMORY_CONTAINER = 0x8002300a,
SCE_NP_COMMERCE2_ERROR_OUT_OF_MEMORY = 0x8002300b,
SCE_NP_COMMERCE2_ERROR_CTX_NOT_FOUND = 0x8002300c,
SCE_NP_COMMERCE2_ERROR_CTXID_NOT_AVAILABLE = 0x8002300d,
SCE_NP_COMMERCE2_ERROR_REQ_NOT_FOUND = 0x8002300e,
SCE_NP_COMMERCE2_ERROR_REQID_NOT_AVAILABLE = 0x8002300f,
SCE_NP_COMMERCE2_ERROR_ABORTED = 0x80023010,
SCE_NP_COMMERCE2_ERROR_RESPONSE_BUF_TOO_SMALL = 0x80023012,
SCE_NP_COMMERCE2_ERROR_COULD_NOT_RECV_WHOLE_RESPONSE_DATA = 0x80023013,
SCE_NP_COMMERCE2_ERROR_INVALID_RESULT_DATA = 0x80023014,
SCE_NP_COMMERCE2_ERROR_UNKNOWN = 0x80023015,
SCE_NP_COMMERCE2_ERROR_SERVER_MAINTENANCE = 0x80023016,
SCE_NP_COMMERCE2_ERROR_SERVER_UNKNOWN = 0x80023017,
SCE_NP_COMMERCE2_ERROR_INSUFFICIENT_BUF_SIZE = 0x80023018,
SCE_NP_COMMERCE2_ERROR_REQ_MAX = 0x80023019,
SCE_NP_COMMERCE2_ERROR_INVALID_TARGET_TYPE = 0x8002301a,
SCE_NP_COMMERCE2_ERROR_INVALID_TARGET_ID = 0x8002301b,
SCE_NP_COMMERCE2_ERROR_INVALID_SIZE = 0x8002301c,
SCE_NP_COMMERCE2_ERROR_DATA_NOT_FOUND = 0x80023087,
SCE_NP_COMMERCE2_SERVER_ERROR_BAD_REQUEST = 0x80023101,
SCE_NP_COMMERCE2_SERVER_ERROR_UNKNOWN_ERROR = 0x80023102,
SCE_NP_COMMERCE2_SERVER_ERROR_SESSION_EXPIRED = 0x80023105,
SCE_NP_COMMERCE2_SERVER_ERROR_ACCESS_PERMISSION_DENIED = 0x80023107,
SCE_NP_COMMERCE2_SERVER_ERROR_NO_SUCH_CATEGORY = 0x80023110,
SCE_NP_COMMERCE2_SERVER_ERROR_NO_SUCH_PRODUCT = 0x80023111,
SCE_NP_COMMERCE2_SERVER_ERROR_NOT_ELIGIBILITY = 0x80023113,
SCE_NP_COMMERCE2_SERVER_ERROR_INVALID_SKU = 0x8002311a,
SCE_NP_COMMERCE2_SERVER_ERROR_ACCOUNT_SUSPENDED1 = 0x8002311b,
SCE_NP_COMMERCE2_SERVER_ERROR_ACCOUNT_SUSPENDED2 = 0x8002311c,
SCE_NP_COMMERCE2_SERVER_ERROR_OVER_SPENDING_LIMIT = 0x80023120,
SCE_NP_COMMERCE2_SERVER_ERROR_INVALID_VOUCHER = 0x8002312f,
SCE_NP_COMMERCE2_SERVER_ERROR_VOUCHER_ALREADY_CONSUMED = 0x80023130,
SCE_NP_COMMERCE2_SERVER_ERROR_EXCEEDS_AGE_LIMIT_IN_BROWSING = 0x80023139,
SCE_NP_COMMERCE2_SYSTEM_UTIL_ERROR_INVALID_VOUCHER = 0x80024002,
};
// Event types
enum
{
SCE_NP_COMMERCE2_EVENT_REQUEST_ERROR = 0x0001,
SCE_NP_COMMERCE2_EVENT_CREATE_SESSION_DONE = 0x0011,
SCE_NP_COMMERCE2_EVENT_CREATE_SESSION_ABORT = 0x0012,
SCE_NP_COMMERCE2_EVENT_DO_CHECKOUT_STARTED = 0x0021,
SCE_NP_COMMERCE2_EVENT_DO_CHECKOUT_SUCCESS = 0x0022,
SCE_NP_COMMERCE2_EVENT_DO_CHECKOUT_BACK = 0x0023,
SCE_NP_COMMERCE2_EVENT_DO_CHECKOUT_FINISHED = 0x0024,
SCE_NP_COMMERCE2_EVENT_DO_DL_LIST_STARTED = 0x0031,
SCE_NP_COMMERCE2_EVENT_DO_DL_LIST_SUCCESS = 0x0032,
SCE_NP_COMMERCE2_EVENT_DO_DL_LIST_FINISHED = 0x0034,
SCE_NP_COMMERCE2_EVENT_DO_PROD_BROWSE_STARTED = 0x0041,
SCE_NP_COMMERCE2_EVENT_DO_PROD_BROWSE_SUCCESS = 0x0042,
SCE_NP_COMMERCE2_EVENT_DO_PROD_BROWSE_BACK = 0x0043,
SCE_NP_COMMERCE2_EVENT_DO_PROD_BROWSE_FINISHED = 0x0044,
SCE_NP_COMMERCE2_EVENT_DO_PROD_BROWSE_OPENED = 0x0045,
SCE_NP_COMMERCE2_EVENT_DO_PRODUCT_CODE_STARTED = 0x0051,
SCE_NP_COMMERCE2_EVENT_DO_PRODUCT_CODE_SUCCESS = 0x0052,
SCE_NP_COMMERCE2_EVENT_DO_PRODUCT_CODE_BACK = 0x0053,
SCE_NP_COMMERCE2_EVENT_DO_PRODUCT_CODE_FINISHED = 0x0054,
SCE_NP_COMMERCE2_EVENT_EMPTY_STORE_CHECK_DONE = 0x0061,
SCE_NP_COMMERCE2_EVENT_EMPTY_STORE_CHECK_ABORT = 0x0062,
SCE_NP_COMMERCE2_EVENT_RESERVED01_STARTED = 0x0071,
SCE_NP_COMMERCE2_EVENT_RESERVED01_SUCCESS = 0x0072,
SCE_NP_COMMERCE2_EVENT_RESERVED01_BACK = 0x0073,
SCE_NP_COMMERCE2_EVENT_RESERVED01_FINISHED = 0x0074,
};
// Category data type
enum SceNpCommerce2CategoryDataType
{
SCE_NP_COMMERCE2_CAT_DATA_TYPE_THIN = 0,
SCE_NP_COMMERCE2_CAT_DATA_TYPE_NORMAL,
SCE_NP_COMMERCE2_CAT_DATA_TYPE_MAX
};
// Game product data type
enum SceNpCommerce2GameProductDataType
{
SCE_NP_COMMERCE2_GAME_PRODUCT_DATA_TYPE_THIN = 0,
SCE_NP_COMMERCE2_GAME_PRODUCT_DATA_TYPE_NORMAL,
SCE_NP_COMMERCE2_GAME_PRODUCT_DATA_TYPE_MAX
};
// SKU data type
enum SceNpCommerce2GameSkuDataType
{
SCE_NP_COMMERCE2_GAME_SKU_DATA_TYPE_THIN = 0,
SCE_NP_COMMERCE2_GAME_SKU_DATA_TYPE_NORMAL,
SCE_NP_COMMERCE2_GAME_SKU_DATA_TYPE_MAX
};
// Store stuff
enum
{
SCE_NP_COMMERCE2_STORE_IS_NOT_EMPTY = 0,
SCE_NP_COMMERCE2_STORE_IS_EMPTY = 1,
SCE_NP_COMMERCE2_STORE_CHECK_TYPE_CATEGORY = 1,
SCE_NP_COMMERCE2_STORE_BROWSE_TYPE_CATEGORY = 1,
SCE_NP_COMMERCE2_STORE_BROWSE_TYPE_PRODUCT = 2,
SCE_NP_COMMERCE2_STORE_BROWSE_TYPE_PRODUCT_CODE = 3,
};
// Content Stuff
enum
{
SCE_NP_COMMERCE2_CONTENT_TYPE_CATEGORY = 1,
SCE_NP_COMMERCE2_CONTENT_TYPE_PRODUCT = 2,
SCE_NP_COMMERCE2_CONTENT_RATING_DESC_TYPE_ICON = 1,
SCE_NP_COMMERCE2_CONTENT_RATING_DESC_TYPE_TEXT = 2,
};
// Game SKU
enum
{
SCE_NP_COMMERCE2_SKU_CHECKOUT_MAX = 16,
SCE_NP_COMMERCE2_SKU_DL_LIST_MAX = 16,
SCE_NP_COMMERCE2_SKU_PURCHASABILITY_FLAG_ON = 1,
SCE_NP_COMMERCE2_SKU_PURCHASABILITY_FLAG_OFF = 0,
SCE_NP_COMMERCE2_SKU_ANN_PURCHASED_CANNOT_PURCHASE_AGAIN = 0x80000000,
SCE_NP_COMMERCE2_SKU_ANN_PURCHASED_CAN_PURCHASE_AGAIN = 0x40000000,
SCE_NP_COMMERCE2_SKU_ANN_IN_THE_CART = 0x20000000,
SCE_NP_COMMERCE2_SKU_ANN_CONTENTLINK_SKU = 0x10000000,
SCE_NP_COMMERCE2_SKU_ANN_CREDIT_CARD_REQUIRED = 0x08000000,
SCE_NP_COMMERCE2_SKU_ANN_CHARGE_IMMEDIATELY = 0x04000000,
};
// Constants for commerce functions and structures
enum
{
SCE_NP_COMMERCE2_VERSION = 2,
SCE_NP_COMMERCE2_CTX_MAX = 1,
SCE_NP_COMMERCE2_REQ_MAX = 1,
SCE_NP_COMMERCE2_CURRENCY_CODE_LEN = 3,
SCE_NP_COMMERCE2_CURRENCY_SYMBOL_LEN = 3,
SCE_NP_COMMERCE2_THOUSAND_SEPARATOR_LEN = 4,
SCE_NP_COMMERCE2_DECIMAL_LETTER_LEN = 4,
SCE_NP_COMMERCE2_SP_NAME_LEN = 256,
SCE_NP_COMMERCE2_CATEGORY_ID_LEN = 56,
SCE_NP_COMMERCE2_CATEGORY_NAME_LEN = 256,
SCE_NP_COMMERCE2_CATEGORY_DESCRIPTION_LEN = 1024,
SCE_NP_COMMERCE2_PRODUCT_ID_LEN = 48,
SCE_NP_COMMERCE2_PRODUCT_NAME_LEN = 256,
SCE_NP_COMMERCE2_PRODUCT_SHORT_DESCRIPTION_LEN = 1024,
SCE_NP_COMMERCE2_PRODUCT_LONG_DESCRIPTION_LEN = 4000,
SCE_NP_COMMERCE2_SKU_ID_LEN = 56,
SCE_NP_COMMERCE2_SKU_NAME_LEN = 180,
SCE_NP_COMMERCE2_URL_LEN = 256,
SCE_NP_COMMERCE2_RATING_SYSTEM_ID_LEN = 16,
SCE_NP_COMMERCE2_RATING_DESCRIPTION_LEN = 60,
SCE_NP_COMMERCE2_RECV_BUF_SIZE = 262144,
SCE_NP_COMMERCE2_PRODUCT_CODE_BLOCK_LEN = 4,
SCE_NP_COMMERCE2_PRODUCT_CODE_INPUT_MODE_USER_INPUT = 0,
SCE_NP_COMMERCE2_PRODUCT_CODE_INPUT_MODE_CODE_SPECIFIED = 1,
SCE_NP_COMMERCE2_GETCAT_MAX_COUNT = 60,
SCE_NP_COMMERCE2_GETPRODLIST_MAX_COUNT = 60,
SCE_NP_COMMERCE2_DO_CHECKOUT_MEMORY_CONTAINER_SIZE = 10485760,
SCE_NP_COMMERCE2_DO_PROD_BROWSE_MEMORY_CONTAINER_SIZE = 16777216,
SCE_NP_COMMERCE2_DO_DL_LIST_MEMORY_CONTAINER_SIZE = 10485760,
SCE_NP_COMMERCE2_DO_PRODUCT_CODE_MEMORY_CONTAINER_SIZE = 16777216,
SCE_NP_COMMERCE2_SYM_POS_PRE = 0,
SCE_NP_COMMERCE2_SYM_POS_POST = 1,
};
// Common structure used when receiving data
struct SceNpCommerce2CommonData
{
be_t<u32> version;
be_t<u32> buf_head;
be_t<u32> buf_size;
be_t<u32> data;
be_t<u32> data_size;
be_t<u32> data2;
be_t<u32> reserved[4];
};
// Structure indicating the range of results obtained
struct SceNpCommerce2Range
{
be_t<u32> startPosition;
be_t<u32> count;
be_t<u32> totalCountOfResults;
};
// Structure for session information
struct SceNpCommerce2SessionInfo
{
s8 currencyCode[SCE_NP_COMMERCE2_CURRENCY_CODE_LEN + 1];
be_t<u32> decimals;
s8 currencySymbol[SCE_NP_COMMERCE2_CURRENCY_SYMBOL_LEN + 1];
be_t<u32> symbolPosition;
b8 symbolWithSpace;
u8 padding1[3];
s8 thousandSeparator[SCE_NP_COMMERCE2_THOUSAND_SEPARATOR_LEN + 1];
s8 decimalLetter[SCE_NP_COMMERCE2_DECIMAL_LETTER_LEN + 1];
u8 padding2[1];
be_t<u32> reserved[4];
};
// Structure for category information
struct SceNpCommerce2CategoryInfo
{
SceNpCommerce2CommonData commonData;
SceNpCommerce2CategoryDataType dataType;
s8 categoryId;
CellRtcTick releaseDate;
s8 categoryName;
s8 categoryDescription;
s8 imageUrl;
s8 spName;
be_t<u32> countOfSubCategory;
be_t<u32> countOfProduct;
};
// Structure for content information within the category
struct SceNpCommerce2ContentInfo
{
SceNpCommerce2CommonData commonData;
be_t<u32> contentType;
};
// Structure for initialized product data
struct SceNpCommerce2GetProductInfoResult
{
SceNpCommerce2CommonData commonData;
};
// Structure for game product information
struct SceNpCommerce2GameProductInfo
{
SceNpCommerce2CommonData commonData;
SceNpCommerce2GameProductDataType dataType;
s8 productId;
be_t<u32> countOfSku;
u8 padding[4];
CellRtcTick releaseDate;
s8 productName;
s8 productShortDescription;
s8 imageUrl;
s8 spName;
s8 productLongDescription;
s8 legalDescription;
};
// Structure for initialized product info list
struct SceNpCommerce2GetProductInfoListResult
{
SceNpCommerce2CommonData commonData;
be_t<u32> countOfProductInfo;
};
// Structure for rating information
struct SceNpCommerce2ContentRatingInfo
{
SceNpCommerce2CommonData commonData;
s8 ratingSystemId;
s8 imageUrl;
be_t<u32> countOfContentRatingDescriptor;
};
// Structure for a rating descriptor
struct SceNpCommerce2ContentRatingDescriptor
{
SceNpCommerce2CommonData commonData;
be_t<u32> descriptorType;
s8 imageUrl;
s8 contentRatingDescription;
};
// Structure for SKU information
struct SceNpCommerce2GameSkuInfo
{
SceNpCommerce2CommonData commonData;
SceNpCommerce2GameSkuDataType dataType;
s8 skuId;
be_t<u32> skuType;
be_t<u32> countUntilExpiration;
be_t<u32> timeUntilExpiration;
be_t<u32> purchasabilityFlag;
be_t<u32> annotation;
b8 downloadable;
u8 padding[3];
be_t<u32> price;
s8 skuName;
s8 productId;
s8 contentLinkUrl;
be_t<u32> countOfRewardInfo;
be_t<u32> reserved[8];
};
// Structure of parameters for in-game product browsing
struct SceNpCommerce2ProductBrowseParam
{
be_t<u32> size;
};
// Structure of parameters for promotion code input
struct SceNpCommerce2ProductCodeParam
{
be_t<u32> size;
be_t<u32> inputMode;
s8 code1[SCE_NP_COMMERCE2_PRODUCT_CODE_BLOCK_LEN + 1];
s8 padding1[3];
s8 code2[SCE_NP_COMMERCE2_PRODUCT_CODE_BLOCK_LEN + 1];
s8 padding2[3];
s8 code3[SCE_NP_COMMERCE2_PRODUCT_CODE_BLOCK_LEN + 1];
s8 padding3[3];
};
struct SceNpCommerce2GetCategoryContentsResult
{
SceNpCommerce2CommonData commonData;
SceNpCommerce2Range rangeOfContents;
};
using SceNpCommerce2Handler = void(u32 ctx_id, u32 subject_id, s32 event, s32 error_code, vm::ptr<void> arg);
| 12,239
|
C++
|
.h
| 305
| 38.337705
| 109
| 0.698337
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,866
|
cellVdec.h
|
RPCS3_rpcs3/rpcs3/Emu/Cell/Modules/cellVdec.h
|
#pragma once
// Error Codes
enum CellVdecError : u32
{
CELL_VDEC_ERROR_ARG = 0x80610101,
CELL_VDEC_ERROR_SEQ = 0x80610102,
CELL_VDEC_ERROR_BUSY = 0x80610103,
CELL_VDEC_ERROR_EMPTY = 0x80610104,
CELL_VDEC_ERROR_AU = 0x80610105,
CELL_VDEC_ERROR_PIC = 0x80610106,
CELL_VDEC_ERROR_FATAL = 0x80610180,
};
enum CellVdecCodecType : s32
{
CELL_VDEC_CODEC_TYPE_MPEG2 = 0,
CELL_VDEC_CODEC_TYPE_AVC = 1,
CELL_VDEC_CODEC_TYPE_DIVX = 5,
CELL_VDEC_CODEC_TYPE_MAX
};
// Callback Messages
enum CellVdecMsgType : s32
{
CELL_VDEC_MSG_TYPE_AUDONE = 0, // decoding finished
CELL_VDEC_MSG_TYPE_PICOUT = 1, // picture done
CELL_VDEC_MSG_TYPE_SEQDONE = 2, // finishing done
CELL_VDEC_MSG_TYPE_ERROR = 3, // fatal error
};
// Decoder Operation Mode
enum CellVdecDecodeMode : s32
{
CELL_VDEC_DEC_MODE_NORMAL,
CELL_VDEC_DEC_MODE_B_SKIP,
CELL_VDEC_DEC_MODE_PB_SKIP,
};
// Output Picture Format Type
enum CellVdecPicFormatType : u32
{
CELL_VDEC_PICFMT_ARGB32_ILV,
CELL_VDEC_PICFMT_RGBA32_ILV,
CELL_VDEC_PICFMT_UYVY422_ILV,
CELL_VDEC_PICFMT_YUV420_PLANAR,
};
// Output Color Matrix Coef
enum CellVdecColorMatrixType : u32
{
CELL_VDEC_COLOR_MATRIX_TYPE_BT601,
CELL_VDEC_COLOR_MATRIX_TYPE_BT709,
};
enum CellVdecPicAttr : s32
{
CELL_VDEC_PICITEM_ATTR_NORMAL,
CELL_VDEC_PICITEM_ATTR_SKIPPED,
};
// Universal Frame Rate Code
enum CellVdecFrameRate : s32
{
CELL_VDEC_FRC_24000DIV1001 = 0x80,
CELL_VDEC_FRC_24 = 0x81,
CELL_VDEC_FRC_25 = 0x82,
CELL_VDEC_FRC_30000DIV1001 = 0x83,
CELL_VDEC_FRC_30 = 0x84,
CELL_VDEC_FRC_50 = 0x85,
CELL_VDEC_FRC_60000DIV1001 = 0x86,
CELL_VDEC_FRC_60 = 0x87,
};
enum
{
CELL_CODEC_PTS_INVALID = 0xffffffff,
CELL_CODEC_DTS_INVALID = 0xffffffff,
};
// Codec Type Information
struct CellVdecType
{
be_t<s32> codecType; // CellVdecCodecType
be_t<u32> profileLevel;
};
// Extended Codec Type Information
struct CellVdecTypeEx
{
be_t<s32> codecType; // CellVdecCodecType
be_t<u32> profileLevel;
be_t<u32> codecSpecificInfo_addr;
};
// Library Attributes
struct CellVdecAttr
{
be_t<u32> memSize; // required memory
u8 cmdDepth; // command queue depth
be_t<u32> decoderVerUpper;
be_t<u32> decoderVerLower;
};
// Configurable Information
struct CellVdecResource
{
be_t<u32> memAddr;
be_t<u32> memSize;
be_t<s32> ppuThreadPriority;
be_t<u32> ppuThreadStackSize;
be_t<s32> spuThreadPriority;
be_t<u32> numOfSpus;
};
// SPURS Information
struct CellVdecResourceSpurs
{
be_t<u32> spursAddr;
u8 tasksetPriority[8];
be_t<u32> tasksetMaxContention;
};
// Extended Configurable Information
struct CellVdecResourceEx
{
be_t<u32> memAddr;
be_t<u32> memSize;
be_t<s32> ppuThreadPriority;
be_t<u32> ppuThreadStackSize;
be_t<s32> spuThreadPriority;
be_t<u32> numOfSpus;
be_t<u32> spursResource_addr;
};
// Access Unit Information
struct CellVdecAuInfo
{
be_t<u32> startAddr;
be_t<u32> size;
CellCodecTimeStamp pts;
CellCodecTimeStamp dts;
be_t<u64> userData;
be_t<u64> codecSpecificData;
};
// Access Unit Information
struct CellVdecAuInfoEx2 // Speculative name
{
be_t<u32> startAddr;
be_t<u32> unk1; // Speculative
be_t<u32> size;
be_t<u32> unk2; // Speculative
CellCodecTimeStamp pts;
CellCodecTimeStamp dts;
be_t<u64> userData;
be_t<u64> codecSpecificData;
};
// Output Picture Information
struct CellVdecPicItem
{
be_t<s32> codecType; // CellVdecCodecType
be_t<u32> startAddr;
be_t<u32> size;
u8 auNum;
CellCodecTimeStamp auPts[2];
CellCodecTimeStamp auDts[2];
be_t<u64> auUserData[2];
be_t<s32> status;
be_t<s32> attr; // CellVdecPicAttr
be_t<u32> picInfo_addr;
};
// Output Picture Format
struct CellVdecPicFormat
{
be_t<u32> formatType; // CellVdecPicFormatType
be_t<u32> colorMatrixType; // CellVdecColorMatrixType
u8 alpha;
};
struct CellVdecPicFormat2
{
be_t<u32> formatType; // CellVdecPicFormatType
be_t<u32> colorMatrixType; // CellVdecColorMatrixType
be_t<u32> unk0;
u8 alpha;
be_t<u32> unk1;
};
using CellVdecCbMsg = u32(u32 handle, CellVdecMsgType msgType, s32 msgData, u32 cbArg);
// Callback Function Information
struct CellVdecCb
{
vm::bptr<CellVdecCbMsg> cbFunc;
be_t<u32> cbArg;
};
// Max CC Data Length
enum
{
CELL_VDEC_AVC_CCD_MAX = 128,
};
enum AVC_level : u8
{
CELL_VDEC_AVC_LEVEL_1P0 = 10,
CELL_VDEC_AVC_LEVEL_1P1 = 11,
CELL_VDEC_AVC_LEVEL_1P2 = 12,
CELL_VDEC_AVC_LEVEL_1P3 = 13,
CELL_VDEC_AVC_LEVEL_2P0 = 20,
CELL_VDEC_AVC_LEVEL_2P1 = 21,
CELL_VDEC_AVC_LEVEL_2P2 = 22,
CELL_VDEC_AVC_LEVEL_3P0 = 30,
CELL_VDEC_AVC_LEVEL_3P1 = 31,
CELL_VDEC_AVC_LEVEL_3P2 = 32,
CELL_VDEC_AVC_LEVEL_4P0 = 40,
CELL_VDEC_AVC_LEVEL_4P1 = 41,
CELL_VDEC_AVC_LEVEL_4P2 = 42,
};
struct CellVdecAvcSpecificInfo
{
be_t<u32> thisSize;
be_t<u16> maxDecodedFrameWidth;
be_t<u16> maxDecodedFrameHeight;
b8 disableDeblockingFilter;
u8 numberOfDecodedFrameBuffer;
};
enum AVC_video_format : u8
{
CELL_VDEC_AVC_VF_COMPONENT = 0x00,
CELL_VDEC_AVC_VF_PAL = 0x01,
CELL_VDEC_AVC_VF_NTSC = 0x02,
CELL_VDEC_AVC_VF_SECAM = 0x03,
CELL_VDEC_AVC_VF_MAC = 0x04,
CELL_VDEC_AVC_VF_UNSPECIFIED = 0x05,
};
enum AVC_colour_primaries : u8
{
CELL_VDEC_AVC_CP_ITU_R_BT_709_5 = 0x01,
CELL_VDEC_AVC_CP_UNSPECIFIED = 0x02,
CELL_VDEC_AVC_CP_ITU_R_BT_470_6_SYS_M = 0x04,
CELL_VDEC_AVC_CP_ITU_R_BT_470_6_SYS_BG = 0x05,
CELL_VDEC_AVC_CP_SMPTE_170_M = 0x06,
CELL_VDEC_AVC_CP_SMPTE_240_M = 0x07,
CELL_VDEC_AVC_CP_GENERIC_FILM = 0x08,
};
enum AVC_transfer_characteristics : u8
{
CELL_VDEC_AVC_TC_ITU_R_BT_709_5 = 0x01,
CELL_VDEC_AVC_TC_UNSPECIFIED = 0x02,
CELL_VDEC_AVC_TC_ITU_R_BT_470_6_SYS_M = 0x04,
CELL_VDEC_AVC_TC_ITU_R_BT_470_6_SYS_BG = 0x05,
CELL_VDEC_AVC_TC_SMPTE_170_M = 0x06,
CELL_VDEC_AVC_TC_SMPTE_240_M = 0x07,
CELL_VDEC_AVC_TC_LINEAR = 0x08,
CELL_VDEC_AVC_TC_LOG_100_1 = 0x09,
CELL_VDEC_AVC_TC_LOG_316_1 = 0x0a,
};
enum AVC_matrix_coefficients : u8
{
CELL_VDEC_AVC_MXC_GBR = 0x00,
CELL_VDEC_AVC_MXC_ITU_R_BT_709_5 = 0x01,
CELL_VDEC_AVC_MXC_UNSPECIFIED = 0x02,
CELL_VDEC_AVC_MXC_FCC = 0x04,
CELL_VDEC_AVC_MXC_ITU_R_BT_470_6_SYS_BG = 0x05,
CELL_VDEC_AVC_MXC_SMPTE_170_M = 0x06,
CELL_VDEC_AVC_MXC_SMPTE_240_M = 0x07,
CELL_VDEC_AVC_MXC_YCGCO = 0x08,
};
enum AVC_FrameRateCode : u8
{
CELL_VDEC_AVC_FRC_24000DIV1001 = 0x00,
CELL_VDEC_AVC_FRC_24 = 0x01,
CELL_VDEC_AVC_FRC_25 = 0x02,
CELL_VDEC_AVC_FRC_30000DIV1001 = 0x03,
CELL_VDEC_AVC_FRC_30 = 0x04,
CELL_VDEC_AVC_FRC_50 = 0x05,
CELL_VDEC_AVC_FRC_60000DIV1001 = 0x06,
CELL_VDEC_AVC_FRC_60 = 0x07,
};
enum AVC_NulUnitPresentFlags : u16
{
CELL_VDEC_AVC_FLG_SPS = 0x0001,
CELL_VDEC_AVC_FLG_PPS = 0x0002,
CELL_VDEC_AVC_FLG_AUD = 0x0004,
CELL_VDEC_AVC_FLG_EO_SEQ = 0x0008,
CELL_VDEC_AVC_FLG_EO_STREAM = 0x0100,
CELL_VDEC_AVC_FLG_FILLER_DATA = 0x0200,
CELL_VDEC_AVC_FLG_PIC_TIMING_SEI = 0x0400,
CELL_VDEC_AVC_FLG_BUFF_PERIOD_SEI = 0x0800,
CELL_VDEC_AVC_FLG_USER_DATA_UNREG_SEI = 0x1000,
};
enum AVC_aspect_ratio_idc : u8
{
CELL_VDEC_AVC_ARI_SAR_UNSPECIFIED = 0x00,
CELL_VDEC_AVC_ARI_SAR_1_1 = 0x01,
CELL_VDEC_AVC_ARI_SAR_12_11 = 0x02,
CELL_VDEC_AVC_ARI_SAR_10_11 = 0x03,
CELL_VDEC_AVC_ARI_SAR_16_11 = 0x04,
CELL_VDEC_AVC_ARI_SAR_40_33 = 0x05,
CELL_VDEC_AVC_ARI_SAR_24_11 = 0x06,
CELL_VDEC_AVC_ARI_SAR_20_11 = 0x07,
CELL_VDEC_AVC_ARI_SAR_32_11 = 0x08,
CELL_VDEC_AVC_ARI_SAR_80_33 = 0x09,
CELL_VDEC_AVC_ARI_SAR_18_11 = 0x0a,
CELL_VDEC_AVC_ARI_SAR_15_11 = 0x0b,
CELL_VDEC_AVC_ARI_SAR_64_33 = 0x0c,
CELL_VDEC_AVC_ARI_SAR_160_99 = 0x0d,
CELL_VDEC_AVC_ARI_SAR_4_3 = 0x0e,
CELL_VDEC_AVC_ARI_SAR_3_2 = 0x0f,
CELL_VDEC_AVC_ARI_SAR_2_1 = 0x10,
CELL_VDEC_AVC_ARI_SAR_EXTENDED_SAR = 0xff,
};
enum AVC_PictureType : u8
{
CELL_VDEC_AVC_PCT_I = 0x00,
CELL_VDEC_AVC_PCT_P = 0x01,
CELL_VDEC_AVC_PCT_B = 0x02,
CELL_VDEC_AVC_PCT_UNKNOWN = 0x03,
};
enum AVC_pic_struct : u8
{
CELL_VDEC_AVC_PSTR_FRAME = 0x00,
CELL_VDEC_AVC_PSTR_FIELD_TOP = 0x01,
CELL_VDEC_AVC_PSTR_FIELD_BTM = 0x02,
CELL_VDEC_AVC_PSTR_FIELD_TOP_BTM = 0x03,
CELL_VDEC_AVC_PSTR_FIELD_BTM_TOP = 0x04,
CELL_VDEC_AVC_PSTR_FIELD_TOP_BTM_TOP = 0x05,
CELL_VDEC_AVC_PSTR_FIELD_BTM_TOP_BTM = 0x06,
CELL_VDEC_AVC_PSTR_FRAME_DOUBLING = 0x07,
CELL_VDEC_AVC_PSTR_FRAME_TRIPLING = 0x08,
};
struct CellVdecAvcInfo
{
be_t<u16> horizontalSize;
be_t<u16> verticalSize;
AVC_PictureType pictureType[2];
b8 idrPictureFlag;
AVC_aspect_ratio_idc aspect_ratio_idc;
be_t<u16> sar_height;
be_t<u16> sar_width;
AVC_pic_struct pic_struct;
be_t<s16> picOrderCount[2];
b8 vui_parameters_present_flag;
b8 frame_mbs_only_flag;
b8 video_signal_type_present_flag;
AVC_video_format video_format;
b8 video_full_range_flag;
b8 colour_description_present_flag;
AVC_colour_primaries colour_primaries;
AVC_transfer_characteristics transfer_characteristics;
AVC_matrix_coefficients matrix_coefficients;
b8 timing_info_present_flag;
AVC_FrameRateCode frameRateCode; // ???
b8 fixed_frame_rate_flag;
b8 low_delay_hrd_flag;
b8 entropy_coding_mode_flag;
be_t<u16> nalUnitPresentFlags;
u8 ccDataLength[2];
u8 ccData[2][CELL_VDEC_AVC_CCD_MAX];
be_t<u64> reserved[2];
};
// DIVX Profile
enum DIVX_level : u8
{
CELL_VDEC_DIVX_QMOBILE = 10,
CELL_VDEC_DIVX_MOBILE = 11,
CELL_VDEC_DIVX_HOME_THEATER = 12,
CELL_VDEC_DIVX_HD_720 = 13,
CELL_VDEC_DIVX_HD_1080 = 14,
};
struct CellVdecDivxSpecificInfo
{
be_t<u32> thisSize;
be_t<u16> maxDecodedFrameWidth;
be_t<u16> maxDecodedFrameHeight;
};
struct CellVdecDivxSpecificInfo2
{
be_t<u32> thisSize;
be_t<u16> maxDecodedFrameWidth;
be_t<u16> maxDecodedFrameHeight;
be_t<u16> numberOfDecodedFrameBuffer;
};
enum DIVX_frameRateCode : u16
{
CELL_VDEC_DIVX_FRC_UNDEFINED = 0x00,
CELL_VDEC_DIVX_FRC_24000DIV1001 = 0x01,
CELL_VDEC_DIVX_FRC_24 = 0x02,
CELL_VDEC_DIVX_FRC_25 = 0x03,
CELL_VDEC_DIVX_FRC_30000DIV1001 = 0x04,
CELL_VDEC_DIVX_FRC_30 = 0x05,
CELL_VDEC_DIVX_FRC_50 = 0x06,
CELL_VDEC_DIVX_FRC_60000DIV1001 = 0x07,
CELL_VDEC_DIVX_FRC_60 = 0x08,
};
enum DIVX_pixelAspectRatio : u8
{
CELL_VDEC_DIVX_ARI_PAR_1_1 = 0x1,
CELL_VDEC_DIVX_ARI_PAR_12_11 = 0x2,
CELL_VDEC_DIVX_ARI_PAR_10_11 = 0x3,
CELL_VDEC_DIVX_ARI_PAR_16_11 = 0x4,
CELL_VDEC_DIVX_ARI_PAR_40_33 = 0x5,
CELL_VDEC_DIVX_ARI_PAR_EXTENDED_PAR = 0xF,
};
enum DIVX_pictureType : u8
{
CELL_VDEC_DIVX_VCT_I = 0x0,
CELL_VDEC_DIVX_VCT_P = 0x1,
CELL_VDEC_DIVX_VCT_B = 0x2,
};
enum DIVX_pictureStruct : u8
{
CELL_VDEC_DIVX_PSTR_FRAME = 0x0,
CELL_VDEC_DIVX_PSTR_TOP_BTM = 0x1,
CELL_VDEC_DIVX_PSTR_BTM_TOP = 0x2,
};
enum DIVX_colourPrimaries : u8
{
CELL_VDEC_DIVX_CP_ITU_R_BT_709 = 0x01,
CELL_VDEC_DIVX_CP_UNSPECIFIED = 0x02,
CELL_VDEC_DIVX_CP_ITU_R_BT_470_SYS_M = 0x04,
CELL_VDEC_DIVX_CP_ITU_R_BT_470_SYS_BG = 0x05,
CELL_VDEC_DIVX_CP_SMPTE_170_M = 0x06,
CELL_VDEC_DIVX_CP_SMPTE_240_M = 0x07,
CELL_VDEC_DIVX_CP_GENERIC_FILM = 0x08,
};
enum DIVX_transferCharacteristics : u8
{
CELL_VDEC_DIVX_TC_ITU_R_BT_709 = 0x01,
CELL_VDEC_DIVX_TC_UNSPECIFIED = 0x02,
CELL_VDEC_DIVX_TC_ITU_R_BT_470_SYS_M = 0x04,
CELL_VDEC_DIVX_TC_ITU_R_BT_470_SYS_BG = 0x05,
CELL_VDEC_DIVX_TC_SMPTE_170_M = 0x06,
CELL_VDEC_DIVX_TC_SMPTE_240_M = 0x07,
CELL_VDEC_DIVX_TC_LINEAR = 0x08,
CELL_VDEC_DIVX_TC_LOG_100_1 = 0x09,
CELL_VDEC_DIVX_TC_LOG_316_1 = 0x0a,
};
enum DIVX_matrixCoefficients : u8
{
CELL_VDEC_DIVX_MXC_ITU_R_BT_709 = 0x01,
CELL_VDEC_DIVX_MXC_UNSPECIFIED = 0x02,
CELL_VDEC_DIVX_MXC_FCC = 0x04,
CELL_VDEC_DIVX_MXC_ITU_R_BT_470_SYS_BG = 0x05,
CELL_VDEC_DIVX_MXC_SMPTE_170_M = 0x06,
CELL_VDEC_DIVX_MXC_SMPTE_240_M = 0x07,
CELL_VDEC_DIVX_MXC_YCGCO = 0x08,
};
struct CellVdecDivxInfo
{
DIVX_pictureType pictureType;
be_t<u16> horizontalSize;
be_t<u16> verticalSize;
DIVX_pixelAspectRatio pixelAspectRatio;
u8 parWidth;
u8 parHeight;
b8 colourDescription;
DIVX_colourPrimaries colourPrimaries;
DIVX_transferCharacteristics transferCharacteristics;
DIVX_matrixCoefficients matrixCoefficients;
DIVX_pictureStruct pictureStruct;
be_t<u16> frameRateCode; // DIVX_frameRateCode
};
enum MPEG2_level
{
CELL_VDEC_MPEG2_MP_LL,
CELL_VDEC_MPEG2_MP_ML,
CELL_VDEC_MPEG2_MP_H14,
CELL_VDEC_MPEG2_MP_HL,
};
struct CellVdecMpeg2SpecificInfo
{
be_t<u32> thisSize;
be_t<u16> maxDecodedFrameWidth;
be_t<u16> maxDecodedFrameHeight;
};
enum MPEG2_headerFlags : u32
{
CELL_VDEC_MPEG2_FLG_SEQ_HDR = 0x00000001,
CELL_VDEC_MPEG2_FLG_SEQ_EXT = 0x00000002,
CELL_VDEC_MPEG2_FLG_SEQ_DSP_EXT = 0x00000004,
CELL_VDEC_MPEG2_FLG_SEQ_USR_DAT = 0x00000008,
CELL_VDEC_MPEG2_FLG_SEQ_END = 0x00000010,
CELL_VDEC_MPEG2_FLG_GOP_HDR = 0x00000020,
CELL_VDEC_MPEG2_FLG_GOP_USR_DAT = 0x00000040,
CELL_VDEC_MPEG2_FLG_PIC_HDR_1 = 0x00000100,
CELL_VDEC_MPEG2_FLG_PIC_EXT_1 = 0x00000200,
CELL_VDEC_MPEG2_FLG_PIC_DSP_EXT_1 = 0x00000400,
CELL_VDEC_MPEG2_FLG_PIC_USR_DAT_1 = 0x00000800,
CELL_VDEC_MPEG2_FLG_PIC_HDR_2 = 0x00001000,
CELL_VDEC_MPEG2_FLG_PIC_EXT_2 = 0x00002000,
CELL_VDEC_MPEG2_FLG_PIC_DSP_EXT_2 = 0x00004000,
CELL_VDEC_MPEG2_FLG_PIC_USR_DAT_2 = 0x00008000,
};
enum MPEG2_aspectRatio : u8
{
CELL_VDEC_MPEG2_ARI_SAR_1_1 = 0x01,
CELL_VDEC_MPEG2_ARI_DAR_4_3 = 0x02,
CELL_VDEC_MPEG2_ARI_DAR_16_9 = 0x03,
CELL_VDEC_MPEG2_ARI_DAR_2P21_1 = 0x04,
};
enum MPEG1_aspectRatio : u8
{
CELL_VDEC_MPEG1_ARI_SAR_1P0 = 0x01,
CELL_VDEC_MPEG1_ARI_SAR_0P6735 = 0x02,
CELL_VDEC_MPEG1_ARI_SAR_0P7031 = 0x03,
CELL_VDEC_MPEG1_ARI_SAR_0P7615 = 0x04,
CELL_VDEC_MPEG1_ARI_SAR_0P8055 = 0x05,
CELL_VDEC_MPEG1_ARI_SAR_0P8437 = 0x06,
CELL_VDEC_MPEG1_ARI_SAR_0P8935 = 0x07,
CELL_VDEC_MPEG1_ARI_SAR_0P9157 = 0x08,
CELL_VDEC_MPEG1_ARI_SAR_0P9815 = 0x09,
CELL_VDEC_MPEG1_ARI_SAR_1P0255 = 0x0a,
CELL_VDEC_MPEG1_ARI_SAR_1P0695 = 0x0b,
CELL_VDEC_MPEG1_ARI_SAR_1P0950 = 0x0c,
CELL_VDEC_MPEG1_ARI_SAR_1P1575 = 0x0d,
CELL_VDEC_MPEG1_ARI_SAR_1P2015 = 0x0e,
};
enum MPEG2_frameRate : u8
{
CELL_VDEC_MPEG2_FRC_FORBIDDEN = 0x00,
CELL_VDEC_MPEG2_FRC_24000DIV1001 = 0x01,
CELL_VDEC_MPEG2_FRC_24 = 0x02,
CELL_VDEC_MPEG2_FRC_25 = 0x03,
CELL_VDEC_MPEG2_FRC_30000DIV1001 = 0x04,
CELL_VDEC_MPEG2_FRC_30 = 0x05,
CELL_VDEC_MPEG2_FRC_50 = 0x06,
CELL_VDEC_MPEG2_FRC_60000DIV1001 = 0x07,
CELL_VDEC_MPEG2_FRC_60 = 0x08,
};
enum MPEG2_videoFormat : u8
{
CELL_VDEC_MPEG2_VF_COMPONENT = 0x00,
CELL_VDEC_MPEG2_VF_PAL = 0x01,
CELL_VDEC_MPEG2_VF_NTSC = 0x02,
CELL_VDEC_MPEG2_VF_SECAM = 0x03,
CELL_VDEC_MPEG2_VF_MAC = 0x04,
CELL_VDEC_MPEG2_VF_UNSPECIFIED = 0x05,
};
enum MPEG2_colourPrimaries : u8
{
CELL_VDEC_MPEG2_CP_FORBIDDEN = 0x00,
CELL_VDEC_MPEG2_CP_ITU_R_BT_709 = 0x01,
CELL_VDEC_MPEG2_CP_UNSPECIFIED = 0x02,
CELL_VDEC_MPEG2_CP_ITU_R_BT_470_2_SYS_M = 0x04,
CELL_VDEC_MPEG2_CP_ITU_R_BT_470_2_SYS_BG = 0x05,
CELL_VDEC_MPEG2_CP_SMPTE_170_M = 0x06,
CELL_VDEC_MPEG2_CP_SMPTE_240_M = 0x07,
};
enum MPEG2_transferCharacteristics : u8
{
CELL_VDEC_MPEG2_TC_FORBIDDEN = 0x00,
CELL_VDEC_MPEG2_TC_ITU_R_BT_709 = 0x01,
CELL_VDEC_MPEG2_TC_UNSPECIFIED = 0x02,
CELL_VDEC_MPEG2_TC_ITU_R_BT_470_2_SYS_M = 0x04,
CELL_VDEC_MPEG2_TC_ITU_R_BT_470_2_SYS_BG = 0x05,
CELL_VDEC_MPEG2_TC_SMPTE_170_M = 0x06,
CELL_VDEC_MPEG2_TC_SMPTE_240_M = 0x07,
CELL_VDEC_MPEG2_TC_LINEAR = 0x08,
CELL_VDEC_MPEG2_TC_LOG_100_1 = 0x09,
CELL_VDEC_MPEG2_TC_LOG_316_1 = 0x0a,
};
enum MPEG2_matrixCoefficients : u8
{
CELL_VDEC_MPEG2_MXC_FORBIDDEN = 0x00,
CELL_VDEC_MPEG2_MXC_ITU_R_BT_709 = 0x01,
CELL_VDEC_MPEG2_MXC_UNSPECIFIED = 0x02,
CELL_VDEC_MPEG2_MXC_FCC = 0x04,
CELL_VDEC_MPEG2_MXC_ITU_R_BT_470_2_SYS_BG = 0x05,
CELL_VDEC_MPEG2_MXC_SMPTE_170_M = 0x06,
CELL_VDEC_MPEG2_MXC_SMPTE_240_M = 0x07,
};
enum MPEG2_pictureCodingType : u8
{
CELL_VDEC_MPEG2_PCT_FORBIDDEN = 0x00,
CELL_VDEC_MPEG2_PCT_I = 0x01,
CELL_VDEC_MPEG2_PCT_P = 0x02,
CELL_VDEC_MPEG2_PCT_B = 0x03,
CELL_VDEC_MPEG2_PCT_D = 0x04,
};
enum MPEG2_pictureStructure : u8
{
CELL_VDEC_MPEG2_PSTR_TOP_FIELD = 0x01,
CELL_VDEC_MPEG2_PSTR_BOTTOM_FIELD = 0x02,
CELL_VDEC_MPEG2_PSTR_FRAME = 0x03,
};
struct CellVdecMpeg2Info
{
be_t<u16> horizontal_size;
be_t<u16> vertical_size;
union
{
MPEG2_aspectRatio aspect_ratio_information;
MPEG1_aspectRatio aspect_ratio_information1;
};
MPEG2_frameRate frame_rate_code;
b8 progressive_sequence;
b8 low_delay;
MPEG2_videoFormat video_format;
b8 colour_description;
MPEG2_colourPrimaries colour_primaries;
MPEG2_transferCharacteristics transfer_characteristics;
MPEG2_matrixCoefficients matrix_coefficients;
be_t<u16> temporal_reference[2];
MPEG2_pictureCodingType picture_coding_type[2];
MPEG2_pictureStructure picture_structure[2];
b8 top_field_first;
b8 repeat_first_field;
b8 progressive_frame;
be_t<u32> time_code;
b8 closed_gop;
b8 broken_link;
be_t<u16> vbv_delay[2];
be_t<u16> display_horizontal_size;
be_t<u16> display_vertical_size;
u8 number_of_frame_centre_offsets[2];
be_t<u16> frame_centre_horizontal_offset[2][3];
be_t<u16> frame_centre_vertical_offset[2][3];
be_t<u32> headerPresentFlags; // MPEG2_headerFlags
be_t<u32> headerRetentionFlags; // MPEG2_headerFlags
b8 mpeg1Flag;
u8 ccDataLength[2];
u8 ccData[2][128];
be_t<u64> reserved[2];
};
| 19,431
|
C++
|
.h
| 605
| 30.338843
| 87
| 0.640966
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,867
|
cellMusic.h
|
RPCS3_rpcs3/rpcs3/Emu/Cell/Modules/cellMusic.h
|
#pragma once
#include "Emu/Memory/vm_ptr.h"
#include "Emu/Cell/ErrorCodes.h"
#include "cellSearch.h"
// Error Codes
enum CellMusicError : u32
{
CELL_MUSIC_CANCELED = 1,
CELL_MUSIC_PLAYBACK_FINISHED = 0x8002c101,
CELL_MUSIC_ERROR_PARAM = 0x8002c102,
CELL_MUSIC_ERROR_BUSY = 0x8002c103,
CELL_MUSIC_ERROR_NO_ACTIVE_CONTENT = 0x8002c104,
CELL_MUSIC_ERROR_NO_MATCH_FOUND = 0x8002c105,
CELL_MUSIC_ERROR_INVALID_CONTEXT = 0x8002c106,
CELL_MUSIC_ERROR_PLAYBACK_FAILURE = 0x8002c107,
CELL_MUSIC_ERROR_NO_MORE_CONTENT = 0x8002c108,
CELL_MUSIC_DIALOG_OPEN = 0x8002c109,
CELL_MUSIC_DIALOG_CLOSE = 0x8002c10a,
CELL_MUSIC_ERROR_GENERIC = 0x8002c1ff,
};
enum CellMusic2Error : u32
{
CELL_MUSIC2_CANCELED = 1,
CELL_MUSIC2_PLAYBACK_FINISHED = 0x8002c101,
CELL_MUSIC2_ERROR_PARAM = 0x8002c102,
CELL_MUSIC2_ERROR_BUSY = 0x8002c103,
CELL_MUSIC2_ERROR_NO_ACTIVE_CONTENT = 0x8002c104,
CELL_MUSIC2_ERROR_NO_MATCH_FOUND = 0x8002c105,
CELL_MUSIC2_ERROR_INVALID_CONTEXT = 0x8002c106,
CELL_MUSIC2_ERROR_PLAYBACK_FAILURE = 0x8002c107,
CELL_MUSIC2_ERROR_NO_MORE_CONTENT = 0x8002c108,
CELL_MUSIC2_DIALOG_OPEN = 0x8002c109,
CELL_MUSIC2_DIALOG_CLOSE = 0x8002c10a,
CELL_MUSIC2_ERROR_GENERIC = 0x8002c1ff,
};
enum
{
CELL_SYSUTIL_MUSIC_INITIALIZING_FINISHED = 1,
CELL_SYSUTIL_MUSIC_SHUTDOWN_FINISHED = 4, // Was 3 in 1.03, changed to 4 in 1.1
CELL_SYSUTIL_MUSIC_LOADING_FINISHED = 5,
CELL_SYSUTIL_MUSIC_UNLOADING_FINISHED = 7,
CELL_SYSUTIL_MUSIC_RELEASED = 9,
CELL_SYSUTIL_MUSIC_GRABBED = 11,
};
enum
{
CELL_SYSUTIL_MUSIC2_INITIALIZING_FINISHED = CELL_SYSUTIL_MUSIC_INITIALIZING_FINISHED,
CELL_SYSUTIL_MUSIC2_SHUTDOWN_FINISHED = CELL_SYSUTIL_MUSIC_SHUTDOWN_FINISHED,
CELL_SYSUTIL_MUSIC2_LOADING_FINISHED = CELL_SYSUTIL_MUSIC_LOADING_FINISHED,
CELL_SYSUTIL_MUSIC2_UNLOADING_FINISHED = CELL_SYSUTIL_MUSIC_UNLOADING_FINISHED,
CELL_SYSUTIL_MUSIC2_RELEASED = CELL_SYSUTIL_MUSIC_RELEASED,
CELL_SYSUTIL_MUSIC2_GRABBED = CELL_SYSUTIL_MUSIC_GRABBED,
};
enum
{
CELL_MUSIC_EVENT_STATUS_NOTIFICATION = 0,
CELL_MUSIC_EVENT_INITIALIZE_RESULT = 1,
CELL_MUSIC_EVENT_FINALIZE_RESULT = 2,
CELL_MUSIC_EVENT_SELECT_CONTENTS_RESULT = 3,
CELL_MUSIC_EVENT_SET_PLAYBACK_COMMAND_RESULT = 4,
CELL_MUSIC_EVENT_SET_VOLUME_RESULT = 5,
CELL_MUSIC_EVENT_SET_SELECTION_CONTEXT_RESULT = 6,
CELL_MUSIC_EVENT_UI_NOTIFICATION = 7,
};
enum
{
CELL_MUSIC2_EVENT_STATUS_NOTIFICATION = CELL_MUSIC_EVENT_STATUS_NOTIFICATION,
CELL_MUSIC2_EVENT_INITIALIZE_RESULT = CELL_MUSIC_EVENT_INITIALIZE_RESULT,
CELL_MUSIC2_EVENT_FINALIZE_RESULT = CELL_MUSIC_EVENT_FINALIZE_RESULT,
CELL_MUSIC2_EVENT_SELECT_CONTENTS_RESULT = CELL_MUSIC_EVENT_SELECT_CONTENTS_RESULT,
CELL_MUSIC2_EVENT_SET_PLAYBACK_COMMAND_RESULT = CELL_MUSIC_EVENT_SET_PLAYBACK_COMMAND_RESULT,
CELL_MUSIC2_EVENT_SET_VOLUME_RESULT = CELL_MUSIC_EVENT_SET_VOLUME_RESULT,
CELL_MUSIC2_EVENT_SET_SELECTION_CONTEXT_RESULT = CELL_MUSIC_EVENT_SET_SELECTION_CONTEXT_RESULT,
CELL_MUSIC2_EVENT_UI_NOTIFICATION = CELL_MUSIC_EVENT_UI_NOTIFICATION,
};
enum
{
CELL_MUSIC_PB_CMD_STOP = 0,
CELL_MUSIC_PB_CMD_PLAY = 1,
CELL_MUSIC_PB_CMD_PAUSE = 2,
CELL_MUSIC_PB_CMD_NEXT = 3,
CELL_MUSIC_PB_CMD_PREV = 4,
CELL_MUSIC_PB_CMD_FASTFORWARD = 5,
CELL_MUSIC_PB_CMD_FASTREVERSE = 6,
};
enum
{
CELL_MUSIC2_PB_CMD_STOP = CELL_MUSIC_PB_CMD_STOP,
CELL_MUSIC2_PB_CMD_PLAY = CELL_MUSIC_PB_CMD_PLAY,
CELL_MUSIC2_PB_CMD_PAUSE = CELL_MUSIC_PB_CMD_PAUSE,
CELL_MUSIC2_PB_CMD_NEXT = CELL_MUSIC_PB_CMD_NEXT,
CELL_MUSIC2_PB_CMD_PREV = CELL_MUSIC_PB_CMD_PREV,
CELL_MUSIC2_PB_CMD_FASTFORWARD = CELL_MUSIC_PB_CMD_FASTFORWARD,
CELL_MUSIC2_PB_CMD_FASTREVERSE = CELL_MUSIC_PB_CMD_FASTREVERSE,
};
enum
{
CELL_MUSIC_PB_STATUS_STOP = 0,
CELL_MUSIC_PB_STATUS_PLAY = 1,
CELL_MUSIC_PB_STATUS_PAUSE = 2,
CELL_MUSIC_PB_STATUS_FASTFORWARD = 3,
CELL_MUSIC_PB_STATUS_FASTREVERSE = 4,
};
enum
{
CELL_MUSIC2_PB_STATUS_STOP = CELL_MUSIC_PB_STATUS_STOP,
CELL_MUSIC2_PB_STATUS_PLAY = CELL_MUSIC_PB_STATUS_PLAY,
CELL_MUSIC2_PB_STATUS_PAUSE = CELL_MUSIC_PB_STATUS_PAUSE,
CELL_MUSIC2_PB_STATUS_FASTFORWARD = CELL_MUSIC_PB_STATUS_FASTFORWARD,
CELL_MUSIC2_PB_STATUS_FASTREVERSE = CELL_MUSIC_PB_STATUS_FASTREVERSE,
};
enum
{
CELL_MUSIC_PLAYBACK_MEMORY_CONTAINER_SIZE = 11 * 1024 * 1024,
CELL_MUSIC_PLAYER_MODE_NORMAL = 0,
CELL_MUSIC2_PLAYER_MODE_NORMAL = CELL_MUSIC_PLAYER_MODE_NORMAL,
CELL_MUSIC_SELECTION_CONTEXT_SIZE = 2048,
};
using CellMusicCallback = void(u32 event, vm::ptr<void> param, vm::ptr<void> userData);
using CellMusic2Callback = void(u32 event, vm::ptr<void> param, vm::ptr<void> userData);
struct CellMusicSelectionContext
{
// TODO: find out what fw does with it
// Let's just hijack it with our own data.
char data[CELL_MUSIC_SELECTION_CONTEXT_SIZE];
};
struct music_selection_context
{
bool valid = false;
char magic[4] = "SUS";
std::string hash;
CellSearchContentType content_type = CELL_SEARCH_CONTENTTYPE_MUSIC;
CellSearchRepeatMode repeat_mode = CELL_SEARCH_REPEATMODE_NONE;
CellSearchContextOption context_option = CELL_SEARCH_CONTEXTOPTION_NONE;
u32 first_track{0};
u32 current_track{0};
std::vector<std::string> playlist;
static constexpr u32 max_depth = 2; // root + 1 folder + file
static constexpr const char* target_file_type = "Music Playlist";
static constexpr const char* target_version = "1.0";
static std::string get_next_hash();
static std::string context_to_hex(const CellMusicSelectionContext& context);
bool set(const CellMusicSelectionContext& in);
CellMusicSelectionContext get() const;
std::string to_string() const;
std::string get_yaml_path() const;
void set_playlist(const std::string& path);
void create_playlist(const std::string& new_hash);
bool load_playlist();
u32 step_track(bool next);
operator bool() const
{
return atomic_storage<bool>::load(valid);
}
// Helper
error_code find_content_id(vm::ptr<CellSearchContentId> contents_id);
};
| 6,361
|
C++
|
.h
| 157
| 38.66879
| 96
| 0.710658
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,868
|
cellCrossController.h
|
RPCS3_rpcs3/rpcs3/Emu/Cell/Modules/cellCrossController.h
|
#pragma once
enum CellCrossControllerError : u32
{
CELL_CROSS_CONTROLLER_ERROR_CANCEL = 0x8002cd80,
CELL_CROSS_CONTROLLER_ERROR_NETWORK = 0x8002cd81,
CELL_CROSS_CONTROLLER_ERROR_OUT_OF_MEMORY = 0x8002cd90,
CELL_CROSS_CONTROLLER_ERROR_FATAL = 0x8002cd91,
CELL_CROSS_CONTROLLER_ERROR_INVALID_PKG_FILENAME = 0x8002cd92,
CELL_CROSS_CONTROLLER_ERROR_INVALID_SIG_FILENAME = 0x8002cd93,
CELL_CROSS_CONTROLLER_ERROR_INVALID_ICON_FILENAME = 0x8002cd94,
CELL_CROSS_CONTROLLER_ERROR_INVALID_VALUE = 0x8002cd95,
CELL_CROSS_CONTROLLER_ERROR_PKG_FILE_OPEN = 0x8002cd96,
CELL_CROSS_CONTROLLER_ERROR_SIG_FILE_OPEN = 0x8002cd97,
CELL_CROSS_CONTROLLER_ERROR_ICON_FILE_OPEN = 0x8002cd98,
CELL_CROSS_CONTROLLER_ERROR_INVALID_STATE = 0x8002cd99,
CELL_CROSS_CONTROLLER_ERROR_INVALID_PKG_FILE = 0x8002cd9a,
CELL_CROSS_CONTROLLER_ERROR_INTERNAL = 0x8002cda0,
};
enum
{
CELL_CROSS_CONTROLLER_STATUS_INITIALIZED = 1,
CELL_CROSS_CONTROLLER_STATUS_FINALIZED = 2
};
enum
{
CELL_CROSS_CONTROLLER_PKG_APP_VER_LEN = 6, // e.g. 01.00
CELL_CROSS_CONTROLLER_PKG_TITLE_ID_LEN = 10, // e.g. NEKO12345
CELL_CROSS_CONTROLLER_PKG_TITLE_LEN = 52, // e.g. Cat Simulator 5
// Undefined helper value
CELL_CROSS_CONTROLLER_PARAM_FILE_NAME_LEN = 255,
};
struct CellCrossControllerParam
{
vm::bcptr<char> pPackageFileName;
vm::bcptr<char> pSignatureFileName;
vm::bcptr<char> pIconFileName;
vm::bptr<void> option;
};
struct CellCrossControllerPackageInfo
{
vm::bcptr<char> pTitle;
vm::bcptr<char> pTitleId;
vm::bcptr<char> pAppVer;
};
using CellCrossControllerCallback = void(s32 status, s32 errorCode, vm::ptr<void> option, vm::ptr<void> userdata);
| 1,756
|
C++
|
.h
| 45
| 37.244444
| 114
| 0.735915
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,869
|
cellCelp8Enc.h
|
RPCS3_rpcs3/rpcs3/Emu/Cell/Modules/cellCelp8Enc.h
|
#pragma once
struct CellSpurs;
// libCelp8Enc = 0x806140a1 - 0x806140bf
// typedef void* CellCelp8EncHandle;
// Return Codes
enum CellCelp8EncError : u32
{
CELL_CELP8ENC_ERROR_FAILED = 0x806140a1,
CELL_CELP8ENC_ERROR_SEQ = 0x806140a2,
CELL_CELP8ENC_ERROR_ARG = 0x806140a3,
CELL_CELP8ENC_ERROR_CORE_FAILED = 0x806140b1,
CELL_CELP8ENC_ERROR_CORE_SEQ = 0x806140b2,
CELL_CELP8ENC_ERROR_CORE_ARG = 0x806140b3,
};
// Definitions
enum CELL_CELP8ENC_MPE_CONFIG
{
CELL_CELP8ENC_MPE_CONFIG_0 = 0,
CELL_CELP8ENC_MPE_CONFIG_2 = 2,
CELL_CELP8ENC_MPE_CONFIG_6 = 6,
CELL_CELP8ENC_MPE_CONFIG_9 = 9,
CELL_CELP8ENC_MPE_CONFIG_12 = 12,
CELL_CELP8ENC_MPE_CONFIG_15 = 15,
CELL_CELP8ENC_MPE_CONFIG_18 = 18,
CELL_CELP8ENC_MPE_CONFIG_21 = 21,
CELL_CELP8ENC_MPE_CONFIG_24 = 24,
CELL_CELP8ENC_MPE_CONFIG_26 = 26,
};
enum CELL_CELP8ENC_SAMPEL_RATE
{
CELL_CELP8ENC_FS_8kHz = 1,
};
enum CELL_CELP8ENC_EXCITATION_MODE
{
CELL_CELP8ENC_EXCITATION_MODE_MPE = 0,
};
enum CELL_CELP8ENC_WORD_SZ
{
CELL_CELP8ENC_WORD_SZ_FLOAT,
};
struct CellCelp8EncAttr
{
be_t<u32> workMemSize;
be_t<u32> celpEncVerUpper;
be_t<u32> celpEncVerLower;
};
struct CellCelp8EncResource
{
be_t<u32> totalMemSize;
vm::bptr<void> startAddr;
be_t<u32> ppuThreadPriority;
be_t<u32> spuThreadPriority;
be_t<u32/*usz*/> ppuThreadStackSize;
};
struct CellCelp8EncParam
{
be_t<u32> excitationMode;
be_t<u32> sampleRate;
be_t<u32> configuration;
be_t<u32> wordSize;
vm::bptr<u8> outBuff;
be_t<u32> outSize;
};
struct CellCelp8EncAuInfo
{
vm::bptr<void> startAddr;
be_t<u32> size;
};
struct CellCelp8EncPcmInfo
{
vm::bptr<void> startAddr;
be_t<u32> size;
};
struct CellCelp8EncResourceEx
{
be_t<u32> totalMemSize;
vm::bptr<void> startAddr;
vm::bptr<CellSpurs> spurs;
u8 priority[8];
be_t<u32> maxContention;
};
| 1,824
|
C++
|
.h
| 81
| 20.82716
| 46
| 0.754772
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,870
|
sceNpClans.h
|
RPCS3_rpcs3/rpcs3/Emu/Cell/Modules/sceNpClans.h
|
#pragma once
#include "sceNp.h"
// Return codes
enum SceNpClansError : u32
{
SCE_NP_CLANS_ERROR_ALREADY_INITIALIZED = 0x80022701,
SCE_NP_CLANS_ERROR_NOT_INITIALIZED = 0x80022702,
SCE_NP_CLANS_ERROR_NOT_SUPPORTED = 0x80022703,
SCE_NP_CLANS_ERROR_OUT_OF_MEMORY = 0x80022704,
SCE_NP_CLANS_ERROR_INVALID_ARGUMENT = 0x80022705,
SCE_NP_CLANS_ERROR_EXCEEDS_MAX = 0x80022706,
SCE_NP_CLANS_ERROR_BAD_RESPONSE = 0x80022707,
SCE_NP_CLANS_ERROR_BAD_DATA = 0x80022708,
SCE_NP_CLANS_ERROR_BAD_REQUEST = 0x80022709,
SCE_NP_CLANS_ERROR_INVALID_SIGNATURE = 0x8002270a,
SCE_NP_CLANS_ERROR_INSUFFICIENT = 0x8002270b,
SCE_NP_CLANS_ERROR_INTERNAL_BUFFER = 0x8002270c,
SCE_NP_CLANS_ERROR_SERVER_MAINTENANCE = 0x8002270d,
SCE_NP_CLANS_ERROR_SERVER_END_OF_SERVICE = 0x8002270e,
SCE_NP_CLANS_ERROR_SERVER_BEFORE_START_OF_SERVICE = 0x8002270f,
SCE_NP_CLANS_ERROR_ABORTED = 0x80022710,
SCE_NP_CLANS_ERROR_SERVICE_UNAVAILABLE = 0x80022711,
SCE_NP_CLANS_SERVER_ERROR_BAD_REQUEST = 0x80022801,
SCE_NP_CLANS_SERVER_ERROR_INVALID_TICKET = 0x80022802,
SCE_NP_CLANS_SERVER_ERROR_INVALID_SIGNATURE = 0x80022803,
SCE_NP_CLANS_SERVER_ERROR_TICKET_EXPIRED = 0x80022804,
SCE_NP_CLANS_SERVER_ERROR_INVALID_NPID = 0x80022805,
SCE_NP_CLANS_SERVER_ERROR_FORBIDDEN = 0x80022806,
SCE_NP_CLANS_SERVER_ERROR_INTERNAL_SERVER_ERROR = 0x80022807,
SCE_NP_CLANS_SERVER_ERROR_BANNED = 0x8002280a,
SCE_NP_CLANS_SERVER_ERROR_BLACKLISTED = 0x80022811,
SCE_NP_CLANS_SERVER_ERROR_INVALID_ENVIRONMENT = 0x8002281d,
SCE_NP_CLANS_SERVER_ERROR_NO_SUCH_CLAN_SERVICE = 0x8002282f,
SCE_NP_CLANS_SERVER_ERROR_NO_SUCH_CLAN = 0x80022830,
SCE_NP_CLANS_SERVER_ERROR_NO_SUCH_CLAN_MEMBER = 0x80022831,
SCE_NP_CLANS_SERVER_ERROR_BEFORE_HOURS = 0x80022832,
SCE_NP_CLANS_SERVER_ERROR_CLOSED_SERVICE = 0x80022833,
SCE_NP_CLANS_SERVER_ERROR_PERMISSION_DENIED = 0x80022834,
SCE_NP_CLANS_SERVER_ERROR_CLAN_LIMIT_REACHED = 0x80022835,
SCE_NP_CLANS_SERVER_ERROR_CLAN_LEADER_LIMIT_REACHED = 0x80022836,
SCE_NP_CLANS_SERVER_ERROR_CLAN_MEMBER_LIMIT_REACHED = 0x80022837,
SCE_NP_CLANS_SERVER_ERROR_CLAN_JOINED_LIMIT_REACHED = 0x80022838,
SCE_NP_CLANS_SERVER_ERROR_MEMBER_STATUS_INVALID = 0x80022839,
SCE_NP_CLANS_SERVER_ERROR_DUPLICATED_CLAN_NAME = 0x8002283a,
SCE_NP_CLANS_SERVER_ERROR_CLAN_LEADER_CANNOT_LEAVE = 0x8002283b,
SCE_NP_CLANS_SERVER_ERROR_INVALID_ROLE_PRIORITY = 0x8002283c,
SCE_NP_CLANS_SERVER_ERROR_ANNOUNCEMENT_LIMIT_REACHED = 0x8002283d,
SCE_NP_CLANS_SERVER_ERROR_CLAN_CONFIG_MASTER_NOT_FOUND = 0x8002283e,
SCE_NP_CLANS_SERVER_ERROR_DUPLICATED_CLAN_TAG = 0x8002283f,
SCE_NP_CLANS_SERVER_ERROR_EXCEEDS_CREATE_CLAN_FREQUENCY = 0x80022840,
SCE_NP_CLANS_SERVER_ERROR_CLAN_PASSPHRASE_INCORRECT = 0x80022841,
SCE_NP_CLANS_SERVER_ERROR_CANNOT_RECORD_BLACKLIST_ENTRY = 0x80022842,
SCE_NP_CLANS_SERVER_ERROR_NO_SUCH_CLAN_ANNOUNCEMENT = 0x80022843,
SCE_NP_CLANS_SERVER_ERROR_VULGAR_WORDS_POSTED = 0x80022844,
SCE_NP_CLANS_SERVER_ERROR_BLACKLIST_LIMIT_REACHED = 0x80022845,
SCE_NP_CLANS_SERVER_ERROR_NO_SUCH_BLACKLIST_ENTRY = 0x80022846,
SCE_NP_CLANS_SERVER_ERROR_INVALID_NP_MESSAGE_FORMAT = 0x8002284b,
SCE_NP_CLANS_SERVER_ERROR_FAILED_TO_SEND_NP_MESSAGE = 0x8002284c,
};
// Clan roles
enum
{
SCE_NP_CLANS_ROLE_UNKNOWN = 0,
SCE_NP_CLANS_ROLE_NON_MEMBER = 1,
SCE_NP_CLANS_ROLE_MEMBER = 2,
SCE_NP_CLANS_ROLE_SUB_LEADER = 3,
SCE_NP_CLANS_ROLE_LEADER = 4,
};
// Clan member status
enum
{
SCE_NP_CLANS_MEMBER_STATUS_UNKNOWN = 0,
SCE_NP_CLANS_MEMBER_STATUS_NORMAL = 1,
SCE_NP_CLANS_MEMBER_STATUS_INVITED = 2,
SCE_NP_CLANS_MEMBER_STATUS_PENDING = 3,
};
// Clan search operators
enum
{
SCE_NP_CLANS_SEARCH_OPERATOR_EQUAL_TO = 0,
SCE_NP_CLANS_SEARCH_OPERATOR_NOT_EQUAL_TO = 1,
SCE_NP_CLANS_SEARCH_OPERATOR_GREATER_THAN = 2,
SCE_NP_CLANS_SEARCH_OPERATOR_GREATER_THAN_OR_EQUAL_TO = 3,
SCE_NP_CLANS_SEARCH_OPERATOR_LESS_THAN = 4,
SCE_NP_CLANS_SEARCH_OPERATOR_LESS_THAN_OR_EQUAL_TO = 5,
SCE_NP_CLANS_SEARCH_OPERATOR_SIMILAR_TO = 6,
};
// Constants for clan functions and structures
enum
{
SCE_NP_CLANS_ANNOUNCEMENT_MESSAGE_BODY_MAX_LENGTH = 1536,
SCE_NP_CLANS_CLAN_BINARY_ATTRIBUTE1_MAX_SIZE = 190,
SCE_NP_CLANS_CLAN_BINARY_DATA_MAX_SIZE = 10240,
SCE_NP_CLANS_MEMBER_BINARY_ATTRIBUTE1_MAX_SIZE = 16,
SCE_NP_CLANS_MEMBER_DESCRIPTION_MAX_LENGTH = 255,
SCE_NP_CLANS_MEMBER_BINARY_DATA_MAX_SIZE = 1024,
SCE_NP_CLANS_MESSAGE_BODY_MAX_LENGTH = 1536,
SCE_NP_CLANS_MESSAGE_SUBJECT_MAX_LENGTH = 54,
SCE_NP_CLANS_MESSAGE_BODY_CHARACTER_MAX = 512,
SCE_NP_CLANS_MESSAGE_SUBJECT_CHARACTER_MAX = 18,
SCE_NP_CLANS_MESSAGE_BINARY_DATA_MAX_SIZE = 1024,
SCE_NP_CLANS_PAGING_REQUEST_START_POSITION_MAX = 1000000,
SCE_NP_CLANS_PAGING_REQUEST_PAGE_MAX = 100,
};
enum
{
SCE_NP_CLANS_FIELDS_SEARCHABLE_ATTR_INT_ATTR1 = 0x00000001,
SCE_NP_CLANS_FIELDS_SEARCHABLE_ATTR_INT_ATTR2 = 0x00000002,
SCE_NP_CLANS_FIELDS_SEARCHABLE_ATTR_INT_ATTR3 = 0x00000004,
SCE_NP_CLANS_FIELDS_SEARCHABLE_ATTR_BIN_ATTR1 = 0x00000008,
SCE_NP_CLANS_FIELDS_SEARCHABLE_PROFILE_TAG = 0x00000010,
SCE_NP_CLANS_FIELDS_SEARCHABLE_PROFILE_NUM_MEMBERS = 0x00000020,
SCE_NP_CLANS_FIELDS_UPDATABLE_CLAN_INFO_DESCR = 0x00000040,
SCE_NP_CLANS_FIELDS_UPDATABLE_CLAN_INFO_BIN_DATA1 = 0x00000080,
SCE_NP_CLANS_FIELDS_UPDATABLE_MEMBER_INFO_DESCR = 0x00000100,
SCE_NP_CLANS_FIELDS_UPDATABLE_MEMBER_INFO_BIN_ATTR1 = 0x00000200,
SCE_NP_CLANS_FIELDS_UPDATABLE_MEMBER_INFO_BIN_DATA1 = 0x00000400,
SCE_NP_CLANS_FIELDS_UPDATABLE_MEMBER_INFO_ALLOW_MSG = 0x00000800,
};
enum
{
SCE_NP_CLANS_MESSAGE_OPTIONS_NONE = 0x00000000,
SCE_NP_CLANS_MESSAGE_OPTIONS_CENSOR = 0x00000001,
};
enum
{
SCE_NP_CLANS_INVALID_ID = 0,
SCE_NP_CLANS_INVALID_REQUEST_HANDLE = 0,
};
// Request handle for clan API
using SceNpClansRequestHandle = vm::ptr<struct SceNpClansRequest>;
// Paging request structure
struct SceNpClansPagingRequest
{
be_t<u32> startPos;
be_t<u32> max;
};
// Paging result structure
struct SceNpClansPagingResult
{
be_t<u32> count;
be_t<u32> total;
};
// Basic clan information
struct SceNpClansClanBasicInfo
{
be_t<u32> clanId;
be_t<u32> numMembers;
s8 name[SCE_NP_CLANS_CLAN_NAME_MAX_LENGTH + 1];
s8 tag[SCE_NP_CLANS_CLAN_TAG_MAX_LENGTH + 1];
u8 reserved[2];
};
// Clan entry structure
struct SceNpClansEntry
{
SceNpClansClanBasicInfo info;
be_t<u32> role;
be_t<s32> status;
b8 allowMsg;
u8 reserved[3];
};
// Clan search attribute structure
struct SceNpClansSearchableAttr
{
be_t<u32> fields;
be_t<u32> intAttr1;
be_t<u32> intAttr2;
be_t<u32> intAttr3;
u8 binAttr1[SCE_NP_CLANS_CLAN_BINARY_ATTRIBUTE1_MAX_SIZE];
u8 reserved[2];
};
// Clan search profile structure
struct SceNpClansSearchableProfile
{
SceNpClansSearchableAttr attr;
be_t<u32> fields;
be_t<u32> numMembers;
be_t<s32> tagSearchOp;
be_t<s32> numMemberSearchOp;
be_t<s32> intAttr1SearchOp;
be_t<s32> intAttr2SearchOp;
be_t<s32> intAttr3SearchOp;
be_t<s32> binAttr1SearchOp;
s8 tag[SCE_NP_CLANS_CLAN_TAG_MAX_LENGTH + 1];
u8 reserved[3];
};
// Clan search name structure
struct SceNpClansSearchableName
{
be_t<s32> nameSearchOp;
s8 name[SCE_NP_CLANS_CLAN_NAME_MAX_LENGTH + 1];
u8 reserved[3];
};
// Updatable clan information structure
struct SceNpClansUpdatableClanInfo
{
be_t<u32> fields;
s8 description[SCE_NP_CLANS_CLAN_DESCRIPTION_MAX_LENGTH + 1];
SceNpClansSearchableAttr attr;
u8 binData1;
be_t<u32> binData1Size;
};
// Clan information structure
struct SceNpClansClanInfo
{
CellRtcTick dateCreated;
SceNpClansClanBasicInfo info;
SceNpClansUpdatableClanInfo updatable;
};
// Updatable member information structure
struct SceNpClansUpdatableMemberInfo
{
be_t<u32> fields;
u8 binData1;
be_t<u32> binData1Size;
u8 binAttr1[SCE_NP_CLANS_CLAN_BINARY_ATTRIBUTE1_MAX_SIZE + 1];
s8 description[SCE_NP_CLANS_MEMBER_DESCRIPTION_MAX_LENGTH + 1];
b8 allowMsg;
u8 reserved[3];
};
// Member entry structure
struct SceNpClansMemberEntry
{
SceNpId npid;
be_t<u32> role;
be_t<s32> status;
SceNpClansUpdatableMemberInfo updatable;
};
// Clan message structure
struct SceNpClansMessage
{
char subject[SCE_NP_CLANS_MESSAGE_SUBJECT_MAX_LENGTH + 1];
char body[SCE_NP_CLANS_MESSAGE_BODY_MAX_LENGTH + 1];
be_t<u32> options;
};
// Clan message data structure
struct SceNpClansMessageData
{
u8 binData1;
be_t<u32> binData1Size;
};
// Clan message entry structure
struct SceNpClansMessageEntry
{
CellRtcTick postDate;
be_t<u32> mId;
SceNpClansMessage message;
SceNpClansMessageData data;
SceNpId npid;
u8 reserved[4];
};
// Blacklist entry structure
struct SceNpClansBlacklistEntry
{
SceNpId entry;
SceNpId registeredBy;
};
// fxm objects
struct sce_np_clans_manager
{
atomic_t<bool> is_initialized = false;
};
| 9,520
|
C++
|
.h
| 262
| 34.603053
| 70
| 0.707074
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,871
|
cellPad.h
|
RPCS3_rpcs3/rpcs3/Emu/Cell/Modules/cellPad.h
|
#pragma once
#include "Emu/Io/pad_types.h"
#include <array>
#include "util/types.hpp"
enum CellPadError : u32
{
CELL_PAD_ERROR_FATAL = 0x80121101,
CELL_PAD_ERROR_INVALID_PARAMETER = 0x80121102,
CELL_PAD_ERROR_ALREADY_INITIALIZED = 0x80121103,
CELL_PAD_ERROR_UNINITIALIZED = 0x80121104,
CELL_PAD_ERROR_RESOURCE_ALLOCATION_FAILED = 0x80121105,
CELL_PAD_ERROR_DATA_READ_FAILED = 0x80121106,
CELL_PAD_ERROR_NO_DEVICE = 0x80121107,
CELL_PAD_ERROR_UNSUPPORTED_GAMEPAD = 0x80121108,
CELL_PAD_ERROR_TOO_MANY_DEVICES = 0x80121109,
CELL_PAD_ERROR_EBUSY = 0x8012110a,
};
enum CellPadFilterError : u32
{
CELL_PADFILTER_ERROR_INVALID_PARAMETER = 0x80121401,
};
// Length returned in CellPadData struct
enum
{
CELL_PAD_LEN_NO_CHANGE = 0,
CELL_PAD_LEN_CHANGE_DEFAULT = 8,
CELL_PAD_LEN_CHANGE_PRESS_ON = 20,
CELL_PAD_LEN_CHANGE_SENSOR_ON = 24,
};
enum
{
CELL_PADFILTER_IIR_CUTOFF_2ND_LPF_BT_050 = 0, // 50% Nyquist frequency
CELL_PADFILTER_IIR_CUTOFF_2ND_LPF_BT_020 = 1, // 20% Nyquist frequency
CELL_PADFILTER_IIR_CUTOFF_2ND_LPF_BT_010 = 2, // 10% Nyquist frequency
};
struct pad_data_internal
{
u16 vendor_id;
u16 product_id;
u32 port_status;
u32 device_capability;
u32 device_type;
u32 pclass_type;
u32 pclass_profile;
ENABLE_BITWISE_SERIALIZATION;
};
struct CellPadInfo
{
be_t<u32> max_connect;
be_t<u32> now_connect;
be_t<u32> system_info;
be_t<u16> vendor_id[CELL_MAX_PADS];
be_t<u16> product_id[CELL_MAX_PADS];
u8 status[CELL_MAX_PADS];
};
struct CellPadInfo2
{
be_t<u32> max_connect;
be_t<u32> now_connect;
be_t<u32> system_info;
be_t<u32> port_status[CELL_PAD_MAX_PORT_NUM];
be_t<u32> port_setting[CELL_PAD_MAX_PORT_NUM];
be_t<u32> device_capability[CELL_PAD_MAX_PORT_NUM];
be_t<u32> device_type[CELL_PAD_MAX_PORT_NUM];
};
struct CellPadPeriphInfo
{
be_t<u32> max_connect;
be_t<u32> now_connect;
be_t<u32> system_info;
be_t<u32> port_status[CELL_PAD_MAX_PORT_NUM];
be_t<u32> port_setting[CELL_PAD_MAX_PORT_NUM];
be_t<u32> device_capability[CELL_PAD_MAX_PORT_NUM];
be_t<u32> device_type[CELL_PAD_MAX_PORT_NUM];
be_t<u32> pclass_type[CELL_PAD_MAX_PORT_NUM];
be_t<u32> pclass_profile[CELL_PAD_MAX_PORT_NUM];
};
struct CellPadPeriphData
{
be_t<u32> pclass_type;
be_t<u32> pclass_profile;
CellPadData cellpad_data;
};
struct CellPadCapabilityInfo
{
be_t<u32> info[CELL_PAD_MAX_CAPABILITY_INFO];
};
struct CellPadActParam
{
u8 motor[CELL_PAD_ACTUATOR_MAX];
u8 reserved[6];
};
struct CellPadFilterIIRSos
{
be_t<s32> u[3];
be_t<s32> a1;
be_t<s32> a2;
be_t<s32> b0;
be_t<s32> b1;
be_t<s32> b2;
};
struct pad_info
{
atomic_t<u32> max_connect = 0;
std::array<u32, CELL_PAD_MAX_PORT_NUM> port_setting{ 0 };
std::array<pad_data_internal, CELL_PAD_MAX_PORT_NUM> reported_info{};
SAVESTATE_INIT_POS(11);
pad_info() = default;
pad_info(utils::serial& ar);
void save(utils::serial& ar);
u32 get_max_connect() const
{
return std::min<u32>(max_connect, CELL_PAD_MAX_PORT_NUM);
}
// Unreliable way the firmware uses to optimize away pad calls for disconnected pads
// This result relies on data updates from config events on a dedicated thread to receive them
bool is_reportedly_connected(u32 port_no) const
{
return port_no < get_max_connect() && !!(reported_info[port_no].port_status & CELL_PAD_STATUS_CONNECTED);
}
};
error_code cellPadGetData(u32 port_no, vm::ptr<CellPadData> data);
error_code cellPadInit(ppu_thread& ppu, u32 max_connect);
error_code cellPadSetPortSetting(u32 port_no, u32 port_setting);
| 3,599
|
C++
|
.h
| 124
| 27.217742
| 107
| 0.724088
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,872
|
cellUsbd.h
|
RPCS3_rpcs3/rpcs3/Emu/Cell/Modules/cellUsbd.h
|
#pragma once
// Return Codes
enum CellUsbdError : u32
{
CELL_USBD_ERROR_NOT_INITIALIZED = 0x80110001,
CELL_USBD_ERROR_ALREADY_INITIALIZED = 0x80110002,
CELL_USBD_ERROR_NO_MEMORY = 0x80110003,
CELL_USBD_ERROR_INVALID_PARAM = 0x80110004,
CELL_USBD_ERROR_INVALID_TRANSFER_TYPE = 0x80110005,
CELL_USBD_ERROR_LDD_ALREADY_REGISTERED = 0x80110006,
CELL_USBD_ERROR_LDD_NOT_ALLOCATED = 0x80110007,
CELL_USBD_ERROR_LDD_NOT_RELEASED = 0x80110008,
CELL_USBD_ERROR_LDD_NOT_FOUND = 0x80110009,
CELL_USBD_ERROR_DEVICE_NOT_FOUND = 0x8011000a,
CELL_USBD_ERROR_PIPE_NOT_ALLOCATED = 0x8011000b,
CELL_USBD_ERROR_PIPE_NOT_RELEASED = 0x8011000c,
CELL_USBD_ERROR_PIPE_NOT_FOUND = 0x8011000d,
CELL_USBD_ERROR_IOREQ_NOT_ALLOCATED = 0x8011000e,
CELL_USBD_ERROR_IOREQ_NOT_RELEASED = 0x8011000f,
CELL_USBD_ERROR_IOREQ_NOT_FOUND = 0x80110010,
CELL_USBD_ERROR_CANNOT_GET_DESCRIPTOR = 0x80110011,
CELL_USBD_ERROR_FATAL = 0x801100ff,
};
// TCC (Transfer Completion Codes)
enum
{
HC_CC_NOERR = 0x0,
EHCI_CC_MISSMF = 0x10,
EHCI_CC_XACT = 0x20,
EHCI_CC_BABBLE = 0x30,
EHCI_CC_DATABUF = 0x40,
EHCI_CC_HALTED = 0x50,
USBD_HC_CC_NOERR = 0x0,
USBD_HC_CC_MISSMF = 0x1,
USBD_HC_CC_XACT = 0x2,
USBD_HC_CC_BABBLE = 0x4,
USBD_HC_CC_DATABUF = 0x8,
};
| 1,365
|
C++
|
.h
| 38
| 34.026316
| 53
| 0.693646
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,873
|
cellSysconf.h
|
RPCS3_rpcs3/rpcs3/Emu/Cell/Modules/cellSysconf.h
|
#pragma once
#include "Emu/Memory/vm_ptr.h"
typedef void(CellSysconfCallback)(s32 result, vm::ptr<void> userdata);
struct CellSysconfBtDeviceInfo
{
be_t<u64> deviceId;
be_t<s32> deviceType; // CellSysconfBtDeviceType
be_t<s32> state; // CellSysconfBtDeviceState
char name[64];
be_t<u32> reserved[4];
};
struct CellSysconfBtDeviceList
{
CellSysconfBtDeviceInfo device[16];
};
enum CellSysconfBtDeviceType : s32
{
CELL_SYSCONF_BT_DEVICE_TYPE_AUDIO = 0x00000001,
CELL_SYSCONF_BT_DEVICE_TYPE_HID = 0x00000002,
};
enum CellSysconfBtDeviceState : s32
{
CELL_SYSCONF_BT_DEVICE_STATE_UNAVAILABLE = 0,
CELL_SYSCONF_BT_DEVICE_STATE_AVAILABLE = 1,
};
enum CellSysConfError : u32
{
CELL_SYSCONF_ERROR_PARAM = 0x8002bb01
};
| 738
|
C++
|
.h
| 29
| 23.827586
| 70
| 0.782051
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,874
|
sysPrxForUser.h
|
RPCS3_rpcs3/rpcs3/Emu/Cell/Modules/sysPrxForUser.h
|
#pragma once
#include "Emu/Memory/vm_ptr.h"
#include "Emu/Cell/ErrorCodes.h"
enum
{
RANDOM_NUMBER_MAX_SIZE = 4096
};
using spu_printf_cb_t = vm::ptr<s32(u32 arg)>;
// Aux
extern spu_printf_cb_t g_spu_printf_agcb;
extern spu_printf_cb_t g_spu_printf_dgcb;
extern spu_printf_cb_t g_spu_printf_atcb;
extern spu_printf_cb_t g_spu_printf_dtcb;
// Functions
vm::ptr<void> _sys_memset(vm::ptr<void> dst, s32 value, u32 size);
struct sys_lwmutex_t;
struct sys_lwmutex_attribute_t;
error_code sys_lwmutex_create(ppu_thread& ppu, vm::ptr<sys_lwmutex_t> lwmutex, vm::ptr<sys_lwmutex_attribute_t> attr);
error_code sys_lwmutex_lock(ppu_thread& CPU, vm::ptr<sys_lwmutex_t> lwmutex, u64 timeout);
error_code sys_lwmutex_trylock(ppu_thread& CPU, vm::ptr<sys_lwmutex_t> lwmutex);
error_code sys_lwmutex_unlock(ppu_thread& CPU, vm::ptr<sys_lwmutex_t> lwmutex);
error_code sys_lwmutex_destroy(ppu_thread& CPU, vm::ptr<sys_lwmutex_t> lwmutex);
struct sys_lwmutex_locker
{
ppu_thread& ppu;
vm::ptr<sys_lwmutex_t> mutex;
sys_lwmutex_locker(ppu_thread& ppu, vm::ptr<sys_lwmutex_t> mutex)
: ppu(ppu)
, mutex(mutex)
{
ensure(sys_lwmutex_lock(ppu, mutex, 0) == CELL_OK);
}
~sys_lwmutex_locker() noexcept(false)
{
ensure(sys_lwmutex_unlock(ppu, mutex) == CELL_OK);
}
};
struct sys_lwcond_t;
struct sys_lwcond_attribute_t;
error_code sys_lwcond_create(ppu_thread& ppu, vm::ptr<sys_lwcond_t> lwcond, vm::ptr<sys_lwmutex_t> lwmutex, vm::ptr<sys_lwcond_attribute_t> attr);
error_code sys_lwcond_destroy(ppu_thread& ppu, vm::ptr<sys_lwcond_t> lwcond);
error_code sys_lwcond_signal(ppu_thread& CPU, vm::ptr<sys_lwcond_t> lwcond);
error_code sys_lwcond_signal_all(ppu_thread& CPU, vm::ptr<sys_lwcond_t> lwcond);
error_code sys_lwcond_signal_to(ppu_thread& CPU, vm::ptr<sys_lwcond_t> lwcond, u64 ppu_thread_id);
error_code sys_lwcond_wait(ppu_thread& CPU, vm::ptr<sys_lwcond_t> lwcond, u64 timeout);
error_code sys_ppu_thread_create(ppu_thread& ppu, vm::ptr<u64> thread_id, u32 entry, u64 arg, s32 prio, u32 stacksize, u64 flags, vm::cptr<char> threadname);
error_code sys_interrupt_thread_disestablish(ppu_thread& ppu, u32 ih);
void sys_ppu_thread_exit(ppu_thread& CPU, u64 val);
void sys_game_process_exitspawn(ppu_thread& ppu, vm::cptr<char> path, vm::cpptr<char> argv, vm::cpptr<char> envp, u32 data, u32 data_size, s32 prio, u64 flags);
void sys_game_process_exitspawn2(ppu_thread& ppu, vm::cptr<char> path, vm::cpptr<char> argv, vm::cpptr<char> envp, u32 data, u32 data_size, s32 prio, u64 flags);
| 2,504
|
C++
|
.h
| 50
| 48.4
| 161
| 0.741485
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,875
|
cellAudio.h
|
RPCS3_rpcs3/rpcs3/Emu/Cell/Modules/cellAudio.h
|
#pragma once
#include "Emu/Memory/vm_ptr.h"
#include "Utilities/Thread.h"
#include "Utilities/simple_ringbuf.h"
#include "Emu/Memory/vm.h"
#include "Emu/Audio/AudioBackend.h"
#include "Emu/Audio/AudioDumper.h"
#include "Emu/Audio/audio_resampler.h"
#include "Emu/system_config_types.h"
struct lv2_event_queue;
// Error codes
enum CellAudioError : u32
{
CELL_AUDIO_ERROR_ALREADY_INIT = 0x80310701,
CELL_AUDIO_ERROR_AUDIOSYSTEM = 0x80310702,
CELL_AUDIO_ERROR_NOT_INIT = 0x80310703,
CELL_AUDIO_ERROR_PARAM = 0x80310704,
CELL_AUDIO_ERROR_PORT_FULL = 0x80310705,
CELL_AUDIO_ERROR_PORT_ALREADY_RUN = 0x80310706,
CELL_AUDIO_ERROR_PORT_NOT_OPEN = 0x80310707,
CELL_AUDIO_ERROR_PORT_NOT_RUN = 0x80310708,
CELL_AUDIO_ERROR_TRANS_EVENT = 0x80310709,
CELL_AUDIO_ERROR_PORT_OPEN = 0x8031070a,
CELL_AUDIO_ERROR_SHAREDMEMORY = 0x8031070b,
CELL_AUDIO_ERROR_MUTEX = 0x8031070c,
CELL_AUDIO_ERROR_EVENT_QUEUE = 0x8031070d,
CELL_AUDIO_ERROR_AUDIOSYSTEM_NOT_FOUND = 0x8031070e,
CELL_AUDIO_ERROR_TAG_NOT_FOUND = 0x8031070f,
};
// constants
enum
{
CELL_AUDIO_BLOCK_8 = 8,
CELL_AUDIO_BLOCK_16 = 16,
CELL_AUDIO_BLOCK_32 = 32,
CELL_AUDIO_BLOCK_SAMPLES = 256,
CELL_AUDIO_CREATEEVENTFLAG_SPU = 0x00000001,
CELL_AUDIO_EVENT_MIX = 0,
CELL_AUDIO_EVENT_HEADPHONE = 1,
CELL_AUDIO_EVENTFLAG_BEFOREMIX = 0x80000000,
CELL_AUDIO_EVENTFLAG_DECIMATE_2 = 0x08000000,
CELL_AUDIO_EVENTFLAG_DECIMATE_4 = 0x10000000,
CELL_AUDIO_EVENTFLAG_HEADPHONE = 0x20000000,
CELL_AUDIO_EVENTFLAG_NOMIX = 0x40000000,
CELL_AUDIO_MAX_PORT = 4,
CELL_AUDIO_MAX_PORT_2 = 8,
CELL_AUDIO_MISC_ACCVOL_ALLDEVICE = 0x0000ffffUL,
CELL_AUDIO_PERSONAL_DEVICE_PRIMARY = 0x8000,
CELL_AUDIO_PORT_2CH = 2,
CELL_AUDIO_PORT_8CH = 8,
CELL_AUDIO_PORTATTR_BGM = 0x0000000000000010ULL,
CELL_AUDIO_PORTATTR_INITLEVEL = 0x0000000000001000ULL,
CELL_AUDIO_PORTATTR_OUT_NO_ROUTE = 0x0000000000100000ULL,
CELL_AUDIO_PORTATTR_OUT_PERSONAL_0 = 0x0000000001000000ULL,
CELL_AUDIO_PORTATTR_OUT_PERSONAL_1 = 0x0000000002000000ULL,
CELL_AUDIO_PORTATTR_OUT_PERSONAL_2 = 0x0000000004000000ULL,
CELL_AUDIO_PORTATTR_OUT_PERSONAL_3 = 0x0000000008000000ULL,
CELL_AUDIO_PORTATTR_OUT_SECONDARY = 0x0000000000000001ULL,
CELL_AUDIO_PORTATTR_OUT_STREAM1 = 0x0000000000000001ULL,
CELL_AUDIO_STATUS_CLOSE = 0x1010,
CELL_AUDIO_STATUS_READY = 1,
CELL_AUDIO_STATUS_RUN = 2,
};
enum class audio_backend_update : u32
{
NONE,
PARAM,
ALL,
};
//libaudio datatypes
struct CellAudioPortParam
{
be_t<u64> nChannel{};
be_t<u64> nBlock{};
be_t<u64> attr{};
be_t<float> level{};
};
struct CellAudioPortConfig
{
vm::bptr<u64> readIndexAddr{};
be_t<u32> status{};
be_t<u64> nChannel{};
be_t<u64> nBlock{};
be_t<u32> portSize{};
be_t<u32> portAddr{};
};
enum : u32
{
AUDIO_PORT_COUNT = 8,
AUDIO_MAX_BLOCK_COUNT = 32,
AUDIO_MAX_CHANNELS_COUNT = 8,
AUDIO_PORT_OFFSET = AUDIO_BUFFER_SAMPLES * AUDIO_MAX_BLOCK_COUNT * AUDIO_MAX_CHANNELS_COUNT * sizeof(f32),
EXTRA_AUDIO_BUFFERS = 8,
MAX_AUDIO_EVENT_QUEUES = 64,
AUDIO_BLOCK_SIZE_2CH = 2 * AUDIO_BUFFER_SAMPLES,
AUDIO_BLOCK_SIZE_8CH = 8 * AUDIO_BUFFER_SAMPLES,
PORT_BUFFER_TAG_COUNT = 6,
PORT_BUFFER_TAG_LAST_2CH = AUDIO_BLOCK_SIZE_2CH - 1,
PORT_BUFFER_TAG_DELTA_2CH = PORT_BUFFER_TAG_LAST_2CH / (PORT_BUFFER_TAG_COUNT - 1),
PORT_BUFFER_TAG_FIRST_2CH = PORT_BUFFER_TAG_LAST_2CH % (PORT_BUFFER_TAG_COUNT - 1),
PORT_BUFFER_TAG_LAST_8CH = AUDIO_BLOCK_SIZE_8CH - 1,
PORT_BUFFER_TAG_DELTA_8CH = PORT_BUFFER_TAG_LAST_8CH / (PORT_BUFFER_TAG_COUNT - 1),
PORT_BUFFER_TAG_FIRST_8CH = PORT_BUFFER_TAG_LAST_8CH % (PORT_BUFFER_TAG_COUNT - 1),
};
enum class audio_port_state : u32
{
closed,
opened,
started,
};
struct audio_port
{
atomic_t<audio_port_state> state = audio_port_state::closed;
u32 number = 0;
vm::ptr<char> addr{};
vm::ptr<u64> index{};
u32 num_channels = 0;
u32 num_blocks = 0;
u64 attr = 0;
u64 cur_pos = 0;
u64 global_counter = 0; // copy of global counter
u64 active_counter = 0;
u32 size = 0;
u64 timestamp = 0; // copy of global timestamp
struct level_set_t
{
float value = 0.0f;
float inc = 0.0f;
};
float level = 0.0f;
atomic_t<level_set_t> level_set{};
u32 block_size() const
{
return num_channels * AUDIO_BUFFER_SAMPLES;
}
u32 buf_size() const
{
return block_size() * sizeof(float);
}
u32 position(s32 offset = 0) const
{
s32 ofs = (offset % num_blocks) + num_blocks;
return (cur_pos + ofs) % num_blocks;
}
u32 buf_addr(s32 offset = 0) const
{
return addr.addr() + position(offset) * buf_size();
}
be_t<f32>* get_vm_ptr(s32 offset = 0) const
{
return vm::_ptr<f32>(buf_addr(offset));
}
// Tags
u32 prev_touched_tag_nr = 0;
f32 last_tag_value[PORT_BUFFER_TAG_COUNT] = { 0 };
void tag(s32 offset = 0);
audio_port() = default;
// Handle copy ctor of atomic var
audio_port(const audio_port& r)
{
std::memcpy(this, &r, sizeof(r));
}
ENABLE_BITWISE_SERIALIZATION;
};
struct cell_audio_config
{
struct raw_config
{
std::string audio_device{};
bool buffering_enabled = false;
s64 desired_buffer_duration = 0;
bool enable_time_stretching = false;
s64 time_stretching_threshold = 0;
bool convert_to_s16 = false;
bool dump_to_file = false;
audio_channel_layout channel_layout = audio_channel_layout::automatic;
audio_renderer renderer = audio_renderer::null;
audio_provider provider = audio_provider::none;
};
raw_config new_raw{};
raw_config raw{};
std::shared_ptr<AudioBackend> backend = nullptr;
AudioChannelCnt audio_downmix = AudioChannelCnt::SURROUND_7_1;
audio_channel_layout backend_channel_layout = audio_channel_layout::surround_7_1;
u32 backend_ch_cnt = 8;
u32 audio_channels = 2;
u32 audio_sampling_rate = DEFAULT_AUDIO_SAMPLING_RATE;
u32 audio_block_period = 0;
u32 audio_sample_size = 0;
f64 audio_min_buffer_duration = 0.0;
u32 audio_buffer_length = 0;
/*
* Buffering
*/
u64 desired_buffer_duration = 0;
// We need a non-blocking backend (implementing play/pause/flush) to be able to do buffering correctly
// We also need to be able to query the current playing state
bool buffering_enabled = false;
u64 minimum_block_period = 0; // the block period will not be dynamically lowered below this value (usecs)
u64 maximum_block_period = 0; // the block period will not be dynamically increased above this value (usecs)
u32 desired_full_buffers = 0;
u32 num_allocated_buffers = 0; // number of ringbuffer buffers
static constexpr f32 period_average_alpha = 0.02f; // alpha factor for the m_average_period rolling average
// when comparing the current period time with the desired period, if it is below this number of usecs we do not wait any longer(quantum dependent)
#ifdef _WIN32
static constexpr s64 period_comparison_margin = 250;
#else
static constexpr s64 period_comparison_margin = 5;
#endif
u64 fully_untouched_timeout = 0; // timeout if the game has not touched any audio buffer yet
u64 partially_untouched_timeout = 0; // timeout if the game has not touched all audio buffers yet
/*
* Time Stretching
*/
// We need to be able to set a dynamic frequency ratio to be able to do time stretching
bool time_stretching_enabled = false;
f32 time_stretching_threshold = 0.0f; // we only apply time stretching below this buffer fill rate (adjusted for average period)
static constexpr f32 time_stretching_step = 0.1f; // will only reduce/increase the frequency ratio in steps of at least this value
/*
* Constructor
*/
cell_audio_config();
/*
* Config changes
*/
void reset(bool backend_changed = true);
};
class audio_ringbuffer
{
private:
const std::shared_ptr<AudioBackend> backend;
const cell_audio_config& cfg;
const u32 buf_sz;
AudioDumper m_dump{};
std::unique_ptr<float[]> buffer[MAX_AUDIO_BUFFERS]{};
simple_ringbuf cb_ringbuf{};
audio_resampler resampler{};
atomic_t<bool> backend_active = false;
atomic_t<bool> backend_device_changed = false;
bool playing = false;
u64 update_timestamp = 0;
u64 play_timestamp = 0;
u64 last_remainder = 0;
f32 frequency_ratio = RESAMPLER_MAX_FREQ_VAL;
u32 cur_pos = 0;
bool get_backend_playing() const
{
return backend->IsPlaying();
}
void commit_data(f32* buf, u32 sample_cnt);
u32 backend_write_callback(u32 size, void *buf);
void backend_state_callback(AudioStateEvent event);
public:
audio_ringbuffer(cell_audio_config &cfg);
~audio_ringbuffer();
void play();
void flush();
u64 update(bool emu_is_paused);
void enqueue(bool enqueue_silence = false, bool force = false);
void enqueue_silence(u32 buf_count = 1, bool force = false);
void process_resampled_data();
f32 set_frequency_ratio(f32 new_ratio);
float* get_buffer(u32 num) const;
static u64 get_timestamp();
float* get_current_buffer() const;
u64 get_enqueued_samples() const;
u64 get_enqueued_playtime() const;
bool is_playing() const
{
return playing;
}
f32 get_frequency_ratio() const
{
return frequency_ratio;
}
bool get_operational_status() const
{
return backend->Operational();
}
bool device_changed()
{
return backend_device_changed.test_and_reset() && backend->DefaultDeviceChanged();
}
std::string_view get_backend_name() const
{
return backend->GetName();
}
};
class cell_audio_thread
{
private:
std::unique_ptr<audio_ringbuffer> ringbuffer{};
void reset_ports(s32 offset = 0);
void advance(u64 timestamp);
std::tuple<u32, u32, u32, u32> count_port_buffer_tags();
template <AudioChannelCnt channels, AudioChannelCnt downmix>
void mix(float* out_buffer, s32 offset = 0);
void finish_port_volume_stepping();
void update_config(bool backend_changed);
void reset_counters();
public:
shared_mutex emu_cfg_upd_m{};
cell_audio_config cfg{};
atomic_t<audio_backend_update> m_update_configuration = audio_backend_update::NONE;
shared_mutex mutex{};
atomic_t<u8> init = 0;
u32 key_count = 0;
u8 event_period = 0;
std::array<u64, MAX_AUDIO_EVENT_QUEUES> event_sources{};
std::array<u64, MAX_AUDIO_EVENT_QUEUES> event_data3{};
struct key_info
{
u8 start_period = 0; // Starting event_period
u32 flags = 0; // iFlags
u64 source = 0; // Event source
u64 ack_timestamp = 0; // timestamp of last call of cellAudioSendAck
std::shared_ptr<lv2_event_queue> port{}; // Underlying event port
};
std::vector<key_info> keys{};
std::array<audio_port, AUDIO_PORT_COUNT> ports{};
u64 m_last_period_end = 0;
u64 m_counter = 0;
u64 m_start_time = 0;
u64 m_dynamic_period = 0;
f32 m_average_playtime = 0.0f;
bool m_backend_failed = false;
bool m_audio_should_restart = false;
void operator()();
SAVESTATE_INIT_POS(9);
cell_audio_thread();
cell_audio_thread(utils::serial& ar);
void save(utils::serial& ar);
audio_port* open_port();
static constexpr auto thread_name = "cellAudio Thread"sv;
};
using cell_audio = named_thread<cell_audio_thread>;
namespace audio
{
cell_audio_config::raw_config get_raw_config();
extern void configure_audio(bool force_reset = false);
}
| 11,347
|
C++
|
.h
| 341
| 31.052786
| 148
| 0.713225
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,876
|
cellKb.h
|
RPCS3_rpcs3/rpcs3/Emu/Cell/Modules/cellKb.h
|
#pragma once
#include "Emu/Io/Keyboard.h"
enum CellKbError : u32
{
CELL_KB_ERROR_FATAL = 0x80121001,
CELL_KB_ERROR_INVALID_PARAMETER = 0x80121002,
CELL_KB_ERROR_ALREADY_INITIALIZED = 0x80121003,
CELL_KB_ERROR_UNINITIALIZED = 0x80121004,
CELL_KB_ERROR_RESOURCE_ALLOCATION_FAILED = 0x80121005,
CELL_KB_ERROR_READ_FAILED = 0x80121006,
CELL_KB_ERROR_NO_DEVICE = 0x80121007,
CELL_KB_ERROR_SYS_SETTING_FAILED = 0x80121008,
};
enum CellKbLedMode
{
CELL_KB_LED_MODE_MANUAL = 0,
CELL_KB_LED_MODE_AUTO1 = 1,
CELL_KB_LED_MODE_AUTO2 = 2,
};
enum
{
CELL_KB_RAWDAT = 0x8000U,
CELL_KB_KEYPAD = 0x4000U,
};
enum
{
CELL_KB_ARRANGEMENT_101 = CELL_KB_MAPPING_101,
CELL_KB_ARRANGEMENT_106 = CELL_KB_MAPPING_106,
CELL_KB_ARRANGEMENT_106_KANA = CELL_KB_MAPPING_106_KANA,
};
struct CellKbInfo
{
be_t<u32> max_connect;
be_t<u32> now_connect;
be_t<u32> info;
u8 status[CELL_KB_MAX_KEYBOARDS];
};
struct CellKbData
{
be_t<u32> led;
be_t<u32> mkey;
be_t<s32> len;
be_t<u16> keycode[CELL_KB_MAX_KEYCODES];
};
struct CellKbConfig
{
be_t<u32> arrange;
be_t<u32> read_mode;
be_t<u32> code_type;
};
| 1,204
|
C++
|
.h
| 50
| 22.38
| 57
| 0.681501
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,877
|
sceNpSns.h
|
RPCS3_rpcs3/rpcs3/Emu/Cell/Modules/sceNpSns.h
|
#pragma once
#include "Emu/Memory/vm_ptr.h"
// Return codes
enum sceNpSnsError : u32
{
SCE_NP_SNS_ERROR_UNKNOWN = 0x80024501,
SCE_NP_SNS_ERROR_NOT_SIGN_IN = 0x80024502,
SCE_NP_SNS_ERROR_INVALID_ARGUMENT = 0x80024503,
SCE_NP_SNS_ERROR_OUT_OF_MEMORY = 0x80024504,
SCE_NP_SNS_ERROR_SHUTDOWN = 0x80024505,
SCE_NP_SNS_ERROR_BUSY = 0x80024506,
SCE_NP_SNS_FB_ERROR_ALREADY_INITIALIZED = 0x80024511,
SCE_NP_SNS_FB_ERROR_NOT_INITIALIZED = 0x80024512,
SCE_NP_SNS_FB_ERROR_EXCEEDS_MAX = 0x80024513,
SCE_NP_SNS_FB_ERROR_UNKNOWN_HANDLE = 0x80024514,
SCE_NP_SNS_FB_ERROR_ABORTED = 0x80024515,
SCE_NP_SNS_FB_ERROR_ALREADY_ABORTED = 0x80024516,
SCE_NP_SNS_FB_ERROR_CONFIG_DISABLED = 0x80024517,
SCE_NP_SNS_FB_ERROR_FBSERVER_ERROR_RESPONSE = 0x80024518,
SCE_NP_SNS_FB_ERROR_THROTTLE_CLOSED = 0x80024519,
SCE_NP_SNS_FB_ERROR_OPERATION_INTERVAL_VIOLATION = 0x8002451a,
SCE_NP_SNS_FB_ERROR_UNLOADED_THROTTLE = 0x8002451b,
SCE_NP_SNS_FB_ERROR_ACCESS_NOT_ALLOWED = 0x8002451c,
};
// Access token param options
enum
{
SCE_NP_SNS_FB_ACCESS_TOKEN_PARAM_OPTIONS_SILENT = 0x00000001
};
// Constants for SNS functions
enum
{
SCE_NP_SNS_FB_INVALID_HANDLE = 0,
SCE_NP_SNS_FB_HANDLE_SLOT_MAX = 4,
SCE_NP_SNS_FB_PERMISSIONS_LENGTH_MAX = 255,
SCE_NP_SNS_FB_ACCESS_TOKEN_LENGTH_MAX = 255,
SCE_NP_SNS_FB_LONG_ACCESS_TOKEN_LENGTH_MAX = 4096
};
struct sns_fb_handle_t
{
static const u32 id_base = 1;
static const u32 id_step = 1;
static const u32 id_count = SCE_NP_SNS_FB_HANDLE_SLOT_MAX + 1;
static const u32 invalid = SCE_NP_SNS_FB_INVALID_HANDLE;
SAVESTATE_INIT_POS(20);
sns_fb_handle_t() = default;
sns_fb_handle_t(utils::serial&){}
void save(utils::serial&){}
};
// Initialization parameters for functionalities coordinated with Facebook
struct SceNpSnsFbInitParams
{
vm::bptr<void> pool;
be_t<u32> poolSize;
};
struct SceNpSnsFbAccessTokenParam
{
be_t<u64> fb_app_id;
char permissions[SCE_NP_SNS_FB_PERMISSIONS_LENGTH_MAX + 1];
be_t<u32> options;
};
struct SceNpSnsFbAccessTokenResult
{
be_t<u64> expiration;
char access_token[SCE_NP_SNS_FB_ACCESS_TOKEN_LENGTH_MAX + 1];
};
struct SceNpSnsFbLongAccessTokenResult
{
be_t<u64> expiration;
char access_token[SCE_NP_SNS_FB_LONG_ACCESS_TOKEN_LENGTH_MAX + 1];
};
// fxm objects
struct sce_np_sns_manager
{
atomic_t<bool> is_initialized = false;
};
| 2,622
|
C++
|
.h
| 76
| 32.789474
| 74
| 0.67206
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,878
|
cellMouse.h
|
RPCS3_rpcs3/rpcs3/Emu/Cell/Modules/cellMouse.h
|
#pragma once
enum CellMouseError : u32
{
CELL_MOUSE_ERROR_FATAL = 0x80121201,
CELL_MOUSE_ERROR_INVALID_PARAMETER = 0x80121202,
CELL_MOUSE_ERROR_ALREADY_INITIALIZED = 0x80121203,
CELL_MOUSE_ERROR_UNINITIALIZED = 0x80121204,
CELL_MOUSE_ERROR_RESOURCE_ALLOCATION_FAILED = 0x80121205,
CELL_MOUSE_ERROR_DATA_READ_FAILED = 0x80121206,
CELL_MOUSE_ERROR_NO_DEVICE = 0x80121207,
CELL_MOUSE_ERROR_SYS_SETTING_FAILED = 0x80121208,
};
enum
{
CELL_MOUSE_MAX_DATA_LIST_NUM = 8,
CELL_MOUSE_MAX_CODES = 64,
CELL_MAX_MICE = 127,
};
struct CellMouseInfo
{
be_t<u32> max_connect;
be_t<u32> now_connect;
be_t<u32> info;
be_t<u16> vendor_id[CELL_MAX_MICE];
be_t<u16> product_id[CELL_MAX_MICE];
u8 status[CELL_MAX_MICE];
};
struct CellMouseInfoTablet
{
be_t<u32> is_supported;
be_t<u32> mode;
};
struct CellMouseData
{
u8 update;
u8 buttons;
s8 x_axis;
s8 y_axis;
s8 wheel;
s8 tilt;
};
struct CellMouseTabletData
{
be_t<s32> len;
u8 data[CELL_MOUSE_MAX_CODES];
};
struct CellMouseDataList
{
be_t<u32> list_num;
CellMouseData list[CELL_MOUSE_MAX_DATA_LIST_NUM];
};
struct CellMouseTabletDataList
{
be_t<u32> list_num;
CellMouseTabletData list[CELL_MOUSE_MAX_DATA_LIST_NUM];
};
struct CellMouseRawData
{
be_t<s32> len;
u8 data[CELL_MOUSE_MAX_CODES];
};
| 1,379
|
C++
|
.h
| 61
| 20.918033
| 58
| 0.702063
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,879
|
cellDaisy.h
|
RPCS3_rpcs3/rpcs3/Emu/Cell/Modules/cellDaisy.h
|
#pragma once
// libDaisy = 0x80410501 - 0x804105ff
// Error codes
enum CellDaisyError : u32
{
CELL_DAISY_ERROR_NO_BEGIN = 0x80410501,
CELL_DAISY_ERROR_INVALID_PORT_ATTACH = 0x80410502,
CELL_DAISY_ERROR_NOT_IMPLEMENTED = 0x80410503,
CELL_DAISY_ERROR_AGAIN = 0x80410511,
CELL_DAISY_ERROR_INVAL = 0x80410512,
CELL_DAISY_ERROR_PERM = 0x80410509,
CELL_DAISY_ERROR_BUSY = 0x8041051A,
CELL_DAISY_ERROR_STAT = 0x8041050F,
};
// Return codes
enum
{
QUEUE_IS_BUSY = 2,
TERMINATED = 3,
GLUE_ACTIVE = 4,
};
// Assertations
enum
{
CELL_DAISY_MIN_QUEUE_SIZE = 1,
CELL_DAISY_MAX_LOCAL_QUEUE_SIZE = 32,
CELL_DAISY_MAX_ATO_QUEUE_SIZE = 32,
CELL_DAISY_MAX_SNR_QUEUE_SIZE = 12,
CELL_DAISY_MIN_ENTRY_SIZE = 16,
CELL_DAISY_MAX_ENTRY_SIZE = (16*1024),
CELL_DAISY_MAX_DMA_TAG = 31,
// CELL_DAISY_ENTRY_SIZE(x)
// CELL_DAISY_EA_ATOMIC(x)
// CELL_DAISY_EA_DMA(x)
};
// Definitions
// The following are prefixed with DAISY_ to prevent name conflits
enum
{
// Queue IO
DAISY_OUTPUT,
DAISY_INPUT,
// Block Mode
DAISY_NOT_STALL = 0,
DAISY_STALL = 1,
// Queue Status
DAISY_PTR_UNAVAILABLE = 0x40000001,
DAISY_PTR_TERMINATED = 0x40000002,
// Buffer Mode
DAISY_COPY = 0,
DAISY_REFERENCE = 1,
// Constructor Mode
DAISY_NO_PARAMETER = 0,
DAISY_PARAMETER = 1,
// Glue Mode
DAISY_ONE_PORT = 1,
DAISY_TWO_PORT = 2,
// Queue Mode
DAISY_IN_ORDER,
DAISY_OUT_OF_ORDER,
// Buffer Type
DAISY_BUFFER_TYPE_REMOTE = 1,
DAISY_BUFFER_TYPE_LOCAL = 2,
// Queue Control Type
DAISY_QCTL_TYPE_ATOMIC = 1,
DAISY_QCTL_TYPE_LOCAL = 2,
DAISY_QCTL_TYPE_SIGNAL_NOTIFICATION = 3,
};
| 1,588
|
C++
|
.h
| 68
| 21.397059
| 66
| 0.731383
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,880
|
cellFontFT.h
|
RPCS3_rpcs3/rpcs3/Emu/Cell/Modules/cellFontFT.h
|
#pragma once
#include "cellFont.h"
#include "Emu/Memory/vm_ptr.h"
struct CellFontLibraryConfigFT
{
vm::bptr<void> library;
CellFontMemoryInterface MemoryIF;
};
using CellFontRendererConfigFT = CellFontRendererConfig;
| 223
|
C++
|
.h
| 9
| 23.111111
| 56
| 0.838095
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,881
|
cellStorage.h
|
RPCS3_rpcs3/rpcs3/Emu/Cell/Modules/cellStorage.h
|
#pragma once
enum CellStorageError : u32
{
CELL_STORAGEDATA_ERROR_BUSY = 0x8002be01,
CELL_STORAGEDATA_ERROR_INTERNAL = 0x8002be02,
CELL_STORAGEDATA_ERROR_PARAM = 0x8002be03,
CELL_STORAGEDATA_ERROR_ACCESS_ERROR = 0x8002be04,
CELL_STORAGEDATA_ERROR_FAILURE = 0x8002be05
};
enum CellStorageDataVersion
{
CELL_STORAGEDATA_VERSION_CURRENT = 0,
CELL_STORAGEDATA_VERSION_DST_FILENAME = 1,
};
enum CellStorageDataParamSize
{
CELL_STORAGEDATA_HDD_PATH_MAX = 1055,
CELL_STORAGEDATA_MEDIA_PATH_MAX = 1024,
CELL_STORAGEDATA_FILENAME_MAX = 64,
CELL_STORAGEDATA_FILESIZE_MAX = 1024 * 1024 * 1024,
CELL_STORAGEDATA_TITLE_MAX = 256
};
inline const char* CELL_STORAGEDATA_IMPORT_FILENAME = "IMPORT.BIN";
inline const char* CELL_STORAGEDATA_EXPORT_FILENAME = "EXPORT.BIN";
struct CellStorageDataSetParam
{
be_t<u32> fileSizeMax;
vm::bptr<char> title;
vm::bptr<void> reserved;
};
using CellStorageDataFinishCallback = void(s32 result, vm::ptr<void> userdata);
| 1,002
|
C++
|
.h
| 31
| 30.645161
| 79
| 0.763731
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,882
|
cellVideoOut.h
|
RPCS3_rpcs3/rpcs3/Emu/Cell/Modules/cellVideoOut.h
|
#pragma once
#include "Emu/Memory/vm_ptr.h"
// Video Out Error Codes
enum CellVideoOutError : u32
{
CELL_VIDEO_OUT_ERROR_NOT_IMPLEMENTED = 0x8002b220,
CELL_VIDEO_OUT_ERROR_ILLEGAL_CONFIGURATION = 0x8002b221,
CELL_VIDEO_OUT_ERROR_ILLEGAL_PARAMETER = 0x8002b222,
CELL_VIDEO_OUT_ERROR_PARAMETER_OUT_OF_RANGE = 0x8002b223,
CELL_VIDEO_OUT_ERROR_DEVICE_NOT_FOUND = 0x8002b224,
CELL_VIDEO_OUT_ERROR_UNSUPPORTED_VIDEO_OUT = 0x8002b225,
CELL_VIDEO_OUT_ERROR_UNSUPPORTED_DISPLAY_MODE = 0x8002b226,
CELL_VIDEO_OUT_ERROR_CONDITION_BUSY = 0x8002b227,
CELL_VIDEO_OUT_ERROR_VALUE_IS_NOT_SET = 0x8002b228,
};
enum CellVideoOut : s32
{
CELL_VIDEO_OUT_PRIMARY = 0,
CELL_VIDEO_OUT_SECONDARY = 1,
};
enum CellVideoOutResolutionId : s32
{
CELL_VIDEO_OUT_RESOLUTION_UNDEFINED = 0,
CELL_VIDEO_OUT_RESOLUTION_1080 = 1,
CELL_VIDEO_OUT_RESOLUTION_720 = 2,
CELL_VIDEO_OUT_RESOLUTION_480 = 4,
CELL_VIDEO_OUT_RESOLUTION_576 = 5,
CELL_VIDEO_OUT_RESOLUTION_1600x1080 = 0xa,
CELL_VIDEO_OUT_RESOLUTION_1440x1080 = 0xb,
CELL_VIDEO_OUT_RESOLUTION_1280x1080 = 0xc,
CELL_VIDEO_OUT_RESOLUTION_960x1080 = 0xd,
CELL_VIDEO_OUT_RESOLUTION_720_3D_FRAME_PACKING = 0x81,
CELL_VIDEO_OUT_RESOLUTION_1024x720_3D_FRAME_PACKING = 0x88,
CELL_VIDEO_OUT_RESOLUTION_960x720_3D_FRAME_PACKING = 0x89,
CELL_VIDEO_OUT_RESOLUTION_800x720_3D_FRAME_PACKING = 0x8a,
CELL_VIDEO_OUT_RESOLUTION_640x720_3D_FRAME_PACKING = 0x8b,
CELL_VIDEO_OUT_RESOLUTION_720_DUALVIEW_FRAME_PACKING = 0x91,
CELL_VIDEO_OUT_RESOLUTION_720_SIMULVIEW_FRAME_PACKING = 0x91,
CELL_VIDEO_OUT_RESOLUTION_1024x720_DUALVIEW_FRAME_PACKING = 0x98,
CELL_VIDEO_OUT_RESOLUTION_1024x720_SIMULVIEW_FRAME_PACKING = 0x98,
CELL_VIDEO_OUT_RESOLUTION_960x720_DUALVIEW_FRAME_PACKING = 0x99,
CELL_VIDEO_OUT_RESOLUTION_960x720_SIMULVIEW_FRAME_PACKING = 0x99,
CELL_VIDEO_OUT_RESOLUTION_800x720_DUALVIEW_FRAME_PACKING = 0x9a,
CELL_VIDEO_OUT_RESOLUTION_800x720_SIMULVIEW_FRAME_PACKING = 0x9a,
CELL_VIDEO_OUT_RESOLUTION_640x720_DUALVIEW_FRAME_PACKING = 0x9b,
CELL_VIDEO_OUT_RESOLUTION_640x720_SIMULVIEW_FRAME_PACKING = 0x9b,
};
enum CellVideoOutScanMode : s32
{
CELL_VIDEO_OUT_SCAN_MODE_INTERLACE,
CELL_VIDEO_OUT_SCAN_MODE_PROGRESSIVE,
};
enum CellVideoOutScanMode2 : s32
{
CELL_VIDEO_OUT_SCAN_MODE2_AUTO,
CELL_VIDEO_OUT_SCAN_MODE2_INTERLACE,
CELL_VIDEO_OUT_SCAN_MODE2_PROGRESSIVE,
};
enum CellVideoOutRefreshRate : s32
{
CELL_VIDEO_OUT_REFRESH_RATE_AUTO = 0x0000,
CELL_VIDEO_OUT_REFRESH_RATE_59_94HZ = 0x0001,
CELL_VIDEO_OUT_REFRESH_RATE_50HZ = 0x0002,
CELL_VIDEO_OUT_REFRESH_RATE_60HZ = 0x0004,
CELL_VIDEO_OUT_REFRESH_RATE_30HZ = 0x0008,
};
enum CellVideoOutPortType : s32
{
CELL_VIDEO_OUT_PORT_NONE = 0x00,
CELL_VIDEO_OUT_PORT_HDMI = 0x01,
CELL_VIDEO_OUT_PORT_NETWORK = 0x41,
CELL_VIDEO_OUT_PORT_COMPOSITE_S = 0x81,
CELL_VIDEO_OUT_PORT_D = 0x82,
CELL_VIDEO_OUT_PORT_COMPONENT = 0x83,
CELL_VIDEO_OUT_PORT_RGB = 0x84,
CELL_VIDEO_OUT_PORT_AVMULTI_SCART = 0x85,
CELL_VIDEO_OUT_PORT_DSUB = 0x86,
};
enum CellVideoOutDisplayAspect : s32
{
CELL_VIDEO_OUT_ASPECT_AUTO,
CELL_VIDEO_OUT_ASPECT_4_3,
CELL_VIDEO_OUT_ASPECT_16_9,
};
enum CellVideoOutBufferColorFormat : s32
{
CELL_VIDEO_OUT_BUFFER_COLOR_FORMAT_X8R8G8B8 = 0,
CELL_VIDEO_OUT_BUFFER_COLOR_FORMAT_X8B8G8R8 = 1,
CELL_VIDEO_OUT_BUFFER_COLOR_FORMAT_R16G16B16X16_FLOAT = 2,
};
enum CellVideoOutOutputState : s32
{
CELL_VIDEO_OUT_OUTPUT_STATE_ENABLED,
CELL_VIDEO_OUT_OUTPUT_STATE_DISABLED,
CELL_VIDEO_OUT_OUTPUT_STATE_PREPARING,
};
enum CellVideoOutDeviceState : s32
{
CELL_VIDEO_OUT_DEVICE_STATE_UNAVAILABLE,
CELL_VIDEO_OUT_DEVICE_STATE_AVAILABLE,
};
enum CellVideoOutColorSpace : s32
{
CELL_VIDEO_OUT_COLOR_SPACE_RGB = 0x01,
CELL_VIDEO_OUT_COLOR_SPACE_YUV = 0x02,
CELL_VIDEO_OUT_COLOR_SPACE_XVYCC = 0x04,
};
enum CellVideoOutDebugMonitorType : s32
{
CELL_VIDEO_OUT_DEBUG_MONITOR_TYPE_UNDEFINED = 0,
CELL_VIDEO_OUT_DEBUG_MONITOR_TYPE_480I_59_94HZ = 1,
CELL_VIDEO_OUT_DEBUG_MONITOR_TYPE_576I_50HZ = 2,
CELL_VIDEO_OUT_DEBUG_MONITOR_TYPE_480P_59_94HZ = 3,
CELL_VIDEO_OUT_DEBUG_MONITOR_TYPE_576P_50HZ = 4,
CELL_VIDEO_OUT_DEBUG_MONITOR_TYPE_1080I_59_94HZ = 5,
CELL_VIDEO_OUT_DEBUG_MONITOR_TYPE_720P_59_94HZ = 7,
CELL_VIDEO_OUT_DEBUG_MONITOR_TYPE_1080P_59_94HZ = 9,
CELL_VIDEO_OUT_DEBUG_MONITOR_TYPE_WXGA_60HZ = 11,
CELL_VIDEO_OUT_DEBUG_MONITOR_TYPE_SXGA_60HZ = 12,
CELL_VIDEO_OUT_DEBUG_MONITOR_TYPE_WUXGA_60HZ = 13,
};
struct CellVideoOutColorInfo
{
be_t<u16> redX;
be_t<u16> redY;
be_t<u16> greenX;
be_t<u16> greenY;
be_t<u16> blueX;
be_t<u16> blueY;
be_t<u16> whiteX;
be_t<u16> whiteY;
be_t<u32> gamma;
};
struct CellVideoOutKSVList
{
u8 ksv[32*5];
u8 reserved[4];
be_t<u32> count;
};
enum CellVideoOutDisplayConversion : s32
{
CELL_VIDEO_OUT_DISPLAY_CONVERSION_NONE = 0x00,
CELL_VIDEO_OUT_DISPLAY_CONVERSION_TO_WXGA = 0x01,
CELL_VIDEO_OUT_DISPLAY_CONVERSION_TO_SXGA = 0x02,
CELL_VIDEO_OUT_DISPLAY_CONVERSION_TO_WUXGA = 0x03,
CELL_VIDEO_OUT_DISPLAY_CONVERSION_TO_1080 = 0x05,
CELL_VIDEO_OUT_DISPLAY_CONVERSION_TO_REMOTEPLAY = 0x10,
CELL_VIDEO_OUT_DISPLAY_CONVERSION_TO_720_3D_FRAME_PACKING = 0x80,
};
struct CellVideoOutDisplayMode
{
u8 resolutionId;
u8 scanMode;
u8 conversion;
u8 aspect;
u8 reserved[2];
be_t<u16> refreshRates;
};
struct CellVideoOutResolution
{
be_t<u16> width;
be_t<u16> height;
};
struct CellVideoOutDeviceInfo
{
u8 portType;
u8 colorSpace;
be_t<u16> latency;
u8 availableModeCount;
u8 state;
u8 rgbOutputRange;
u8 reserved[5];
CellVideoOutColorInfo colorInfo;
CellVideoOutDisplayMode availableModes[32];
CellVideoOutKSVList ksvList;
};
struct CellVideoOutState
{
u8 state;
u8 colorSpace;
u8 reserved[6];
CellVideoOutDisplayMode displayMode;
};
struct CellVideoOutConfiguration
{
u8 resolutionId;
u8 format;
u8 aspect;
u8 reserved[9];
be_t<u32> pitch;
};
struct CellVideoOutOption
{
be_t<u32> reserved;
};
enum CellVideoOutEvent : s32
{
CELL_VIDEO_OUT_EVENT_DEVICE_CHANGED = 0,
CELL_VIDEO_OUT_EVENT_OUTPUT_DISABLED = 1,
CELL_VIDEO_OUT_EVENT_DEVICE_AUTHENTICATED = 2,
CELL_VIDEO_OUT_EVENT_OUTPUT_ENABLED = 3,
};
enum CellVideoOutCopyControl : s32
{
CELL_VIDEO_OUT_COPY_CONTROL_COPY_FREE = 0,
CELL_VIDEO_OUT_COPY_CONTROL_COPY_ONCE = 1,
CELL_VIDEO_OUT_COPY_CONTROL_COPY_NEVER = 2,
};
enum CellVideoOutRGBOutputRange : s32
{
CELL_VIDEO_OUT_RGB_OUTPUT_RANGE_LIMITED = 0,
CELL_VIDEO_OUT_RGB_OUTPUT_RANGE_FULL = 1,
};
using CellVideoOutCallback = s32(u32 slot, u32 videoOut, u32 deviceIndex, u32 event, vm::ptr<CellVideoOutDeviceInfo> info, vm::ptr<void> userData);
| 7,041
|
C++
|
.h
| 214
| 31.14486
| 147
| 0.717794
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,883
|
cellScreenshot.h
|
RPCS3_rpcs3/rpcs3/Emu/Cell/Modules/cellScreenshot.h
|
#pragma once
#include "Emu/Memory/vm_ptr.h"
// Return Codes
enum CellScreenShotError : u32
{
CELL_SCREENSHOT_ERROR_INTERNAL = 0x8002d101,
CELL_SCREENSHOT_ERROR_PARAM = 0x8002d102,
CELL_SCREENSHOT_ERROR_DECODE = 0x8002d103,
CELL_SCREENSHOT_ERROR_NOSPACE = 0x8002d104,
CELL_SCREENSHOT_ERROR_UNSUPPORTED_COLOR_FORMAT = 0x8002d105,
};
enum CellScreenShotParamSize
{
CELL_SCREENSHOT_PHOTO_TITLE_MAX_LENGTH = 64,
CELL_SCREENSHOT_GAME_TITLE_MAX_LENGTH = 64,
CELL_SCREENSHOT_GAME_COMMENT_MAX_SIZE = 1024,
};
struct CellScreenShotSetParam
{
vm::bcptr<char> photo_title;
vm::bcptr<char> game_title;
vm::bcptr<char> game_comment;
vm::bptr<void> reserved;
};
struct screenshot_info
{
bool is_enabled{false};
std::string photo_title;
std::string game_title;
std::string game_comment;
s32 overlay_offset_x{0};
s32 overlay_offset_y{0};
std::string overlay_dir_name;
std::string overlay_file_name;
std::string get_overlay_path() const;
std::string get_photo_title() const;
std::string get_game_title() const;
std::string get_game_comment() const;
std::string get_screenshot_path(const std::string& date_path) const;
};
struct screenshot_manager : public screenshot_info
{
shared_mutex mutex;
};
| 1,286
|
C++
|
.h
| 44
| 27.431818
| 69
| 0.731549
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,884
|
cellUserInfo.h
|
RPCS3_rpcs3/rpcs3/Emu/Cell/Modules/cellUserInfo.h
|
#pragma once
#include "Emu/Memory/vm_ptr.h"
// Error Codes
enum CellUserInfoError : u32
{
CELL_USERINFO_ERROR_BUSY = 0x8002c301,
CELL_USERINFO_ERROR_INTERNAL = 0x8002c302,
CELL_USERINFO_ERROR_PARAM = 0x8002c303,
CELL_USERINFO_ERROR_NOUSER = 0x8002c304,
};
// Enums
enum CellUserInfoParamSize
{
CELL_USERINFO_USER_MAX = 16,
CELL_USERINFO_TITLE_SIZE = 256,
CELL_USERINFO_USERNAME_SIZE = 64,
};
enum CellUserInfoListType
{
CELL_USERINFO_LISTTYPE_ALL = 0,
CELL_USERINFO_LISTTYPE_NOCURRENT = 1,
};
enum cell_user_callback_result : u32
{
CELL_USERINFO_RET_OK = 0,
CELL_USERINFO_RET_CANCEL = 1,
};
enum : u32
{
CELL_SYSUTIL_USERID_CURRENT = 0,
CELL_SYSUTIL_USERID_MAX = 99999999,
};
enum : u32
{
CELL_USERINFO_FOCUS_LISTHEAD = 0xffffffff
};
// Structs
struct CellUserInfoUserStat
{
be_t<u32> id;
char name[CELL_USERINFO_USERNAME_SIZE];
};
struct CellUserInfoUserList
{
be_t<u32> userId[CELL_USERINFO_USER_MAX];
};
struct CellUserInfoListSet
{
vm::bptr<char> title;
be_t<u32> focus; // id
be_t<u32> fixedListNum;
vm::bptr<CellUserInfoUserList> fixedList;
vm::bptr<void> reserved;
};
struct CellUserInfoTypeSet
{
vm::bptr<char> title;
be_t<u32> focus; // id
be_t<u32> type; // CellUserInfoListType
vm::bptr<void> reserved;
};
using CellUserInfoFinishCallback = void(s32 result, vm::ptr<CellUserInfoUserStat> selectedUser, vm::ptr<void> userdata);
| 1,413
|
C++
|
.h
| 62
| 21.177419
| 120
| 0.746826
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,885
|
cellPngDec.h
|
RPCS3_rpcs3/rpcs3/Emu/Cell/Modules/cellPngDec.h
|
#pragma once
#include "Emu/Memory/vm_ptr.h"
#include "png.h"
enum : u32
{
PNGDEC_CODEC_VERSION = 0x00420000,
};
// Return Codes
enum CellPngDecError
{
CELL_PNGDEC_ERROR_HEADER = 0x80611201,
CELL_PNGDEC_ERROR_STREAM_FORMAT = 0x80611202,
CELL_PNGDEC_ERROR_ARG = 0x80611203,
CELL_PNGDEC_ERROR_SEQ = 0x80611204,
CELL_PNGDEC_ERROR_BUSY = 0x80611205,
CELL_PNGDEC_ERROR_FATAL = 0x80611206,
CELL_PNGDEC_ERROR_OPEN_FILE = 0x80611207,
CELL_PNGDEC_ERROR_SPU_UNSUPPORT = 0x80611208,
CELL_PNGDEC_ERROR_SPU_ERROR = 0x80611209,
CELL_PNGDEC_ERROR_CB_PARAM = 0x8061120a,
};
// Consts
enum CellPngDecColorSpace : s32
{
CELL_PNGDEC_GRAYSCALE = 1,
CELL_PNGDEC_RGB = 2,
CELL_PNGDEC_PALETTE = 4,
CELL_PNGDEC_GRAYSCALE_ALPHA = 9,
CELL_PNGDEC_RGBA = 10,
CELL_PNGDEC_ARGB = 20,
};
enum CellPngDecSpuThreadEna : s32
{
CELL_PNGDEC_SPU_THREAD_DISABLE = 0,
CELL_PNGDEC_SPU_THREAD_ENABLE = 1,
};
enum CellPngDecStreamSrcSel : s32
{
CELL_PNGDEC_FILE = 0,
CELL_PNGDEC_BUFFER = 1,
};
enum CellPngDecInterlaceMode : s32
{
CELL_PNGDEC_NO_INTERLACE = 0,
CELL_PNGDEC_ADAM7_INTERLACE = 1,
};
enum CellPngDecOutputMode : s32
{
CELL_PNGDEC_TOP_TO_BOTTOM = 0,
CELL_PNGDEC_BOTTOM_TO_TOP = 1,
};
enum CellPngDecPackFlag : s32
{
CELL_PNGDEC_1BYTE_PER_NPIXEL = 0,
CELL_PNGDEC_1BYTE_PER_1PIXEL = 1,
};
enum CellPngDecAlphaSelect : s32
{
CELL_PNGDEC_STREAM_ALPHA = 0,
CELL_PNGDEC_FIX_ALPHA = 1,
};
enum CellPngDecCommand : s32
{
CELL_PNGDEC_CONTINUE = 0,
CELL_PNGDEC_STOP = 1,
};
enum CellPngDecDecodeStatus : s32
{
CELL_PNGDEC_DEC_STATUS_FINISH = 0,
CELL_PNGDEC_DEC_STATUS_STOP = 1,
};
enum CellPngDecBufferMode : s32
{
CELL_PNGDEC_LINE_MODE = 1,
};
enum CellPngDecSpuMode : s32
{
CELL_PNGDEC_RECEIVE_EVENT = 0,
CELL_PNGDEC_TRYRECEIVE_EVENT = 1,
};
// Callbacks for memory management
using CellPngDecCbControlMalloc = vm::ptr<void>(u32 size, vm::ptr<void> cbCtrlMallocArg);
using CellPngDecCbControlFree = s32(vm::ptr<void> ptr, vm::ptr<void> cbCtrlFreeArg);
// Structs
struct CellPngDecThreadInParam
{
be_t<s32> spuThreadEnable; // CellPngDecSpuThreadEna
be_t<u32> ppuThreadPriority;
be_t<u32> spuThreadPriority;
vm::bptr<CellPngDecCbControlMalloc> cbCtrlMallocFunc;
vm::bptr<void> cbCtrlMallocArg;
vm::bptr<CellPngDecCbControlFree> cbCtrlFreeFunc;
vm::bptr<void> cbCtrlFreeArg;
};
struct CellPngDecExtThreadInParam
{
vm::bptr<struct CellSpurs> spurs;
u8 priority[8];
be_t<u32> maxContention;
};
struct CellPngDecThreadOutParam
{
be_t<u32> pngCodecVersion;
};
struct CellPngDecExtThreadOutParam
{
be_t<u32> reserved;
};
struct CellPngDecSrc
{
be_t<s32> srcSelect; // CellPngDecStreamSrcSel
vm::bcptr<char> fileName;
be_t<s64> fileOffset;
be_t<u32> fileSize;
vm::bptr<void> streamPtr;
be_t<u32> streamSize;
be_t<s32> spuThreadEnable; // CellGifDecSpuThreadEna
};
struct CellPngDecOpnInfo
{
be_t<u32> initSpaceAllocated;
};
struct CellPngDecInfo
{
be_t<u32> imageWidth;
be_t<u32> imageHeight;
be_t<u32> numComponents;
be_t<s32> colorSpace; // CellPngDecColorSpace
be_t<u32> bitDepth;
be_t<s32> interlaceMethod; // CellPngDecInterlaceMode
be_t<u32> chunkInformation;
};
struct CellPngDecInParam
{
vm::bptr<volatile s32> commandPtr; // CellPngDecCommand
be_t<s32> outputMode; // CellPngDecOutputMode
be_t<s32> outputColorSpace; // CellPngDecColorSpace
be_t<u32> outputBitDepth;
be_t<s32> outputPackFlag; // CellPngDecPackFlag
be_t<s32> outputAlphaSelect; // CellPngDecAlphaSelect
be_t<u32> outputColorAlpha;
};
struct CellPngDecOutParam
{
be_t<u64> outputWidthByte;
be_t<u32> outputWidth;
be_t<u32> outputHeight;
be_t<u32> outputComponents;
be_t<u32> outputBitDepth;
be_t<s32> outputMode; // CellPngDecOutputMode
be_t<s32> outputColorSpace; // CellPngDecOutputMode
be_t<u32> useMemorySpace;
};
struct CellPngDecDataCtrlParam
{
be_t<u64> outputBytesPerLine;
};
struct CellPngDecDataOutInfo
{
be_t<u32> chunkInformation;
be_t<u32> numText;
be_t<u32> numUnknownChunk;
be_t<s32> status; // CellPngDecDecodeStatus
};
// Structs for decoding partial streams
struct CellPngDecStrmInfo
{
be_t<u32> decodedStrmSize;
};
struct CellPngDecStrmParam
{
vm::bptr<void> strmPtr;
be_t<u32> strmSize;
};
struct CellPngDecDispInfo
{
be_t<u64> outputFrameWidthByte;
be_t<u32> outputFrameHeight;
be_t<u64> outputStartXByte;
be_t<u32> outputStartY;
be_t<u64> outputWidthByte;
be_t<u32> outputHeight;
be_t<u32> outputBitDepth;
be_t<u32> outputComponents;
be_t<u32> nextOutputStartY;
be_t<u32> scanPassCount;
vm::bptr<void> outputImage;
};
struct CellPngDecDispParam
{
vm::bptr<void> nextOutputImage;
};
struct CellPngDecOpnParam
{
be_t<u32> selectChunk;
};
struct CellPngDecExtInfo
{
be_t<u64> reserved;
};
struct CellPngDecExtInParam
{
be_t<s32> bufferMode; // CellPngDecBufferMode
be_t<u32> outputCounts;
be_t<s32> spuMode; // CellPngDecSpuMode
};
struct CellPngDecExtOutParam
{
be_t<u64> outputWidthByte;
be_t<u32> outputHeight;
};
// Callbacks for decoding partial streams
using CellPngDecCbControlStream = s32(vm::ptr<CellPngDecStrmInfo> strmInfo, vm::ptr<CellPngDecStrmParam> strmParam, vm::ptr<void> cbCtrlStrmArg);
using CellPngDecCbControlDisp = s32(vm::ptr<CellPngDecDispInfo> dispInfo, vm::ptr<CellPngDecDispParam> dispParam, vm::ptr<void> cbCtrlDispArg);
struct CellPngDecCbCtrlStrm
{
vm::bptr<CellPngDecCbControlStream> cbCtrlStrmFunc;
vm::bptr<void> cbCtrlStrmArg;
};
struct CellPngDecCbCtrlDisp
{
vm::bptr<CellPngDecCbControlDisp> cbCtrlDispFunc;
vm::bptr<void> cbCtrlDispArg;
};
// Custom structs
struct PngHandle
{
vm::ptr<CellPngDecCbControlMalloc> malloc_;
vm::ptr<void> malloc_arg;
vm::ptr<CellPngDecCbControlFree> free_;
vm::ptr<void> free_arg;
};
// For reading from a buffer using libpng
struct PngBuffer
{
// The cursor location and data pointer for reading from a buffer
usz cursor;
usz length;
vm::bptr<void> data;
// The file descriptor, and whether we need to read from a file descriptor
bool file;
u32 fd;
};
struct PngStream
{
// PNG decoding structures
CellPngDecInfo info;
CellPngDecOutParam out_param;
CellPngDecSrc source;
// Partial decoding
CellPngDecCbCtrlStrm cbCtrlStream;
CellPngDecCbCtrlDisp cbCtrlDisp;
vm::ptr<CellPngDecDispInfo> cbDispInfo;
vm::ptr<CellPngDecDispParam> cbDispParam;
ppu_thread* ppuContext;
u32 outputCounts = 0;
u32 nextRow = 0;
bool endOfFile = false;
// Pixel packing value
be_t<s32> packing;
u32 passes;
// PNG custom read function structure, for decoding from a buffer
vm::ptr<PngBuffer> buffer;
// libpng structures for reading and decoding the PNG file
png_structp png_ptr;
png_infop info_ptr;
};
// Converts libpng colour type to cellPngDec colour type
static s32 getPngDecColourType(u8 type)
{
switch (type)
{
case PNG_COLOR_TYPE_RGB: return CELL_PNGDEC_RGB;
case PNG_COLOR_TYPE_RGBA: return CELL_PNGDEC_RGBA; // We can't diffrentiate between ARGB and RGBA. Doesn't seem to be exactly important.
case PNG_COLOR_TYPE_PALETTE: return CELL_PNGDEC_PALETTE;
case PNG_COLOR_TYPE_GRAY: return CELL_PNGDEC_GRAYSCALE;
case PNG_COLOR_TYPE_GRAY_ALPHA: return CELL_PNGDEC_GRAYSCALE_ALPHA;
default: fmt::throw_exception("Unknown colour type: %d", type);
}
}
static bool cellPngColorSpaceHasAlpha(u32 colorspace)
{
switch (colorspace)
{
case CELL_PNGDEC_RGBA:
case CELL_PNGDEC_ARGB:
case CELL_PNGDEC_GRAYSCALE_ALPHA:
return true;
default:
return false;
}
}
// Custom exception for libPng errors
class LibPngCustomException : public std::runtime_error
{
public:
LibPngCustomException(char const* const message) : runtime_error(message) {}
};
| 7,683
|
C++
|
.h
| 298
| 24.067114
| 145
| 0.770657
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,886
|
cellRudp.h
|
RPCS3_rpcs3/rpcs3/Emu/Cell/Modules/cellRudp.h
|
#pragma once
#include "Emu/Memory/vm_ptr.h"
// Return Codes
constexpr auto CELL_RUDP_SUCCESS = CELL_OK;
enum CellRudpError : u32
{
CELL_RUDP_ERROR_NOT_INITIALIZED = 0x80770001,
CELL_RUDP_ERROR_ALREADY_INITIALIZED = 0x80770002,
CELL_RUDP_ERROR_INVALID_CONTEXT_ID = 0x80770003,
CELL_RUDP_ERROR_INVALID_ARGUMENT = 0x80770004,
CELL_RUDP_ERROR_INVALID_OPTION = 0x80770005,
CELL_RUDP_ERROR_INVALID_MUXMODE = 0x80770006,
CELL_RUDP_ERROR_MEMORY = 0x80770007,
CELL_RUDP_ERROR_INTERNAL = 0x80770008,
CELL_RUDP_ERROR_CONN_RESET = 0x80770009,
CELL_RUDP_ERROR_CONN_REFUSED = 0x8077000a,
CELL_RUDP_ERROR_CONN_TIMEOUT = 0x8077000b,
CELL_RUDP_ERROR_CONN_VERSION_MISMATCH = 0x8077000c,
CELL_RUDP_ERROR_CONN_TRANSPORT_TYPE_MISMATCH = 0x8077000d,
CELL_RUDP_ERROR_QUALITY_LEVEL_MISMATCH = 0x8077000e,
CELL_RUDP_ERROR_THREAD = 0x8077000f,
CELL_RUDP_ERROR_THREAD_IN_USE = 0x80770010,
CELL_RUDP_ERROR_NOT_ACCEPTABLE = 0x80770011,
CELL_RUDP_ERROR_MSG_TOO_LARGE = 0x80770012,
CELL_RUDP_ERROR_NOT_BOUND = 0x80770013,
CELL_RUDP_ERROR_CANCELLED = 0x80770014,
CELL_RUDP_ERROR_INVALID_VPORT = 0x80770015,
CELL_RUDP_ERROR_WOULDBLOCK = 0x80770016,
CELL_RUDP_ERROR_VPORT_IN_USE = 0x80770017,
CELL_RUDP_ERROR_VPORT_EXHAUSTED = 0x80770018,
CELL_RUDP_ERROR_INVALID_SOCKET = 0x80770019,
CELL_RUDP_ERROR_BUFFER_TOO_SMALL = 0x8077001a,
CELL_RUDP_ERROR_MSG_MALFORMED = 0x8077001b,
CELL_RUDP_ERROR_ADDR_IN_USE = 0x8077001c,
CELL_RUDP_ERROR_ALREADY_BOUND = 0x8077001d,
CELL_RUDP_ERROR_ALREADY_EXISTS = 0x8077001e,
CELL_RUDP_ERROR_INVALID_POLL_ID = 0x8077001f,
CELL_RUDP_ERROR_TOO_MANY_CONTEXTS = 0x80770020,
CELL_RUDP_ERROR_IN_PROGRESS = 0x80770021,
CELL_RUDP_ERROR_NO_EVENT_HANDLER = 0x80770022,
CELL_RUDP_ERROR_PAYLOAD_TOO_LARGE = 0x80770023,
CELL_RUDP_ERROR_END_OF_DATA = 0x80770024,
CELL_RUDP_ERROR_ALREADY_ESTABLISHED = 0x80770025,
CELL_RUDP_ERROR_KEEP_ALIVE_FAILURE = 0x80770026,
};
// Context options
enum
{
CELL_RUDP_OPTION_MAX_PAYLOAD = 1,
CELL_RUDP_OPTION_SNDBUF = 2,
CELL_RUDP_OPTION_RCVBUF = 3,
CELL_RUDP_OPTION_NODELAY = 4,
CELL_RUDP_OPTION_DELIVERY_CRITICAL = 5,
CELL_RUDP_OPTION_ORDER_CRITICAL = 6,
CELL_RUDP_OPTION_NONBLOCK = 7,
CELL_RUDP_OPTION_STREAM = 8,
CELL_RUDP_OPTION_CONNECTION_TIMEOUT = 9,
CELL_RUDP_OPTION_CLOSE_WAIT_TIMEOUT = 10,
CELL_RUDP_OPTION_AGGREGATION_TIMEOUT = 11,
CELL_RUDP_OPTION_LAST_ERROR = 14,
CELL_RUDP_OPTION_READ_TIMEOUT = 15,
CELL_RUDP_OPTION_WRITE_TIMEOUT = 16,
CELL_RUDP_OPTION_FLUSH_TIMEOUT = 17,
CELL_RUDP_OPTION_KEEP_ALIVE_INTERVAL = 18,
CELL_RUDP_OPTION_KEEP_ALIVE_TIMEOUT = 19,
};
// Polling event flags
enum
{
CELL_RUDP_POLL_EV_READ = 0x0001,
CELL_RUDP_POLL_EV_WRITE = 0x0002,
CELL_RUDP_POLL_EV_FLUSH = 0x0004,
CELL_RUDP_POLL_EV_ERROR = 0x0008,
};
struct sys_net_sockaddr;
using CellRudpEventHandler = s32(s32 event_id, s32 soc, vm::cptr<u8> data, u32 datalen, vm::cptr<sys_net_sockaddr> addr, u32 addrlen, vm::ptr<void> arg);
using CellRudpAllocatorFuncAlloc = vm::ptr<void>(u32 size);
using CellRudpAllocatorFuncFree = void(vm::ptr<void> ptr);
struct CellRudpAllocator
{
vm::bptr<CellRudpAllocatorFuncAlloc> app_malloc;
vm::bptr<CellRudpAllocatorFuncFree> app_free;
};
| 3,789
|
C++
|
.h
| 83
| 43.807229
| 153
| 0.645118
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,887
|
cellFs.h
|
RPCS3_rpcs3/rpcs3/Emu/Cell/Modules/cellFs.h
|
#pragma once
#include "Emu/Memory/vm_ptr.h"
// CellFsRingBuffer.copy
enum : s32
{
CELL_FS_ST_COPY = 0,
CELL_FS_ST_COPYLESS = 1,
};
struct CellFsRingBuffer
{
be_t<u64> ringbuf_size;
be_t<u64> block_size;
be_t<u64> transfer_rate;
be_t<s32> copy;
};
// cellFsStReadGetStatus status
enum : u64
{
CELL_FS_ST_INITIALIZED = 0x0001,
CELL_FS_ST_NOT_INITIALIZED = 0x0002,
CELL_FS_ST_STOP = 0x0100,
CELL_FS_ST_PROGRESS = 0x0200,
};
enum : s32
{
CELL_FS_AIO_MAX_FS = 10, // cellFsAioInit limit
CELL_FS_AIO_MAX_REQUEST = 32, // cellFsAioRead request limit per mount point
};
struct CellFsAio
{
be_t<u32> fd;
be_t<u64> offset;
vm::bptrb<void> buf;
be_t<u64> size;
be_t<u64> user_data;
};
| 728
|
C++
|
.h
| 36
| 18.583333
| 77
| 0.686589
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,888
|
cellImeJp.h
|
RPCS3_rpcs3/rpcs3/Emu/Cell/Modules/cellImeJp.h
|
#pragma once
#include "Emu/Memory/vm_ptr.h"
typedef vm::ptr<void> CellImeJpHandle;
// Return Codes
enum CellImeJpError : u32
{
CELL_IMEJP_ERROR_ERR = 0x8002bf01,
CELL_IMEJP_ERROR_CONTEXT = 0x8002bf11,
CELL_IMEJP_ERROR_ALREADY_OPEN = 0x8002bf21,
CELL_IMEJP_ERROR_DIC_OPEN = 0x8002bf31,
CELL_IMEJP_ERROR_PARAM = 0x8002bf41,
CELL_IMEJP_ERROR_IME_ALREADY_IN_USE = 0x8002bf51,
CELL_IMEJP_ERROR_OTHER = 0x8002bfff,
};
// Input state of the ImeJp
enum
{
CELL_IMEJP_BEFORE_INPUT = 0,
CELL_IMEJP_BEFORE_CONVERT = 1,
CELL_IMEJP_CONVERTING = 2,
CELL_IMEJP_CANDIDATE_EMPTY = 3,
CELL_IMEJP_POSTCONVERT_KANA = 4,
CELL_IMEJP_POSTCONVERT_HALF = 5,
CELL_IMEJP_POSTCONVERT_RAW = 6,
CELL_IMEJP_CANDIDATES = 7,
CELL_IMEJP_MOVE_CLAUSE_GAP = 8,
};
// cellImeJpEnterChar, returning values pointed in pOutputStatus.
enum
{
CELL_IMEJP_RET_NONE = 0,
CELL_IMEJP_RET_THROUGH = 1,
CELL_IMEJP_RET_CONFIRMED = 2,
};
enum
{
CELL_IMEJP_ROMAN_INPUT = 0,
CELL_IMEJP_KANA_INPUT = 1,
};
enum
{
CELL_IMEJP_DSPCHAR_HIRA = 1,
CELL_IMEJP_DSPCHAR_FKANA = 2,
CELL_IMEJP_DSPCHAR_RAW = 3,
CELL_IMEJP_DSPCHAR_HKANA = 4,
CELL_IMEJP_DSPCHAR_HRAW = 5,
};
enum
{
CELL_IMEJP_FIXINMODE_OFF = 0,
CELL_IMEJP_FIXINMODE_HIRA = 1,
CELL_IMEJP_FIXINMODE_FKAN = 2,
CELL_IMEJP_FIXINMODE_RAW = 3,
CELL_IMEJP_FIXINMODE_HKAN = 4,
CELL_IMEJP_FIXINMODE_HRAW = 5,
};
enum
{
CELL_IMEJP_EXTENSIONCH_NONE = 0x0000,
CELL_IMEJP_EXTENSIONCH_HANKANA = 0x0001,
CELL_IMEJP_EXTENSIONCH_UD09TO15 = 0x0004,
CELL_IMEJP_EXTENSIONCH_UD85TO94 = 0x0008,
CELL_IMEJP_EXTENSIONCH_OUTJIS = 0x0010,
};
enum
{
CELL_IMEJP_POSTCONV_HIRA = 1,
CELL_IMEJP_POSTCONV_KANA = 2,
CELL_IMEJP_POSTCONV_HALF = 3,
CELL_IMEJP_POSTCONV_RAW = 4,
};
enum
{
CELL_IMEJP_FOCUS_NEXT = 0,
CELL_IMEJP_FOCUS_BEFORE = 1,
CELL_IMEJP_FOCUS_TOP = 2,
CELL_IMEJP_FOCUS_END = 3,
};
enum
{
CELL_IMEJP_DIC_PATH_MAXLENGTH = 256,
// Helper
CELL_IMEJP_STRING_MAXLENGTH = 128, // including terminator
};
struct CellImeJpAddDic
{
char path[CELL_IMEJP_DIC_PATH_MAXLENGTH];
};
struct CellImeJpPredictItem
{
u16 KanaYomi[31];
u16 Hyoki[61];
};
struct ime_jp_manager
{
shared_mutex mutex;
atomic_t<bool> is_initialized{ false };
u32 input_state = CELL_IMEJP_BEFORE_INPUT;
std::vector<std::string> dictionary_paths;
std::u16string confirmed_string; // Confirmed part of the string (first part of the entire string)
std::u16string converted_string; // Converted part of the unconfirmed input string
std::u16string input_string; // Unconfirmed part of the string (second part of the entire string)
usz cursor = 0; // The cursor. Can move across the entire input string.
usz focus_begin = 0; // Begin of the focus string
usz focus_length = 0; // Length of the focus string
s16 fix_input_mode = CELL_IMEJP_FIXINMODE_OFF;
s16 input_char_type = CELL_IMEJP_DSPCHAR_HIRA;
s16 kana_input_mode = CELL_IMEJP_ROMAN_INPUT;
s16 allowed_extensions = CELL_IMEJP_EXTENSIONCH_UD09TO15 | CELL_IMEJP_EXTENSIONCH_UD85TO94 | CELL_IMEJP_EXTENSIONCH_OUTJIS;
ime_jp_manager();
bool addChar(u16 c);
bool addString(vm::cptr<u16> str);
bool backspaceWord();
bool deleteWord();
bool remove_character(bool forward);
void clear_input();
void move_cursor(s8 amount); // s8 because CELL_IMEJP_STRING_MAXLENGTH is 128
void move_focus(s8 amount); // s8 because CELL_IMEJP_STRING_MAXLENGTH is 128
void move_focus_end(s8 amount, bool wrap_around); // s8 because CELL_IMEJP_STRING_MAXLENGTH is 128
struct candidate
{
std::u16string text; // Actual text of the candidate
u16 offset = 0; // The offset of the next character after the candidate replaced part of the current focus.
};
std::vector<candidate> get_candidate_list() const;
std::u16string get_focus_string() const;
};
| 3,887
|
C++
|
.h
| 127
| 28.779528
| 124
| 0.720246
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,889
|
cellSysutil.h
|
RPCS3_rpcs3/rpcs3/Emu/Cell/Modules/cellSysutil.h
|
#pragma once
#include "Emu/Memory/vm_ptr.h"
using CellSysutilUserId = u32;
enum
{
CELL_SYSUTIL_ERROR_BASE_INTERNAL = 0x8002b000,
CELL_SYSUTIL_ERROR_BASE_COMMON = 0x8002b100,
CELL_SYSUTIL_ERROR_BASE_SYSTEMPARAM = 0x8002b200,
CELL_SYSUTIL_ERROR_BASE_MSGDIALOG = 0x8002b300,
CELL_SYSUTIL_ERROR_BASE_SAVEDATA = 0x8002b400,
CELL_SYSUTIL_ERROR_BASE_OSKDIALOG = 0x8002b500,
CELL_SYSUTIL_ERROR_BASE_GAMEDATA = 0x8002b600,
CELL_SYSUTIL_ERROR_BASE_AVC = 0x8002b700,
CELL_SYSUTIL_ERROR_BASE_NETCTL = 0x8002b800,
CELL_SYSUTIL_ERROR_BASE_WEBBROWSER = 0x8002b900,
CELL_SYSUTIL_ERROR_BASE_HDDGAME = 0x8002ba00,
CELL_SYSUTIL_ERROR_BASE_SYSCONF = 0x8002bb00,
CELL_SYSUTIL_ERROR_BASE_SYSCACHE = 0x8002bc00,
CELL_SYSUTIL_ERROR_BASE_DISCGAME = 0x8002bd00,
CELL_SYSUTIL_ERROR_BASE_STORAGEDATA = 0x8002be00,
CELL_SYSUTIL_ERROR_BASE_IMEJP = 0x8002bf00,
CELL_SYSUTIL_ERROR_BASE_FILE_SELECT = 0x8002c000,
CELL_SYSUTIL_ERROR_BASE_MUSIC = 0x8002c100,
CELL_SYSUTIL_ERROR_BASE_PHOTO_EXPORT_UTIL = 0x8002c200,
CELL_SYSUTIL_ERROR_BASE_USERINFO = 0x8002c300,
CELL_SYSUTIL_ERROR_BASE_PRINT = 0x8002c400,
CELL_SYSUTIL_ERROR_BASE_REC = 0x8002c500,
CELL_SYSUTIL_ERROR_BASE_MUSIC_EXPORT_UTIL = 0x8002c600,
CELL_SYSUTIL_ERROR_BASE_PHOTO_IMPORT = 0x8002c700,
CELL_SYSUTIL_ERROR_BASE_SEARCH = 0x8002c800,
CELL_SYSUTIL_ERROR_BASE_PHOTO_DECODE = 0x8002c900,
CELL_SYSUTIL_ERROR_BASE_VIDEO_EXPORT_UTIL = 0x8002ca00,
CELL_SYSUTIL_ERROR_BASE_GAME = 0x8002cb00,
CELL_SYSUTIL_ERROR_BASE_GAMEUPDATE = 0x8002cc00,
CELL_SYSUTIL_ERROR_BASE_AP = 0x8002cd00,
CELL_SYSUTIL_ERROR_BASE_COMBOPLAY = 0x8002cd80,
CELL_SYSUTIL_ERROR_BASE_BGDL = 0x8002ce00,
CELL_SYSUTIL_ERROR_BASE_VIDEO_UPLOAD_UTIL = 0x8002d000,
CELL_SYSUTIL_ERROR_BASE_SCREENSHOT = 0x8002d100,
CELL_SYSUTIL_ERROR_BASE_AUTHDIALOG = 0x8002d200,
CELL_SYSUTIL_ERROR_BASE_BGMPLAYBACK_EX = 0x8002d300,
CELL_SYSUTIL_ERROR_BASE_SYSTEM_CHAT = 0x8002d400,
CELL_SYSUTIL_ERROR_BASE_PHOTO_NETWORK_SHARING = 0x8002d500,
};
enum CellSysutilError : u32
{
CELL_SYSUTIL_ERROR_TYPE = 0x8002b101,
CELL_SYSUTIL_ERROR_VALUE = 0x8002b102,
CELL_SYSUTIL_ERROR_SIZE = 0x8002b103,
CELL_SYSUTIL_ERROR_NUM = 0x8002b104,
CELL_SYSUTIL_ERROR_BUSY = 0x8002b105,
CELL_SYSUTIL_ERROR_STATUS = 0x8002b106,
CELL_SYSUTIL_ERROR_MEMORY = 0x8002b107,
CELL_SYSUTIL_ERROR_3D_SUPPORT = 0x8002b108,
};
// Parameter IDs
enum CellSysutilParamId: s32
{
// Integers
CELL_SYSUTIL_SYSTEMPARAM_ID_LANG = 0x0111,
CELL_SYSUTIL_SYSTEMPARAM_ID_ENTER_BUTTON_ASSIGN = 0x0112,
CELL_SYSUTIL_SYSTEMPARAM_ID_DATE_FORMAT = 0x0114,
CELL_SYSUTIL_SYSTEMPARAM_ID_TIME_FORMAT = 0x0115,
CELL_SYSUTIL_SYSTEMPARAM_ID_TIMEZONE = 0x0116,
CELL_SYSUTIL_SYSTEMPARAM_ID_SUMMERTIME = 0x0117,
CELL_SYSUTIL_SYSTEMPARAM_ID_GAME_PARENTAL_LEVEL = 0x0121,
CELL_SYSUTIL_SYSTEMPARAM_ID_LICENSE_AREA = 0x0122,
CELL_SYSUTIL_SYSTEMPARAM_ID_GAME_PARENTAL_LEVEL0_RESTRICT = 0x0123,
CELL_SYSUTIL_SYSTEMPARAM_ID_CURRENT_USER_HAS_NP_ACCOUNT = 0x0141,
CELL_SYSUTIL_SYSTEMPARAM_ID_CAMERA_PLFREQ = 0x0151,
CELL_SYSUTIL_SYSTEMPARAM_ID_PAD_RUMBLE = 0x0152,
CELL_SYSUTIL_SYSTEMPARAM_ID_KEYBOARD_TYPE = 0x0153,
CELL_SYSUTIL_SYSTEMPARAM_ID_JAPANESE_KEYBOARD_ENTRY_METHOD = 0x0154,
CELL_SYSUTIL_SYSTEMPARAM_ID_CHINESE_KEYBOARD_ENTRY_METHOD = 0x0155,
CELL_SYSUTIL_SYSTEMPARAM_ID_PAD_AUTOOFF = 0x0156,
CELL_SYSUTIL_SYSTEMPARAM_ID_MAGNETOMETER = 0x0157,
// Strings
CELL_SYSUTIL_SYSTEMPARAM_ID_NICKNAME = 0x0113,
CELL_SYSUTIL_SYSTEMPARAM_ID_CURRENT_USERNAME = 0x0131,
// Unknown strings
CELL_SYSUTIL_SYSTEMPARAM_ID_x1008 = 0x1008,
CELL_SYSUTIL_SYSTEMPARAM_ID_x1011 = 0x1011,
CELL_SYSUTIL_SYSTEMPARAM_ID_x1012 = 0x1012, // Equal meaning to x1011
CELL_SYSUTIL_SYSTEMPARAM_ID_x1024 = 0x1024,
};
enum CellSysutilLang : s32
{
CELL_SYSUTIL_LANG_JAPANESE = 0,
CELL_SYSUTIL_LANG_ENGLISH_US = 1,
CELL_SYSUTIL_LANG_FRENCH = 2,
CELL_SYSUTIL_LANG_SPANISH = 3,
CELL_SYSUTIL_LANG_GERMAN = 4,
CELL_SYSUTIL_LANG_ITALIAN = 5,
CELL_SYSUTIL_LANG_DUTCH = 6,
CELL_SYSUTIL_LANG_PORTUGUESE_PT = 7,
CELL_SYSUTIL_LANG_RUSSIAN = 8,
CELL_SYSUTIL_LANG_KOREAN = 9,
CELL_SYSUTIL_LANG_CHINESE_T = 10,
CELL_SYSUTIL_LANG_CHINESE_S = 11,
CELL_SYSUTIL_LANG_FINNISH = 12,
CELL_SYSUTIL_LANG_SWEDISH = 13,
CELL_SYSUTIL_LANG_DANISH = 14,
CELL_SYSUTIL_LANG_NORWEGIAN = 15,
CELL_SYSUTIL_LANG_POLISH = 16,
CELL_SYSUTIL_LANG_PORTUGUESE_BR = 17, // FW 4.00
CELL_SYSUTIL_LANG_ENGLISH_GB = 18, // FW 4.00
CELL_SYSUTIL_LANG_TURKISH = 19, // FW 4.30
};
enum
{
CELL_SYSUTIL_SYSTEMPARAM_NICKNAME_SIZE = 0x80,
CELL_SYSUTIL_SYSTEMPARAM_CURRENT_USERNAME_SIZE = 0x40
};
enum
{
CELL_SYSUTIL_KEYBOARD_ENTRY_METHOD_ROMAJI_INPUT = 0,
CELL_SYSUTIL_KEYBOARD_ENTRY_METHOD_KANA_INPUT = 1,
};
enum
{
CELL_SYSUTIL_KEYBOARD_ENTRY_METHOD_ZHUYIN_INPUT = 0,
CELL_SYSUTIL_KEYBOARD_ENTRY_METHOD_PINYIN_INPUT = 1,
CELL_SYSUTIL_KEYBOARD_ENTRY_METHOD_CANGJIE_INPUT = 2,
};
enum
{
CELL_SYSUTIL_REQUEST_EXITGAME = 0x0101,
CELL_SYSUTIL_DRAWING_BEGIN = 0x0121,
CELL_SYSUTIL_DRAWING_END = 0x0122,
CELL_SYSUTIL_SYSTEM_MENU_OPEN = 0x0131,
CELL_SYSUTIL_SYSTEM_MENU_CLOSE = 0x0132,
CELL_SYSUTIL_BGMPLAYBACK_PLAY = 0x0141,
CELL_SYSUTIL_BGMPLAYBACK_STOP = 0x0142,
CELL_SYSUTIL_NP_INVITATION_SELECTED = 0x0151,
CELL_SYSUTIL_NP_DATA_MESSAGE_SELECTED = 0x0152,
CELL_SYSUTIL_SYSCHAT_START = 0x0161,
CELL_SYSUTIL_SYSCHAT_STOP = 0x0162,
CELL_SYSUTIL_SYSCHAT_VOICE_STREAMING_RESUMED = 0x0163,
CELL_SYSUTIL_SYSCHAT_VOICE_STREAMING_PAUSED = 0x0164,
};
using CellSysutilCallback = void(u64 status, u64 param, vm::ptr<void> userdata);
enum
{
CELL_SYSUTIL_ENTER_BUTTON_ASSIGN_CIRCLE = 0,
CELL_SYSUTIL_ENTER_BUTTON_ASSIGN_CROSS = 1,
};
enum
{
CELL_SYSUTIL_DATE_FMT_YYYYMMDD = 0,
CELL_SYSUTIL_DATE_FMT_DDMMYYYY = 1,
CELL_SYSUTIL_DATE_FMT_MMDDYYYY = 2,
};
enum
{
CELL_SYSUTIL_TIME_FMT_CLOCK12 = 0,
CELL_SYSUTIL_TIME_FMT_CLOCK24 = 1,
};
enum
{
CELL_SYSUTIL_GAME_PARENTAL_OFF = 0,
CELL_SYSUTIL_GAME_PARENTAL_LEVEL01 = 1,
CELL_SYSUTIL_GAME_PARENTAL_LEVEL02 = 2,
CELL_SYSUTIL_GAME_PARENTAL_LEVEL03 = 3,
CELL_SYSUTIL_GAME_PARENTAL_LEVEL04 = 4,
CELL_SYSUTIL_GAME_PARENTAL_LEVEL05 = 5,
CELL_SYSUTIL_GAME_PARENTAL_LEVEL06 = 6,
CELL_SYSUTIL_GAME_PARENTAL_LEVEL07 = 7,
CELL_SYSUTIL_GAME_PARENTAL_LEVEL08 = 8,
CELL_SYSUTIL_GAME_PARENTAL_LEVEL09 = 9,
CELL_SYSUTIL_GAME_PARENTAL_LEVEL10 = 10,
CELL_SYSUTIL_GAME_PARENTAL_LEVEL11 = 11,
};
enum
{
CELL_SYSUTIL_GAME_PARENTAL_LEVEL0_RESTRICT_OFF = 0,
CELL_SYSUTIL_GAME_PARENTAL_LEVEL0_RESTRICT_ON = 1,
};
enum
{
CELL_SYSUTIL_CAMERA_PLFREQ_DISABLED = 0,
CELL_SYSUTIL_CAMERA_PLFREQ_50HZ = 1,
CELL_SYSUTIL_CAMERA_PLFREQ_60HZ = 2,
CELL_SYSUTIL_CAMERA_PLFREQ_DEVCIE_DEPEND = 4,
};
enum
{
CELL_SYSUTIL_PAD_RUMBLE_OFF = 0,
CELL_SYSUTIL_PAD_RUMBLE_ON = 1,
};
// License areas
enum CellSysutilLicenseArea : s32 // Made up name
{
CELL_SYSUTIL_LICENSE_AREA_J = 0, // SCEJ (Japan)
CELL_SYSUTIL_LICENSE_AREA_A = 1, // SCEA (North America, South America, Canada, Brazil)
CELL_SYSUTIL_LICENSE_AREA_E = 2, // SCEE (UK, Europe, Eastern Europe, Oceania, Russia)
CELL_SYSUTIL_LICENSE_AREA_H = 3, // SCEH (Hong Kong, Taiwan, Southeast Asia)
CELL_SYSUTIL_LICENSE_AREA_K = 4, // SCEK (Korea)
CELL_SYSUTIL_LICENSE_AREA_C = 5, // SCH (China)
CELL_SYSUTIL_LICENSE_AREA_OTHER = 100, // Other
};
enum
{
CELL_SYSUTIL_PAD_AUTOOFF_OFF = 0,
CELL_SYSUTIL_PAD_AUTOOFF_ON = 1,
};
enum
{
CELL_SYSUTIL_MAGNETOMETER_OFF = 0,
CELL_SYSUTIL_MAGNETOMETER_ON = 1,
};
enum
{
CELL_SYSUTIL_INTERNET_BROWSER_START_RESTRICT_OFF = 0,
CELL_SYSUTIL_INTERNET_BROWSER_START_RESTRICT_ON = 1,
};
enum
{
CELL_SYSCACHE_RET_OK_CLEARED = 0,
CELL_SYSCACHE_RET_OK_RELAYED = 1,
CELL_SYSCACHE_ID_SIZE = 32,
CELL_SYSCACHE_PATH_MAX = 1055,
};
enum CellSysCacheError : u32
{
CELL_SYSCACHE_ERROR_ACCESS_ERROR = 0x8002bc01, // I don't think we need this
CELL_SYSCACHE_ERROR_INTERNAL = 0x8002bc02, // Not really useful, if we run out of HDD space sys_fs should handle that
CELL_SYSCACHE_ERROR_PARAM = 0x8002bc03,
CELL_SYSCACHE_ERROR_NOTMOUNTED = 0x8002bc04, // We don't really need to simulate the mounting, so this is probably useless
};
enum CellBgmplaybackError : u32
{
CELL_SYSUTIL_BGMPLAYBACK_ERROR_PARAM = 0x8002b101,
CELL_SYSUTIL_BGMPLAYBACK_ERROR_BUSY = 0x8002b102,
CELL_SYSUTIL_BGMPLAYBACK_ERROR_GENERIC = 0x8002b1FF,
CELL_SYSUTIL_BGMPLAYBACK_EX_ERROR_PARAM = 0x8002d301,
CELL_SYSUTIL_BGMPLAYBACK_EX_ERROR_ALREADY_SETPARAM = 0x8002d302,
CELL_SYSUTIL_BGMPLAYBACK_EX_ERROR_DISABLE_SETPARAM = 0x8002d303,
CELL_SYSUTIL_BGMPLAYBACK_EX_ERROR_GENERIC = 0x8002d3FF,
};
enum CellSysutilBgmPlaybackStatusState
{
CELL_SYSUTIL_BGMPLAYBACK_STATUS_PLAY = 0,
CELL_SYSUTIL_BGMPLAYBACK_STATUS_STOP = 1
};
enum CellSysutilBgmPlaybackStatusEnabled
{
CELL_SYSUTIL_BGMPLAYBACK_STATUS_ENABLE = 0,
CELL_SYSUTIL_BGMPLAYBACK_STATUS_DISABLE = 1
};
enum
{
CELL_SYSUTIL_BGMPLAYBACK_FADE_INVALID = -1
};
struct CellSysutilBgmPlaybackStatus
{
u8 playerState;
u8 enableState;
char contentId[16]; // CellSearchContentId
u8 currentFadeRatio; // current volume ratio (0=0%, 255=100%)
char reserved[13];
};
struct CellSysutilBgmPlaybackStatus2
{
u8 playerState;
char reserved[7];
};
struct CellSysutilBgmPlaybackExtraParam
{
be_t<s32> systemBgmFadeInTime;
be_t<s32> systemBgmFadeOutTime;
be_t<s32> gameBgmFadeInTime;
be_t<s32> gameBgmFadeOutTime;
char reserved[8];
};
struct CellSysCacheParam
{
char cacheId[CELL_SYSCACHE_ID_SIZE];
char getCachePath[CELL_SYSCACHE_PATH_MAX];
vm::bptr<void> reserved;
};
template <u32 BaseEvent>
struct SysutilEventStatus
{
atomic_t<bool> active = false;
};
extern atomic_t<usz> g_sysutil_callback_id_assigner;
extern void sysutil_register_cb_with_id_internal(std::function<s32(ppu_thread&)>&& cb, usz call_id);
extern void sysutil_unregister_cb_with_id_internal(usz call_id);
template <typename T>
const usz g_sysutil_dispatcher_id = g_sysutil_callback_id_assigner++;
template <typename T>
void sysutil_register_cb_with_id(std::function<s32(ppu_thread&)>&& cb)
{
sysutil_register_cb_with_id_internal(std::move(cb), g_sysutil_dispatcher_id<T>);
}
template <typename T>
void sysutil_unregister_cb_with_id()
{
sysutil_unregister_cb_with_id_internal(g_sysutil_dispatcher_id<T>);
}
using SysutilMenuOpenStatus = SysutilEventStatus<CELL_SYSUTIL_SYSTEM_MENU_OPEN>;
extern void sysutil_register_cb(std::function<s32(ppu_thread&)>&&);
extern s32 sysutil_send_system_cmd(u64 status, u64 param);
s32 sysutil_check_name_string(const char* src, s32 minlen, s32 maxlen);
| 11,635
|
C++
|
.h
| 304
| 36.496711
| 126
| 0.694284
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,890
|
cellGifDec.h
|
RPCS3_rpcs3/rpcs3/Emu/Cell/Modules/cellGifDec.h
|
#pragma once
#include "Emu/Memory/vm_ptr.h"
// Return Codes
enum CellGifDecError : u32
{
CELL_GIFDEC_ERROR_OPEN_FILE = 0x80611300,
CELL_GIFDEC_ERROR_STREAM_FORMAT = 0x80611301,
CELL_GIFDEC_ERROR_SEQ = 0x80611302,
CELL_GIFDEC_ERROR_ARG = 0x80611303,
CELL_GIFDEC_ERROR_FATAL = 0x80611304,
CELL_GIFDEC_ERROR_SPU_UNSUPPORT = 0x80611305,
CELL_GIFDEC_ERROR_SPU_ERROR = 0x80611306,
CELL_GIFDEC_ERROR_CB_PARAM = 0x80611307,
};
enum CellGifDecStreamSrcSel : s32
{
CELL_GIFDEC_FILE = 0, // Input from a file
CELL_GIFDEC_BUFFER = 1, // Input from a buffer
};
enum CellGifDecSpuThreadEna : s32
{
CELL_GIFDEC_SPU_THREAD_DISABLE = 0, // Do not use SPU threads
CELL_GIFDEC_SPU_THREAD_ENABLE = 1, // Use SPU threads
};
enum CellGifDecRecordType : s32
{
CELL_GIFDEC_RECORD_TYPE_IMAGE_DESC = 1, // Image data block
CELL_GIFDEC_RECORD_TYPE_EXTENSION = 2, // Extension block
CELL_GIFDEC_RECORD_TYPE_TERMINATE = 3, // Trailer block
};
enum CellGifDecColorSpace : s32
{
CELL_GIFDEC_RGBA = 10, // RGBA
CELL_GIFDEC_ARGB = 20, // ARGB
};
enum CellGifDecCommand : s32
{
CELL_GIFDEC_CONTINUE = 0, // Continue decoding
CELL_GIFDEC_STOP = 1, // Force decoding to stop
};
enum CellGifDecDecodeStatus : s32
{
CELL_GIFDEC_DEC_STATUS_FINISH = 0, // Decoding finished
CELL_GIFDEC_DEC_STATUS_STOP = 1, // Decoding was stopped
};
enum CellGifDecBufferMode : s32
{
CELL_GIFDEC_LINE_MODE = 1
};
enum CellGifDecSpuMode : s32
{
CELL_GIFDEC_RECEIVE_EVENT = 0,
CELL_GIFDEC_TRYRECEIVE_EVENT = 1
};
enum CellGifDecInterlaceMode : s32
{
CELL_GIFDEC_NO_INTERLACE = 0,
CELL_GIFDEC_INTERLACE = 1
};
// Callbacks for memory management
using CellGifDecCbControlMalloc = vm::ptr<void>(u32 size, vm::ptr<void> cbCtrlMallocArg);
using CellGifDecCbControlFree = s32(vm::ptr<void> ptr, vm::ptr<void> cbCtrlFreeArg);
// Structs
struct CellGifDecThreadInParam
{
be_t<s32> spuThreadEnable; // CellGifDecSpuThreadEna
be_t<u32> ppuThreadPriority;
be_t<u32> spuThreadPriority;
vm::bptr<CellGifDecCbControlMalloc> cbCtrlMallocFunc;
vm::bptr<void> cbCtrlMallocArg;
vm::bptr<CellGifDecCbControlFree> cbCtrlFreeFunc;
vm::bptr<void> cbCtrlFreeArg;
};
struct CellGifDecThreadOutParam
{
be_t<u32> gifCodecVersion;
};
struct CellGifDecExtThreadInParam
{
vm::bptr<struct CellSpurs> spurs;
u8 priority[8];
be_t<u32> maxContention;
};
struct CellGifDecExtThreadOutParam
{
be_t<u64> reserved;
};
struct CellGifDecSrc
{
be_t<s32> srcSelect; // CellGifDecStreamSrcSel
vm::bcptr<char> fileName;
be_t<s64> fileOffset;
be_t<u32> fileSize;
vm::bptr<void> streamPtr;
be_t<u32> streamSize;
be_t<s32> spuThreadEnable; // CellGifDecSpuThreadEna
};
struct CellGifDecOpnInfo
{
be_t<u32> initSpaceAllocated;
};
struct CellGifDecInfo
{
be_t<u32> SWidth;
be_t<u32> SHeight;
be_t<u32> SGlobalColorTableFlag;
be_t<u32> SColorResolution;
be_t<u32> SSortFlag;
be_t<u32> SSizeOfGlobalColorTable;
be_t<u32> SBackGroundColor;
be_t<u32> SPixelAspectRatio;
};
struct CellGifDecInParam
{
vm::bptr<volatile s32> commandPtr; // CellGifDecCommand
be_t<s32> colorSpace; // CellGifDecColorSpace
u8 outputColorAlpha1;
u8 outputColorAlpha2;
u8 reserved[2];
};
struct CellGifDecOutParam
{
be_t<u64> outputWidthByte;
be_t<u32> outputWidth;
be_t<u32> outputHeight;
be_t<u32> outputComponents;
be_t<u32> outputBitDepth;
be_t<s32> outputColorSpace; // CellGifDecColorSpace
be_t<u32> useMemorySpace;
};
struct CellGifDecExtension
{
u8 label;
vm::bptr<u8> data;
};
struct CellGifDecDataOutInfo
{
be_t<s32> recordType; // CellGifDecRecordType
CellGifDecExtension outExtension;
be_t<s32> status; // CellGifDecDecodeStatus
};
struct CellGifDecDataCtrlParam
{
be_t<u64> outputBytesPerLine;
};
struct CellGifDecExtInfo
{
vm::bptr<u64> reserved;
};
struct CellGifDecStrmInfo
{
be_t<u32> decodedStrmSize;
};
struct CellGifDecStrmParam
{
vm::bptr<void> strmPtr;
be_t<u32> strmSize;
};
using CellGifDecCbControlStream = s32(vm::ptr<CellGifDecStrmInfo> strmInfo, vm::ptr<CellGifDecStrmParam> strmParam, vm::ptr<void> cbCtrlStrmArg);
struct CellGifDecCbCtrlStrm
{
vm::bptr<CellGifDecCbControlStream> cbCtrlStrmFunc;
vm::bptr<void> cbCtrlStrmArg;
};
struct CellGifDecExtInParam
{
be_t<s32> bufferMode; // CellGifDecBufferMode
be_t<u32> outputCounts;
be_t<s32> spuMode; // CellGifDecSpuMode
};
struct CellGifDecExtOutParam
{
be_t<u64> outputWidthByte;
be_t<u32> outputHeight;
};
struct CellGifDecDispParam
{
vm::bptr<void> nextOutputImage;
};
struct CellGifDecDispInfo
{
be_t<u64> outputFrameWidthByte;
be_t<u32> outputFrameHeight;
be_t<u64> outputStartXByte;
be_t<u32> outputStartY;
be_t<u64> outputWidthByte;
be_t<u32> outputHeight;
be_t<u32> outputBitDepth;
be_t<u32> outputComponents;
be_t<u32> scanPassCount;
vm::bptr<void> outputImage;
be_t<s32> interlaceFlag; // CellGifDecInterlaceMode
};
using CellGifDecCbControlDisp = s32(vm::ptr<CellGifDecDispInfo> dispInfo, vm::ptr<CellGifDecDispParam> dispParam, vm::ptr<void> cbCtrlDispArg);
struct CellGifDecCbCtrlDisp
{
vm::bptr<CellGifDecCbControlDisp> cbCtrlDispFunc;
vm::bptr<void> cbCtrlDispArg;
};
// Custom structs
struct GifDecoder
{
};
struct GifStream
{
u32 fd{};
u64 fileSize{};
CellGifDecInfo info{};
CellGifDecOutParam outParam{};
CellGifDecSrc src{};
};
| 5,335
|
C++
|
.h
| 211
| 23.412322
| 145
| 0.770395
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,891
|
cellAudioOut.h
|
RPCS3_rpcs3/rpcs3/Emu/Cell/Modules/cellAudioOut.h
|
#pragma once
#include "Emu/Audio/AudioBackend.h"
#include "Emu/Memory/vm_ptr.h"
// Error codes
enum CellAudioOutError : u32
{
CELL_AUDIO_OUT_ERROR_NOT_IMPLEMENTED = 0x8002b240,
CELL_AUDIO_OUT_ERROR_ILLEGAL_CONFIGURATION = 0x8002b241,
CELL_AUDIO_OUT_ERROR_ILLEGAL_PARAMETER = 0x8002b242,
CELL_AUDIO_OUT_ERROR_PARAMETER_OUT_OF_RANGE = 0x8002b243,
CELL_AUDIO_OUT_ERROR_DEVICE_NOT_FOUND = 0x8002b244,
CELL_AUDIO_OUT_ERROR_UNSUPPORTED_AUDIO_OUT = 0x8002b245,
CELL_AUDIO_OUT_ERROR_UNSUPPORTED_SOUND_MODE = 0x8002b246,
CELL_AUDIO_OUT_ERROR_CONDITION_BUSY = 0x8002b247,
};
enum CellAudioOut
{
CELL_AUDIO_OUT_PRIMARY = 0,
CELL_AUDIO_OUT_SECONDARY = 1,
};
enum CellAudioOutDownMixer
{
CELL_AUDIO_OUT_DOWNMIXER_NONE = 0,
CELL_AUDIO_OUT_DOWNMIXER_TYPE_A = 1,
CELL_AUDIO_OUT_DOWNMIXER_TYPE_B = 2,
};
enum CellAudioOutDeviceMode
{
CELL_AUDIO_OUT_SINGLE_DEVICE_MODE = 0,
CELL_AUDIO_OUT_MULTI_DEVICE_MODE = 1,
CELL_AUDIO_OUT_MULTI_DEVICE_MODE_2 = 2,
};
enum CellAudioOutPortType
{
CELL_AUDIO_OUT_PORT_HDMI = 0,
CELL_AUDIO_OUT_PORT_SPDIF = 1,
CELL_AUDIO_OUT_PORT_ANALOG = 2,
CELL_AUDIO_OUT_PORT_USB = 3,
CELL_AUDIO_OUT_PORT_BLUETOOTH = 4,
CELL_AUDIO_OUT_PORT_NETWORK = 5,
};
enum CellAudioOutDeviceState
{
CELL_AUDIO_OUT_DEVICE_STATE_UNAVAILABLE = 0,
CELL_AUDIO_OUT_DEVICE_STATE_AVAILABLE = 1,
};
enum CellAudioOutOutputState
{
CELL_AUDIO_OUT_OUTPUT_STATE_ENABLED = 0,
CELL_AUDIO_OUT_OUTPUT_STATE_DISABLED = 1,
CELL_AUDIO_OUT_OUTPUT_STATE_PREPARING = 2,
};
enum CellAudioOutCodingType
{
CELL_AUDIO_OUT_CODING_TYPE_LPCM = 0,
CELL_AUDIO_OUT_CODING_TYPE_AC3 = 1,
CELL_AUDIO_OUT_CODING_TYPE_MPEG1 = 2,
CELL_AUDIO_OUT_CODING_TYPE_MP3 = 3,
CELL_AUDIO_OUT_CODING_TYPE_MPEG2 = 4,
CELL_AUDIO_OUT_CODING_TYPE_AAC = 5,
CELL_AUDIO_OUT_CODING_TYPE_DTS = 6,
CELL_AUDIO_OUT_CODING_TYPE_ATRAC = 7,
CELL_AUDIO_OUT_CODING_TYPE_DOLBY_TRUE_HD = 8, // Speculative name
CELL_AUDIO_OUT_CODING_TYPE_DOLBY_DIGITAL_PLUS = 9,
CELL_AUDIO_OUT_CODING_TYPE_DTS_HD_HIGHRES = 10, // Speculative name
CELL_AUDIO_OUT_CODING_TYPE_DTS_HD_MASTER = 11, // Speculative name
CELL_AUDIO_OUT_CODING_TYPE_BITSTREAM = 0xff,
};
enum CellAudioOutChnum
{
CELL_AUDIO_OUT_CHNUM_2 = 2,
CELL_AUDIO_OUT_CHNUM_4 = 4,
CELL_AUDIO_OUT_CHNUM_6 = 6,
CELL_AUDIO_OUT_CHNUM_8 = 8,
};
enum CellAudioOutFs
{
CELL_AUDIO_OUT_FS_32KHZ = 0x01,
CELL_AUDIO_OUT_FS_44KHZ = 0x02,
CELL_AUDIO_OUT_FS_48KHZ = 0x04,
CELL_AUDIO_OUT_FS_88KHZ = 0x08,
CELL_AUDIO_OUT_FS_96KHZ = 0x10,
CELL_AUDIO_OUT_FS_176KHZ = 0x20,
CELL_AUDIO_OUT_FS_192KHZ = 0x40,
};
enum CellAudioOutSpeakerLayout
{
CELL_AUDIO_OUT_SPEAKER_LAYOUT_DEFAULT = 0x00000000,
CELL_AUDIO_OUT_SPEAKER_LAYOUT_2CH = 0x00000001,
CELL_AUDIO_OUT_SPEAKER_LAYOUT_6CH_LREClr = 0x00010000,
CELL_AUDIO_OUT_SPEAKER_LAYOUT_8CH_LREClrxy = 0x40000000,
};
enum CellAudioOutEvent
{
CELL_AUDIO_OUT_EVENT_DEVICE_CHANGED = 0,
CELL_AUDIO_OUT_EVENT_OUTPUT_DISABLED = 1,
CELL_AUDIO_OUT_EVENT_DEVICE_AUTHENTICATED = 2,
CELL_AUDIO_OUT_EVENT_OUTPUT_ENABLED = 3,
};
enum CellAudioOutCopyControl
{
CELL_AUDIO_OUT_COPY_CONTROL_COPY_FREE = 0,
CELL_AUDIO_OUT_COPY_CONTROL_COPY_ONCE = 1,
CELL_AUDIO_OUT_COPY_CONTROL_COPY_NEVER = 2,
};
struct CellAudioOutConfiguration
{
u8 channel;
u8 encoder;
u8 reserved[10];
be_t<u32> downMixer;
};
struct CellAudioOutSoundMode
{
u8 type;
u8 channel;
u8 fs;
u8 reserved;
be_t<u32> layout;
ENABLE_BITWISE_SERIALIZATION;
};
struct CellAudioOutDeviceInfo
{
u8 portType;
u8 availableModeCount;
u8 state;
u8 reserved[3];
be_t<u16> latency;
CellAudioOutSoundMode availableModes[16];
};
struct CellAudioOutState
{
u8 state;
u8 encoder;
u8 reserved[6];
be_t<u32> downMixer;
CellAudioOutSoundMode soundMode;
};
struct CellAudioOutSoundMode2
{
u8 type;
u8 channel;
be_t<u16> fs;
u8 reserved[4];
};
struct CellAudioOutDeviceInfo2
{
u8 portType;
u8 availableModeCount;
u8 state;
u8 deviceNumber;
u8 reserved[12];
be_t<u64> deviceId;
be_t<u64> type;
char name[64];
CellAudioOutSoundMode2 availableModes2[16];
};
struct CellAudioOutOption
{
be_t<u32> reserved;
};
struct CellAudioOutRegistrationOption
{
be_t<u32> reserved;
};
struct CellAudioOutDeviceConfiguration
{
u8 volume;
u8 reserved[31];
};
typedef s32(CellAudioOutCallback)(u32 slot, u32 audioOut, u32 deviceIndex, u32 event, vm::ptr<CellAudioOutDeviceInfo> info, vm::ptr<void> userData);
// FXO Object
struct audio_out_configuration
{
shared_mutex mtx;
struct audio_out
{
u32 state = CELL_AUDIO_OUT_OUTPUT_STATE_ENABLED;
u32 channels = CELL_AUDIO_OUT_CHNUM_2;
u32 encoder = CELL_AUDIO_OUT_CODING_TYPE_LPCM;
u32 downmixer = CELL_AUDIO_OUT_DOWNMIXER_NONE;
u32 copy_control = CELL_AUDIO_OUT_COPY_CONTROL_COPY_FREE;
std::vector<CellAudioOutSoundMode> sound_modes;
CellAudioOutSoundMode sound_mode{};
std::pair<AudioChannelCnt, AudioChannelCnt> get_channel_count_and_downmixer() const;
};
std::array<audio_out, 2> out;
SAVESTATE_INIT_POS(8.9); // Is a dependency of cellAudio
audio_out_configuration();
audio_out_configuration(utils::serial& ar);
void save(utils::serial& ar);
};
| 5,284
|
C++
|
.h
| 192
| 25.692708
| 148
| 0.736062
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,892
|
cellSsl.h
|
RPCS3_rpcs3/rpcs3/Emu/Cell/Modules/cellSsl.h
|
#pragma once
enum CellSslError : u32
{
CELL_SSL_ERROR_NOT_INITIALIZED = 0x80740001,
CELL_SSL_ERROR_ALREADY_INITIALIZED = 0x80740002,
CELL_SSL_ERROR_INITIALIZATION_FAILED = 0x80740003,
CELL_SSL_ERROR_NO_BUFFER = 0x80740004,
CELL_SSL_ERROR_INVALID_CERTIFICATE = 0x80740005,
CELL_SSL_ERROR_UNRETRIEVABLE = 0x80740006,
CELL_SSL_ERROR_INVALID_FORMAT = 0x80740007,
CELL_SSL_ERROR_NOT_FOUND = 0x80740008,
CELL_SSL_ERROR_INVALID_TIME = 0x80740031,
CELL_SSL_ERROR_INAVLID_NEGATIVE_TIME = 0x80740032,
CELL_SSL_ERROR_INCORRECT_TIME = 0x80740033,
CELL_SSL_ERROR_UNDEFINED_TIME_TYPE = 0x80740034,
CELL_SSL_ERROR_NO_MEMORY = 0x80740035,
CELL_SSL_ERROR_NO_STRING = 0x80740036,
CELL_SSL_ERROR_UNKNOWN_LOAD_CERT = 0x80740037
};
// Certificate load flags
enum : u64
{
CELL_SSL_LOAD_CERT_SCE01 = 0x0000000000000001ULL,
CELL_SSL_LOAD_CERT_SCE02 = 0x0000000000000002ULL,
CELL_SSL_LOAD_CERT_SCE03 = 0x0000000000000004ULL,
CELL_SSL_LOAD_CERT_SCE04 = 0x0000000000000008ULL,
CELL_SSL_LOAD_CERT_SCE05 = 0x0000000000000010ULL,
CELL_SSL_LOAD_CERT_BALTIMORE_CT = 0x0000000000000020ULL,
CELL_SSL_LOAD_CERT_CLASS1_PCA_G2_V2 = 0x0000000000000040ULL,
CELL_SSL_LOAD_CERT_CLASS1_PCA_G3_V2 = 0x0000000000000080ULL,
CELL_SSL_LOAD_CERT_CLASS1_PCA_SS_V4 = 0x0000000000000100ULL,
CELL_SSL_LOAD_CERT_CLASS2_PCA_G2_V2 = 0x0000000000000200ULL,
CELL_SSL_LOAD_CERT_CLASS2_PCA_G3_V2 = 0x0000000000000400ULL,
CELL_SSL_LOAD_CERT_CLASS2_PCA_SS_V4 = 0x0000000000000800ULL,
CELL_SSL_LOAD_CERT_CLASS3_PCA_G2_V2 = 0x0000000000001000ULL,
CELL_SSL_LOAD_CERT_CLASS3_PCA_G3_V2 = 0x0000000000002000ULL,
CELL_SSL_LOAD_CERT_CLASS3_PCA_SS_V4 = 0x0000000000004000ULL,
CELL_SSL_LOAD_CERT_CLASS4_PCA_G2_V2 = 0x0000000000008000ULL,
CELL_SSL_LOAD_CERT_CLASS4_PCA_G3_V2 = 0x0000000000010000ULL,
CELL_SSL_LOAD_CERT_ENTRUST_NET_SS_CA = 0x0000000000020000ULL,
CELL_SSL_LOAD_CERT_EQUIFAX_SEC_CA = 0x0000000000040000ULL,
CELL_SSL_LOAD_CERT_EQUIFAX_SEC_EBUS1 = 0x0000000000080000ULL,
CELL_SSL_LOAD_CERT_GEOTRUST_GCA = 0x0000000000100000ULL,
CELL_SSL_LOAD_CERT_GLOBALSIGN_RCA = 0x0000000000200000ULL,
CELL_SSL_LOAD_CERT_GTE_CT_G_RCA = 0x0000000000400000ULL,
CELL_SSL_LOAD_CERT_GTE_CT_ROOT = 0x0000000000800000ULL,
CELL_SSL_LOAD_CERT_RSA1024_V1 = 0x0000000001000000ULL,
CELL_SSL_LOAD_CERT_RSA2048_V3 = 0x0000000002000000ULL,
CELL_SSL_LOAD_CERT_RSA_SECURE_SERVER = 0x0000000004000000ULL,
CELL_SSL_LOAD_CERT_THAWTE_PREM_SCA = 0x0000000008000000ULL,
CELL_SSL_LOAD_CERT_THAWTE_SCA = 0x0000000010000000ULL,
CELL_SSL_LOAD_CERT_VALICERT_CLASS2 = 0x0000000020000000ULL,
CELL_SSL_LOAD_CERT_VERISIGN_TSA_CA = 0x0000000040000000ULL,
CELL_SSL_LOAD_CERT_AAA_CERT_SERVICES = 0x0000000080000000ULL,
CELL_SSL_LOAD_CERT_ADDTRUST_EXT_CA = 0x0000000100000000ULL,
CELL_SSL_LOAD_CERT_UTN_USERFIRST_HW = 0x0000000200000000ULL,
CELL_SSL_LOAD_CERT_EQUIFAX_SEC_G_EBUS1 = 0x0000000400000000ULL,
CELL_SSL_LOAD_CERT_CLASS3_PCA_G5 = 0x0000000800000000ULL,
CELL_SSL_LOAD_CERT_DIGICERT_HA_EV_RCA = 0x0000001000000000ULL,
CELL_SSL_LOAD_CERT_DIGICERT_A_ID_RCA = 0x0000002000000000ULL,
CELL_SSL_LOAD_CERT_DIGICERT_GLOBAL_RCA = 0x0000004000000000ULL,
CELL_SSL_LOAD_CERT_CT_G_ROOT = 0x0000008000000000ULL,
CELL_SSL_LOAD_CERT_ENTRUST_CA2048 = 0x0000010000000000ULL,
CELL_SSL_LOAD_CERT_ENTRUST_RCA = 0x0000020000000000ULL,
CELL_SSL_LOAD_CERT_GLOBALSIGN_RCA_R2 = 0x0000040000000000ULL,
CELL_SSL_LOAD_CERT_GODADDY_CLASS2_CA = 0x0000080000000000ULL,
CELL_SSL_LOAD_CERT_STARFIELD_CLASS2_CA = 0x0000100000000000ULL,
CELL_SSL_LOAD_CERT_STARFIELD_S_RC = 0x0000200000000000ULL,
CELL_SSL_LOAD_CERT_THATE_PRIMARY_RCA = 0x0000400000000000ULL,
CELL_SSL_LOAD_CERT_VALICERT_CLASS1_VA = 0x0000800000000000ULL,
CELL_SSL_LOAD_CERT_SECOM_RCA1 = 0x0001000000000000ULL,
CELL_SSL_LOAD_CERT_SECURE_TRUST_CA = 0x0002000000000000ULL,
CELL_SSL_LOAD_CERT_ENTRUST_RCA_G2 = 0x0004000000000000ULL,
CELL_SSL_LOAD_CERT_VERISIGN_U_RCA = 0x0008000000000000ULL,
CELL_SSL_LOAD_CERT_GODADDY_C2_CA_G2 = 0x0010000000000000ULL,
CELL_SSL_LOAD_CERT_STARFIELD_C2_CA_G2 = 0x0020000000000000ULL,
CELL_SSL_LOAD_CERT_STARFIELD_S_RC_G2 = 0x0040000000000000ULL,
CELL_SSL_LOAD_CERT_STARTCOM_CA = 0x0080000000000000ULL,
CELL_SSL_LOAD_CERT_STARTCOM_CA_G2 = 0x0100000000000000ULL,
CELL_SSL_LOAD_CERT_SECOM_RCA2 = 0x0200000000000000ULL,
// Composite Flags
CELL_SSL_LOAD_CERT_SCE =
(
CELL_SSL_LOAD_CERT_SCE01 |
CELL_SSL_LOAD_CERT_SCE02 |
CELL_SSL_LOAD_CERT_SCE03 |
CELL_SSL_LOAD_CERT_SCE04 |
CELL_SSL_LOAD_CERT_SCE05
),
CELL_SSL_LOAD_CERT_SHA256 =
(
CELL_SSL_LOAD_CERT_GLOBALSIGN_RCA_R2 |
CELL_SSL_LOAD_CERT_ENTRUST_RCA_G2 |
CELL_SSL_LOAD_CERT_VERISIGN_U_RCA |
CELL_SSL_LOAD_CERT_GODADDY_C2_CA_G2 |
CELL_SSL_LOAD_CERT_STARFIELD_C2_CA_G2 |
CELL_SSL_LOAD_CERT_STARFIELD_S_RC_G2 |
CELL_SSL_LOAD_CERT_STARTCOM_CA |
CELL_SSL_LOAD_CERT_STARTCOM_CA_G2 |
CELL_SSL_LOAD_CERT_SECOM_RCA2
),
CELL_SSL_LOAD_CERT_NORMAL =
(
CELL_SSL_LOAD_CERT_BALTIMORE_CT |
CELL_SSL_LOAD_CERT_CLASS3_PCA_G2_V2 |
CELL_SSL_LOAD_CERT_CLASS3_PCA_G3_V2 |
CELL_SSL_LOAD_CERT_CLASS3_PCA_SS_V4 |
CELL_SSL_LOAD_CERT_ENTRUST_NET_SS_CA |
CELL_SSL_LOAD_CERT_EQUIFAX_SEC_CA |
CELL_SSL_LOAD_CERT_EQUIFAX_SEC_EBUS1 |
CELL_SSL_LOAD_CERT_GEOTRUST_GCA |
CELL_SSL_LOAD_CERT_GLOBALSIGN_RCA |
CELL_SSL_LOAD_CERT_GTE_CT_G_RCA |
CELL_SSL_LOAD_CERT_RSA1024_V1 |
CELL_SSL_LOAD_CERT_RSA2048_V3 |
CELL_SSL_LOAD_CERT_THAWTE_PREM_SCA |
CELL_SSL_LOAD_CERT_THAWTE_SCA |
CELL_SSL_LOAD_CERT_VALICERT_CLASS2 |
CELL_SSL_LOAD_CERT_AAA_CERT_SERVICES |
CELL_SSL_LOAD_CERT_ADDTRUST_EXT_CA |
CELL_SSL_LOAD_CERT_UTN_USERFIRST_HW |
CELL_SSL_LOAD_CERT_EQUIFAX_SEC_G_EBUS1 |
CELL_SSL_LOAD_CERT_CLASS3_PCA_G5 |
CELL_SSL_LOAD_CERT_DIGICERT_HA_EV_RCA |
CELL_SSL_LOAD_CERT_DIGICERT_A_ID_RCA |
CELL_SSL_LOAD_CERT_DIGICERT_GLOBAL_RCA |
CELL_SSL_LOAD_CERT_CT_G_ROOT |
CELL_SSL_LOAD_CERT_ENTRUST_CA2048 |
CELL_SSL_LOAD_CERT_ENTRUST_RCA |
CELL_SSL_LOAD_CERT_GODADDY_CLASS2_CA |
CELL_SSL_LOAD_CERT_STARFIELD_CLASS2_CA |
CELL_SSL_LOAD_CERT_STARFIELD_S_RC |
CELL_SSL_LOAD_CERT_THATE_PRIMARY_RCA |
CELL_SSL_LOAD_CERT_VALICERT_CLASS1_VA |
CELL_SSL_LOAD_CERT_SECOM_RCA1 |
CELL_SSL_LOAD_CERT_SECURE_TRUST_CA |
CELL_SSL_LOAD_CERT_SHA256
),
CELL_SSL_LOAD_CERT_ALL =
(
CELL_SSL_LOAD_CERT_SCE |
CELL_SSL_LOAD_CERT_NORMAL
),
CELL_SSL_LOAD_CERT_OBSOLETE =
(
CELL_SSL_LOAD_CERT_RSA_SECURE_SERVER |
CELL_SSL_LOAD_CERT_VERISIGN_TSA_CA |
CELL_SSL_LOAD_CERT_GTE_CT_ROOT
),
CELL_SSL_LOAD_CERT_NOT_FOR_SERVER =
(
CELL_SSL_LOAD_CERT_CLASS1_PCA_G2_V2 |
CELL_SSL_LOAD_CERT_CLASS1_PCA_G3_V2 |
CELL_SSL_LOAD_CERT_CLASS1_PCA_SS_V4 |
CELL_SSL_LOAD_CERT_CLASS2_PCA_G2_V2 |
CELL_SSL_LOAD_CERT_CLASS2_PCA_G3_V2 |
CELL_SSL_LOAD_CERT_CLASS2_PCA_SS_V4 |
CELL_SSL_LOAD_CERT_CLASS4_PCA_G2_V2 |
CELL_SSL_LOAD_CERT_CLASS4_PCA_G3_V2
),
};
enum // Cipher
{
CELL_SSL_CIPHER_UNKNOWN = -1,
CELL_SSL_CIPHER_RSA_WITH_3DES_EDE_CBC_SHA = 0,
CELL_SSL_CIPHER_RSA_WITH_RC4_128_SHA = 1,
CELL_SSL_CIPHER_RSA_WITH_RC4_128_MD5 = 2,
CELL_SSL_CIPHER_RSA_WITH_DES_CBC_SHA = 3,
CELL_SSL_CIPHER_RSA_EXPORT1024_WITH_DES_CBC_SHA = 4,
CELL_SSL_CIPHER_RSA_EXPORT1024_WITH_RC4_56_SHA = 5,
CELL_SSL_CIPHER_RSA_EXPORT_WITH_DES40_CBC_SHA = 6,
CELL_SSL_CIPHER_RSA_EXPORT_WITH_RC2_CBC_40_MD5 = 7,
CELL_SSL_CIPHER_RSA_EXPORT_WITH_RC4_40_MD5 = 8
};
enum // Version
{
CELL_SSL_VERSION_UNKNOWN = -1,
CELL_SSL_VERSION_TLS1 = 0,
CELL_SSL_VERSION_SSL3 = 1
};
enum // Other Constants
{
CELL_SSL_MD5_FINGERPRINT_MAX_SIZE = 20
};
enum SpecialCerts
{
BaltimoreCert = 6,
Class3G2V2Cert = 13,
ClassSSV4Cert = 15,
EntrustNetCert = 18,
GTECyberTrustGlobalCert = 23
};
struct ssl_manager
{
atomic_t<bool> is_init{ false };
};
b8 _cellSslIsInitd();
| 8,160
|
C++
|
.h
| 197
| 39.182741
| 64
| 0.724884
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,893
|
sys_net_.h
|
RPCS3_rpcs3/rpcs3/Emu/Cell/Modules/sys_net_.h
|
#pragma once
#include "Emu/Cell/lv2/sys_net.h"
#include "Emu/Memory/vm.h"
struct sys_net_sockinfo_t
{
be_t<s32> s;
be_t<s32> proto;
be_t<s32> recv_queue_length;
be_t<s32> send_queue_length;
sys_net_in_addr local_adr;
be_t<s32> local_port;
sys_net_in_addr remote_adr;
be_t<s32> remote_port;
be_t<s32> state;
};
struct sys_net_sockinfo_ex_t
{
be_t<s32> s;
be_t<s32> proto;
be_t<s32> recv_queue_length;
be_t<s32> send_queue_length;
sys_net_in_addr local_adr;
be_t<s32> local_port;
sys_net_in_addr remote_adr;
be_t<s32> remote_port;
be_t<s32> state;
be_t<s32> socket_type;
be_t<s32> local_vport;
be_t<s32> remote_vport;
be_t<s32> reserved[8];
};
struct sys_net_initialize_parameter_t
{
vm::bptr<void> memory;
be_t<s32> memory_size;
be_t<s32> flags;
};
| 777
|
C++
|
.h
| 37
| 19.216216
| 37
| 0.709239
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,894
|
cellAtracXdec.h
|
RPCS3_rpcs3/rpcs3/Emu/Cell/Modules/cellAtracXdec.h
|
#pragma once
#ifdef _MSC_VER
#pragma warning(push, 0)
#else
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wall"
#pragma GCC diagnostic ignored "-Wextra"
#pragma GCC diagnostic ignored "-Wold-style-cast"
#endif
extern "C"
{
#include "libavcodec/avcodec.h"
}
constexpr int averror_eof = AVERROR_EOF; // Workaround for old-style-cast error
#ifdef _MSC_VER
#pragma warning(pop)
#else
#pragma GCC diagnostic pop
#endif
#include "Utilities/cond.h"
#include "cellPamf.h"
#include "cellAdec.h"
enum CellAtracXdecError : u32
{
CELL_ADEC_ERROR_ATX_OFFSET = 0x80612200,
CELL_ADEC_ERROR_ATX_NONE = 0x80612200,
CELL_ADEC_ERROR_ATX_OK = 0x80612200,
CELL_ADEC_ERROR_ATX_BUSY = 0x80612264,
CELL_ADEC_ERROR_ATX_EMPTY = 0x80612265,
CELL_ADEC_ERROR_ATX_ATSHDR = 0x80612266,
CELL_ADEC_ERROR_ATX_NON_FATAL = 0x80612281,
CELL_ADEC_ERROR_ATX_NOT_IMPLE = 0x80612282,
CELL_ADEC_ERROR_ATX_PACK_CE_OVERFLOW = 0x80612283,
CELL_ADEC_ERROR_ATX_ILLEGAL_NPROCQUS = 0x80612284,
CELL_ADEC_ERROR_ATX_FATAL = 0x8061228c,
CELL_ADEC_ERROR_ATX_ENC_OVERFLOW = 0x8061228d,
CELL_ADEC_ERROR_ATX_PACK_CE_UNDERFLOW = 0x8061228e,
CELL_ADEC_ERROR_ATX_SYNTAX_IDCT = 0x8061228f,
CELL_ADEC_ERROR_ATX_SYNTAX_GAINADJ = 0x80612290,
CELL_ADEC_ERROR_ATX_SYNTAX_IDSF = 0x80612291,
CELL_ADEC_ERROR_ATX_SYNTAX_SPECTRA = 0x80612292,
CELL_ADEC_ERROR_ATX_SYNTAX_IDWL = 0x80612293,
CELL_ADEC_ERROR_ATX_SYNTAX_GHWAVE = 0x80612294,
CELL_ADEC_ERROR_ATX_SYNTAX_SHEADER = 0x80612295,
CELL_ADEC_ERROR_ATX_SYNTAX_IDWL_A = 0x80612296,
CELL_ADEC_ERROR_ATX_SYNTAX_IDWL_B = 0x80612297,
CELL_ADEC_ERROR_ATX_SYNTAX_IDWL_C = 0x80612298,
CELL_ADEC_ERROR_ATX_SYNTAX_IDWL_D = 0x80612299,
CELL_ADEC_ERROR_ATX_SYNTAX_IDWL_E = 0x8061229a,
CELL_ADEC_ERROR_ATX_SYNTAX_IDSF_A = 0x8061229b,
CELL_ADEC_ERROR_ATX_SYNTAX_IDSF_B = 0x8061229c,
CELL_ADEC_ERROR_ATX_SYNTAX_IDSF_C = 0x8061229d,
CELL_ADEC_ERROR_ATX_SYNTAX_IDSF_D = 0x8061229e,
CELL_ADEC_ERROR_ATX_SYNTAX_IDCT_A = 0x8061229f,
CELL_ADEC_ERROR_ATX_SYNTAX_GC_NGC = 0x806122a0,
CELL_ADEC_ERROR_ATX_SYNTAX_GC_IDLEV_A = 0x806122a1,
CELL_ADEC_ERROR_ATX_SYNTAX_GC_IDLOC_A = 0x806122a2,
CELL_ADEC_ERROR_ATX_SYNTAX_GC_IDLEV_B = 0x806122a3,
CELL_ADEC_ERROR_ATX_SYNTAX_GC_IDLOC_B = 0x806122a4,
CELL_ADEC_ERROR_ATX_SYNTAX_SN_NWVS = 0x806122a5,
CELL_ADEC_ERROR_ATX_FATAL_HANDLE = 0x806122aa,
CELL_ADEC_ERROR_ATX_ASSERT_SAMPLING_FREQ = 0x806122ab,
CELL_ADEC_ERROR_ATX_ASSERT_CH_CONFIG_INDEX = 0x806122ac,
CELL_ADEC_ERROR_ATX_ASSERT_NBYTES = 0x806122ad,
CELL_ADEC_ERROR_ATX_ASSERT_BLOCK_NUM = 0x806122ae,
CELL_ADEC_ERROR_ATX_ASSERT_BLOCK_ID = 0x806122af,
CELL_ADEC_ERROR_ATX_ASSERT_CHANNELS = 0x806122b0,
CELL_ADEC_ERROR_ATX_UNINIT_BLOCK_SPECIFIED = 0x806122b1,
CELL_ADEC_ERROR_ATX_POSCFG_PRESENT = 0x806122b2,
CELL_ADEC_ERROR_ATX_BUFFER_OVERFLOW = 0x806122b3,
CELL_ADEC_ERROR_ATX_ILL_BLK_TYPE_ID = 0x806122b4,
CELL_ADEC_ERROR_ATX_UNPACK_CHANNEL_BLK_FAILED = 0x806122b5,
CELL_ADEC_ERROR_ATX_ILL_BLK_ID_USED_1 = 0x806122b6,
CELL_ADEC_ERROR_ATX_ILL_BLK_ID_USED_2 = 0x806122b7,
CELL_ADEC_ERROR_ATX_ILLEGAL_ENC_SETTING = 0x806122b8,
CELL_ADEC_ERROR_ATX_ILLEGAL_DEC_SETTING = 0x806122b9,
CELL_ADEC_ERROR_ATX_ASSERT_NSAMPLES = 0x806122ba,
CELL_ADEC_ERROR_ATX_ILL_SYNCWORD = 0x806122bb,
CELL_ADEC_ERROR_ATX_ILL_SAMPLING_FREQ = 0x806122bc,
CELL_ADEC_ERROR_ATX_ILL_CH_CONFIG_INDEX = 0x806122bd,
CELL_ADEC_ERROR_ATX_RAW_DATA_FRAME_SIZE_OVER = 0x806122be,
CELL_ADEC_ERROR_ATX_SYNTAX_ENHANCE_LENGTH_OVER = 0x806122bf,
CELL_ADEC_ERROR_ATX_SPU_INTERNAL_FAIL = 0x806122c8,
};
enum : u32
{
CELL_ADEC_ATRACX_WORD_SZ_16BIT = 0x02,
CELL_ADEC_ATRACX_WORD_SZ_24BIT = 0x03,
CELL_ADEC_ATRACX_WORD_SZ_32BIT = 0x04,
CELL_ADEC_ATRACX_WORD_SZ_FLOAT = 0x84,
};
enum : u8
{
CELL_ADEC_ATRACX_ATS_HDR_NOTINC = 0,
CELL_ADEC_ATRACX_ATS_HDR_INC = 1,
};
enum : u8
{
ATRACX_DOWNMIX_OFF = 0,
ATRACX_DOWNMIX_ON = 1,
};
struct CellAdecParamAtracX
{
be_t<u32> sampling_freq;
be_t<u32> ch_config_idx;
be_t<u32> nch_out;
be_t<u32> nbytes;
std::array<u8, 4> extra_config_data;
be_t<u32> bw_pcm;
u8 downmix_flag;
u8 au_includes_ats_hdr_flg;
};
struct CellAdecAtracXInfo
{
be_t<u32> samplingFreq;
be_t<u32> channelConfigIndex;
be_t<u32> nbytes;
};
CHECK_SIZE(CellAdecAtracXInfo, 12);
struct AtracXdecAtsHeader
{
be_t<u16> sync_word; // 0x0fd0
be_t<u16> params; // 3 bits: sample rate, 3 bits: channel config, 10 bits: (nbytes / 8) - 1
u8 extra_config_data[4];
};
CHECK_SIZE(AtracXdecAtsHeader, 8);
enum class AtracXdecCmdType : u32
{
invalid,
start_seq,
decode_au,
end_seq,
close,
};
struct AtracXdecCmd
{
be_t<AtracXdecCmdType> type;
be_t<s32> pcm_handle;
vm::bcptr<u8> au_start_addr;
be_t<u32> au_size;
vm::bptr<void> pcm_start_addr; // Unused
be_t<u32> pcm_size; // Unused
CellAdecParamAtracX atracx_param;
AtracXdecCmd() = default; // cellAdecOpen()
AtracXdecCmd(AtracXdecCmdType&& type) // cellAdecEndSeq(), cellAdecClose()
: type(type)
{
}
AtracXdecCmd(AtracXdecCmdType&& type, const CellAdecParamAtracX& atracx_param) // cellAdecStartSeq()
: type(type), atracx_param(atracx_param)
{
}
AtracXdecCmd(AtracXdecCmdType&& type, const s32& pcm_handle, const CellAdecAuInfo& au_info) // cellAdecDecodeAu()
: type(type), pcm_handle(pcm_handle), au_start_addr(au_info.startAddr), au_size(au_info.size)
{
}
};
CHECK_SIZE(AtracXdecCmd, 0x34);
struct AtracXdecDecoder
{
be_t<u32> sampling_freq;
be_t<u32> ch_config_idx;
be_t<u32> nch_in;
be_t<u32> nch_blocks;
be_t<u32> nbytes;
be_t<u32> nch_out;
be_t<u32> bw_pcm;
be_t<u32> nbytes_128_aligned;
be_t<u32> status;
be_t<u32> pcm_output_size;
const vm::bptr<u8> work_mem;
// HLE exclusive
b8 config_is_set = false; // For savestates
const AVCodec* codec;
AVCodecContext* ctx;
AVPacket* packet;
AVFrame* frame;
u8 spurs_stuff[84]; // 120 bytes on LLE, pointers to CellSpurs, CellSpursTaskset, etc.
be_t<u32> spurs_task_id; // CellSpursTaskId
AtracXdecDecoder(vm::ptr<u8> work_mem) : work_mem(work_mem) {}
void alloc_avcodec();
void free_avcodec();
void init_avcodec();
error_code set_config_info(u32 sampling_freq, u32 ch_config_idx, u32 nbytes);
error_code init_decode(u32 bw_pcm, u32 nch_out);
error_code parse_ats_header(vm::cptr<u8> au_start_addr);
};
CHECK_SIZE(AtracXdecDecoder, 0xa8);
struct AtracXdecContext
{
be_t<u64> thread_id; // sys_ppu_thread_t
shared_mutex queue_mutex; // sys_mutex_t
cond_variable queue_not_empty; // sys_cond_t
AdecCmdQueue<AtracXdecCmd> cmd_queue;
shared_mutex output_mutex; // sys_mutex_t
cond_variable output_consumed; // sys_cond_t
be_t<u32> output_locked = false;
be_t<u32> run_thread_mutex; // sys_mutex_t
be_t<u32> run_thread_cond; // sys_cond_t
be_t<u32> run_thread = true;
const AdecCb<AdecNotifyAuDone> notify_au_done;
const AdecCb<AdecNotifyPcmOut> notify_pcm_out;
const AdecCb<AdecNotifyError> notify_error;
const AdecCb<AdecNotifySeqDone> notify_seq_done;
const vm::bptr<u8> work_mem;
// HLE exclusive
u64 cmd_counter = 0; // For debugging
AtracXdecCmd cmd; // For savestates; if savestate was created while processing a decode command, we need to save the current command
b8 skip_getting_command = false; // For savestates; skips getting a new command from the queue
b8 skip_next_frame; // Needed to emulate behavior of LLE SPU program, it doesn't output the first frame after a sequence reset or error
u8 spurs_stuff[58]; // 120 bytes on LLE, pointers to CellSpurs, CellSpursTaskset, etc.
CellAdecParamAtracX atracx_param;
u8 reserved;
b8 first_decode;
AtracXdecDecoder decoder;
AtracXdecContext(vm::ptr<AdecNotifyAuDone> notifyAuDone, vm::ptr<void> notifyAuDoneArg, vm::ptr<AdecNotifyPcmOut> notifyPcmOut, vm::ptr<void> notifyPcmOutArg,
vm::ptr<AdecNotifyError> notifyError, vm::ptr<void> notifyErrorArg, vm::ptr<AdecNotifySeqDone> notifySeqDone, vm::ptr<void> notifySeqDoneArg, vm::bptr<u8> work_mem)
: notify_au_done{ notifyAuDone, notifyAuDoneArg }
, notify_pcm_out{ notifyPcmOut, notifyPcmOutArg }
, notify_error{ notifyError, notifyErrorArg }
, notify_seq_done{ notifySeqDone, notifySeqDoneArg }
, work_mem(work_mem)
, decoder(work_mem)
{
}
void exec(ppu_thread& ppu);
template <AtracXdecCmdType type>
error_code send_command(ppu_thread& ppu, auto&&... args);
};
static_assert(std::is_standard_layout_v<AtracXdecContext>);
CHECK_SIZE_ALIGN(AtracXdecContext, 0x268, 8);
constexpr u32 ATXDEC_SPURS_STRUCTS_SIZE = 0x1cf00; // CellSpurs, CellSpursTaskset, context, etc.
constexpr u16 ATXDEC_SAMPLES_PER_FRAME = 0x800;
constexpr u16 ATXDEC_MAX_FRAME_LENGTH = 0x2000;
constexpr std::array<u8, 8> ATXDEC_NCH_BLOCKS_MAP = { 0, 1, 1, 2, 3, 4, 5, 5 };
// Expected output channel order
// - for 1 to 7 channels: Front Left, Center, Front Right, Rear Left, Rear Right, Rear Center, LFE
// - for 8 channels: Front Left, Front Right, Center, LFE, Rear Left, Rear Right, Side Left, Side Right
// FFmpeg output
// - ver <= 5.1.2: Front Left, Front Right, Center, Rear Left, Rear Right, Rear Center, Side Left, Side Right, LFE
// - ver >= 5.1.3: Front Left, Front Right, Center, LFE, Rear Left, Rear Right, Rear Center, Side Left, Side Right
constexpr u8 ATXDEC_AVCODEC_CH_MAP[7][8] =
{
{ 0 },
{ 0, 1 },
{ 0, 2, 1 },
{ 0, 2, 1, 3 },
#if LIBAVCODEC_VERSION_INT < AV_VERSION_INT(59, 51, 101)
{ 0, 2, 1, 3, 4, 5 },
{ 0, 2, 1, 3, 4, 5, 6 },
{ 0, 1, 2, 4, 5, 6, 7, 3 }
#else
{ 0, 2, 1, 4, 5, 3 },
{ 0, 2, 1, 4, 5, 6, 3 },
{ 0, 1, 2, 3, 4, 5, 6, 7 }
#endif
};
| 10,171
|
C++
|
.h
| 257
| 37.661479
| 166
| 0.688621
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,895
|
cellPngEnc.h
|
RPCS3_rpcs3/rpcs3/Emu/Cell/Modules/cellPngEnc.h
|
#pragma once
// Error Codes
enum CellPngEncError
{
CELL_PNGENC_ERROR_ARG = 0x80611291,
CELL_PNGENC_ERROR_SEQ = 0x80611292,
CELL_PNGENC_ERROR_BUSY = 0x80611293,
CELL_PNGENC_ERROR_EMPTY = 0x80611294,
CELL_PNGENC_ERROR_RESET = 0x80611295,
CELL_PNGENC_ERROR_FATAL = 0x80611296,
CELL_PNGENC_ERROR_STREAM_ABORT = 0x806112A1,
CELL_PNGENC_ERROR_STREAM_SKIP = 0x806112A2,
CELL_PNGENC_ERROR_STREAM_OVERFLOW = 0x806112A3,
CELL_PNGENC_ERROR_STREAM_FILE_OPEN = 0x806112A4,
};
enum CellPngEncColorSpace
{
CELL_PNGENC_COLOR_SPACE_GRAYSCALE = 1,
CELL_PNGENC_COLOR_SPACE_RGB = 2,
CELL_PNGENC_COLOR_SPACE_PALETTE = 4,
CELL_PNGENC_COLOR_SPACE_GRAYSCALE_ALPHA = 9,
CELL_PNGENC_COLOR_SPACE_RGBA = 10,
CELL_PNGENC_COLOR_SPACE_ARGB = 20
};
enum CellPngEncCompressionLevel
{
CELL_PNGENC_COMPR_LEVEL_0,
CELL_PNGENC_COMPR_LEVEL_1,
CELL_PNGENC_COMPR_LEVEL_2,
CELL_PNGENC_COMPR_LEVEL_3,
CELL_PNGENC_COMPR_LEVEL_4,
CELL_PNGENC_COMPR_LEVEL_5,
CELL_PNGENC_COMPR_LEVEL_6,
CELL_PNGENC_COMPR_LEVEL_7,
CELL_PNGENC_COMPR_LEVEL_8,
CELL_PNGENC_COMPR_LEVEL_9
};
enum CellPngEncFilterType
{
CELL_PNGENC_FILTER_TYPE_NONE = 0x08,
CELL_PNGENC_FILTER_TYPE_SUB = 0x10,
CELL_PNGENC_FILTER_TYPE_UP = 0x20,
CELL_PNGENC_FILTER_TYPE_AVG = 0x40,
CELL_PNGENC_FILTER_TYPE_PAETH = 0x80,
CELL_PNGENC_FILTER_TYPE_ALL = 0xF8
};
enum CellPngEncChunkType
{
CELL_PNGENC_CHUNK_TYPE_PLTE,
CELL_PNGENC_CHUNK_TYPE_TRNS,
CELL_PNGENC_CHUNK_TYPE_CHRM,
CELL_PNGENC_CHUNK_TYPE_GAMA,
CELL_PNGENC_CHUNK_TYPE_ICCP,
CELL_PNGENC_CHUNK_TYPE_SBIT,
CELL_PNGENC_CHUNK_TYPE_SRGB,
CELL_PNGENC_CHUNK_TYPE_TEXT,
CELL_PNGENC_CHUNK_TYPE_BKGD,
CELL_PNGENC_CHUNK_TYPE_HIST,
CELL_PNGENC_CHUNK_TYPE_PHYS,
CELL_PNGENC_CHUNK_TYPE_SPLT,
CELL_PNGENC_CHUNK_TYPE_TIME,
CELL_PNGENC_CHUNK_TYPE_OFFS,
CELL_PNGENC_CHUNK_TYPE_PCAL,
CELL_PNGENC_CHUNK_TYPE_SCAL,
CELL_PNGENC_CHUNK_TYPE_UNKNOWN
};
enum CellPngEncLocation
{
CELL_PNGENC_LOCATION_FILE,
CELL_PNGENC_LOCATION_BUFFER
};
//typedef void *CellPngEncHandle;
struct CellPngEncExParam // Size 8
{
be_t<s32> index;
vm::bptr<s32> value;
};
struct CellPngEncConfig // Size 28
{
be_t<u32> maxWidth;
be_t<u32> maxHeight;
be_t<u32> maxBitDepth;
b8 enableSpu;
u8 padding[3];
be_t<u32> addMemSize;
vm::bptr<CellPngEncExParam> exParamList;
be_t<u32> exParamNum;
};
struct CellPngEncAttr // Size 16
{
be_t<u32> memSize; // usz
u8 cmdQueueDepth;
u8 padding[3];
be_t<u32> versionUpper;
be_t<u32> versionLower;
};
struct CellPngEncResource // Size 16
{
vm::bptr<void> memAddr;
be_t<u32> memSize; // usz
be_t<s32> ppuThreadPriority;
be_t<s32> spuThreadPriority;
};
struct CellPngEncResourceEx // Size 24
{
vm::bptr<void> memAddr;
be_t<u32> memSize; // usz
be_t<s32> ppuThreadPriority;
vm::bptr<void> spurs; // CellSpurs
u8 priority[8];
};
struct CellPngEncPicture // Size 40
{
be_t<u32> width;
be_t<u32> height;
be_t<u32> pitchWidth;
be_t<u32> colorSpace; // CellPngEncColorSpace
be_t<u32> bitDepth;
b8 packedPixel;
u8 padding[3]; // TODO: is this correct?
vm::bptr<void> pictureAddr;
be_t<u64> userData;
};
struct CellPngEncAncillaryChunk // Size 8
{
be_t<u32> chunkType; // CellPngEncChunkType
vm::bptr<void> chunkData;
};
struct CellPngEncEncodeParam // Size 24
{
b8 enableSpu;
u8 padding[3];
be_t<u32> encodeColorSpace; // CellPngEncColorSpace
be_t<u32> compressionLevel; // CellPngEncCompressionLevel
be_t<u32> filterType;
vm::bptr<CellPngEncAncillaryChunk> ancillaryChunkList;
be_t<u32> ancillaryChunkNum;
};
struct CellPngEncOutputParam // Size 16
{
be_t<u32> location; // CellPngEncLocation
vm::bcptr<char> streamFileName;
vm::bptr<void> streamAddr;
be_t<u32> limitSize; // usz
};
struct CellPngEncStreamInfo // Size 40
{
be_t<s32> state;
be_t<u32> location; // CellPngEncLocation
vm::bcptr<char> streamFileName;
vm::bptr<void> streamAddr;
be_t<u32> limitSize; // usz
be_t<u32> streamSize; // usz
be_t<u32> processedLine;
be_t<u64> userData;
// TODO: where are the missing 4 bytes?
};
| 4,218
|
C++
|
.h
| 157
| 24.299363
| 58
| 0.717854
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,896
|
sys_crashdump.h
|
RPCS3_rpcs3/rpcs3/Emu/Cell/Modules/sys_crashdump.h
|
#pragma once
#include "Emu/Memory/vm_ptr.h"
enum
{
SYS_CRASH_DUMP_MAX_LABEL_SIZE = 16,
SYS_CRASH_DUMP_MAX_LOG_AREA = 127 // not actually defined in CELL
};
struct sys_crash_dump_log_area_info_t
{
char label[SYS_CRASH_DUMP_MAX_LABEL_SIZE]; // 15 + 1 (0 terminated)
vm::bptr<void> addr;
be_t<u32> size;
};
| 311
|
C++
|
.h
| 13
| 22.384615
| 68
| 0.716216
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,897
|
cellGcmSys.h
|
RPCS3_rpcs3/rpcs3/Emu/Cell/Modules/cellGcmSys.h
|
#pragma once
#include "Emu/RSX/GCM.h"
#include "Emu/Memory/vm_ptr.h"
enum CellGcmError : u32
{
CELL_GCM_ERROR_FAILURE = 0x802100ff,
CELL_GCM_ERROR_NO_IO_PAGE_TABLE = 0x80210001,
CELL_GCM_ERROR_INVALID_ENUM = 0x80210002,
CELL_GCM_ERROR_INVALID_VALUE = 0x80210003,
CELL_GCM_ERROR_INVALID_ALIGNMENT = 0x80210004,
CELL_GCM_ERROR_ADDRESS_OVERWRAP = 0x80210005,
};
struct CellGcmOffsetTable
{
vm::bptr<u16> ioAddress;
vm::bptr<u16> eaAddress;
};
struct gcm_config
{
u32 zculls_addr;
vm::ptr<CellGcmDisplayInfo> gcm_buffers = vm::null;
u32 tiles_addr;
u32 ctxt_addr;
CellGcmConfig current_config;
CellGcmContextData current_context;
gcmInfo gcm_info;
CellGcmOffsetTable offsetTable{};
u16 IoMapTable[0xC00]{};
shared_mutex gcmio_mutex;
u64 system_mode = 0;
u32 local_size = 0;
u32 local_addr = 0;
atomic_t<u32> reserved_size = 0;
};
void InitOffsetTable();
| 902
|
C++
|
.h
| 35
| 23.885714
| 52
| 0.752914
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,898
|
cellSync.h
|
RPCS3_rpcs3/rpcs3/Emu/Cell/Modules/cellSync.h
|
#pragma once
#include "Emu/Memory/vm_ptr.h"
#include "Utilities/BitField.h"
#include "Emu/Cell/ErrorCodes.h"
// Return Codes
enum CellSyncError : u32
{
CELL_SYNC_ERROR_AGAIN = 0x80410101,
CELL_SYNC_ERROR_INVAL = 0x80410102,
CELL_SYNC_ERROR_NOSYS = 0x80410103,
CELL_SYNC_ERROR_NOMEM = 0x80410104,
CELL_SYNC_ERROR_SRCH = 0x80410105,
CELL_SYNC_ERROR_NOENT = 0x80410106,
CELL_SYNC_ERROR_NOEXEC = 0x80410107,
CELL_SYNC_ERROR_DEADLK = 0x80410108,
CELL_SYNC_ERROR_PERM = 0x80410109,
CELL_SYNC_ERROR_BUSY = 0x8041010A,
CELL_SYNC_ERROR_ABORT = 0x8041010C,
CELL_SYNC_ERROR_FAULT = 0x8041010D,
CELL_SYNC_ERROR_CHILD = 0x8041010E,
CELL_SYNC_ERROR_STAT = 0x8041010F,
CELL_SYNC_ERROR_ALIGN = 0x80410110,
CELL_SYNC_ERROR_NULL_POINTER = 0x80410111,
CELL_SYNC_ERROR_NOT_SUPPORTED_THREAD = 0x80410112,
CELL_SYNC_ERROR_NO_NOTIFIER = 0x80410113,
CELL_SYNC_ERROR_NO_SPU_CONTEXT_STORAGE = 0x80410114,
};
enum CellSyncError1 : u32
{
CELL_SYNC_ERROR_SHOTAGE = 0x80410112,
CELL_SYNC_ERROR_UNKNOWNKEY = 0x80410113,
};
struct CellSyncMutex
{
struct Counter
{
be_t<u16> rel;
be_t<u16> acq;
auto lock_begin()
{
return acq++;
}
bool try_lock()
{
if (rel != acq) [[unlikely]]
{
return false;
}
acq++;
return true;
}
void unlock()
{
rel++;
}
};
atomic_t<Counter> ctrl;
};
CHECK_SIZE_ALIGN(CellSyncMutex, 4, 4);
struct CellSyncBarrier
{
struct alignas(4) ctrl_t
{
be_t<s16> value;
be_t<u16> count;
};
atomic_t<ctrl_t> ctrl;
static inline bool try_notify(ctrl_t& ctrl)
{
if (ctrl.value & 0x8000)
{
return false;
}
if (++ctrl.value == ctrl.count)
{
ctrl.value |= 0x8000;
}
return true;
}
static inline bool try_wait(ctrl_t& ctrl)
{
if ((ctrl.value & 0x8000) == 0)
{
return false;
}
if (--ctrl.value == -0x8000)
{
ctrl.value = 0;
}
return true;
}
};
CHECK_SIZE_ALIGN(CellSyncBarrier, 4, 4);
struct alignas(16) CellSyncRwm
{
struct alignas(4) ctrl_t
{
be_t<u16> readers;
be_t<u16> writers;
};
atomic_t<ctrl_t> ctrl;
be_t<u32> size;
vm::bptr<void, u64> buffer;
static inline bool try_read_begin(ctrl_t& ctrl)
{
if (ctrl.writers)
{
return false;
}
ctrl.readers++;
return true;
}
static inline bool try_read_end(ctrl_t& ctrl)
{
if (ctrl.readers == 0)
{
return false;
}
ctrl.readers--;
return true;
}
static inline bool try_write_begin(ctrl_t& ctrl)
{
if (ctrl.writers)
{
return false;
}
ctrl.writers = 1;
return true;
}
};
CHECK_SIZE_ALIGN(CellSyncRwm, 16, 16);
struct alignas(32) CellSyncQueue
{
struct ctrl_t
{
union
{
be_t<u32> x0;
bf_t<be_t<u32>, 0, 24> next;
bf_t<be_t<u32>, 24, 8> _pop;
};
union
{
be_t<u32> x4;
bf_t<be_t<u32>, 0, 24> count;
bf_t<be_t<u32>, 24, 8> _push;
};
};
atomic_t<ctrl_t> ctrl;
be_t<u32> size;
be_t<u32> depth;
vm::bptr<u8, u64> buffer;
be_t<u64> reserved;
u32 check_depth() const
{
const auto data = ctrl.load();
if (data.next > depth || data.count > depth)
{
fmt::throw_exception("Invalid queue pointers");
}
return depth;
}
static inline bool try_push_begin(ctrl_t& ctrl, u32 depth, u32* position)
{
const u32 count = ctrl.count;
if (ctrl._push || count + ctrl._pop >= depth)
{
return false;
}
*position = ctrl.next;
ctrl.next = *position + 1 != depth ? *position + 1 : 0;
ctrl.count = count + 1;
ctrl._push = 1;
return true;
}
static inline void push_end(ctrl_t& ctrl)
{
ctrl._push = 0;
}
static inline bool try_pop_begin(ctrl_t& ctrl, u32 depth, u32* position)
{
const u32 count = ctrl.count;
if (ctrl._pop || count <= ctrl._push)
{
return false;
}
ctrl._pop = 1;
*position = ctrl.next + depth - count;
ctrl.count = count - 1;
return true;
}
static inline bool try_peek_begin(ctrl_t& ctrl, u32 depth, u32* position)
{
const u32 count = ctrl.count;
if (ctrl._pop || count <= ctrl._push)
{
return false;
}
ctrl._pop = 1;
*position = ctrl.next + depth - count;
return true;
}
static inline void pop_end(ctrl_t& ctrl)
{
ctrl._pop = 0;
}
static inline bool try_clear_begin_1(ctrl_t& ctrl)
{
if (ctrl._pop)
{
return false;
}
ctrl._pop = 1;
return true;
}
static inline bool try_clear_begin_2(ctrl_t& ctrl)
{
if (ctrl._push)
{
return false;
}
ctrl._push = 1;
return true;
}
};
CHECK_SIZE_ALIGN(CellSyncQueue, 32, 32);
enum CellSyncQueueDirection : u32 // CellSyncLFQueueDirection
{
CELL_SYNC_QUEUE_SPU2SPU = 0, // SPU to SPU
CELL_SYNC_QUEUE_SPU2PPU = 1, // SPU to PPU
CELL_SYNC_QUEUE_PPU2SPU = 2, // PPU to SPU
CELL_SYNC_QUEUE_ANY2ANY = 3, // SPU/PPU to SPU/PPU
};
struct alignas(128) CellSyncLFQueue
{
struct pop1_t
{
be_t<u16> m_h1;
be_t<u16> m_h2;
be_t<u16> m_h3;
be_t<u16> m_h4;
};
struct pop2_t
{
be_t<u16> pack;
};
struct pop3_t
{
be_t<u16> m_h1;
be_t<u16> m_h2;
};
struct push1_t
{
be_t<u16> m_h5;
be_t<u16> m_h6;
be_t<u16> m_h7;
be_t<u16> m_h8;
};
struct push2_t
{
be_t<u16> pack;
};
struct push3_t
{
be_t<u16> m_h5;
be_t<u16> m_h6;
};
union // 0x0
{
atomic_t<pop1_t> pop1;
atomic_t<pop3_t> pop3;
};
union // 0x8
{
atomic_t<push1_t> push1;
atomic_t<push3_t> push3;
};
be_t<u32> m_size; // 0x10
be_t<u32> m_depth; // 0x14
vm::bcptr<void, u64> m_buffer; // 0x18
u8 m_bs[4]; // 0x20
be_t<u32> m_direction; // 0x24 CellSyncQueueDirection
be_t<u32> m_v1; // 0x28
atomic_be_t<s32> init; // 0x2C
atomic_t<push2_t> push2; // 0x30
be_t<u16> m_hs1[15]; // 0x32
atomic_t<pop2_t> pop2; // 0x50
be_t<u16> m_hs2[15]; // 0x52
vm::bptr<void, u64> m_eaSignal; // 0x70
be_t<u32> m_v2; // 0x78
be_t<u32> m_eq_id; // 0x7C
};
CHECK_SIZE_ALIGN(CellSyncLFQueue, 128, 128);
// Prototypes
error_code cellSyncLFQueueInitialize(vm::ptr<CellSyncLFQueue> queue, vm::cptr<void> buffer, u32 size, u32 depth, u32 direction, vm::ptr<void> eaSignal);
| 6,347
|
C++
|
.h
| 296
| 18.780405
| 152
| 0.614407
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,899
|
cellPng.h
|
RPCS3_rpcs3/rpcs3/Emu/Cell/Modules/cellPng.h
|
#pragma once
#include "Emu/Memory/vm_ptr.h"
enum CellPngTxtType : s32
{
CELL_PNG_TEXT = 0,
CELL_PNG_ZTXT = 1,
CELL_PNG_ITXT = 2,
};
enum CellPngUnknownLocation : s32
{
CELL_PNG_BEFORE_PLTE = 1,
CELL_PNG_BEFORE_IDAT = 2,
CELL_PNG_AFTER_IDAT = 8,
};
struct CellPngPLTEentry
{
u8 red;
u8 green;
u8 blue;
};
struct CellPngPaletteEntries
{
be_t<u16> red;
be_t<u16> green;
be_t<u16> blue;
be_t<u16> alpha;
be_t<u16> frequency;
};
struct CellPngSPLTentry
{
vm::bptr<char> paletteName;
u8 sampleDepth;
vm::bptr<CellPngPaletteEntries> paletteEntries;
be_t<u32> paletteEntriesNumber;
};
struct CellPngTextInfo
{
be_t<s32> txtType; // CellPngTxtType
vm::bptr<char> keyword;
vm::bptr<char> text;
be_t<u32> textLength;
vm::bptr<char> languageTag;
vm::bptr<char> translatedKeyword;
};
struct CellPngPLTE
{
be_t<u32> paletteEntriesNumber;
vm::bptr<CellPngPLTEentry> paletteEntries;
};
struct CellPngGAMA
{
be_t<double> gamma;
};
struct CellPngSRGB
{
be_t<u32> renderingIntent;
};
struct CellPngICCP
{
vm::bptr<char> profileName;
vm::bptr<char> profile;
be_t<u32> profileLength;
};
struct CellPngSBIT
{
be_t<u32> red;
be_t<u32> green;
be_t<u32> blue;
be_t<u32> gray;
be_t<u32> alpha;
};
struct CellPngTRNS
{
vm::bptr<char> alphaForPaletteIndex;
be_t<u32> alphaForPaletteIndexNumber;
be_t<u16> red;
be_t<u16> green;
be_t<u16> blue;
be_t<u16> gray;
};
struct CellPngHIST
{
vm::bptr<u16> histgramEntries;
be_t<u32> histgramEntriesNumber;
};
struct CellPngTIME
{
be_t<u16> year;
u8 month;
u8 day;
u8 hour;
u8 minute;
u8 second;
};
struct CellPngBKGD
{
u8 paletteIndex;
be_t<u32> red;
be_t<u32> green;
be_t<u32> blue;
be_t<u32> gray;
};
struct CellPngSPLT
{
vm::bptr<CellPngSPLTentry> sPLTentries;
be_t<u32> sPLTentriesNumber;
};
struct CellPngOFFS
{
be_t<s32> xPosition;
be_t<s32> yPosition;
be_t<u32> unitSpecifier;
};
struct CellPngPHYS
{
be_t<u32> xAxis;
be_t<u32> yAxis;
be_t<u32> unitSpecifier;
};
struct CellPngSCAL
{
be_t<u32> unitSpecifier;
be_t<double> pixelWidth;
be_t<double> pixelHeight;
};
struct CellPngCHRM
{
be_t<double> whitePointX;
be_t<double> whitePointY;
be_t<double> redX;
be_t<double> redY;
be_t<double> greenX;
be_t<double> greenY;
be_t<double> blueX;
be_t<double> blueY;
};
struct CellPngPCAL
{
vm::bptr<char> calibrationName;
be_t<s32> x0;
be_t<s32> x1;
be_t<u32> equationType;
be_t<u32> numberOfParameters;
vm::bptr<char> unitName;
vm::bpptr<char> parameter;
};
struct CellPngUnknownChunk
{
char chunkType[5];
vm::bptr<char> chunkData;
be_t<u32> length;
be_t<s32> location; // CellPngUnknownLocation
};
| 2,619
|
C++
|
.h
| 153
| 15.411765
| 48
| 0.747442
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,900
|
cellRec.h
|
RPCS3_rpcs3/rpcs3/Emu/Cell/Modules/cellRec.h
|
#pragma once
enum CellRecError : u32
{
CELL_REC_ERROR_OUT_OF_MEMORY = 0x8002c501,
CELL_REC_ERROR_FATAL = 0x8002c502,
CELL_REC_ERROR_INVALID_VALUE = 0x8002c503,
CELL_REC_ERROR_FILE_OPEN = 0x8002c504,
CELL_REC_ERROR_FILE_WRITE = 0x8002c505,
CELL_REC_ERROR_INVALID_STATE = 0x8002c506,
CELL_REC_ERROR_FILE_NO_DATA = 0x8002c507
};
enum
{
CELL_REC_STATUS_UNLOAD = 0,
CELL_REC_STATUS_OPEN = 1,
CELL_REC_STATUS_START = 2,
CELL_REC_STATUS_STOP = 3,
CELL_REC_STATUS_CLOSE = 4,
CELL_REC_STATUS_ERR = 10
};
enum
{
CELL_REC_MIN_MEMORY_CONTAINER_SIZE = 0,
CELL_REC_MAX_MEMORY_CONTAINER_SIZE = 16 * 1024 * 1024, // 9 * 1024 * 1024 if SDK < 0x300000
CELL_REC_MAX_PATH_LEN = 1023,
};
enum
{
CELL_REC_PARAM_PPU_THREAD_PRIORITY_DEFAULT = 400,
CELL_REC_PARAM_SPU_THREAD_PRIORITY_DEFAULT = 60,
CELL_REC_PARAM_CAPTURE_PRIORITY_HIGHEST = 0,
CELL_REC_PARAM_CAPTURE_PRIORITY_EXCEPT_NOTIFICATION = 1,
CELL_REC_PARAM_CAPTURE_PRIORITY_GAME_SCREEN = 2,
CELL_REC_PARAM_USE_SYSTEM_SPU_DISABLE = 0,
CELL_REC_PARAM_USE_SYSTEM_SPU_ENABLE = 1,
CELL_REC_PARAM_XMB_BGM_DISABLE = 0,
CELL_REC_PARAM_XMB_BGM_ENABLE = 1,
CELL_REC_PARAM_MPEG4_FAST_ENCODE_DISABLE = 0,
CELL_REC_PARAM_MPEG4_FAST_ENCODE_ENABLE = 1,
CELL_REC_PARAM_VIDEO_INPUT_DISABLE = 0,
CELL_REC_PARAM_VIDEO_INPUT_ARGB_4_3 = 1,
CELL_REC_PARAM_VIDEO_INPUT_ARGB_16_9 = 2,
CELL_REC_PARAM_VIDEO_INPUT_RGBA_4_3 = 3,
CELL_REC_PARAM_VIDEO_INPUT_RGBA_16_9 = 4,
CELL_REC_PARAM_VIDEO_INPUT_YUV420PLANAR_16_9 = 5,
CELL_REC_PARAM_AUDIO_INPUT_DISABLE = 0,
CELL_REC_PARAM_AUDIO_INPUT_ENABLE = 1,
CELL_REC_PARAM_AUDIO_INPUT_MIX_VOL_MIN = 0,
CELL_REC_PARAM_AUDIO_INPUT_MIX_VOL_MAX = 100,
CELL_REC_PARAM_REDUCE_MEMSIZE_DISABLE = 0,
CELL_REC_PARAM_REDUCE_MEMSIZE_ENABLE = 1,
// SMALL = 320x240 (4:3) or 368x208 (16:9)
// MIDDLE = 368x272 (4:3) or 480x272 (16:9)
// LARGE = 480x368 (4:3) or 640x368 (16:9)
// HD720 = 1280x720 (16:9)
// PS3 playable format; all
// PSP playable format: MPEG4 + SMALL, AVC + SMALL, AVC + MIDDLE
CELL_REC_PARAM_VIDEO_FMT_MPEG4_SMALL_512K_30FPS = 0x0000,
CELL_REC_PARAM_VIDEO_FMT_MPEG4_SMALL_768K_30FPS = 0x0010,
CELL_REC_PARAM_VIDEO_FMT_MPEG4_MIDDLE_512K_30FPS = 0x0100,
CELL_REC_PARAM_VIDEO_FMT_MPEG4_MIDDLE_768K_30FPS = 0x0110,
CELL_REC_PARAM_VIDEO_FMT_MPEG4_LARGE_512K_30FPS = 0x0200,
CELL_REC_PARAM_VIDEO_FMT_MPEG4_LARGE_768K_30FPS = 0x0210,
CELL_REC_PARAM_VIDEO_FMT_MPEG4_LARGE_1024K_30FPS = 0x0220,
CELL_REC_PARAM_VIDEO_FMT_MPEG4_LARGE_1536K_30FPS = 0x0230,
CELL_REC_PARAM_VIDEO_FMT_MPEG4_LARGE_2048K_30FPS = 0x0240,
CELL_REC_PARAM_VIDEO_FMT_AVC_MP_SMALL_512K_30FPS = 0x1000,
CELL_REC_PARAM_VIDEO_FMT_AVC_MP_SMALL_768K_30FPS = 0x1010,
CELL_REC_PARAM_VIDEO_FMT_AVC_MP_MIDDLE_512K_30FPS = 0x1100,
CELL_REC_PARAM_VIDEO_FMT_AVC_MP_MIDDLE_768K_30FPS = 0x1110,
CELL_REC_PARAM_VIDEO_FMT_AVC_MP_MIDDLE_1024K_30FPS = 0x1120,
CELL_REC_PARAM_VIDEO_FMT_AVC_MP_MIDDLE_1536K_30FPS = 0x1130,
CELL_REC_PARAM_VIDEO_FMT_AVC_BL_SMALL_512K_30FPS = 0x2000,
CELL_REC_PARAM_VIDEO_FMT_AVC_BL_SMALL_768K_30FPS = 0x2010,
CELL_REC_PARAM_VIDEO_FMT_AVC_BL_MIDDLE_512K_30FPS = 0x2100,
CELL_REC_PARAM_VIDEO_FMT_AVC_BL_MIDDLE_768K_30FPS = 0x2110,
CELL_REC_PARAM_VIDEO_FMT_AVC_BL_MIDDLE_1024K_30FPS = 0x2120,
CELL_REC_PARAM_VIDEO_FMT_AVC_BL_MIDDLE_1536K_30FPS = 0x2130,
CELL_REC_PARAM_VIDEO_FMT_MJPEG_SMALL_5000K_30FPS = 0x3060,
CELL_REC_PARAM_VIDEO_FMT_MJPEG_MIDDLE_5000K_30FPS = 0x3160,
CELL_REC_PARAM_VIDEO_FMT_MJPEG_LARGE_11000K_30FPS = 0x3270,
CELL_REC_PARAM_VIDEO_FMT_MJPEG_HD720_11000K_30FPS = 0x3670,
CELL_REC_PARAM_VIDEO_FMT_MJPEG_HD720_20000K_30FPS = 0x3680,
CELL_REC_PARAM_VIDEO_FMT_MJPEG_HD720_25000K_30FPS = 0x3690,
CELL_REC_PARAM_VIDEO_FMT_M4HD_SMALL_768K_30FPS = 0x4010,
CELL_REC_PARAM_VIDEO_FMT_M4HD_MIDDLE_768K_30FPS = 0x4110,
CELL_REC_PARAM_VIDEO_FMT_M4HD_LARGE_1536K_30FPS = 0x4230,
CELL_REC_PARAM_VIDEO_FMT_M4HD_LARGE_2048K_30FPS = 0x4240,
CELL_REC_PARAM_VIDEO_FMT_M4HD_HD720_2048K_30FPS = 0x4640,
CELL_REC_PARAM_VIDEO_FMT_M4HD_HD720_5000K_30FPS = 0x4660,
CELL_REC_PARAM_VIDEO_FMT_M4HD_HD720_11000K_30FPS = 0x4670,
CELL_REC_PARAM_AUDIO_FMT_AAC_96K = 0x0000,
CELL_REC_PARAM_AUDIO_FMT_AAC_128K = 0x0001,
CELL_REC_PARAM_AUDIO_FMT_AAC_64K = 0x0002,
CELL_REC_PARAM_AUDIO_FMT_ULAW_384K = 0x1007,
CELL_REC_PARAM_AUDIO_FMT_ULAW_768K = 0x1008,
CELL_REC_PARAM_AUDIO_FMT_PCM_384K = 0x2007,
CELL_REC_PARAM_AUDIO_FMT_PCM_768K = 0x2008,
CELL_REC_PARAM_AUDIO_FMT_PCM_1536K = 0x2009,
CELL_REC_PARAM_VIDEO_FMT_YOUTUBE = 0x0310,
CELL_REC_PARAM_VIDEO_FMT_YOUTUBE_LARGE = CELL_REC_PARAM_VIDEO_FMT_MPEG4_LARGE_2048K_30FPS,
CELL_REC_PARAM_VIDEO_FMT_YOUTUBE_HD720 = CELL_REC_PARAM_VIDEO_FMT_M4HD_HD720_5000K_30FPS,
CELL_REC_PARAM_AUDIO_FMT_YOUTUBE = CELL_REC_PARAM_AUDIO_FMT_AAC_64K,
CELL_REC_PARAM_VIDEO_FMT_YOUTUBE_MJPEG = CELL_REC_PARAM_VIDEO_FMT_MJPEG_HD720_11000K_30FPS,
CELL_REC_PARAM_AUDIO_FMT_YOUTUBE_MJPEG = CELL_REC_PARAM_AUDIO_FMT_PCM_768K,
CELL_REC_AUDIO_BLOCK_SAMPLES = 256,
};
enum
{
CELL_REC_INFO_VIDEO_INPUT_ADDR = 0,
CELL_REC_INFO_VIDEO_INPUT_WIDTH = 1,
CELL_REC_INFO_VIDEO_INPUT_PITCH = 2,
CELL_REC_INFO_VIDEO_INPUT_HEIGHT = 3,
CELL_REC_INFO_AUDIO_INPUT_ADDR = 4,
CELL_REC_INFO_MOVIE_TIME_MSEC = 5,
CELL_REC_INFO_SPURS_SYSTEMWORKLOAD_ID = 6,
};
enum
{
CELL_REC_SETINFO_MOVIE_START_TIME_MSEC = 100,
CELL_REC_SETINFO_MOVIE_END_TIME_MSEC = 101,
CELL_REC_SETINFO_MOVIE_META = 200,
CELL_REC_SETINFO_SCENE_META = 201,
CELL_REC_MOVIE_META_GAME_TITLE_LEN = 128,
CELL_REC_MOVIE_META_MOVIE_TITLE_LEN = 128,
CELL_REC_MOVIE_META_DESCRIPTION_LEN = 384,
CELL_REC_MOVIE_META_USERDATA_LEN = 64,
CELL_REC_SCENE_META_TYPE_CHAPTER = 0,
CELL_REC_SCENE_META_TYPE_CLIP_HIGHLIGHT = 1,
CELL_REC_SCENE_META_TYPE_CLIP_USER = 2,
CELL_REC_SCENE_META_TITLE_LEN = 128,
CELL_REC_SCENE_META_TAG_NUM = 6,
CELL_REC_SCENE_META_TAG_LEN = 64,
};
enum
{
CELL_REC_OPTION_PPU_THREAD_PRIORITY = 1,
CELL_REC_OPTION_SPU_THREAD_PRIORITY = 2,
CELL_REC_OPTION_CAPTURE_PRIORITY = 3,
CELL_REC_OPTION_USE_SYSTEM_SPU = 4,
CELL_REC_OPTION_FIT_TO_YOUTUBE = 5,
CELL_REC_OPTION_XMB_BGM = 6,
CELL_REC_OPTION_RING_SEC = 7,
CELL_REC_OPTION_MPEG4_FAST_ENCODE = 8,
CELL_REC_OPTION_VIDEO_INPUT = 9,
CELL_REC_OPTION_AUDIO_INPUT = 10,
CELL_REC_OPTION_AUDIO_INPUT_MIX_VOL = 11,
CELL_REC_OPTION_REDUCE_MEMSIZE = 12,
CELL_REC_OPTION_SHOW_XMB = 13,
CELL_REC_OPTION_METADATA_FILENAME = 14,
CELL_REC_OPTION_SPURS = 15,
};
struct CellRecSpursParam
{
vm::bptr<struct CellSpurs> pSpurs;
be_t<s32> spu_usage_rate;
u8 priority[8];
};
struct CellRecOption
{
be_t<s32> option;
union
{
be_t<s32> ppu_thread_priority; // CELL_REC_OPTION_PPU_THREAD_PRIORITY
be_t<s32> spu_thread_priority; // CELL_REC_OPTION_SPU_THREAD_PRIORITY
be_t<s32> capture_priority; // CELL_REC_OPTION_CAPTURE_PRIORITY
be_t<s32> use_system_spu; // CELL_REC_OPTION_USE_SYSTEM_SPU
be_t<s32> fit_to_youtube; // CELL_REC_OPTION_FIT_TO_YOUTUBE
be_t<s32> xmb_bgm; // CELL_REC_OPTION_XMB_BGM
be_t<s32> mpeg4_fast_encode; // CELL_REC_OPTION_MPEG4_FAST_ENCODE
be_t<u32> ring_sec; // CELL_REC_OPTION_RING_SEC
be_t<s32> video_input; // CELL_REC_OPTION_VIDEO_INPUT
be_t<s32> audio_input; // CELL_REC_OPTION_AUDIO_INPUT
be_t<s32> audio_input_mix_vol; // CELL_REC_OPTION_AUDIO_INPUT_MIX_VOL
be_t<s32> reduce_memsize; // CELL_REC_OPTION_REDUCE_MEMSIZE
be_t<s32> show_xmb; // CELL_REC_OPTION_SHOW_XMB
vm::bptr<char> metadata_filename; // CELL_REC_OPTION_METADATA_FILENAME
vm::bptr<CellRecSpursParam> pSpursParam; // CELL_REC_OPTION_SPURS
be_t<u64> dummy; // -
} value;
};
struct CellRecParam
{
be_t<s32> videoFmt;
be_t<s32> audioFmt;
be_t<s32> numOfOpt;
vm::bptr<CellRecOption> pOpt;
};
struct CellRecMovieMetadata
{
vm::bptr<char> gameTitle;
vm::bptr<char> movieTitle;
vm::bptr<char> description;
vm::bptr<char> userdata;
};
struct CellRecSceneMetadata
{
be_t<u32> type;
be_t<u64> startTime;
be_t<u64> endTime;
u8 unk[4]; // NOTE: there seems to be undocumented padding
vm::bptr<char> title;
be_t<u32> tagNum;
vm::bpptr<char> tag;
};
using CellRecCallback = void(s32 recStatus, s32 recError, vm::ptr<void> userdata);
| 8,594
|
C++
|
.h
| 206
| 39.640777
| 92
| 0.696647
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,901
|
cellMusicDecode.h
|
RPCS3_rpcs3/rpcs3/Emu/Cell/Modules/cellMusicDecode.h
|
#pragma once
// Return Codes (CELL_MUSIC_DECODE2 codes are omitted if they are identical)
enum CellMusicDecodeError : u32
{
CELL_MUSIC_DECODE_CANCELED = 1,
CELL_MUSIC_DECODE_DECODE_FINISHED = 0x8002C101,
CELL_MUSIC_DECODE_ERROR_PARAM = 0x8002C102,
CELL_MUSIC_DECODE_ERROR_BUSY = 0x8002C103,
CELL_MUSIC_DECODE_ERROR_NO_ACTIVE_CONTENT = 0x8002C104,
CELL_MUSIC_DECODE_ERROR_NO_MATCH_FOUND = 0x8002C105,
CELL_MUSIC_DECODE_ERROR_INVALID_CONTEXT = 0x8002C106,
CELL_MUSIC_DECODE_ERROR_DECODE_FAILURE = 0x8002C107,
CELL_MUSIC_DECODE_ERROR_NO_MORE_CONTENT = 0x8002C108,
CELL_MUSIC_DECODE_DIALOG_OPEN = 0x8002C109,
CELL_MUSIC_DECODE_DIALOG_CLOSE = 0x8002C10A,
CELL_MUSIC_DECODE_ERROR_NO_LPCM_DATA = 0x8002C10B,
CELL_MUSIC_DECODE_NEXT_CONTENTS_READY = 0x8002C10C,
CELL_MUSIC_DECODE_ERROR_GENERIC = 0x8002C1FF,
};
// Constants (CELL_MUSIC_DECODE2 codes are omitted if they are identical)
enum
{
CELL_MUSIC_DECODE_EVENT_STATUS_NOTIFICATION = 0,
CELL_MUSIC_DECODE_EVENT_INITIALIZE_RESULT = 1,
CELL_MUSIC_DECODE_EVENT_FINALIZE_RESULT = 2,
CELL_MUSIC_DECODE_EVENT_SELECT_CONTENTS_RESULT = 3,
CELL_MUSIC_DECODE_EVENT_SET_DECODE_COMMAND_RESULT = 4,
CELL_MUSIC_DECODE_EVENT_SET_SELECTION_CONTEXT_RESULT = 5,
CELL_MUSIC_DECODE_EVENT_UI_NOTIFICATION = 6,
CELL_MUSIC_DECODE_EVENT_NEXT_CONTENTS_READY_RESULT = 7,
CELL_MUSIC_DECODE_MODE_NORMAL = 0,
CELL_MUSIC_DECODE_CMD_STOP = 0,
CELL_MUSIC_DECODE_CMD_START = 1,
CELL_MUSIC_DECODE_CMD_NEXT = 2,
CELL_MUSIC_DECODE_CMD_PREV = 3,
CELL_MUSIC_DECODE_STATUS_DORMANT = 0,
CELL_MUSIC_DECODE_STATUS_DECODING = 1,
CELL_MUSIC_DECODE_POSITION_NONE = 0,
CELL_MUSIC_DECODE_POSITION_START = 1,
CELL_MUSIC_DECODE_POSITION_MID = 2,
CELL_MUSIC_DECODE_POSITION_END = 3,
CELL_MUSIC_DECODE_POSITION_END_LIST_END = 4,
CELL_MUSIC_DECODE2_MODE_NORMAL = 0,
CELL_MUSIC_DECODE2_SPEED_MAX = 0,
CELL_MUSIC_DECODE2_SPEED_2 = 2,
CELL_SYSUTIL_MUSIC_DECODE2_INITIALIZING_FINISHED = 1,
CELL_SYSUTIL_MUSIC_DECODE2_SHUTDOWN_FINISHED = 4, // 3(SDK103) -> 4(SDK110)
CELL_SYSUTIL_MUSIC_DECODE2_LOADING_FINISHED = 5,
CELL_SYSUTIL_MUSIC_DECODE2_UNLOADING_FINISHED = 7,
CELL_SYSUTIL_MUSIC_DECODE2_RELEASED = 9,
CELL_SYSUTIL_MUSIC_DECODE2_GRABBED = 11,
CELL_MUSIC_DECODE2_MIN_BUFFER_SIZE = 448 * 1024,
CELL_MUSIC_DECODE2_MANAGEMENT_SIZE = 64 * 1024,
CELL_MUSIC_DECODE2_PAGESIZE_64K = 64 * 1024,
CELL_MUSIC_DECODE2_PAGESIZE_1M = 1 * 1024 * 1024,
};
using CellMusicDecodeCallback = void(u32, vm::ptr<void> param, vm::ptr<void> userData);
using CellMusicDecode2Callback = void(u32, vm::ptr<void> param, vm::ptr<void> userData);
| 2,752
|
C++
|
.h
| 58
| 45.448276
| 88
| 0.719717
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,902
|
cellVpost.h
|
RPCS3_rpcs3/rpcs3/Emu/Cell/Modules/cellVpost.h
|
#pragma once
#ifdef _MSC_VER
#pragma warning(push, 0)
#else
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wall"
#pragma GCC diagnostic ignored "-Wextra"
#pragma GCC diagnostic ignored "-Wold-style-cast"
#endif
extern "C"
{
#include "libswscale/swscale.h"
}
#ifdef _MSC_VER
#pragma warning(pop)
#else
#pragma GCC diagnostic pop
#endif
// Error Codes
enum CellVpostError : u32
{
CELL_VPOST_ERROR_Q_ARG_CFG_NULL = 0x80610410,
CELL_VPOST_ERROR_Q_ARG_CFG_INVALID = 0x80610411,
CELL_VPOST_ERROR_Q_ARG_ATTR_NULL = 0x80610412,
CELL_VPOST_ERROR_O_ARG_CFG_NULL = 0x80610440,
CELL_VPOST_ERROR_O_ARG_CFG_INVALID = 0x80610441,
CELL_VPOST_ERROR_O_ARG_RSRC_NULL = 0x80610442,
CELL_VPOST_ERROR_O_ARG_RSRC_INVALID = 0x80610443,
CELL_VPOST_ERROR_O_ARG_HDL_NULL = 0x80610444,
CELL_VPOST_ERROR_O_FATAL_QUERY_FAIL = 0x80610460,
CELL_VPOST_ERROR_O_FATAL_CREATEMON_FAIL = 0x80610461,
CELL_VPOST_ERROR_O_FATAL_INITSPURS_FAIL = 0x80610462,
CELL_VPOST_ERROR_C_ARG_HDL_NULL = 0x80610470,
CELL_VPOST_ERROR_C_ARG_HDL_INVALID = 0x80610471,
CELL_VPOST_ERROR_C_FATAL_LOCKMON_FAIL = 0x80610490,
CELL_VPOST_ERROR_C_FATAL_UNLOCKMON_FAIL = 0x80610491,
CELL_VPOST_ERROR_C_FATAL_DESTROYMON_FAIL = 0x80610492,
CELL_VPOST_ERROR_C_FATAL_FINSPURS_FAIL = 0x80610463,
CELL_VPOST_ERROR_E_ARG_HDL_NULL = 0x806104a0,
CELL_VPOST_ERROR_E_ARG_HDL_INVALID = 0x806104a1,
CELL_VPOST_ERROR_E_ARG_INPICBUF_NULL = 0x806104a2,
CELL_VPOST_ERROR_E_ARG_INPICBUF_INVALID = 0x806104a3,
CELL_VPOST_ERROR_E_ARG_CTRL_NULL = 0x806104a4,
CELL_VPOST_ERROR_E_ARG_CTRL_INVALID = 0x806104a5,
CELL_VPOST_ERROR_E_ARG_OUTPICBUF_NULL = 0x806104a6,
CELL_VPOST_ERROR_E_ARG_OUTPICBUF_INVALID = 0x806104a7,
CELL_VPOST_ERROR_E_ARG_PICINFO_NULL = 0x806104a8,
CELL_VPOST_ERROR_E_FATAL_LOCKMON_FAIL = 0x806104c0,
CELL_VPOST_ERROR_E_FATAL_UNLOCKMON_FAIL = 0x806104c1,
CELL_VPOST_ENT_ERROR_Q_ARG_ATTR_NULL = 0x80618110,
CELL_VPOST_ENT_ERROR_O_ARG_RSRC_NULL = 0x80618140,
CELL_VPOST_ENT_ERROR_O_ARG_RSRC_INVALID = 0x80618141,
CELL_VPOST_ENT_ERROR_O_ARG_HDL_NULL = 0x80618142,
CELL_VPOST_ENT_ERROR_O_FATAL_QUERY_FAIL = 0x80618160,
CELL_VPOST_ENT_ERROR_O_FATAL_CSPUCORE_FAIL = 0x80618161,
CELL_VPOST_ENT_ERROR_C_ARG_HDL_NULL = 0x80618170,
CELL_VPOST_ENT_ERROR_C_ARG_HDL_INVALID = 0x80618171,
CELL_VPOST_ENT_ERROR_C_FATAL_SNDCMD_FAIL = 0x80618190,
CELL_VPOST_ENT_ERROR_C_FATAL_RCVRES_FAIL = 0x80618191,
CELL_VPOST_ENT_ERROR_C_FATAL_DSPUCORE_FAIL = 0x80618192,
CELL_VPOST_ENT_ERROR_E_ARG_HDL_NULL = 0x806181a0,
CELL_VPOST_ENT_ERROR_E_ARG_HDL_INVALID = 0x806181a1,
CELL_VPOST_ENT_ERROR_E_ARG_INPICBUF_NULL = 0x806181a2,
CELL_VPOST_ENT_ERROR_E_ARG_INPICBUF_INVALID = 0x806181a3,
CELL_VPOST_ENT_ERROR_E_ARG_INPICINFO_NULL = 0x806181a4,
CELL_VPOST_ENT_ERROR_E_ARG_INPICINFO_INVALID = 0x806181a5,
CELL_VPOST_ENT_ERROR_E_ARG_CTRL_NULL = 0x806181a6,
CELL_VPOST_ENT_ERROR_E_ARG_CTRL_INVALID = 0x806181a7,
CELL_VPOST_ENT_ERROR_E_ARG_COMB_INVALID = 0x806181a8,
CELL_VPOST_ENT_ERROR_E_ARG_OUTPICBUF_NULL = 0x806181a9,
CELL_VPOST_ENT_ERROR_E_ARG_OUTPICBUF_INVALID = 0x806181aa,
CELL_VPOST_ENT_ERROR_E_ARG_OUTPICINFO_NULL = 0x806181ab,
CELL_VPOST_ENT_ERROR_E_FATAL_SNDCMD_FAIL = 0x806181c0,
CELL_VPOST_ENT_ERROR_E_FATAL_RCVRES_FAIL = 0x806181c1,
CELL_VPOST_ENT_ERROR_E_FATAL_SPUCORE_FAIL = 0x806181c2,
CELL_VPOST_IPC_ERROR_Q_ARG_ATTR_NULL = 0x80618210,
CELL_VPOST_IPC_ERROR_O_ARG_RSRC_NULL = 0x80618240,
CELL_VPOST_IPC_ERROR_O_ARG_RSRC_INVALID = 0x80618241,
CELL_VPOST_IPC_ERROR_O_ARG_HDL_NULL = 0x80618242,
CELL_VPOST_IPC_ERROR_O_FATAL_QUERY_FAIL = 0x80618260,
CELL_VPOST_IPC_ERROR_O_FATAL_CSPUCORE_FAIL = 0x80618261,
CELL_VPOST_IPC_ERROR_C_ARG_HDL_NULL = 0x80618270,
CELL_VPOST_IPC_ERROR_C_ARG_HDL_INVALID = 0x80618271,
CELL_VPOST_IPC_ERROR_C_FATAL_SNDCMD_FAIL = 0x80618290,
CELL_VPOST_IPC_ERROR_C_FATAL_RCVRES_FAIL = 0x80618291,
CELL_VPOST_IPC_ERROR_C_FATAL_DSPUCORE_FAIL = 0x80618292,
CELL_VPOST_IPC_ERROR_E_ARG_HDL_NULL = 0x806182a0,
CELL_VPOST_IPC_ERROR_E_ARG_HDL_INVALID = 0x806182a1,
CELL_VPOST_IPC_ERROR_E_ARG_INPICBUF_NULL = 0x806182a2,
CELL_VPOST_IPC_ERROR_E_ARG_INPICBUF_INVALID = 0x806182a3,
CELL_VPOST_IPC_ERROR_E_ARG_INPICINFO_NULL = 0x806182a4,
CELL_VPOST_IPC_ERROR_E_ARG_INPICINFO_INVALID = 0x806182a5,
CELL_VPOST_IPC_ERROR_E_ARG_CTRL_NULL = 0x806182a6,
CELL_VPOST_IPC_ERROR_E_ARG_CTRL_INVALID = 0x806182a7,
CELL_VPOST_IPC_ERROR_E_ARG_COMB_INVALID = 0x806182a8,
CELL_VPOST_IPC_ERROR_E_ARG_OUTPICBUF_NULL = 0x806182a9,
CELL_VPOST_IPC_ERROR_E_ARG_OUTPICBUF_INVALID = 0x806182aa,
CELL_VPOST_IPC_ERROR_E_ARG_OUTPICINFO_NULL = 0x806182ab,
CELL_VPOST_IPC_ERROR_E_FATAL_SNDCMD_FAIL = 0x806182c0,
CELL_VPOST_IPC_ERROR_E_FATAL_RCVRES_FAIL = 0x806182c1,
CELL_VPOST_IPC_ERROR_E_FATAL_SPUCORE_FAIL = 0x806182c2,
CELL_VPOST_VSC_ERROR_Q_ARG_ATTR_NULL = 0x80618310,
CELL_VPOST_VSC_ERROR_O_ARG_RSRC_NULL = 0x80618340,
CELL_VPOST_VSC_ERROR_O_ARG_RSRC_INVALID = 0x80618341,
CELL_VPOST_VSC_ERROR_O_ARG_HDL_NULL = 0x80618342,
CELL_VPOST_VSC_ERROR_O_FATAL_QUERY_FAIL = 0x80618360,
CELL_VPOST_VSC_ERROR_O_FATAL_CSPUCORE_FAIL = 0x80618361,
CELL_VPOST_VSC_ERROR_C_ARG_HDL_NULL = 0x80618370,
CELL_VPOST_VSC_ERROR_C_ARG_HDL_INVALID = 0x80618371,
CELL_VPOST_VSC_ERROR_C_FATAL_SNDCMD_FAIL = 0x80618390,
CELL_VPOST_VSC_ERROR_C_FATAL_RCVRES_FAIL = 0x80618391,
CELL_VPOST_VSC_ERROR_C_FATAL_DSPUCORE_FAIL = 0x80618392,
CELL_VPOST_VSC_ERROR_E_ARG_HDL_NULL = 0x806183a0,
CELL_VPOST_VSC_ERROR_E_ARG_HDL_INVALID = 0x806183a1,
CELL_VPOST_VSC_ERROR_E_ARG_INPICBUF_NULL = 0x806183a2,
CELL_VPOST_VSC_ERROR_E_ARG_INPICBUF_INVALID = 0x806183a3,
CELL_VPOST_VSC_ERROR_E_ARG_INPICINFO_NULL = 0x806183a4,
CELL_VPOST_VSC_ERROR_E_ARG_INPICINFO_INVALID = 0x806183a5,
CELL_VPOST_VSC_ERROR_E_ARG_CTRL_NULL = 0x806183a6,
CELL_VPOST_VSC_ERROR_E_ARG_CTRL_INVALID = 0x806183a7,
CELL_VPOST_VSC_ERROR_E_ARG_COMB_INVALID = 0x806183a8,
CELL_VPOST_VSC_ERROR_E_ARG_OUTPICBUF_NULL = 0x806183a9,
CELL_VPOST_VSC_ERROR_E_ARG_OUTPICBUF_INVALID = 0x806183aa,
CELL_VPOST_VSC_ERROR_E_ARG_OUTPICINFO_NULL = 0x806183ab,
CELL_VPOST_VSC_ERROR_E_FATAL_SNDCMD_FAIL = 0x806183c0,
CELL_VPOST_VSC_ERROR_E_FATAL_RCVRES_FAIL = 0x806183c1,
CELL_VPOST_VSC_ERROR_E_FATAL_SPUCORE_FAIL = 0x806183c2,
CELL_VPOST_CSC_ERROR_Q_ARG_ATTR_NULL = 0x80618410,
CELL_VPOST_CSC_ERROR_O_ARG_RSRC_NULL = 0x80618440,
CELL_VPOST_CSC_ERROR_O_ARG_RSRC_INVALID = 0x80618441,
CELL_VPOST_CSC_ERROR_O_ARG_HDL_NULL = 0x80618442,
CELL_VPOST_CSC_ERROR_O_FATAL_QUERY_FAIL = 0x80618460,
CELL_VPOST_CSC_ERROR_O_FATAL_CSPUCORE_FAIL = 0x80618461,
CELL_VPOST_CSC_ERROR_C_ARG_HDL_NULL = 0x80618470,
CELL_VPOST_CSC_ERROR_C_ARG_HDL_INVALID = 0x80618471,
CELL_VPOST_CSC_ERROR_C_FATAL_SNDCMD_FAIL = 0x80618490,
CELL_VPOST_CSC_ERROR_C_FATAL_RCVRES_FAIL = 0x80618491,
CELL_VPOST_CSC_ERROR_C_FATAL_DSPUCORE_FAIL = 0x80618492,
CELL_VPOST_CSC_ERROR_E_ARG_HDL_NULL = 0x806184a0,
CELL_VPOST_CSC_ERROR_E_ARG_HDL_INVALID = 0x806184a1,
CELL_VPOST_CSC_ERROR_E_ARG_INPICBUF_NULL = 0x806184a2,
CELL_VPOST_CSC_ERROR_E_ARG_INPICBUF_INVALID = 0x806184a3,
CELL_VPOST_CSC_ERROR_E_ARG_INPICINFO_NULL = 0x806184a4,
CELL_VPOST_CSC_ERROR_E_ARG_INPICINFO_INVALID = 0x806184a5,
CELL_VPOST_CSC_ERROR_E_ARG_CTRL_NULL = 0x806184a6,
CELL_VPOST_CSC_ERROR_E_ARG_CTRL_INVALID = 0x806184a7,
CELL_VPOST_CSC_ERROR_E_ARG_COMB_INVALID = 0x806184a8,
CELL_VPOST_CSC_ERROR_E_ARG_OUTPICBUF_NULL = 0x806184a9,
CELL_VPOST_CSC_ERROR_E_ARG_OUTPICBUF_INVALID = 0x806184aa,
CELL_VPOST_CSC_ERROR_E_ARG_OUTPICINFO_NULL = 0x806184ab,
CELL_VPOST_CSC_ERROR_E_FATAL_SNDCMD_FAIL = 0x806184c0,
CELL_VPOST_CSC_ERROR_E_FATAL_RCVRES_FAIL = 0x806184c1,
CELL_VPOST_CSC_ERROR_E_FATAL_SPUCORE_FAIL = 0x806184c2,
};
enum CellVpostPictureDepth : s32
{
CELL_VPOST_PIC_DEPTH_8,
};
enum CellVpostPictureFormatIn : s32
{
CELL_VPOST_PIC_FMT_IN_YUV420_PLANAR,
};
enum CellVpostPictureFormatOut : s32
{
CELL_VPOST_PIC_FMT_OUT_RGBA_ILV,
CELL_VPOST_PIC_FMT_OUT_YUV420_PLANAR,
};
enum CellVpostPictureStructure : s32
{
CELL_VPOST_PIC_STRUCT_PFRM,
CELL_VPOST_PIC_STRUCT_IFRM,
CELL_VPOST_PIC_STRUCT_ITOP,
CELL_VPOST_PIC_STRUCT_IBTM,
};
enum CellVpostExecType : s32
{
CELL_VPOST_EXEC_TYPE_PFRM_PFRM,
CELL_VPOST_EXEC_TYPE_PTOP_ITOP,
CELL_VPOST_EXEC_TYPE_PBTM_IBTM,
CELL_VPOST_EXEC_TYPE_ITOP_PFRM,
CELL_VPOST_EXEC_TYPE_IBTM_PFRM,
CELL_VPOST_EXEC_TYPE_IFRM_IFRM,
CELL_VPOST_EXEC_TYPE_ITOP_ITOP,
CELL_VPOST_EXEC_TYPE_IBTM_IBTM,
};
enum CellVpostChromaPositionType : s32
{
CELL_VPOST_CHROMA_POS_TYPE_A,
CELL_VPOST_CHROMA_POS_TYPE_B,
};
enum CellVpostScanType : s32
{
CELL_VPOST_SCAN_TYPE_P,
CELL_VPOST_SCAN_TYPE_I,
};
enum CellVpostQuantRange : s32
{
CELL_VPOST_QUANT_RANGE_FULL,
CELL_VPOST_QUANT_RANGE_BROADCAST,
};
enum CellVpostColorMatrix : s32
{
CELL_VPOST_COLOR_MATRIX_BT601,
CELL_VPOST_COLOR_MATRIX_BT709,
};
enum CellVpostScalerType : s32
{
CELL_VPOST_SCALER_TYPE_BILINEAR,
CELL_VPOST_SCALER_TYPE_LINEAR_SHARP,
CELL_VPOST_SCALER_TYPE_2X4TAP,
CELL_VPOST_SCALER_TYPE_8X4TAP,
};
enum CellVpostIpcType : s32
{
CELL_VPOST_IPC_TYPE_DOUBLING,
CELL_VPOST_IPC_TYPE_LINEAR,
CELL_VPOST_IPC_TYPE_MAVG,
};
struct CellVpostCfgParam
{
be_t<u32> inMaxWidth;
be_t<u32> inMaxHeight;
be_t<s32> inDepth; // CellVpostPictureDepth
be_t<s32> inPicFmt; // CellVpostPictureFormatIn
be_t<u32> outMaxWidth;
be_t<u32> outMaxHeight;
be_t<s32> outDepth; // CellVpostPictureDepth
be_t<s32> outPicFmt; // CellVpostPictureFormatOut
be_t<u32> reserved1;
be_t<u32> reserved2;
};
struct CellVpostAttr
{
be_t<u32> memSize;
u8 delay;
be_t<u32> vpostVerUpper;
be_t<u32> vpostVerLower;
};
struct CellVpostResource
{
be_t<u32> memAddr;
be_t<u32> memSize;
be_t<s32> ppuThreadPriority;
be_t<u32> ppuThreadStackSize;
be_t<s32> spuThreadPriority;
be_t<u32> numOfSpus;
};
struct CellVpostResourceEx
{
be_t<u32> memAddr;
be_t<u32> memSize;
be_t<u32> spurs_addr;
u8 priority[8];
be_t<u32> maxContention;
};
struct CellVpostWindow
{
be_t<u32> x;
be_t<u32> y;
be_t<u32> width;
be_t<u32> height;
};
struct CellVpostCtrlParam
{
be_t<s32> execType; // CellVpostExecType
be_t<s32> scalerType; // CellVpostScalerType
be_t<s32> ipcType; // CellVpostIpcType
be_t<u32> inWidth;
be_t<u32> inHeight;
be_t<s32> inChromaPosType; // CellVpostChromaPositionType
be_t<s32> inQuantRange; // CellVpostQuantRange
be_t<s32> inColorMatrix; // CellVpostColorMatrix
CellVpostWindow inWindow;
be_t<u32> outWidth;
be_t<u32> outHeight;
CellVpostWindow outWindow;
u8 outAlpha;
be_t<u64> userData;
be_t<u32> reserved1;
be_t<u32> reserved2;
};
struct CellVpostPictureInfo
{
be_t<u32> inWidth;
be_t<u32> inHeight;
be_t<s32> inDepth; // CellVpostPictureDepth
be_t<s32> inScanType; // CellVpostScanType
be_t<s32> inPicFmt; // CellVpostPictureFormatIn
be_t<s32> inChromaPosType; // CellVpostChromaPositionType
be_t<s32> inPicStruct; // CellVpostPictureStructure
be_t<s32> inQuantRange; // CellVpostQuantRange
be_t<s32> inColorMatrix; // CellVpostColorMatrix
be_t<u32> outWidth;
be_t<u32> outHeight;
be_t<s32> outDepth; // CellVpostPictureDepth
be_t<s32> outScanType; // CellVpostScanType
be_t<s32> outPicFmt; // CellVpostPictureFormatOut
be_t<s32> outChromaPosType; // CellVpostChromaPositionType
be_t<s32> outPicStruct; // CellVpostPictureStructure
be_t<s32> outQuantRange; // CellVpostQuantRange
be_t<s32> outColorMatrix; // CellVpostColorMatrix
be_t<u64> userData;
be_t<u32> reserved1;
be_t<u32> reserved2;
};
class VpostInstance
{
public:
static const u32 id_base = 1;
static const u32 id_step = 1;
static const u32 id_count = 1023;
SAVESTATE_INIT_POS(23);
const bool to_rgba;
SwsContext* sws{};
VpostInstance(bool rgba)
: to_rgba(rgba)
{
}
~VpostInstance()
{
sws_freeContext(sws);
}
};
| 12,345
|
C++
|
.h
| 323
| 36.352941
| 59
| 0.731125
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,903
|
cellCelpEnc.h
|
RPCS3_rpcs3/rpcs3/Emu/Cell/Modules/cellCelpEnc.h
|
#pragma once
struct CellSpurs;
// libCelpEnc = 0x80614001 - 0x806140ff
// typedef void* CellCelpEncHandle;
// Return Codes
enum CellCelpEncError : u32
{
CELL_CELPENC_ERROR_FAILED = 0x80614001,
CELL_CELPENC_ERROR_SEQ = 0x80614002,
CELL_CELPENC_ERROR_ARG = 0x80614003,
CELL_CELPENC_ERROR_CORE_FAILED = 0x80614081,
CELL_CELPENC_ERROR_CORE_SEQ = 0x80614082,
CELL_CELPENC_ERROR_CORE_ARG = 0x80614083,
};
// Definitions
enum CELL_CELPENC_RPE_CONFIG
{
CELL_CELPENC_RPE_CONFIG_0,
CELL_CELPENC_RPE_CONFIG_1,
CELL_CELPENC_RPE_CONFIG_2,
CELL_CELPENC_RPE_CONFIG_3,
};
enum CELL_CELPENC_SAMPEL_RATE
{
CELL_CELPENC_FS_16kHz = 2,
};
enum CELL_CELPENC_EXCITATION_MODE
{
CELL_CELPENC_EXCITATION_MODE_RPE = 1,
};
enum CELL_CELPENC_WORD_SZ
{
CELL_CELPENC_WORD_SZ_INT16_LE,
CELL_CELPENC_WORD_SZ_FLOAT
};
struct CellCelpEncAttr
{
be_t<u32> workMemSize;
be_t<u32> celpEncVerUpper;
be_t<u32> celpEncVerLower;
};
struct CellCelpEncResource
{
be_t<u32> totalMemSize;
vm::bptr<void> startAddr;
be_t<u32> ppuThreadPriority;
be_t<u32> spuThreadPriority;
be_t<u32/*usz*/> ppuThreadStackSize;
};
struct CellCelpEncParam
{
be_t<u32> excitationMode;
be_t<u32> sampleRate;
be_t<u32> configuration;
be_t<u32> wordSize;
vm::bptr<u8> outBuff;
be_t<u32> outSize;
};
struct CellCelpEncAuInfo
{
vm::bptr<void> startAddr;
be_t<u32> size;
};
struct CellCelpEncPcmInfo
{
vm::bptr<void> startAddr;
be_t<u32> size;
};
struct CellCelpEncResourceEx
{
be_t<u32> totalMemSize;
vm::bptr<void> startAddr;
vm::bptr<CellSpurs> spurs;
u8 priority[8];
be_t<u32> maxContention;
};
| 1,604
|
C++
|
.h
| 76
| 19.434211
| 45
| 0.759577
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,904
|
cellNetCtl.h
|
RPCS3_rpcs3/rpcs3/Emu/Cell/Modules/cellNetCtl.h
|
#pragma once
#include "Emu/Memory/vm_ptr.h"
// Error Codes
enum CellNetCtlError : u32
{
CELL_NET_CTL_ERROR_NOT_INITIALIZED = 0x80130101,
CELL_NET_CTL_ERROR_NOT_TERMINATED = 0x80130102,
CELL_NET_CTL_ERROR_HANDLER_MAX = 0x80130103,
CELL_NET_CTL_ERROR_ID_NOT_FOUND = 0x80130104,
CELL_NET_CTL_ERROR_INVALID_ID = 0x80130105,
CELL_NET_CTL_ERROR_INVALID_CODE = 0x80130106,
CELL_NET_CTL_ERROR_INVALID_ADDR = 0x80130107,
CELL_NET_CTL_ERROR_NOT_CONNECTED = 0x80130108,
CELL_NET_CTL_ERROR_NOT_AVAIL = 0x80130109,
CELL_NET_CTL_ERROR_INVALID_TYPE = 0x8013010a,
CELL_NET_CTL_ERROR_INVALID_SIZE = 0x8013010b,
CELL_NET_CTL_ERROR_NET_DISABLED = 0x80130181,
CELL_NET_CTL_ERROR_NET_NOT_CONNECTED = 0x80130182,
CELL_NET_CTL_ERROR_NP_NO_ACCOUNT = 0x80130183,
CELL_NET_CTL_ERROR_NP_RESERVED1 = 0x80130184,
CELL_NET_CTL_ERROR_NP_RESERVED2 = 0x80130185,
CELL_NET_CTL_ERROR_NET_CABLE_NOT_CONNECTED = 0x80130186,
CELL_NET_CTL_ERROR_DIALOG_CANCELED = 0x80130190,
CELL_NET_CTL_ERROR_DIALOG_ABORTED = 0x80130191,
CELL_NET_CTL_ERROR_WLAN_DEAUTHED = 0x80130137,
CELL_NET_CTL_ERROR_WLAN_KEYINFO_EXCHNAGE_TIMEOUT = 0x8013013d,
CELL_NET_CTL_ERROR_WLAN_ASSOC_FAILED = 0x8013013e,
CELL_NET_CTL_ERROR_WLAN_AP_DISAPPEARED = 0x8013013f,
CELL_NET_CTL_ERROR_PPPOE_SESSION_INIT = 0x80130409,
CELL_NET_CTL_ERROR_PPPOE_SESSION_NO_PADO = 0x8013040a,
CELL_NET_CTL_ERROR_PPPOE_SESSION_NO_PADS = 0x8013040b,
CELL_NET_CTL_ERROR_PPPOE_SESSION_GET_PADT = 0x8013040d,
CELL_NET_CTL_ERROR_PPPOE_SESSION_SERVICE_NAME = 0x8013040f,
CELL_NET_CTL_ERROR_PPPOE_SESSION_AC_SYSTEM = 0x80130410,
CELL_NET_CTL_ERROR_PPPOE_SESSION_GENERIC = 0x80130411,
CELL_NET_CTL_ERROR_PPPOE_STATUS_AUTH = 0x80130412,
CELL_NET_CTL_ERROR_PPPOE_STATUS_NETWORK = 0x80130413,
CELL_NET_CTL_ERROR_PPPOE_STATUS_TERMINATE = 0x80130414,
CELL_NET_CTL_ERROR_DHCP_LEASE_TIME = 0x80130504,
CELL_GAMEUPDATE_ERROR_NOT_INITIALIZED = 0x8002cc01,
CELL_GAMEUPDATE_ERROR_ALREADY_INITIALIZED = 0x8002cc02,
CELL_GAMEUPDATE_ERROR_INVALID_ADDR = 0x8002cc03,
CELL_GAMEUPDATE_ERROR_INVALID_SIZE = 0x8002cc04,
CELL_GAMEUPDATE_ERROR_INVALID_MEMORY_CONTAINER = 0x8002cc05,
CELL_GAMEUPDATE_ERROR_INSUFFICIENT_MEMORY_CONTAINER = 0x8002cc06,
CELL_GAMEUPDATE_ERROR_BUSY = 0x8002cc07,
CELL_GAMEUPDATE_ERROR_NOT_START = 0x8002cc08,
CELL_GAMEUPDATE_ERROR_LOAD_FAILED = 0x8002cc09,
};
// Network connection states
enum CellNetCtlState : s32
{
CELL_NET_CTL_STATE_Disconnected = 0,
CELL_NET_CTL_STATE_Connecting = 1,
CELL_NET_CTL_STATE_IPObtaining = 2,
CELL_NET_CTL_STATE_IPObtained = 3,
};
// Transition connection states
enum
{
CELL_NET_CTL_EVENT_CONNECT_REQ = 0,
CELL_NET_CTL_EVENT_ESTABLISH = 1,
CELL_NET_CTL_EVENT_GET_IP = 2,
CELL_NET_CTL_EVENT_DISCONNECT_REQ = 3,
CELL_NET_CTL_EVENT_ERROR = 4,
CELL_NET_CTL_EVENT_LINK_DISCONNECTED = 5,
CELL_NET_CTL_EVENT_AUTO_RETRY = 6,
};
// Network connection devices
enum
{
CELL_NET_CTL_DEVICE_WIRED = 0,
CELL_NET_CTL_DEVICE_WIRELESS = 1,
};
// Cable connection types
enum
{
CELL_NET_CTL_LINK_TYPE_AUTO = 0,
CELL_NET_CTL_LINK_TYPE_10BASE_HALF = 1,
CELL_NET_CTL_LINK_TYPE_10BASE_FULL = 2,
CELL_NET_CTL_LINK_TYPE_100BASE_HALF = 3,
CELL_NET_CTL_LINK_TYPE_100BASE_FULL = 4,
CELL_NET_CTL_LINK_TYPE_1000BASE_HALF = 5,
CELL_NET_CTL_LINK_TYPE_1000BASE_FULL = 6,
};
// Link connection states
enum
{
CELL_NET_CTL_LINK_DISCONNECTED = 0,
CELL_NET_CTL_LINK_CONNECTED = 1,
};
// Wireless connection security measures
enum
{
CELL_NET_CTL_WLAN_SECURITY_NOAUTH = 0,
CELL_NET_CTL_WLAN_SECURITY_WEP = 1,
CELL_NET_CTL_WLAN_SECURITY_WPAPSK_TKIP = 2,
CELL_NET_CTL_WLAN_SECURITY_WPAPSK_AES = 3,
CELL_NET_CTL_WLAN_SECURITY_UNSUPPORTED = 4,
CELL_NET_CTL_WLAN_SECURITY_WPA2PSK_TKIP = 5,
CELL_NET_CTL_WLAN_SECURITY_WPA2PSK_AES = 6,
CELL_NET_CTL_WLAN_SECURITY_WPAPSK_WPA2PSK = 7,
};
// 802.1X settings
enum
{
CELL_NET_CTL_8021X_NONE = 0,
CELL_NET_CTL_8021X_EAP_MD5 = 1,
};
// IP settings
enum
{
CELL_NET_CTL_IP_DHCP = 0,
CELL_NET_CTL_IP_STATIC = 1,
CELL_NET_CTL_IP_PPPOE = 2,
};
// HTTP proxy settings
enum
{
CELL_NET_CTL_HTTP_PROXY_OFF = 0,
CELL_NET_CTL_HTTP_PROXY_ON = 1,
};
// UPnP settings
enum
{
CELL_NET_CTL_UPNP_ON = 0,
CELL_NET_CTL_UPNP_OFF = 1,
};
// Codes for information
enum
{
CELL_NET_CTL_INFO_DEVICE = 1,
CELL_NET_CTL_INFO_ETHER_ADDR = 2,
CELL_NET_CTL_INFO_MTU = 3,
CELL_NET_CTL_INFO_LINK = 4,
CELL_NET_CTL_INFO_LINK_TYPE = 5,
CELL_NET_CTL_INFO_BSSID = 6,
CELL_NET_CTL_INFO_SSID = 7,
CELL_NET_CTL_INFO_WLAN_SECURITY = 8,
CELL_NET_CTL_INFO_8021X_TYPE = 9,
CELL_NET_CTL_INFO_8021X_AUTH_NAME = 10,
CELL_NET_CTL_INFO_RSSI = 11,
CELL_NET_CTL_INFO_CHANNEL = 12,
CELL_NET_CTL_INFO_IP_CONFIG = 13,
CELL_NET_CTL_INFO_DHCP_HOSTNAME = 14,
CELL_NET_CTL_INFO_PPPOE_AUTH_NAME = 15,
CELL_NET_CTL_INFO_IP_ADDRESS = 16,
CELL_NET_CTL_INFO_NETMASK = 17,
CELL_NET_CTL_INFO_DEFAULT_ROUTE = 18,
CELL_NET_CTL_INFO_PRIMARY_DNS = 19,
CELL_NET_CTL_INFO_SECONDARY_DNS = 20,
CELL_NET_CTL_INFO_HTTP_PROXY_CONFIG = 21,
CELL_NET_CTL_INFO_HTTP_PROXY_SERVER = 22,
CELL_NET_CTL_INFO_HTTP_PROXY_PORT = 23,
CELL_NET_CTL_INFO_UPNP_CONFIG = 24,
CELL_NET_CTL_INFO_RESERVED1 = 25,
CELL_NET_CTL_INFO_RESERVED2 = 26,
};
// Network start dialogs
enum
{
CELL_NET_CTL_NETSTART_TYPE_NET = 0,
CELL_NET_CTL_NETSTART_TYPE_NP = 1,
CELL_NET_CTL_NETSTART_TYPE_MAX = 2,
};
// Network start dialog statuses
enum
{
CELL_SYSUTIL_NET_CTL_NETSTART_LOADED = 0x0801,
CELL_SYSUTIL_NET_CTL_NETSTART_FINISHED = 0x0802,
CELL_SYSUTIL_NET_CTL_NETSTART_UNLOADED = 0x0803,
};
// UPnP NAT statuses
enum
{
CELL_NET_CTL_NATINFO_UPNP_UNCHECKED = 0,
CELL_NET_CTL_NATINFO_UPNP_NO = 1,
CELL_NET_CTL_NATINFO_UPNP_USED = 2,
};
// STUN NAT statuses
enum
{
CELL_NET_CTL_NATINFO_STUN_UNCHECKED = 0,
CELL_NET_CTL_NATINFO_STUN_FAILED = 1,
CELL_NET_CTL_NATINFO_STUN_OK = 2,
};
// NAT types
enum
{
CELL_NET_CTL_NATINFO_NAT_TYPE_1 = 1,
CELL_NET_CTL_NATINFO_NAT_TYPE_2 = 2,
CELL_NET_CTL_NATINFO_NAT_TYPE_3 = 3,
};
enum
{
CELL_NET_CTL_ETHER_ADDR_LEN = 6,
CELL_NET_CTL_BSSID_LEN = 6,
CELL_NET_CTL_SSID_LEN = 32,
CELL_NET_CTL_WLAN_SECURITY_KEY_LEN = (64 + 1),
CELL_NET_CTL_AUTH_NAME_LEN = (127 + 1),
CELL_NET_CTL_AUTH_KEY_LEN = (127 + 1),
CELL_NET_CTL_DHCP_HOSTNAME_LEN = (254 + 1),
CELL_NET_CTL_HOSTNAME_LEN = (255 + 1),
CELL_NET_CTL_IPV4_ADDR_STR_LEN = 16,
};
struct CellNetCtlEtherAddr
{
u8 data[CELL_NET_CTL_ETHER_ADDR_LEN];
u8 padding[2];
};
struct CellNetCtlSSID
{
u8 data[CELL_NET_CTL_SSID_LEN];
u8 term;
u8 padding[3];
};
union CellNetCtlInfo
{
be_t<u32> device;
CellNetCtlEtherAddr ether_addr;
be_t<u32> mtu;
be_t<u32> link;
be_t<u32> link_type;
CellNetCtlEtherAddr bssid;
CellNetCtlSSID ssid;
be_t<u32> wlan_security;
be_t<u32> auth_8021x_type;
char auth_8021x_auth_name[CELL_NET_CTL_AUTH_NAME_LEN];
u8 rssi;
u8 channel;
be_t<u32> ip_config;
char dhcp_hostname[CELL_NET_CTL_HOSTNAME_LEN];
char pppoe_auth_name[CELL_NET_CTL_AUTH_NAME_LEN];
char ip_address[CELL_NET_CTL_IPV4_ADDR_STR_LEN];
char netmask[CELL_NET_CTL_IPV4_ADDR_STR_LEN];
char default_route[CELL_NET_CTL_IPV4_ADDR_STR_LEN];
char primary_dns[CELL_NET_CTL_IPV4_ADDR_STR_LEN];
char secondary_dns[CELL_NET_CTL_IPV4_ADDR_STR_LEN];
be_t<u32> http_proxy_config;
char http_proxy_server[CELL_NET_CTL_HOSTNAME_LEN];
be_t<u16> http_proxy_port;
be_t<u32> upnp_config;
};
struct CellNetCtlNetStartDialogParam
{
be_t<u32> size;
be_t<s32> type;
be_t<u32> cid; // Unused
};
struct CellNetCtlNetStartDialogResult
{
be_t<u32> size;
be_t<s32> result;
};
struct CellNetCtlNatInfo
{
be_t<u32> size;
be_t<s32> upnp_status;
be_t<s32> stun_status;
be_t<s32> nat_type;
be_t<u32> mapped_addr;
};
typedef void(cellNetCtlHandler)(s32 prev_state, s32 new_state, s32 event, s32 error_code, vm::ptr<u32> arg);
inline const char* InfoCodeToName(s32 code)
{
switch (code)
{
case CELL_NET_CTL_INFO_DEVICE: return "INFO_DEVICE";
case CELL_NET_CTL_INFO_ETHER_ADDR: return "INFO_ETHER_ADDR";
case CELL_NET_CTL_INFO_MTU: return "INFO_MTU";
case CELL_NET_CTL_INFO_LINK: return "INFO_LINK";
case CELL_NET_CTL_INFO_LINK_TYPE: return "INFO_LINK_TYPE";
case CELL_NET_CTL_INFO_BSSID: return "INFO_BSSID";
case CELL_NET_CTL_INFO_SSID: return "INFO_SSID";
case CELL_NET_CTL_INFO_WLAN_SECURITY: return "INFO_WLAN_SECURITY";
case CELL_NET_CTL_INFO_8021X_TYPE: return "INFO_8021X_TYPE";
case CELL_NET_CTL_INFO_8021X_AUTH_NAME: return "INFO_8021X_AUTH_NAME";
case CELL_NET_CTL_INFO_RSSI: return "INFO_RSSI";
case CELL_NET_CTL_INFO_CHANNEL: return "INFO_CHANNEL";
case CELL_NET_CTL_INFO_IP_CONFIG: return "INFO_IP_CONFIG";
case CELL_NET_CTL_INFO_DHCP_HOSTNAME: return "INFO_DHCP_HOSTNAME";
case CELL_NET_CTL_INFO_PPPOE_AUTH_NAME: return "INFO_PPPOE_AUTH_NAME";
case CELL_NET_CTL_INFO_IP_ADDRESS: return "INFO_IP_ADDRESS";
case CELL_NET_CTL_INFO_NETMASK: return "INFO_NETMASK";
case CELL_NET_CTL_INFO_DEFAULT_ROUTE: return "INFO_DEFAULT_ROUTE";
case CELL_NET_CTL_INFO_PRIMARY_DNS: return "INFO_PRIMARY_DNS";
case CELL_NET_CTL_INFO_SECONDARY_DNS: return "INFO_SECONDARY_DNS";
case CELL_NET_CTL_INFO_HTTP_PROXY_CONFIG: return "INFO_HTTP_PROXY_CONFIG";
case CELL_NET_CTL_INFO_HTTP_PROXY_SERVER: return "INFO_HTTP_PROXY_SERVER";
case CELL_NET_CTL_INFO_HTTP_PROXY_PORT: return "INFO_HTTP_PROXY_PORT";
case CELL_NET_CTL_INFO_UPNP_CONFIG: return "INFO_UPNP_CONFIG";
default: return "???";
}
}
enum
{
CELL_GAMEUPDATE_RESULT_STATUS_NO_UPDATE = 0,
CELL_GAMEUPDATE_RESULT_STATUS_UPDATE_FOUND = 1,
CELL_GAMEUPDATE_RESULT_STATUS_MAINTENANCE = 2,
CELL_GAMEUPDATE_RESULT_STATUS_ERROR = 3,
CELL_GAMEUPDATE_RESULT_STATUS_CANCELLED = 4,
CELL_GAMEUPDATE_RESULT_STATUS_FINISHED = 5,
CELL_GAMEUPDATE_RESULT_STATUS_ABORTED = 6,
CELL_GAMEUPDATE_RESULT_STATUS_SYSTEM_UPDATE_NEEDED = 7
};
| 10,746
|
C++
|
.h
| 305
| 33.455738
| 108
| 0.67227
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,905
|
sceNpTrophy.h
|
RPCS3_rpcs3/rpcs3/Emu/Cell/Modules/sceNpTrophy.h
|
#pragma once
#include "util/types.hpp"
#include "util/endian.hpp"
#include "Emu/Memory/vm_ptr.h"
#include "Emu/Cell/ErrorCodes.h"
#include <vector>
// Error codes
enum SceNpTrophyError : u32
{
SCE_NP_TROPHY_ERROR_ALREADY_INITIALIZED = 0x80022901,
SCE_NP_TROPHY_ERROR_NOT_INITIALIZED = 0x80022902,
SCE_NP_TROPHY_ERROR_NOT_SUPPORTED = 0x80022903,
SCE_NP_TROPHY_ERROR_CONTEXT_NOT_REGISTERED = 0x80022904,
SCE_NP_TROPHY_ERROR_OUT_OF_MEMORY = 0x80022905,
SCE_NP_TROPHY_ERROR_INVALID_ARGUMENT = 0x80022906,
SCE_NP_TROPHY_ERROR_EXCEEDS_MAX = 0x80022907,
SCE_NP_TROPHY_ERROR_INSUFFICIENT = 0x80022909,
SCE_NP_TROPHY_ERROR_UNKNOWN_CONTEXT = 0x8002290a,
SCE_NP_TROPHY_ERROR_INVALID_FORMAT = 0x8002290b,
SCE_NP_TROPHY_ERROR_BAD_RESPONSE = 0x8002290c,
SCE_NP_TROPHY_ERROR_INVALID_GRADE = 0x8002290d,
SCE_NP_TROPHY_ERROR_INVALID_CONTEXT = 0x8002290e,
SCE_NP_TROPHY_ERROR_PROCESSING_ABORTED = 0x8002290f,
SCE_NP_TROPHY_ERROR_ABORT = 0x80022910,
SCE_NP_TROPHY_ERROR_UNKNOWN_HANDLE = 0x80022911,
SCE_NP_TROPHY_ERROR_LOCKED = 0x80022912,
SCE_NP_TROPHY_ERROR_HIDDEN = 0x80022913,
SCE_NP_TROPHY_ERROR_CANNOT_UNLOCK_PLATINUM = 0x80022914,
SCE_NP_TROPHY_ERROR_ALREADY_UNLOCKED = 0x80022915,
SCE_NP_TROPHY_ERROR_INVALID_TYPE = 0x80022916,
SCE_NP_TROPHY_ERROR_INVALID_HANDLE = 0x80022917,
SCE_NP_TROPHY_ERROR_INVALID_NP_COMM_ID = 0x80022918,
SCE_NP_TROPHY_ERROR_UNKNOWN_NP_COMM_ID = 0x80022919,
SCE_NP_TROPHY_ERROR_DISC_IO = 0x8002291a,
SCE_NP_TROPHY_ERROR_CONF_DOES_NOT_EXIST = 0x8002291b,
SCE_NP_TROPHY_ERROR_UNSUPPORTED_FORMAT = 0x8002291c,
SCE_NP_TROPHY_ERROR_ALREADY_INSTALLED = 0x8002291d,
SCE_NP_TROPHY_ERROR_BROKEN_DATA = 0x8002291e,
SCE_NP_TROPHY_ERROR_VERIFICATION_FAILURE = 0x8002291f,
SCE_NP_TROPHY_ERROR_INVALID_TROPHY_ID = 0x80022920,
SCE_NP_TROPHY_ERROR_UNKNOWN_TROPHY_ID = 0x80022921,
SCE_NP_TROPHY_ERROR_UNKNOWN_TITLE = 0x80022922,
SCE_NP_TROPHY_ERROR_UNKNOWN_FILE = 0x80022923,
SCE_NP_TROPHY_ERROR_DISC_NOT_MOUNTED = 0x80022924,
SCE_NP_TROPHY_ERROR_SHUTDOWN = 0x80022925,
SCE_NP_TROPHY_ERROR_TITLE_ICON_NOT_FOUND = 0x80022926,
SCE_NP_TROPHY_ERROR_TROPHY_ICON_NOT_FOUND = 0x80022927,
SCE_NP_TROPHY_ERROR_INSUFFICIENT_DISK_SPACE = 0x80022928,
SCE_NP_TROPHY_ERROR_ILLEGAL_UPDATE = 0x8002292a,
SCE_NP_TROPHY_ERROR_SAVEDATA_USER_DOES_NOT_MATCH = 0x8002292b,
SCE_NP_TROPHY_ERROR_TROPHY_ID_DOES_NOT_EXIST = 0x8002292c,
SCE_NP_TROPHY_ERROR_SERVICE_UNAVAILABLE = 0x8002292d,
SCE_NP_TROPHY_ERROR_UNKNOWN = 0x800229ff,
};
enum
{
SCE_NP_TROPHY_TITLE_MAX_SIZE = 128,
SCE_NP_TROPHY_GAME_DESCR_MAX_SIZE = 1024,
SCE_NP_TROPHY_NAME_MAX_SIZE = 128,
SCE_NP_TROPHY_DESCR_MAX_SIZE = 1024,
SCE_NP_TROPHY_FLAG_SETSIZE = 128,
SCE_NP_TROPHY_FLAG_BITS_SHIFT = 5,
SCE_NP_TROPHY_INVALID_CONTEXT = 0,
SCE_NP_TROPHY_INVALID_HANDLE = 0,
};
enum : u32
{
SCE_NP_TROPHY_INVALID_TROPHY_ID = 0xffffffff,
};
enum SceNpTrophyGrade
{
SCE_NP_TROPHY_GRADE_UNKNOWN = 0,
SCE_NP_TROPHY_GRADE_PLATINUM = 1,
SCE_NP_TROPHY_GRADE_GOLD = 2,
SCE_NP_TROPHY_GRADE_SILVER = 3,
SCE_NP_TROPHY_GRADE_BRONZE = 4,
};
enum
{
SCE_NP_TROPHY_OPTIONS_CREATE_CONTEXT_READ_ONLY = 1,
SCE_NP_TROPHY_OPTIONS_REGISTER_CONTEXT_SHOW_ERROR_EXIT = 1
};
struct SceNpTrophyGameDetails
{
be_t<u32> numTrophies;
be_t<u32> numPlatinum;
be_t<u32> numGold;
be_t<u32> numSilver;
be_t<u32> numBronze;
char title[SCE_NP_TROPHY_TITLE_MAX_SIZE];
char description[SCE_NP_TROPHY_GAME_DESCR_MAX_SIZE];
u8 reserved[4];
};
struct SceNpTrophyGameData
{
be_t<u32> unlockedTrophies;
be_t<u32> unlockedPlatinum;
be_t<u32> unlockedGold;
be_t<u32> unlockedSilver;
be_t<u32> unlockedBronze;
};
struct SceNpTrophyDetails
{
be_t<s32> trophyId; // SceNpTrophyId
be_t<u32> trophyGrade; // SceNpTrophyGrade
char name[SCE_NP_TROPHY_NAME_MAX_SIZE];
char description[SCE_NP_TROPHY_DESCR_MAX_SIZE];
b8 hidden;
u8 reserved[3];
};
struct SceNpTrophyData
{
be_t<u64> timestamp; // CellRtcTick
be_t<s32> trophyId; // SceNpTrophyId
b8 unlocked;
u8 reserved[3];
};
struct SceNpTrophyFlagArray
{
be_t<u32> flag_bits[SCE_NP_TROPHY_FLAG_SETSIZE >> SCE_NP_TROPHY_FLAG_BITS_SHIFT];
};
enum
{
SCE_NP_TROPHY_STATUS_UNKNOWN = 0,
SCE_NP_TROPHY_STATUS_NOT_INSTALLED = 1,
SCE_NP_TROPHY_STATUS_DATA_CORRUPT = 2,
SCE_NP_TROPHY_STATUS_INSTALLED = 3,
SCE_NP_TROPHY_STATUS_REQUIRES_UPDATE = 4,
SCE_NP_TROPHY_STATUS_PROCESSING_SETUP = 5,
SCE_NP_TROPHY_STATUS_PROCESSING_PROGRESS = 6,
SCE_NP_TROPHY_STATUS_PROCESSING_FINALIZE = 7,
SCE_NP_TROPHY_STATUS_PROCESSING_COMPLETE = 8,
SCE_NP_TROPHY_STATUS_CHANGES_DETECTED = 9,
};
enum : u32
{
NP_TROPHY_COMM_SIGN_MAGIC = 0xB9DDE13B,
};
using SceNpTrophyStatusCallback = s32(u32 context, u32 status, s32 completed, s32 total, vm::ptr<void> arg);
// Forward declare this function since trophyunlock needs it
error_code sceNpTrophyGetTrophyInfo(u32 context, u32 handle, s32 trophyId, vm::ptr<SceNpTrophyDetails> details, vm::ptr<SceNpTrophyData> data);
class TrophyNotificationBase
{
public:
virtual ~TrophyNotificationBase();
virtual s32 ShowTrophyNotification(const SceNpTrophyDetails& trophy, const std::vector<uchar>& trophyIconBfr) = 0;
};
| 5,775
|
C++
|
.h
| 147
| 37.469388
| 143
| 0.680464
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,906
|
cellAudioIn.h
|
RPCS3_rpcs3/rpcs3/Emu/Cell/Modules/cellAudioIn.h
|
#pragma once
#include "util/types.hpp"
#include "util/endian.hpp"
// Error codes
enum CellAudioInError : u32
{
CELL_AUDIO_IN_ERROR_NOT_IMPLEMENTED = 0x8002b260,
CELL_AUDIO_IN_ERROR_ILLEGAL_CONFIGURATION = 0x8002b261,
CELL_AUDIO_IN_ERROR_ILLEGAL_PARAMETER = 0x8002b262,
CELL_AUDIO_IN_ERROR_PARAMETER_OUT_OF_RANGE = 0x8002b263,
CELL_AUDIO_IN_ERROR_DEVICE_NOT_FOUND = 0x8002b264,
CELL_AUDIO_IN_ERROR_UNSUPPORTED_AUDIO_IN = 0x8002b265,
CELL_AUDIO_IN_ERROR_UNSUPPORTED_SOUND_MODE = 0x8002b266,
CELL_AUDIO_IN_ERROR_CONDITION_BUSY = 0x8002b267,
};
enum CellAudioInDeviceMode
{
CELL_AUDIO_IN_SINGLE_DEVICE_MODE = 0,
CELL_AUDIO_IN_MULTI_DEVICE_MODE = 1,
CELL_AUDIO_IN_MULTI_DEVICE_MODE_2 = 2,
CELL_AUDIO_IN_MULTI_DEVICE_MODE_10 = 10,
};
enum CellAudioInPortType
{
CELL_AUDIO_IN_PORT_USB = 3,
CELL_AUDIO_IN_PORT_BLUETOOTH = 4,
};
enum CellAudioInDeviceState
{
CELL_AUDIO_IN_DEVICE_STATE_UNAVAILABLE = 0,
CELL_AUDIO_IN_DEVICE_STATE_AVAILABLE = 1,
};
enum CellAudioInCodingType
{
CELL_AUDIO_IN_CODING_TYPE_LPCM = 0,
};
enum CellAudioInChnum
{
CELL_AUDIO_IN_CHNUM_NONE = 0,
CELL_AUDIO_IN_CHNUM_1 = 1,
CELL_AUDIO_IN_CHNUM_2 = 2,
};
enum CellAudioInFs
{
CELL_AUDIO_IN_FS_UNDEFINED = 0x00,
CELL_AUDIO_IN_FS_8KHZ = 0x01,
CELL_AUDIO_IN_FS_12KHZ = 0x02,
CELL_AUDIO_IN_FS_16KHZ = 0x04,
CELL_AUDIO_IN_FS_24KHZ = 0x08,
CELL_AUDIO_IN_FS_32KHZ = 0x10,
CELL_AUDIO_IN_FS_48KHZ = 0x20,
};
struct CellAudioInSoundMode
{
u8 type;
u8 channel;
be_t<u16> fs;
u8 reserved[4];
};
struct CellAudioInDeviceInfo
{
u8 portType;
u8 availableModeCount;
u8 state;
u8 deviceNumber;
u8 reserved[12];
be_t<u64> deviceId;
be_t<u64> type;
char name[64];
CellAudioInSoundMode availableModes[16];
};
struct CellAudioInRegistrationOption
{
be_t<u32> reserved;
};
struct CellAudioInDeviceConfiguration
{
u8 volume;
u8 reserved[31];
};
| 1,914
|
C++
|
.h
| 80
| 22.2375
| 57
| 0.739846
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,907
|
cellL10n.h
|
RPCS3_rpcs3/rpcs3/Emu/Cell/Modules/cellL10n.h
|
#pragma once
// L10nResult
enum
{
ConversionOK,
SRCIllegal,
DSTExhausted,
ConverterUnknown,
};
// detection result
enum
{
L10N_STR_UNKNOWN = (1 << 0),
L10N_STR_ASCII = (1 << 1),
L10N_STR_JIS = (1 << 2),
L10N_STR_EUCJP = (1 << 3),
L10N_STR_SJIS = (1 << 4),
L10N_STR_UTF8 = (1 << 5),
L10N_STR_ILLEGAL = (1 << 16),
L10N_STR_ERROR = (1 << 17),
};
// CodePages
enum
{
L10N_UTF8 = 0,
L10N_UTF16,
L10N_UTF32,
L10N_UCS2,
L10N_UCS4,
L10N_ISO_8859_1,
L10N_ISO_8859_2,
L10N_ISO_8859_3,
L10N_ISO_8859_4,
L10N_ISO_8859_5,
L10N_ISO_8859_6,
L10N_ISO_8859_7,
L10N_ISO_8859_8,
L10N_ISO_8859_9,
L10N_ISO_8859_10,
L10N_ISO_8859_11,
L10N_ISO_8859_13,
L10N_ISO_8859_14,
L10N_ISO_8859_15,
L10N_ISO_8859_16,
L10N_CODEPAGE_437,
L10N_CODEPAGE_850,
L10N_CODEPAGE_863,
L10N_CODEPAGE_866,
L10N_CODEPAGE_932,
L10N_SHIFT_JIS,
L10N_CODEPAGE_936,
L10N_GBK,
L10N_CODEPAGE_949,
L10N_UHC,
L10N_CODEPAGE_950,
L10N_BIG5,
L10N_CODEPAGE_1251,
L10N_CODEPAGE_1252,
L10N_EUC_CN,
L10N_EUC_JP,
L10N_EUC_KR,
L10N_ISO_2022_JP,
L10N_JIS,
L10N_ARIB,
L10N_HZ,
L10N_GB18030,
L10N_RIS_506,
L10N_MUSIC_SHIFT_JIS,
//FW 3.10 and below
L10N_CODEPAGE_852,
L10N_CODEPAGE_1250,
L10N_CODEPAGE_737,
L10N_CODEPAGE_1253,
L10N_CODEPAGE_857,
L10N_CODEPAGE_1254,
L10N_CODEPAGE_775,
L10N_CODEPAGE_1257,
L10N_CODEPAGE_855,
L10N_CODEPAGE_858,
L10N_CODEPAGE_860,
L10N_CODEPAGE_861,
L10N_CODEPAGE_865,
L10N_CODEPAGE_869,
_L10N_CODE_
};
| 1,459
|
C++
|
.h
| 85
| 15.258824
| 30
| 0.707816
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,908
|
cellHttp.h
|
RPCS3_rpcs3/rpcs3/Emu/Cell/Modules/cellHttp.h
|
#pragma once
// libHttp = 0x80710001 - 0x80710fff
// libHttps = 0x80710a01 - 0x80710aff
enum
{
CELL_HTTP_MAX_USERNAME = 256,
CELL_HTTP_MAX_PASSWORD = 256,
};
enum
{
CELL_HTTP_NET_ERROR_TYPE_MASK = 0xffffff00,
CELL_HTTP_NET_ERROR_MASK = 0xff,
CELL_HTTP_ERROR_NET_RESOLVER = 0x80710100,
CELL_HTTP_ERROR_NET_ABORT = 0x80710200,
CELL_HTTP_ERROR_NET_OPTION = 0x80710300,
CELL_HTTP_ERROR_NET_SOCKET = 0x80710400,
CELL_HTTP_ERROR_NET_CONNECT = 0x80710500,
CELL_HTTP_ERROR_NET_SEND = 0x80710600,
CELL_HTTP_ERROR_NET_RECV = 0x80710700,
CELL_HTTP_ERROR_NET_SELECT = 0x80710800,
// CELL_HTTP_NET_ERROR
// CELL_HTTP_IS_NET_RESOLVER_ERROR
};
// Error Codes - Http
enum CellHttpError
{
CELL_HTTP_ERROR_ALREADY_INITIALIZED = 0x80710001,
CELL_HTTP_ERROR_NOT_INITIALIZED = 0x80710002,
CELL_HTTP_ERROR_NO_MEMORY = 0x80710003,
CELL_HTTP_ERROR_NO_BUFFER = 0x80710004,
CELL_HTTP_ERROR_NO_STRING = 0x80710005,
CELL_HTTP_ERROR_INSUFFICIENT = 0x80710006,
CELL_HTTP_ERROR_INVALID_URI = 0x80710007,
CELL_HTTP_ERROR_INVALID_HEADER = 0x80710008,
CELL_HTTP_ERROR_BAD_METHOD = 0x80710009,
CELL_HTTP_ERROR_BAD_CLIENT = 0x80710010,
CELL_HTTP_ERROR_BAD_TRANS = 0x80710011,
CELL_HTTP_ERROR_NO_CONNECTION = 0x80710012,
CELL_HTTP_ERROR_NO_REQUEST_SENT = 0x80710013,
CELL_HTTP_ERROR_ALREADY_BUILT = 0x80710014,
CELL_HTTP_ERROR_ALREADY_SENT = 0x80710015,
CELL_HTTP_ERROR_NO_HEADER = 0x80710016,
CELL_HTTP_ERROR_NO_CONTENT_LENGTH = 0x80710017,
CELL_HTTP_ERROR_TOO_MANY_REDIRECTS = 0x80710018,
CELL_HTTP_ERROR_TOO_MANY_AUTHS = 0x80710019,
CELL_HTTP_ERROR_TRANS_NO_CONNECTION = 0x80710020,
CELL_HTTP_ERROR_CB_FAILED = 0x80710021,
CELL_HTTP_ERROR_NOT_PIPED = 0x80710022,
CELL_HTTP_ERROR_OUT_OF_ORDER_PIPE = 0x80710023,
CELL_HTTP_ERROR_TRANS_ABORTED = 0x80710024,
CELL_HTTP_ERROR_BROKEN_PIPELINE = 0x80710025,
CELL_HTTP_ERROR_UNAVAILABLE = 0x80710026,
CELL_HTTP_ERROR_INVALID_VALUE = 0x80710027,
CELL_HTTP_ERROR_CANNOT_AUTHENTICATE = 0x80710028,
CELL_HTTP_ERROR_COOKIE_NOT_FOUND = 0x80710041,
CELL_HTTP_ERROR_COOKIE_INVALID_DOMAIN = 0x80710042,
CELL_HTTP_ERROR_CACHE_ALREADY_INITIALIZED = 0x80710043,
CELL_HTTP_ERROR_CACHE_NOT_INITIALIZED = 0x80710044,
CELL_HTTP_ERROR_LINE_EXCEEDS_MAX = 0x80710045,
CELL_HTTP_ERROR_REQUIRES_BASIC_AUTH = 0x80710046,
CELL_HTTP_ERROR_UNKNOWN = 0x80710051,
CELL_HTTP_ERROR_INTERNAL = 0x80710052,
CELL_HTTP_ERROR_NONREMOVABLE = 0x80710053,
CELL_HTTP_ERROR_BAD_CONN = 0x80710054,
CELL_HTTP_ERROR_BAD_MAN = 0x80710055,
CELL_HTTP_ERROR_NO_POOL = 0x80710056,
CELL_HTTP_ERROR_NO_REQUEST = 0x80710057,
CELL_HTTP_ERROR_LOCK_FAILED = 0x80710058,
CELL_HTTP_ERROR_INVALID_DATA = 0x80710059,
CELL_HTTP_ERROR_BROKEN_CHUNK = 0x8071005a,
CELL_HTTP_ERROR_DECODE_SETUP = 0x8071005b,
CELL_HTTP_ERROR_DECODE_STREAM = 0x8071005c,
CELL_HTTP_ERROR_BROKEN_DECODE_STREAM = 0x8071005d,
CELL_HTTP_ERROR_INVALID_DCACHE_PATH = 0x80710060,
CELL_HTTP_ERROR_DCACHE_ALREADY_INITIALIZED = 0x80710061,
CELL_HTTP_ERROR_DCACHE_NOT_INITIALIZED = 0x80710062,
CELL_HTTP_ERROR_TOO_MANY_DCACHE_ENTRY = 0x80710063,
CELL_HTTP_ERROR_DUP_DCACHE_ENTRY = 0x80710064,
CELL_HTTP_ERROR_WRITE_DCACHE = 0x80710065,
CELL_HTTP_ERROR_READ_DCACHE = 0x80710066,
CELL_HTTP_ERROR_CACHE_TOO_LARGE = 0x80710067,
CELL_HTTP_ERROR_INVALID_DCACHE_VERSION = 0x80710068,
CELL_HTTP_ERROR_DCACHE_FILE_BROKEN = 0x80710069,
CELL_HTTP_ERROR_DCACHE_EXCEEDS_MAX = 0x8071006a,
CELL_HTTP_ERROR_DCACHE_BUSY = 0x8071006b,
CELL_HTTP_ERROR_DCACHE_INDEX_BROKEN = 0x8071006c,
CELL_HTTP_ERROR_INVALID_DCACHE_INDEX_NODE = 0x8071006d,
CELL_HTTP_ERROR_DCACHE_FILE_INCONSISTENCY = 0x8071006e,
CELL_HTTP_ERROR_DCACHE_URI_TOO_LONG = 0x8071006f,
CELL_HTTP_ERROR_READ_DCACHE_EOF = 0x80710070,
CELL_HTTP_ERROR_END_OF_DCACHE_INDEX_NODE = 0x80710071,
CELL_HTTP_ERROR_NO_CACHE_MEMORY = 0x80710072,
CELL_HTTP_ERROR_DCACHE_BROKEN = 0x80710073,
CELL_HTTP_ERROR_DCACHE_TOO_MANY_WRITE = 0x80710074,
CELL_HTTP_ERROR_DCACHE_TOO_MANY_READ = 0x80710075,
CELL_HTTP_ERROR_DCACHE_FATAL = 0x80710076,
CELL_HTTP_ERROR_DCACHE_UNSUPPORTED_FEATURE = 0x80710077,
CELL_HTTP_ERROR_DCACHE_INDEX_IS_ALREADY_OPEN = 0x80710078,
CELL_HTTP_ERROR_DCACHE_INDEX_IS_OPENING = 0x80710079,
CELL_HTTP_ERROR_DCACHE_UNKNOWN = 0x80710080,
CELL_HTTP_ERROR_DCACHE_INDEX_IS_CLOSED = 0x80710081,
CELL_HTTP_ERROR_DCACHE_ABORTED = 0x80710082,
CELL_HTTP_ERROR_DCACHE_INDEX_IS_CLOSING = 0x80710083,
CELL_HTTP_ERROR_DCACHE_UNKNOWN_INDEX_STATE = 0x80710084,
CELL_HTTP_ERROR_NET_FIN = 0x80710091,
CELL_HTTP_ERROR_NET_CONNECT_TIMEOUT = 0x80710092,
CELL_HTTP_ERROR_NET_SELECT_TIMEOUT = 0x80710093,
CELL_HTTP_ERROR_NET_SEND_TIMEOUT = 0x80710094,
};
// Error Codes - Https
enum CellHttpsError : u32
{
CELL_HTTPS_ERROR_CERTIFICATE_LOAD = 0x80710a01,
CELL_HTTPS_ERROR_BAD_MEMORY = 0x80710a02,
CELL_HTTPS_ERROR_CONTEXT_CREATION = 0x80710a03,
CELL_HTTPS_ERROR_CONNECTION_CREATION = 0x80710a04,
CELL_HTTPS_ERROR_SOCKET_ASSOCIATION = 0x80710a05,
CELL_HTTPS_ERROR_HANDSHAKE = 0x80710a06,
CELL_HTTPS_ERROR_LOOKUP_CERTIFICATE = 0x80710a07,
CELL_HTTPS_ERROR_NO_SSL = 0x80710a08,
CELL_HTTPS_ERROR_KEY_LOAD = 0x80710a09,
CELL_HTTPS_ERROR_CERT_KEY_MISMATCH = 0x80710a0a,
CELL_HTTPS_ERROR_KEY_NEEDS_CERT = 0x80710a0b,
CELL_HTTPS_ERROR_CERT_NEEDS_KEY = 0x80710a0c,
CELL_HTTPS_ERROR_RETRY_CONNECTION = 0x80710a0d,
CELL_HTTPS_ERROR_NET_SSL_CONNECT = 0x80710b00,
CELL_HTTPS_ERROR_NET_SSL_SEND = 0x80710c00,
CELL_HTTPS_ERROR_NET_SSL_RECV = 0x80710d00,
};
enum CellHttpErrorNet
{
CELL_HTTP_ERROR_NET_RESOLVER_NETDB_INTERNAL = 0x807101ff,
CELL_HTTP_ERROR_NET_RESOLVER_HOST_NOT_FOUND = 0x80710101,
CELL_HTTP_ERROR_NET_RESOLVER_TRY_AGAIN = 0x80710102,
CELL_HTTP_ERROR_NET_RESOLVER_NO_RECOVERY = 0x80710103,
CELL_HTTP_ERROR_NET_RESOLVER_NO_DATA = 0x80710104,
CELL_HTTP_ERROR_NET_RESOLVER_NO_ADDRESS = 0x80710104,
CELL_HTTP_ERROR_NET_ABORT_EPERM = 0x80710201,
CELL_HTTP_ERROR_NET_ABORT_ENOENT = 0x80710202,
CELL_HTTP_ERROR_NET_ABORT_ESRCH = 0x80710203,
CELL_HTTP_ERROR_NET_ABORT_EINTR = 0x80710204,
CELL_HTTP_ERROR_NET_ABORT_EIO = 0x80710205,
CELL_HTTP_ERROR_NET_ABORT_ENXIO = 0x80710206,
CELL_HTTP_ERROR_NET_ABORT_E2BIG = 0x80710207,
CELL_HTTP_ERROR_NET_ABORT_ENOEXC = 0x80710208,
CELL_HTTP_ERROR_NET_ABORT_EBADF = 0x80710209,
CELL_HTTP_ERROR_NET_ABORT_ECHILD = 0x8071020a,
CELL_HTTP_ERROR_NET_ABORT_EDEADLK = 0x8071020b,
CELL_HTTP_ERROR_NET_ABORT_ENOMEM = 0x8071020c,
CELL_HTTP_ERROR_NET_ABORT_EACCES = 0x8071020d,
CELL_HTTP_ERROR_NET_ABORT_EFAULT = 0x8071020e,
CELL_HTTP_ERROR_NET_ABORT_ENOTBLK = 0x8071020f,
CELL_HTTP_ERROR_NET_ABORT_EBUSY = 0x80710210,
CELL_HTTP_ERROR_NET_ABORT_EEXIST = 0x80710211,
CELL_HTTP_ERROR_NET_ABORT_EXDEV = 0x80710212,
CELL_HTTP_ERROR_NET_ABORT_ENODEV = 0x80710213,
CELL_HTTP_ERROR_NET_ABORT_ENOTDIR = 0x80710214,
CELL_HTTP_ERROR_NET_ABORT_EISDIR = 0x80710215,
CELL_HTTP_ERROR_NET_ABORT_EINVAL = 0x80710216,
CELL_HTTP_ERROR_NET_ABORT_ENFILE = 0x80710217,
CELL_HTTP_ERROR_NET_ABORT_EMFILE = 0x80710218,
CELL_HTTP_ERROR_NET_ABORT_ENOTTY = 0x80710219,
CELL_HTTP_ERROR_NET_ABORT_ETXTBSY = 0x8071021a,
CELL_HTTP_ERROR_NET_ABORT_EFBIG = 0x8071021b,
CELL_HTTP_ERROR_NET_ABORT_ENOSPC = 0x8071021c,
CELL_HTTP_ERROR_NET_ABORT_ESPIPE = 0x8071021d,
CELL_HTTP_ERROR_NET_ABORT_EROFS = 0x8071021e,
CELL_HTTP_ERROR_NET_ABORT_EMLINK = 0x8071021f,
CELL_HTTP_ERROR_NET_ABORT_EPIPE = 0x80710220,
CELL_HTTP_ERROR_NET_ABORT_EDOM = 0x80710221,
CELL_HTTP_ERROR_NET_ABORT_ERANGE = 0x80710222,
CELL_HTTP_ERROR_NET_ABORT_EAGAIN = 0x80710223,
CELL_HTTP_ERROR_NET_ABORT_EWOULDBLOCK = 0x80710223,
CELL_HTTP_ERROR_NET_ABORT_EINPROGRESS = 0x80710224,
CELL_HTTP_ERROR_NET_ABORT_EALREADY = 0x80710225,
CELL_HTTP_ERROR_NET_ABORT_ENOTSOCK = 0x80710226,
CELL_HTTP_ERROR_NET_ABORT_EDESTADDRREQ = 0x80710227,
CELL_HTTP_ERROR_NET_ABORT_EMSGSIZE = 0x80710228,
CELL_HTTP_ERROR_NET_ABORT_EPROTOTYPE = 0x80710229,
CELL_HTTP_ERROR_NET_ABORT_ENOPROTOOPT = 0x8071022a,
CELL_HTTP_ERROR_NET_ABORT_EPROTONOSUPPORT = 0x8071022b,
CELL_HTTP_ERROR_NET_ABORT_ESOCKTNOSUPPORT = 0x8071022c,
CELL_HTTP_ERROR_NET_ABORT_EOPNOTSUPP = 0x8071022d,
CELL_HTTP_ERROR_NET_ABORT_EPFNOSUPPORT = 0x8071022e,
CELL_HTTP_ERROR_NET_ABORT_EAFNOSUPPORT = 0x8071022f,
CELL_HTTP_ERROR_NET_ABORT_EADDRINUSE = 0x80710230,
CELL_HTTP_ERROR_NET_ABORT_EADDRNOTAVAIL = 0x80710231,
CELL_HTTP_ERROR_NET_ABORT_ENETDOWN = 0x80710232,
CELL_HTTP_ERROR_NET_ABORT_ENETUNREACH = 0x80710233,
CELL_HTTP_ERROR_NET_ABORT_ENETRESET = 0x80710234,
CELL_HTTP_ERROR_NET_ABORT_ECONNABORTED = 0x80710235,
CELL_HTTP_ERROR_NET_ABORT_ECONNRESET = 0x80710236,
CELL_HTTP_ERROR_NET_ABORT_ENOBUFS = 0x80710237,
CELL_HTTP_ERROR_NET_ABORT_EISCONN = 0x80710238,
CELL_HTTP_ERROR_NET_ABORT_ENOTCONN = 0x80710239,
CELL_HTTP_ERROR_NET_ABORT_ESHUTDOWN = 0x8071023a,
CELL_HTTP_ERROR_NET_ABORT_ETOOMANYREFS = 0x8071023b,
CELL_HTTP_ERROR_NET_ABORT_ETIMEDOUT = 0x8071023c,
CELL_HTTP_ERROR_NET_ABORT_ECONNREFUSED = 0x8071023d,
CELL_HTTP_ERROR_NET_ABORT_ELOOP = 0x8071023e,
CELL_HTTP_ERROR_NET_ABORT_ENAMETOOLONG = 0x8071023f,
CELL_HTTP_ERROR_NET_ABORT_EHOSTDOWN = 0x80710240,
CELL_HTTP_ERROR_NET_ABORT_EHOSTUNREACH = 0x80710241,
CELL_HTTP_ERROR_NET_ABORT_ENOTEMPTY = 0x80710242,
CELL_HTTP_ERROR_NET_ABORT_EPROCLIM = 0x80710243,
CELL_HTTP_ERROR_NET_ABORT_EUSERS = 0x80710244,
CELL_HTTP_ERROR_NET_ABORT_EDQUOT = 0x80710245,
CELL_HTTP_ERROR_NET_ABORT_ESTALE = 0x80710246,
CELL_HTTP_ERROR_NET_ABORT_EREMOTE = 0x80710247,
CELL_HTTP_ERROR_NET_ABORT_EBADRPC = 0x80710248,
CELL_HTTP_ERROR_NET_ABORT_ERPCMISMATCH = 0x80710249,
CELL_HTTP_ERROR_NET_ABORT_EPROGUNAVAIL = 0x8071024a,
CELL_HTTP_ERROR_NET_ABORT_EPROGMISMATCH = 0x8071024b,
CELL_HTTP_ERROR_NET_ABORT_EPROCUNAVAIL = 0x8071024c,
CELL_HTTP_ERROR_NET_ABORT_ENOLCK = 0x8071024d,
CELL_HTTP_ERROR_NET_ABORT_ENOSYS = 0x8071024e,
CELL_HTTP_ERROR_NET_ABORT_EFTYPE = 0x8071024f,
CELL_HTTP_ERROR_NET_ABORT_EAUTH = 0x80710250,
CELL_HTTP_ERROR_NET_ABORT_ENEEDAUTH = 0x80710251,
CELL_HTTP_ERROR_NET_ABORT_EIDRM = 0x80710252,
CELL_HTTP_ERROR_NET_ABORT_ENOMSG = 0x80710253,
CELL_HTTP_ERROR_NET_ABORT_EOVERFLOW = 0x80710254,
CELL_HTTP_ERROR_NET_ABORT_EILSEQ = 0x80710255,
CELL_HTTP_ERROR_NET_ABORT_ENOTSUP = 0x80710256,
CELL_HTTP_ERROR_NET_ABORT_ECANCELED = 0x80710257,
CELL_HTTP_ERROR_NET_ABORT_EBADMSG = 0x80710258,
CELL_HTTP_ERROR_NET_ABORT_ENODATA = 0x80710259,
CELL_HTTP_ERROR_NET_ABORT_ENOSR = 0x8071025a,
CELL_HTTP_ERROR_NET_ABORT_ENOSTR = 0x8071025b,
CELL_HTTP_ERROR_NET_ABORT_ETIME = 0x8071025c,
CELL_HTTP_ERROR_NET_OPTION_EPERM = 0x80710301,
CELL_HTTP_ERROR_NET_OPTION_ENOENT = 0x80710302,
CELL_HTTP_ERROR_NET_OPTION_ESRCH = 0x80710303,
CELL_HTTP_ERROR_NET_OPTION_EINTR = 0x80710304,
CELL_HTTP_ERROR_NET_OPTION_EIO = 0x80710305,
CELL_HTTP_ERROR_NET_OPTION_ENXIO = 0x80710306,
CELL_HTTP_ERROR_NET_OPTION_E2BIG = 0x80710307,
CELL_HTTP_ERROR_NET_OPTION_ENOEXC = 0x80710308,
CELL_HTTP_ERROR_NET_OPTION_EBADF = 0x80710309,
CELL_HTTP_ERROR_NET_OPTION_ECHILD = 0x8071030a,
CELL_HTTP_ERROR_NET_OPTION_EDEADLK = 0x8071030b,
CELL_HTTP_ERROR_NET_OPTION_ENOMEM = 0x8071030c,
CELL_HTTP_ERROR_NET_OPTION_EACCES = 0x8071030d,
CELL_HTTP_ERROR_NET_OPTION_EFAULT = 0x8071030e,
CELL_HTTP_ERROR_NET_OPTION_ENOTBLK = 0x8071030f,
CELL_HTTP_ERROR_NET_OPTION_EBUSY = 0x80710310,
CELL_HTTP_ERROR_NET_OPTION_EEXIST = 0x80710311,
CELL_HTTP_ERROR_NET_OPTION_EXDEV = 0x80710312,
CELL_HTTP_ERROR_NET_OPTION_ENODEV = 0x80710313,
CELL_HTTP_ERROR_NET_OPTION_ENOTDIR = 0x80710314,
CELL_HTTP_ERROR_NET_OPTION_EISDIR = 0x80710315,
CELL_HTTP_ERROR_NET_OPTION_EINVAL = 0x80710316,
CELL_HTTP_ERROR_NET_OPTION_ENFILE = 0x80710317,
CELL_HTTP_ERROR_NET_OPTION_EMFILE = 0x80710318,
CELL_HTTP_ERROR_NET_OPTION_ENOTTY = 0x80710319,
CELL_HTTP_ERROR_NET_OPTION_ETXTBSY = 0x8071031a,
CELL_HTTP_ERROR_NET_OPTION_EFBIG = 0x8071031b,
CELL_HTTP_ERROR_NET_OPTION_ENOSPC = 0x8071031c,
CELL_HTTP_ERROR_NET_OPTION_ESPIPE = 0x8071031d,
CELL_HTTP_ERROR_NET_OPTION_EROFS = 0x8071031e,
CELL_HTTP_ERROR_NET_OPTION_EMLINK = 0x8071031f,
CELL_HTTP_ERROR_NET_OPTION_EPIPE = 0x80710320,
CELL_HTTP_ERROR_NET_OPTION_EDOM = 0x80710321,
CELL_HTTP_ERROR_NET_OPTION_ERANGE = 0x80710322,
CELL_HTTP_ERROR_NET_OPTION_EAGAIN = 0x80710323,
CELL_HTTP_ERROR_NET_OPTION_EWOULDBLOCK = 0x80710323,
CELL_HTTP_ERROR_NET_OPTION_EINPROGRESS = 0x80710324,
CELL_HTTP_ERROR_NET_OPTION_EALREADY = 0x80710325,
CELL_HTTP_ERROR_NET_OPTION_ENOTSOCK = 0x80710326,
CELL_HTTP_ERROR_NET_OPTION_EDESTADDRREQ = 0x80710327,
CELL_HTTP_ERROR_NET_OPTION_EMSGSIZE = 0x80710328,
CELL_HTTP_ERROR_NET_OPTION_EPROTOTYPE = 0x80710329,
CELL_HTTP_ERROR_NET_OPTION_ENOPROTOOPT = 0x8071032a,
CELL_HTTP_ERROR_NET_OPTION_EPROTONOSUPPORT = 0x8071032b,
CELL_HTTP_ERROR_NET_OPTION_ESOCKTNOSUPPORT = 0x8071032c,
CELL_HTTP_ERROR_NET_OPTION_EOPNOTSUPP = 0x8071032d,
CELL_HTTP_ERROR_NET_OPTION_EPFNOSUPPORT = 0x8071032e,
CELL_HTTP_ERROR_NET_OPTION_EAFNOSUPPORT = 0x8071032f,
CELL_HTTP_ERROR_NET_OPTION_EADDRINUSE = 0x80710330,
CELL_HTTP_ERROR_NET_OPTION_EADDRNOTAVAIL = 0x80710331,
CELL_HTTP_ERROR_NET_OPTION_ENETDOWN = 0x80710332,
CELL_HTTP_ERROR_NET_OPTION_ENETUNREACH = 0x80710333,
CELL_HTTP_ERROR_NET_OPTION_ENETRESET = 0x80710334,
CELL_HTTP_ERROR_NET_OPTION_ECONNABORTED = 0x80710335,
CELL_HTTP_ERROR_NET_OPTION_ECONNRESET = 0x80710336,
CELL_HTTP_ERROR_NET_OPTION_ENOBUFS = 0x80710337,
CELL_HTTP_ERROR_NET_OPTION_EISCONN = 0x80710338,
CELL_HTTP_ERROR_NET_OPTION_ENOTCONN = 0x80710339,
CELL_HTTP_ERROR_NET_OPTION_ESHUTDOWN = 0x8071033a,
CELL_HTTP_ERROR_NET_OPTION_ETOOMANYREFS = 0x8071033b,
CELL_HTTP_ERROR_NET_OPTION_ETIMEDOUT = 0x8071033c,
CELL_HTTP_ERROR_NET_OPTION_ECONNREFUSED = 0x8071033d,
CELL_HTTP_ERROR_NET_OPTION_ELOOP = 0x8071033e,
CELL_HTTP_ERROR_NET_OPTION_ENAMETOOLONG = 0x8071033f,
CELL_HTTP_ERROR_NET_OPTION_EHOSTDOWN = 0x80710340,
CELL_HTTP_ERROR_NET_OPTION_EHOSTUNREACH = 0x80710341,
CELL_HTTP_ERROR_NET_OPTION_ENOTEMPTY = 0x80710342,
CELL_HTTP_ERROR_NET_OPTION_EPROCLIM = 0x80710343,
CELL_HTTP_ERROR_NET_OPTION_EUSERS = 0x80710344,
CELL_HTTP_ERROR_NET_OPTION_EDQUOT = 0x80710345,
CELL_HTTP_ERROR_NET_OPTION_ESTALE = 0x80710346,
CELL_HTTP_ERROR_NET_OPTION_EREMOTE = 0x80710347,
CELL_HTTP_ERROR_NET_OPTION_EBADRPC = 0x80710348,
CELL_HTTP_ERROR_NET_OPTION_ERPCMISMATCH = 0x80710349,
CELL_HTTP_ERROR_NET_OPTION_EPROGUNAVAIL = 0x8071034a,
CELL_HTTP_ERROR_NET_OPTION_EPROGMISMATCH = 0x8071034b,
CELL_HTTP_ERROR_NET_OPTION_EPROCUNAVAIL = 0x8071034c,
CELL_HTTP_ERROR_NET_OPTION_ENOLCK = 0x8071034d,
CELL_HTTP_ERROR_NET_OPTION_ENOSYS = 0x8071034e,
CELL_HTTP_ERROR_NET_OPTION_EFTYPE = 0x8071034f,
CELL_HTTP_ERROR_NET_OPTION_EAUTH = 0x80710350,
CELL_HTTP_ERROR_NET_OPTION_ENEEDAUTH = 0x80710351,
CELL_HTTP_ERROR_NET_OPTION_EIDRM = 0x80710352,
CELL_HTTP_ERROR_NET_OPTION_ENOMSG = 0x80710353,
CELL_HTTP_ERROR_NET_OPTION_EOVERFLOW = 0x80710354,
CELL_HTTP_ERROR_NET_OPTION_EILSEQ = 0x80710355,
CELL_HTTP_ERROR_NET_OPTION_ENOTSUP = 0x80710356,
CELL_HTTP_ERROR_NET_OPTION_ECANCELED = 0x80710357,
CELL_HTTP_ERROR_NET_OPTION_EBADMSG = 0x80710358,
CELL_HTTP_ERROR_NET_OPTION_ENODATA = 0x80710359,
CELL_HTTP_ERROR_NET_OPTION_ENOSR = 0x8071035a,
CELL_HTTP_ERROR_NET_OPTION_ENOSTR = 0x8071035b,
CELL_HTTP_ERROR_NET_OPTION_ETIME = 0x8071035c,
CELL_HTTP_ERROR_NET_SOCKET_EPERM = 0x80710401,
CELL_HTTP_ERROR_NET_SOCKET_ENOENT = 0x80710402,
CELL_HTTP_ERROR_NET_SOCKET_ESRCH = 0x80710403,
CELL_HTTP_ERROR_NET_SOCKET_EINTR = 0x80710404,
CELL_HTTP_ERROR_NET_SOCKET_EIO = 0x80710405,
CELL_HTTP_ERROR_NET_SOCKET_ENXIO = 0x80710406,
CELL_HTTP_ERROR_NET_SOCKET_E2BIG = 0x80710407,
CELL_HTTP_ERROR_NET_SOCKET_ENOEXC = 0x80710408,
CELL_HTTP_ERROR_NET_SOCKET_EBADF = 0x80710409,
CELL_HTTP_ERROR_NET_SOCKET_ECHILD = 0x8071040a,
CELL_HTTP_ERROR_NET_SOCKET_EDEADLK = 0x8071040b,
CELL_HTTP_ERROR_NET_SOCKET_ENOMEM = 0x8071040c,
CELL_HTTP_ERROR_NET_SOCKET_EACCES = 0x8071040d,
CELL_HTTP_ERROR_NET_SOCKET_EFAULT = 0x8071040e,
CELL_HTTP_ERROR_NET_SOCKET_ENOTBLK = 0x8071040f,
CELL_HTTP_ERROR_NET_SOCKET_EBUSY = 0x80710410,
CELL_HTTP_ERROR_NET_SOCKET_EEXIST = 0x80710411,
CELL_HTTP_ERROR_NET_SOCKET_EXDEV = 0x80710412,
CELL_HTTP_ERROR_NET_SOCKET_ENODEV = 0x80710413,
CELL_HTTP_ERROR_NET_SOCKET_ENOTDIR = 0x80710414,
CELL_HTTP_ERROR_NET_SOCKET_EISDIR = 0x80710415,
CELL_HTTP_ERROR_NET_SOCKET_EINVAL = 0x80710416,
CELL_HTTP_ERROR_NET_SOCKET_ENFILE = 0x80710417,
CELL_HTTP_ERROR_NET_SOCKET_EMFILE = 0x80710418,
CELL_HTTP_ERROR_NET_SOCKET_ENOTTY = 0x80710419,
CELL_HTTP_ERROR_NET_SOCKET_ETXTBSY = 0x8071041a,
CELL_HTTP_ERROR_NET_SOCKET_EFBIG = 0x8071041b,
CELL_HTTP_ERROR_NET_SOCKET_ENOSPC = 0x8071041c,
CELL_HTTP_ERROR_NET_SOCKET_ESPIPE = 0x8071041d,
CELL_HTTP_ERROR_NET_SOCKET_EROFS = 0x8071041e,
CELL_HTTP_ERROR_NET_SOCKET_EMLINK = 0x8071041f,
CELL_HTTP_ERROR_NET_SOCKET_EPIPE = 0x80710420,
CELL_HTTP_ERROR_NET_SOCKET_EDOM = 0x80710421,
CELL_HTTP_ERROR_NET_SOCKET_ERANGE = 0x80710422,
CELL_HTTP_ERROR_NET_SOCKET_EAGAIN = 0x80710423,
CELL_HTTP_ERROR_NET_SOCKET_EWOULDBLOCK = 0x80710423,
CELL_HTTP_ERROR_NET_SOCKET_EINPROGRESS = 0x80710424,
CELL_HTTP_ERROR_NET_SOCKET_EALREADY = 0x80710425,
CELL_HTTP_ERROR_NET_SOCKET_ENOTSOCK = 0x80710426,
CELL_HTTP_ERROR_NET_SOCKET_EDESTADDRREQ = 0x80710427,
CELL_HTTP_ERROR_NET_SOCKET_EMSGSIZE = 0x80710428,
CELL_HTTP_ERROR_NET_SOCKET_EPROTOTYPE = 0x80710429,
CELL_HTTP_ERROR_NET_SOCKET_ENOPROTOOPT = 0x8071042a,
CELL_HTTP_ERROR_NET_SOCKET_EPROTONOSUPPORT = 0x8071042b,
CELL_HTTP_ERROR_NET_SOCKET_ESOCKTNOSUPPORT = 0x8071042c,
CELL_HTTP_ERROR_NET_SOCKET_EOPNOTSUPP = 0x8071042d,
CELL_HTTP_ERROR_NET_SOCKET_EPFNOSUPPORT = 0x8071042e,
CELL_HTTP_ERROR_NET_SOCKET_EAFNOSUPPORT = 0x8071042f,
CELL_HTTP_ERROR_NET_SOCKET_EADDRINUSE = 0x80710430,
CELL_HTTP_ERROR_NET_SOCKET_EADDRNOTAVAIL = 0x80710431,
CELL_HTTP_ERROR_NET_SOCKET_ENETDOWN = 0x80710432,
CELL_HTTP_ERROR_NET_SOCKET_ENETUNREACH = 0x80710433,
CELL_HTTP_ERROR_NET_SOCKET_ENETRESET = 0x80710434,
CELL_HTTP_ERROR_NET_SOCKET_ECONNABORTED = 0x80710435,
CELL_HTTP_ERROR_NET_SOCKET_ECONNRESET = 0x80710436,
CELL_HTTP_ERROR_NET_SOCKET_ENOBUFS = 0x80710437,
CELL_HTTP_ERROR_NET_SOCKET_EISCONN = 0x80710438,
CELL_HTTP_ERROR_NET_SOCKET_ENOTCONN = 0x80710439,
CELL_HTTP_ERROR_NET_SOCKET_ESHUTDOWN = 0x8071043a,
CELL_HTTP_ERROR_NET_SOCKET_ETOOMANYREFS = 0x8071043b,
CELL_HTTP_ERROR_NET_SOCKET_ETIMEDOUT = 0x8071043c,
CELL_HTTP_ERROR_NET_SOCKET_ECONNREFUSED = 0x8071043d,
CELL_HTTP_ERROR_NET_SOCKET_ELOOP = 0x8071043e,
CELL_HTTP_ERROR_NET_SOCKET_ENAMETOOLONG = 0x8071043f,
CELL_HTTP_ERROR_NET_SOCKET_EHOSTDOWN = 0x80710440,
CELL_HTTP_ERROR_NET_SOCKET_EHOSTUNREACH = 0x80710441,
CELL_HTTP_ERROR_NET_SOCKET_ENOTEMPTY = 0x80710442,
CELL_HTTP_ERROR_NET_SOCKET_EPROCLIM = 0x80710443,
CELL_HTTP_ERROR_NET_SOCKET_EUSERS = 0x80710444,
CELL_HTTP_ERROR_NET_SOCKET_EDQUOT = 0x80710445,
CELL_HTTP_ERROR_NET_SOCKET_ESTALE = 0x80710446,
CELL_HTTP_ERROR_NET_SOCKET_EREMOTE = 0x80710447,
CELL_HTTP_ERROR_NET_SOCKET_EBADRPC = 0x80710448,
CELL_HTTP_ERROR_NET_SOCKET_ERPCMISMATCH = 0x80710449,
CELL_HTTP_ERROR_NET_SOCKET_EPROGUNAVAIL = 0x8071044a,
CELL_HTTP_ERROR_NET_SOCKET_EPROGMISMATCH = 0x8071044b,
CELL_HTTP_ERROR_NET_SOCKET_EPROCUNAVAIL = 0x8071044c,
CELL_HTTP_ERROR_NET_SOCKET_ENOLCK = 0x8071044d,
CELL_HTTP_ERROR_NET_SOCKET_ENOSYS = 0x8071044e,
CELL_HTTP_ERROR_NET_SOCKET_EFTYPE = 0x8071044f,
CELL_HTTP_ERROR_NET_SOCKET_EAUTH = 0x80710450,
CELL_HTTP_ERROR_NET_SOCKET_ENEEDAUTH = 0x80710451,
CELL_HTTP_ERROR_NET_SOCKET_EIDRM = 0x80710452,
CELL_HTTP_ERROR_NET_SOCKET_ENOMSG = 0x80710453,
CELL_HTTP_ERROR_NET_SOCKET_EOVERFLOW = 0x80710454,
CELL_HTTP_ERROR_NET_SOCKET_EILSEQ = 0x80710455,
CELL_HTTP_ERROR_NET_SOCKET_ENOTSUP = 0x80710456,
CELL_HTTP_ERROR_NET_SOCKET_ECANCELED = 0x80710457,
CELL_HTTP_ERROR_NET_SOCKET_EBADMSG = 0x80710458,
CELL_HTTP_ERROR_NET_SOCKET_ENODATA = 0x80710459,
CELL_HTTP_ERROR_NET_SOCKET_ENOSR = 0x8071045a,
CELL_HTTP_ERROR_NET_SOCKET_ENOSTR = 0x8071045b,
CELL_HTTP_ERROR_NET_SOCKET_ETIME = 0x8071045c,
CELL_HTTP_ERROR_NET_CONNECT_EPERM = 0x80710501,
CELL_HTTP_ERROR_NET_CONNECT_ENOENT = 0x80710502,
CELL_HTTP_ERROR_NET_CONNECT_ESRCH = 0x80710503,
CELL_HTTP_ERROR_NET_CONNECT_EINTR = 0x80710504,
CELL_HTTP_ERROR_NET_CONNECT_EIO = 0x80710505,
CELL_HTTP_ERROR_NET_CONNECT_ENXIO = 0x80710506,
CELL_HTTP_ERROR_NET_CONNECT_E2BIG = 0x80710507,
CELL_HTTP_ERROR_NET_CONNECT_ENOEXC = 0x80710508,
CELL_HTTP_ERROR_NET_CONNECT_EBADF = 0x80710509,
CELL_HTTP_ERROR_NET_CONNECT_ECHILD = 0x8071050a,
CELL_HTTP_ERROR_NET_CONNECT_EDEADLK = 0x8071050b,
CELL_HTTP_ERROR_NET_CONNECT_ENOMEM = 0x8071050c,
CELL_HTTP_ERROR_NET_CONNECT_EACCES = 0x8071050d,
CELL_HTTP_ERROR_NET_CONNECT_EFAULT = 0x8071050e,
CELL_HTTP_ERROR_NET_CONNECT_ENOTBLK = 0x8071050f,
CELL_HTTP_ERROR_NET_CONNECT_EBUSY = 0x80710510,
CELL_HTTP_ERROR_NET_CONNECT_EEXIST = 0x80710511,
CELL_HTTP_ERROR_NET_CONNECT_EXDEV = 0x80710512,
CELL_HTTP_ERROR_NET_CONNECT_ENODEV = 0x80710513,
CELL_HTTP_ERROR_NET_CONNECT_ENOTDIR = 0x80710514,
CELL_HTTP_ERROR_NET_CONNECT_EISDIR = 0x80710515,
CELL_HTTP_ERROR_NET_CONNECT_EINVAL = 0x80710516,
CELL_HTTP_ERROR_NET_CONNECT_ENFILE = 0x80710517,
CELL_HTTP_ERROR_NET_CONNECT_EMFILE = 0x80710518,
CELL_HTTP_ERROR_NET_CONNECT_ENOTTY = 0x80710519,
CELL_HTTP_ERROR_NET_CONNECT_ETXTBSY = 0x8071051a,
CELL_HTTP_ERROR_NET_CONNECT_EFBIG = 0x8071051b,
CELL_HTTP_ERROR_NET_CONNECT_ENOSPC = 0x8071051c,
CELL_HTTP_ERROR_NET_CONNECT_ESPIPE = 0x8071051d,
CELL_HTTP_ERROR_NET_CONNECT_EROFS = 0x8071051e,
CELL_HTTP_ERROR_NET_CONNECT_EMLINK = 0x8071051f,
CELL_HTTP_ERROR_NET_CONNECT_EPIPE = 0x80710520,
CELL_HTTP_ERROR_NET_CONNECT_EDOM = 0x80710521,
CELL_HTTP_ERROR_NET_CONNECT_ERANGE = 0x80710522,
CELL_HTTP_ERROR_NET_CONNECT_EAGAIN = 0x80710523,
CELL_HTTP_ERROR_NET_CONNECT_EWOULDBLOCK = 0x80710523,
CELL_HTTP_ERROR_NET_CONNECT_EINPROGRESS = 0x80710524,
CELL_HTTP_ERROR_NET_CONNECT_EALREADY = 0x80710525,
CELL_HTTP_ERROR_NET_CONNECT_ENOTSOCK = 0x80710526,
CELL_HTTP_ERROR_NET_CONNECT_EDESTADDRREQ = 0x80710527,
CELL_HTTP_ERROR_NET_CONNECT_EMSGSIZE = 0x80710528,
CELL_HTTP_ERROR_NET_CONNECT_EPROTOTYPE = 0x80710529,
CELL_HTTP_ERROR_NET_CONNECT_ENOPROTOOPT = 0x8071052a,
CELL_HTTP_ERROR_NET_CONNECT_EPROTONOSUPPORT = 0x8071052b,
CELL_HTTP_ERROR_NET_CONNECT_ESOCKTNOSUPPORT = 0x8071052c,
CELL_HTTP_ERROR_NET_CONNECT_EOPNOTSUPP = 0x8071052d,
CELL_HTTP_ERROR_NET_CONNECT_EPFNOSUPPORT = 0x8071052e,
CELL_HTTP_ERROR_NET_CONNECT_EAFNOSUPPORT = 0x8071052f,
CELL_HTTP_ERROR_NET_CONNECT_EADDRINUSE = 0x80710530,
CELL_HTTP_ERROR_NET_CONNECT_EADDRNOTAVAIL = 0x80710531,
CELL_HTTP_ERROR_NET_CONNECT_ENETDOWN = 0x80710532,
CELL_HTTP_ERROR_NET_CONNECT_ENETUNREACH = 0x80710533,
CELL_HTTP_ERROR_NET_CONNECT_ENETRESET = 0x80710534,
CELL_HTTP_ERROR_NET_CONNECT_ECONNABORTED = 0x80710535,
CELL_HTTP_ERROR_NET_CONNECT_ECONNRESET = 0x80710536,
CELL_HTTP_ERROR_NET_CONNECT_ENOBUFS = 0x80710537,
CELL_HTTP_ERROR_NET_CONNECT_EISCONN = 0x80710538,
CELL_HTTP_ERROR_NET_CONNECT_ENOTCONN = 0x80710539,
CELL_HTTP_ERROR_NET_CONNECT_ESHUTDOWN = 0x8071053a,
CELL_HTTP_ERROR_NET_CONNECT_ETOOMANYREFS = 0x8071053b,
CELL_HTTP_ERROR_NET_CONNECT_ETIMEDOUT = 0x8071053c,
CELL_HTTP_ERROR_NET_CONNECT_ECONNREFUSED = 0x8071053d,
CELL_HTTP_ERROR_NET_CONNECT_ELOOP = 0x8071053e,
CELL_HTTP_ERROR_NET_CONNECT_ENAMETOOLONG = 0x8071053f,
CELL_HTTP_ERROR_NET_CONNECT_EHOSTDOWN = 0x80710540,
CELL_HTTP_ERROR_NET_CONNECT_EHOSTUNREACH = 0x80710541,
CELL_HTTP_ERROR_NET_CONNECT_ENOTEMPTY = 0x80710542,
CELL_HTTP_ERROR_NET_CONNECT_EPROCLIM = 0x80710543,
CELL_HTTP_ERROR_NET_CONNECT_EUSERS = 0x80710544,
CELL_HTTP_ERROR_NET_CONNECT_EDQUOT = 0x80710545,
CELL_HTTP_ERROR_NET_CONNECT_ESTALE = 0x80710546,
CELL_HTTP_ERROR_NET_CONNECT_EREMOTE = 0x80710547,
CELL_HTTP_ERROR_NET_CONNECT_EBADRPC = 0x80710548,
CELL_HTTP_ERROR_NET_CONNECT_ERPCMISMATCH = 0x80710549,
CELL_HTTP_ERROR_NET_CONNECT_EPROGUNAVAIL = 0x8071054a,
CELL_HTTP_ERROR_NET_CONNECT_EPROGMISMATCH = 0x8071054b,
CELL_HTTP_ERROR_NET_CONNECT_EPROCUNAVAIL = 0x8071054c,
CELL_HTTP_ERROR_NET_CONNECT_ENOLCK = 0x8071054d,
CELL_HTTP_ERROR_NET_CONNECT_ENOSYS = 0x8071054e,
CELL_HTTP_ERROR_NET_CONNECT_EFTYPE = 0x8071054f,
CELL_HTTP_ERROR_NET_CONNECT_EAUTH = 0x80710550,
CELL_HTTP_ERROR_NET_CONNECT_ENEEDAUTH = 0x80710551,
CELL_HTTP_ERROR_NET_CONNECT_EIDRM = 0x80710552,
CELL_HTTP_ERROR_NET_CONNECT_ENOMSG = 0x80710553,
CELL_HTTP_ERROR_NET_CONNECT_EOVERFLOW = 0x80710554,
CELL_HTTP_ERROR_NET_CONNECT_EILSEQ = 0x80710555,
CELL_HTTP_ERROR_NET_CONNECT_ENOTSUP = 0x80710556,
CELL_HTTP_ERROR_NET_CONNECT_ECANCELED = 0x80710557,
CELL_HTTP_ERROR_NET_CONNECT_EBADMSG = 0x80710558,
CELL_HTTP_ERROR_NET_CONNECT_ENODATA = 0x80710559,
CELL_HTTP_ERROR_NET_CONNECT_ENOSR = 0x8071055a,
CELL_HTTP_ERROR_NET_CONNECT_ENOSTR = 0x8071055b,
CELL_HTTP_ERROR_NET_CONNECT_ETIME = 0x8071055c,
CELL_HTTP_ERROR_NET_SEND_EPERM = 0x80710601,
CELL_HTTP_ERROR_NET_SEND_ENOENT = 0x80710602,
CELL_HTTP_ERROR_NET_SEND_ESRCH = 0x80710603,
CELL_HTTP_ERROR_NET_SEND_EINTR = 0x80710604,
CELL_HTTP_ERROR_NET_SEND_EIO = 0x80710605,
CELL_HTTP_ERROR_NET_SEND_ENXIO = 0x80710606,
CELL_HTTP_ERROR_NET_SEND_E2BIG = 0x80710607,
CELL_HTTP_ERROR_NET_SEND_ENOEXC = 0x80710608,
CELL_HTTP_ERROR_NET_SEND_EBADF = 0x80710609,
CELL_HTTP_ERROR_NET_SEND_ECHILD = 0x8071060a,
CELL_HTTP_ERROR_NET_SEND_EDEADLK = 0x8071060b,
CELL_HTTP_ERROR_NET_SEND_ENOMEM = 0x8071060c,
CELL_HTTP_ERROR_NET_SEND_EACCES = 0x8071060d,
CELL_HTTP_ERROR_NET_SEND_EFAULT = 0x8071060e,
CELL_HTTP_ERROR_NET_SEND_ENOTBLK = 0x8071060f,
CELL_HTTP_ERROR_NET_SEND_EBUSY = 0x80710610,
CELL_HTTP_ERROR_NET_SEND_EEXIST = 0x80710611,
CELL_HTTP_ERROR_NET_SEND_EXDEV = 0x80710612,
CELL_HTTP_ERROR_NET_SEND_ENODEV = 0x80710613,
CELL_HTTP_ERROR_NET_SEND_ENOTDIR = 0x80710614,
CELL_HTTP_ERROR_NET_SEND_EISDIR = 0x80710615,
CELL_HTTP_ERROR_NET_SEND_EINVAL = 0x80710616,
CELL_HTTP_ERROR_NET_SEND_ENFILE = 0x80710617,
CELL_HTTP_ERROR_NET_SEND_EMFILE = 0x80710618,
CELL_HTTP_ERROR_NET_SEND_ENOTTY = 0x80710619,
CELL_HTTP_ERROR_NET_SEND_ETXTBSY = 0x8071061a,
CELL_HTTP_ERROR_NET_SEND_EFBIG = 0x8071061b,
CELL_HTTP_ERROR_NET_SEND_ENOSPC = 0x8071061c,
CELL_HTTP_ERROR_NET_SEND_ESPIPE = 0x8071061d,
CELL_HTTP_ERROR_NET_SEND_EROFS = 0x8071061e,
CELL_HTTP_ERROR_NET_SEND_EMLINK = 0x8071061f,
CELL_HTTP_ERROR_NET_SEND_EPIPE = 0x80710620,
CELL_HTTP_ERROR_NET_SEND_EDOM = 0x80710621,
CELL_HTTP_ERROR_NET_SEND_ERANGE = 0x80710622,
CELL_HTTP_ERROR_NET_SEND_EAGAIN = 0x80710623,
CELL_HTTP_ERROR_NET_SEND_EWOULDBLOCK = 0x80710623,
CELL_HTTP_ERROR_NET_SEND_EINPROGRESS = 0x80710624,
CELL_HTTP_ERROR_NET_SEND_EALREADY = 0x80710625,
CELL_HTTP_ERROR_NET_SEND_ENOTSOCK = 0x80710626,
CELL_HTTP_ERROR_NET_SEND_EDESTADDRREQ = 0x80710627,
CELL_HTTP_ERROR_NET_SEND_EMSGSIZE = 0x80710628,
CELL_HTTP_ERROR_NET_SEND_EPROTOTYPE = 0x80710629,
CELL_HTTP_ERROR_NET_SEND_ENOPROTOOPT = 0x8071062a,
CELL_HTTP_ERROR_NET_SEND_EPROTONOSUPPORT = 0x8071062b,
CELL_HTTP_ERROR_NET_SEND_ESOCKTNOSUPPORT = 0x8071062c,
CELL_HTTP_ERROR_NET_SEND_EOPNOTSUPP = 0x8071062d,
CELL_HTTP_ERROR_NET_SEND_EPFNOSUPPORT = 0x8071062e,
CELL_HTTP_ERROR_NET_SEND_EAFNOSUPPORT = 0x8071062f,
CELL_HTTP_ERROR_NET_SEND_EADDRINUSE = 0x80710630,
CELL_HTTP_ERROR_NET_SEND_EADDRNOTAVAIL = 0x80710631,
CELL_HTTP_ERROR_NET_SEND_ENETDOWN = 0x80710632,
CELL_HTTP_ERROR_NET_SEND_ENETUNREACH = 0x80710633,
CELL_HTTP_ERROR_NET_SEND_ENETRESET = 0x80710634,
CELL_HTTP_ERROR_NET_SEND_ECONNABORTED = 0x80710635,
CELL_HTTP_ERROR_NET_SEND_ECONNRESET = 0x80710636,
CELL_HTTP_ERROR_NET_SEND_ENOBUFS = 0x80710637,
CELL_HTTP_ERROR_NET_SEND_EISCONN = 0x80710638,
CELL_HTTP_ERROR_NET_SEND_ENOTCONN = 0x80710639,
CELL_HTTP_ERROR_NET_SEND_ESHUTDOWN = 0x8071063a,
CELL_HTTP_ERROR_NET_SEND_ETOOMANYREFS = 0x8071063b,
CELL_HTTP_ERROR_NET_SEND_ETIMEDOUT = 0x8071063c,
CELL_HTTP_ERROR_NET_SEND_ECONNREFUSED = 0x8071063d,
CELL_HTTP_ERROR_NET_SEND_ELOOP = 0x8071063e,
CELL_HTTP_ERROR_NET_SEND_ENAMETOOLONG = 0x8071063f,
CELL_HTTP_ERROR_NET_SEND_EHOSTDOWN = 0x80710640,
CELL_HTTP_ERROR_NET_SEND_EHOSTUNREACH = 0x80710641,
CELL_HTTP_ERROR_NET_SEND_ENOTEMPTY = 0x80710642,
CELL_HTTP_ERROR_NET_SEND_EPROCLIM = 0x80710643,
CELL_HTTP_ERROR_NET_SEND_EUSERS = 0x80710644,
CELL_HTTP_ERROR_NET_SEND_EDQUOT = 0x80710645,
CELL_HTTP_ERROR_NET_SEND_ESTALE = 0x80710646,
CELL_HTTP_ERROR_NET_SEND_EREMOTE = 0x80710647,
CELL_HTTP_ERROR_NET_SEND_EBADRPC = 0x80710648,
CELL_HTTP_ERROR_NET_SEND_ERPCMISMATCH = 0x80710649,
CELL_HTTP_ERROR_NET_SEND_EPROGUNAVAIL = 0x8071064a,
CELL_HTTP_ERROR_NET_SEND_EPROGMISMATCH = 0x8071064b,
CELL_HTTP_ERROR_NET_SEND_EPROCUNAVAIL = 0x8071064c,
CELL_HTTP_ERROR_NET_SEND_ENOLCK = 0x8071064d,
CELL_HTTP_ERROR_NET_SEND_ENOSYS = 0x8071064e,
CELL_HTTP_ERROR_NET_SEND_EFTYPE = 0x8071064f,
CELL_HTTP_ERROR_NET_SEND_EAUTH = 0x80710650,
CELL_HTTP_ERROR_NET_SEND_ENEEDAUTH = 0x80710651,
CELL_HTTP_ERROR_NET_SEND_EIDRM = 0x80710652,
CELL_HTTP_ERROR_NET_SEND_ENOMSG = 0x80710653,
CELL_HTTP_ERROR_NET_SEND_EOVERFLOW = 0x80710654,
CELL_HTTP_ERROR_NET_SEND_EILSEQ = 0x80710655,
CELL_HTTP_ERROR_NET_SEND_ENOTSUP = 0x80710656,
CELL_HTTP_ERROR_NET_SEND_ECANCELED = 0x80710657,
CELL_HTTP_ERROR_NET_SEND_EBADMSG = 0x80710658,
CELL_HTTP_ERROR_NET_SEND_ENODATA = 0x80710659,
CELL_HTTP_ERROR_NET_SEND_ENOSR = 0x8071065a,
CELL_HTTP_ERROR_NET_SEND_ENOSTR = 0x8071065b,
CELL_HTTP_ERROR_NET_SEND_ETIME = 0x8071065c,
CELL_HTTP_ERROR_NET_RECV_EPERM = 0x80710701,
CELL_HTTP_ERROR_NET_RECV_ENOENT = 0x80710702,
CELL_HTTP_ERROR_NET_RECV_ESRCH = 0x80710703,
CELL_HTTP_ERROR_NET_RECV_EINTR = 0x80710704,
CELL_HTTP_ERROR_NET_RECV_EIO = 0x80710705,
CELL_HTTP_ERROR_NET_RECV_ENXIO = 0x80710706,
CELL_HTTP_ERROR_NET_RECV_E2BIG = 0x80710707,
CELL_HTTP_ERROR_NET_RECV_ENOEXC = 0x80710708,
CELL_HTTP_ERROR_NET_RECV_EBADF = 0x80710709,
CELL_HTTP_ERROR_NET_RECV_ECHILD = 0x8071070a,
CELL_HTTP_ERROR_NET_RECV_EDEADLK = 0x8071070b,
CELL_HTTP_ERROR_NET_RECV_ENOMEM = 0x8071070c,
CELL_HTTP_ERROR_NET_RECV_EACCES = 0x8071070d,
CELL_HTTP_ERROR_NET_RECV_EFAULT = 0x8071070e,
CELL_HTTP_ERROR_NET_RECV_ENOTBLK = 0x8071070f,
CELL_HTTP_ERROR_NET_RECV_EBUSY = 0x80710710,
CELL_HTTP_ERROR_NET_RECV_EEXIST = 0x80710711,
CELL_HTTP_ERROR_NET_RECV_EXDEV = 0x80710712,
CELL_HTTP_ERROR_NET_RECV_ENODEV = 0x80710713,
CELL_HTTP_ERROR_NET_RECV_ENOTDIR = 0x80710714,
CELL_HTTP_ERROR_NET_RECV_EISDIR = 0x80710715,
CELL_HTTP_ERROR_NET_RECV_EINVAL = 0x80710716,
CELL_HTTP_ERROR_NET_RECV_ENFILE = 0x80710717,
CELL_HTTP_ERROR_NET_RECV_EMFILE = 0x80710718,
CELL_HTTP_ERROR_NET_RECV_ENOTTY = 0x80710719,
CELL_HTTP_ERROR_NET_RECV_ETXTBSY = 0x8071071a,
CELL_HTTP_ERROR_NET_RECV_EFBIG = 0x8071071b,
CELL_HTTP_ERROR_NET_RECV_ENOSPC = 0x8071071c,
CELL_HTTP_ERROR_NET_RECV_ESPIPE = 0x8071071d,
CELL_HTTP_ERROR_NET_RECV_EROFS = 0x8071071e,
CELL_HTTP_ERROR_NET_RECV_EMLINK = 0x8071071f,
CELL_HTTP_ERROR_NET_RECV_EPIPE = 0x80710720,
CELL_HTTP_ERROR_NET_RECV_EDOM = 0x80710721,
CELL_HTTP_ERROR_NET_RECV_ERANGE = 0x80710722,
CELL_HTTP_ERROR_NET_RECV_EAGAIN = 0x80710723,
CELL_HTTP_ERROR_NET_RECV_EWOULDBLOCK = 0x80710723,
CELL_HTTP_ERROR_NET_RECV_EINPROGRESS = 0x80710724,
CELL_HTTP_ERROR_NET_RECV_EALREADY = 0x80710725,
CELL_HTTP_ERROR_NET_RECV_ENOTSOCK = 0x80710726,
CELL_HTTP_ERROR_NET_RECV_EDESTADDRREQ = 0x80710727,
CELL_HTTP_ERROR_NET_RECV_EMSGSIZE = 0x80710728,
CELL_HTTP_ERROR_NET_RECV_EPROTOTYPE = 0x80710729,
CELL_HTTP_ERROR_NET_RECV_ENOPROTOOPT = 0x8071072a,
CELL_HTTP_ERROR_NET_RECV_EPROTONOSUPPORT = 0x8071072b,
CELL_HTTP_ERROR_NET_RECV_ESOCKTNOSUPPORT = 0x8071072c,
CELL_HTTP_ERROR_NET_RECV_EOPNOTSUPP = 0x8071072d,
CELL_HTTP_ERROR_NET_RECV_EPFNOSUPPORT = 0x8071072e,
CELL_HTTP_ERROR_NET_RECV_EAFNOSUPPORT = 0x8071072f,
CELL_HTTP_ERROR_NET_RECV_EADDRINUSE = 0x80710730,
CELL_HTTP_ERROR_NET_RECV_EADDRNOTAVAIL = 0x80710731,
CELL_HTTP_ERROR_NET_RECV_ENETDOWN = 0x80710732,
CELL_HTTP_ERROR_NET_RECV_ENETUNREACH = 0x80710733,
CELL_HTTP_ERROR_NET_RECV_ENETRESET = 0x80710734,
CELL_HTTP_ERROR_NET_RECV_ECONNABORTED = 0x80710735,
CELL_HTTP_ERROR_NET_RECV_ECONNRESET = 0x80710736,
CELL_HTTP_ERROR_NET_RECV_ENOBUFS = 0x80710737,
CELL_HTTP_ERROR_NET_RECV_EISCONN = 0x80710738,
CELL_HTTP_ERROR_NET_RECV_ENOTCONN = 0x80710739,
CELL_HTTP_ERROR_NET_RECV_ESHUTDOWN = 0x8071073a,
CELL_HTTP_ERROR_NET_RECV_ETOOMANYREFS = 0x8071073b,
CELL_HTTP_ERROR_NET_RECV_ETIMEDOUT = 0x8071073c,
CELL_HTTP_ERROR_NET_RECV_ECONNREFUSED = 0x8071073d,
CELL_HTTP_ERROR_NET_RECV_ELOOP = 0x8071073e,
CELL_HTTP_ERROR_NET_RECV_ENAMETOOLONG = 0x8071073f,
CELL_HTTP_ERROR_NET_RECV_EHOSTDOWN = 0x80710740,
CELL_HTTP_ERROR_NET_RECV_EHOSTUNREACH = 0x80710741,
CELL_HTTP_ERROR_NET_RECV_ENOTEMPTY = 0x80710742,
CELL_HTTP_ERROR_NET_RECV_EPROCLIM = 0x80710743,
CELL_HTTP_ERROR_NET_RECV_EUSERS = 0x80710744,
CELL_HTTP_ERROR_NET_RECV_EDQUOT = 0x80710745,
CELL_HTTP_ERROR_NET_RECV_ESTALE = 0x80710746,
CELL_HTTP_ERROR_NET_RECV_EREMOTE = 0x80710747,
CELL_HTTP_ERROR_NET_RECV_EBADRPC = 0x80710748,
CELL_HTTP_ERROR_NET_RECV_ERPCMISMATCH = 0x80710749,
CELL_HTTP_ERROR_NET_RECV_EPROGUNAVAIL = 0x8071074a,
CELL_HTTP_ERROR_NET_RECV_EPROGMISMATCH = 0x8071074b,
CELL_HTTP_ERROR_NET_RECV_EPROCUNAVAIL = 0x8071074c,
CELL_HTTP_ERROR_NET_RECV_ENOLCK = 0x8071074d,
CELL_HTTP_ERROR_NET_RECV_ENOSYS = 0x8071074e,
CELL_HTTP_ERROR_NET_RECV_EFTYPE = 0x8071074f,
CELL_HTTP_ERROR_NET_RECV_EAUTH = 0x80710750,
CELL_HTTP_ERROR_NET_RECV_ENEEDAUTH = 0x80710751,
CELL_HTTP_ERROR_NET_RECV_EIDRM = 0x80710752,
CELL_HTTP_ERROR_NET_RECV_ENOMSG = 0x80710753,
CELL_HTTP_ERROR_NET_RECV_EOVERFLOW = 0x80710754,
CELL_HTTP_ERROR_NET_RECV_EILSEQ = 0x80710755,
CELL_HTTP_ERROR_NET_RECV_ENOTSUP = 0x80710756,
CELL_HTTP_ERROR_NET_RECV_ECANCELED = 0x80710757,
CELL_HTTP_ERROR_NET_RECV_EBADMSG = 0x80710758,
CELL_HTTP_ERROR_NET_RECV_ENODATA = 0x80710759,
CELL_HTTP_ERROR_NET_RECV_ENOSR = 0x8071075a,
CELL_HTTP_ERROR_NET_RECV_ENOSTR = 0x8071075b,
CELL_HTTP_ERROR_NET_RECV_ETIME = 0x8071075c,
CELL_HTTP_ERROR_NET_SELECT_EPERM = 0x80710801,
CELL_HTTP_ERROR_NET_SELECT_ENOENT = 0x80710802,
CELL_HTTP_ERROR_NET_SELECT_ESRCH = 0x80710803,
CELL_HTTP_ERROR_NET_SELECT_EINTR = 0x80710804,
CELL_HTTP_ERROR_NET_SELECT_EIO = 0x80710805,
CELL_HTTP_ERROR_NET_SELECT_ENXIO = 0x80710806,
CELL_HTTP_ERROR_NET_SELECT_E2BIG = 0x80710807,
CELL_HTTP_ERROR_NET_SELECT_ENOEXC = 0x80710808,
CELL_HTTP_ERROR_NET_SELECT_EBADF = 0x80710809,
CELL_HTTP_ERROR_NET_SELECT_ECHILD = 0x8071080a,
CELL_HTTP_ERROR_NET_SELECT_EDEADLK = 0x8071080b,
CELL_HTTP_ERROR_NET_SELECT_ENOMEM = 0x8071080c,
CELL_HTTP_ERROR_NET_SELECT_EACCES = 0x8071080d,
CELL_HTTP_ERROR_NET_SELECT_EFAULT = 0x8071080e,
CELL_HTTP_ERROR_NET_SELECT_ENOTBLK = 0x8071080f,
CELL_HTTP_ERROR_NET_SELECT_EBUSY = 0x80710810,
CELL_HTTP_ERROR_NET_SELECT_EEXIST = 0x80710811,
CELL_HTTP_ERROR_NET_SELECT_EXDEV = 0x80710812,
CELL_HTTP_ERROR_NET_SELECT_ENODEV = 0x80710813,
CELL_HTTP_ERROR_NET_SELECT_ENOTDIR = 0x80710814,
CELL_HTTP_ERROR_NET_SELECT_EISDIR = 0x80710815,
CELL_HTTP_ERROR_NET_SELECT_EINVAL = 0x80710816,
CELL_HTTP_ERROR_NET_SELECT_ENFILE = 0x80710817,
CELL_HTTP_ERROR_NET_SELECT_EMFILE = 0x80710818,
CELL_HTTP_ERROR_NET_SELECT_ENOTTY = 0x80710819,
CELL_HTTP_ERROR_NET_SELECT_ETXTBSY = 0x8071081a,
CELL_HTTP_ERROR_NET_SELECT_EFBIG = 0x8071081b,
CELL_HTTP_ERROR_NET_SELECT_ENOSPC = 0x8071081c,
CELL_HTTP_ERROR_NET_SELECT_ESPIPE = 0x8071081d,
CELL_HTTP_ERROR_NET_SELECT_EROFS = 0x8071081e,
CELL_HTTP_ERROR_NET_SELECT_EMLINK = 0x8071081f,
CELL_HTTP_ERROR_NET_SELECT_EPIPE = 0x80710820,
CELL_HTTP_ERROR_NET_SELECT_EDOM = 0x80710821,
CELL_HTTP_ERROR_NET_SELECT_ERANGE = 0x80710822,
CELL_HTTP_ERROR_NET_SELECT_EAGAIN = 0x80710823,
CELL_HTTP_ERROR_NET_SELECT_EWOULDBLOCK = 0x80710823,
CELL_HTTP_ERROR_NET_SELECT_EINPROGRESS = 0x80710824,
CELL_HTTP_ERROR_NET_SELECT_EALREADY = 0x80710825,
CELL_HTTP_ERROR_NET_SELECT_ENOTSOCK = 0x80710826,
CELL_HTTP_ERROR_NET_SELECT_EDESTADDRREQ = 0x80710827,
CELL_HTTP_ERROR_NET_SELECT_EMSGSIZE = 0x80710828,
CELL_HTTP_ERROR_NET_SELECT_EPROTOTYPE = 0x80710829,
CELL_HTTP_ERROR_NET_SELECT_ENOPROTOOPT = 0x8071082a,
CELL_HTTP_ERROR_NET_SELECT_EPROTONOSUPPORT = 0x8071082b,
CELL_HTTP_ERROR_NET_SELECT_ESOCKTNOSUPPORT = 0x8071082c,
CELL_HTTP_ERROR_NET_SELECT_EOPNOTSUPP = 0x8071082d,
CELL_HTTP_ERROR_NET_SELECT_EPFNOSUPPORT = 0x8071082e,
CELL_HTTP_ERROR_NET_SELECT_EAFNOSUPPORT = 0x8071082f,
CELL_HTTP_ERROR_NET_SELECT_EADDRINUSE = 0x80710830,
CELL_HTTP_ERROR_NET_SELECT_EADDRNOTAVAIL = 0x80710831,
CELL_HTTP_ERROR_NET_SELECT_ENETDOWN = 0x80710832,
CELL_HTTP_ERROR_NET_SELECT_ENETUNREACH = 0x80710833,
CELL_HTTP_ERROR_NET_SELECT_ENETRESET = 0x80710834,
CELL_HTTP_ERROR_NET_SELECT_ECONNABORTED = 0x80710835,
CELL_HTTP_ERROR_NET_SELECT_ECONNRESET = 0x80710836,
CELL_HTTP_ERROR_NET_SELECT_ENOBUFS = 0x80710837,
CELL_HTTP_ERROR_NET_SELECT_EISCONN = 0x80710838,
CELL_HTTP_ERROR_NET_SELECT_ENOTCONN = 0x80710839,
CELL_HTTP_ERROR_NET_SELECT_ESHUTDOWN = 0x8071083a,
CELL_HTTP_ERROR_NET_SELECT_ETOOMANYREFS = 0x8071083b,
CELL_HTTP_ERROR_NET_SELECT_ETIMEDOUT = 0x8071083c,
CELL_HTTP_ERROR_NET_SELECT_ECONNREFUSED = 0x8071083d,
CELL_HTTP_ERROR_NET_SELECT_ELOOP = 0x8071083e,
CELL_HTTP_ERROR_NET_SELECT_ENAMETOOLONG = 0x8071083f,
CELL_HTTP_ERROR_NET_SELECT_EHOSTDOWN = 0x80710840,
CELL_HTTP_ERROR_NET_SELECT_EHOSTUNREACH = 0x80710841,
CELL_HTTP_ERROR_NET_SELECT_ENOTEMPTY = 0x80710842,
CELL_HTTP_ERROR_NET_SELECT_EPROCLIM = 0x80710843,
CELL_HTTP_ERROR_NET_SELECT_EUSERS = 0x80710844,
CELL_HTTP_ERROR_NET_SELECT_EDQUOT = 0x80710845,
CELL_HTTP_ERROR_NET_SELECT_ESTALE = 0x80710846,
CELL_HTTP_ERROR_NET_SELECT_EREMOTE = 0x80710847,
CELL_HTTP_ERROR_NET_SELECT_EBADRPC = 0x80710848,
CELL_HTTP_ERROR_NET_SELECT_ERPCMISMATCH = 0x80710849,
CELL_HTTP_ERROR_NET_SELECT_EPROGUNAVAIL = 0x8071084a,
CELL_HTTP_ERROR_NET_SELECT_EPROGMISMATCH = 0x8071084b,
CELL_HTTP_ERROR_NET_SELECT_EPROCUNAVAIL = 0x8071084c,
CELL_HTTP_ERROR_NET_SELECT_ENOLCK = 0x8071084d,
CELL_HTTP_ERROR_NET_SELECT_ENOSYS = 0x8071084e,
CELL_HTTP_ERROR_NET_SELECT_EFTYPE = 0x8071084f,
CELL_HTTP_ERROR_NET_SELECT_EAUTH = 0x80710850,
CELL_HTTP_ERROR_NET_SELECT_ENEEDAUTH = 0x80710851,
CELL_HTTP_ERROR_NET_SELECT_EIDRM = 0x80710852,
CELL_HTTP_ERROR_NET_SELECT_ENOMSG = 0x80710853,
CELL_HTTP_ERROR_NET_SELECT_EOVERFLOW = 0x80710854,
CELL_HTTP_ERROR_NET_SELECT_EILSEQ = 0x80710855,
CELL_HTTP_ERROR_NET_SELECT_ENOTSUP = 0x80710856,
CELL_HTTP_ERROR_NET_SELECT_ECANCELED = 0x80710857,
CELL_HTTP_ERROR_NET_SELECT_EBADMSG = 0x80710858,
CELL_HTTP_ERROR_NET_SELECT_ENODATA = 0x80710859,
CELL_HTTP_ERROR_NET_SELECT_ENOSR = 0x8071085a,
CELL_HTTP_ERROR_NET_SELECT_ENOSTR = 0x8071085b,
CELL_HTTP_ERROR_NET_SELECT_ETIME = 0x8071085c,
CELL_HTTP_ERROR_NET_SSL_CONNECT_EPERM = 0x80710b01,
CELL_HTTP_ERROR_NET_SSL_CONNECT_ENOENT = 0x80710b02,
CELL_HTTP_ERROR_NET_SSL_CONNECT_ESRCH = 0x80710b03,
CELL_HTTP_ERROR_NET_SSL_CONNECT_EINTR = 0x80710b04,
CELL_HTTP_ERROR_NET_SSL_CONNECT_EIO = 0x80710b05,
CELL_HTTP_ERROR_NET_SSL_CONNECT_ENXIO = 0x80710b06,
CELL_HTTP_ERROR_NET_SSL_CONNECT_E2BIG = 0x80710b07,
CELL_HTTP_ERROR_NET_SSL_CONNECT_ENOEXC = 0x80710b08,
CELL_HTTP_ERROR_NET_SSL_CONNECT_EBADF = 0x80710b09,
CELL_HTTP_ERROR_NET_SSL_CONNECT_ECHILD = 0x80710b0a,
CELL_HTTP_ERROR_NET_SSL_CONNECT_EDEADLK = 0x80710b0b,
CELL_HTTP_ERROR_NET_SSL_CONNECT_ENOMEM = 0x80710b0c,
CELL_HTTP_ERROR_NET_SSL_CONNECT_EACCES = 0x80710b0d,
CELL_HTTP_ERROR_NET_SSL_CONNECT_EFAULT = 0x80710b0e,
CELL_HTTP_ERROR_NET_SSL_CONNECT_ENOTBLK = 0x80710b0f,
CELL_HTTP_ERROR_NET_SSL_CONNECT_EBUSY = 0x80710b10,
CELL_HTTP_ERROR_NET_SSL_CONNECT_EEXIST = 0x80710b11,
CELL_HTTP_ERROR_NET_SSL_CONNECT_EXDEV = 0x80710b12,
CELL_HTTP_ERROR_NET_SSL_CONNECT_ENODEV = 0x80710b13,
CELL_HTTP_ERROR_NET_SSL_CONNECT_ENOTDIR = 0x80710b14,
CELL_HTTP_ERROR_NET_SSL_CONNECT_EISDIR = 0x80710b15,
CELL_HTTP_ERROR_NET_SSL_CONNECT_EINVAL = 0x80710b16,
CELL_HTTP_ERROR_NET_SSL_CONNECT_ENFILE = 0x80710b17,
CELL_HTTP_ERROR_NET_SSL_CONNECT_EMFILE = 0x80710b18,
CELL_HTTP_ERROR_NET_SSL_CONNECT_ENOTTY = 0x80710b19,
CELL_HTTP_ERROR_NET_SSL_CONNECT_ETXTBSY = 0x80710b1a,
CELL_HTTP_ERROR_NET_SSL_CONNECT_EFBIG = 0x80710b1b,
CELL_HTTP_ERROR_NET_SSL_CONNECT_ENOSPC = 0x80710b1c,
CELL_HTTP_ERROR_NET_SSL_CONNECT_ESPIPE = 0x80710b1d,
CELL_HTTP_ERROR_NET_SSL_CONNECT_EROFS = 0x80710b1e,
CELL_HTTP_ERROR_NET_SSL_CONNECT_EMLINK = 0x80710b1f,
CELL_HTTP_ERROR_NET_SSL_CONNECT_EPIPE = 0x80710b20,
CELL_HTTP_ERROR_NET_SSL_CONNECT_EDOM = 0x80710b21,
CELL_HTTP_ERROR_NET_SSL_CONNECT_ERANGE = 0x80710b22,
CELL_HTTP_ERROR_NET_SSL_CONNECT_EAGAIN = 0x80710b23,
CELL_HTTP_ERROR_NET_SSL_CONNECT_EWOULDBLOCK = 0x80710b23,
CELL_HTTP_ERROR_NET_SSL_CONNECT_EINPROGRESS = 0x80710b24,
CELL_HTTP_ERROR_NET_SSL_CONNECT_EALREADY = 0x80710b25,
CELL_HTTP_ERROR_NET_SSL_CONNECT_ENOTSOCK = 0x80710b26,
CELL_HTTP_ERROR_NET_SSL_CONNECT_EDESTADDRREQ = 0x80710b27,
CELL_HTTP_ERROR_NET_SSL_CONNECT_EMSGSIZE = 0x80710b28,
CELL_HTTP_ERROR_NET_SSL_CONNECT_EPROTOTYPE = 0x80710b29,
CELL_HTTP_ERROR_NET_SSL_CONNECT_ENOPROTOOPT = 0x80710b2a,
CELL_HTTP_ERROR_NET_SSL_CONNECT_EPROTONOSUPPORT = 0x80710b2b,
CELL_HTTP_ERROR_NET_SSL_CONNECT_ESOCKTNOSUPPORT = 0x80710b2c,
CELL_HTTP_ERROR_NET_SSL_CONNECT_EOPNOTSUPP = 0x80710b2d,
CELL_HTTP_ERROR_NET_SSL_CONNECT_EPFNOSUPPORT = 0x80710b2e,
CELL_HTTP_ERROR_NET_SSL_CONNECT_EAFNOSUPPORT = 0x80710b2f,
CELL_HTTP_ERROR_NET_SSL_CONNECT_EADDRINUSE = 0x80710b30,
CELL_HTTP_ERROR_NET_SSL_CONNECT_EADDRNOTAVAIL = 0x80710b31,
CELL_HTTP_ERROR_NET_SSL_CONNECT_ENETDOWN = 0x80710b32,
CELL_HTTP_ERROR_NET_SSL_CONNECT_ENETUNREACH = 0x80710b33,
CELL_HTTP_ERROR_NET_SSL_CONNECT_ENETRESET = 0x80710b34,
CELL_HTTP_ERROR_NET_SSL_CONNECT_ECONNABORTED = 0x80710b35,
CELL_HTTP_ERROR_NET_SSL_CONNECT_ECONNRESET = 0x80710b36,
CELL_HTTP_ERROR_NET_SSL_CONNECT_ENOBUFS = 0x80710b37,
CELL_HTTP_ERROR_NET_SSL_CONNECT_EISCONN = 0x80710b38,
CELL_HTTP_ERROR_NET_SSL_CONNECT_ENOTCONN = 0x80710b39,
CELL_HTTP_ERROR_NET_SSL_CONNECT_ESHUTDOWN = 0x80710b3a,
CELL_HTTP_ERROR_NET_SSL_CONNECT_ETOOMANYREFS = 0x80710b3b,
CELL_HTTP_ERROR_NET_SSL_CONNECT_ETIMEDOUT = 0x80710b3c,
CELL_HTTP_ERROR_NET_SSL_CONNECT_ECONNREFUSED = 0x80710b3d,
CELL_HTTP_ERROR_NET_SSL_CONNECT_ELOOP = 0x80710b3e,
CELL_HTTP_ERROR_NET_SSL_CONNECT_ENAMETOOLONG = 0x80710b3f,
CELL_HTTP_ERROR_NET_SSL_CONNECT_EHOSTDOWN = 0x80710b40,
CELL_HTTP_ERROR_NET_SSL_CONNECT_EHOSTUNREACH = 0x80710b41,
CELL_HTTP_ERROR_NET_SSL_CONNECT_ENOTEMPTY = 0x80710b42,
CELL_HTTP_ERROR_NET_SSL_CONNECT_EPROCLIM = 0x80710b43,
CELL_HTTP_ERROR_NET_SSL_CONNECT_EUSERS = 0x80710b44,
CELL_HTTP_ERROR_NET_SSL_CONNECT_EDQUOT = 0x80710b45,
CELL_HTTP_ERROR_NET_SSL_CONNECT_ESTALE = 0x80710b46,
CELL_HTTP_ERROR_NET_SSL_CONNECT_EREMOTE = 0x80710b47,
CELL_HTTP_ERROR_NET_SSL_CONNECT_EBADRPC = 0x80710b48,
CELL_HTTP_ERROR_NET_SSL_CONNECT_ERPCMISMATCH = 0x80710b49,
CELL_HTTP_ERROR_NET_SSL_CONNECT_EPROGUNAVAIL = 0x80710b4a,
CELL_HTTP_ERROR_NET_SSL_CONNECT_EPROGMISMATCH = 0x80710b4b,
CELL_HTTP_ERROR_NET_SSL_CONNECT_EPROCUNAVAIL = 0x80710b4c,
CELL_HTTP_ERROR_NET_SSL_CONNECT_ENOLCK = 0x80710b4d,
CELL_HTTP_ERROR_NET_SSL_CONNECT_ENOSYS = 0x80710b4e,
CELL_HTTP_ERROR_NET_SSL_CONNECT_EFTYPE = 0x80710b4f,
CELL_HTTP_ERROR_NET_SSL_CONNECT_EAUTH = 0x80710b50,
CELL_HTTP_ERROR_NET_SSL_CONNECT_ENEEDAUTH = 0x80710b51,
CELL_HTTP_ERROR_NET_SSL_CONNECT_EIDRM = 0x80710b52,
CELL_HTTP_ERROR_NET_SSL_CONNECT_ENOMSG = 0x80710b53,
CELL_HTTP_ERROR_NET_SSL_CONNECT_EOVERFLOW = 0x80710b54,
CELL_HTTP_ERROR_NET_SSL_CONNECT_EILSEQ = 0x80710b55,
CELL_HTTP_ERROR_NET_SSL_CONNECT_ENOTSUP = 0x80710b56,
CELL_HTTP_ERROR_NET_SSL_CONNECT_ECANCELED = 0x80710b57,
CELL_HTTP_ERROR_NET_SSL_CONNECT_EBADMSG = 0x80710b58,
CELL_HTTP_ERROR_NET_SSL_CONNECT_ENODATA = 0x80710b59,
CELL_HTTP_ERROR_NET_SSL_CONNECT_ENOSR = 0x80710b5a,
CELL_HTTP_ERROR_NET_SSL_CONNECT_ENOSTR = 0x80710b5b,
CELL_HTTP_ERROR_NET_SSL_CONNECT_ETIME = 0x80710b5c,
CELL_HTTP_ERROR_NET_SSL_SEND_EPERM = 0x80710c01,
CELL_HTTP_ERROR_NET_SSL_SEND_ENOENT = 0x80710c02,
CELL_HTTP_ERROR_NET_SSL_SEND_ESRCH = 0x80710c03,
CELL_HTTP_ERROR_NET_SSL_SEND_EINTR = 0x80710c04,
CELL_HTTP_ERROR_NET_SSL_SEND_EIO = 0x80710c05,
CELL_HTTP_ERROR_NET_SSL_SEND_ENXIO = 0x80710c06,
CELL_HTTP_ERROR_NET_SSL_SEND_E2BIG = 0x80710c07,
CELL_HTTP_ERROR_NET_SSL_SEND_ENOEXC = 0x80710c08,
CELL_HTTP_ERROR_NET_SSL_SEND_EBADF = 0x80710c09,
CELL_HTTP_ERROR_NET_SSL_SEND_ECHILD = 0x80710c0a,
CELL_HTTP_ERROR_NET_SSL_SEND_EDEADLK = 0x80710c0b,
CELL_HTTP_ERROR_NET_SSL_SEND_ENOMEM = 0x80710c0c,
CELL_HTTP_ERROR_NET_SSL_SEND_EACCES = 0x80710c0d,
CELL_HTTP_ERROR_NET_SSL_SEND_EFAULT = 0x80710c0e,
CELL_HTTP_ERROR_NET_SSL_SEND_ENOTBLK = 0x80710c0f,
CELL_HTTP_ERROR_NET_SSL_SEND_EBUSY = 0x80710c10,
CELL_HTTP_ERROR_NET_SSL_SEND_EEXIST = 0x80710c11,
CELL_HTTP_ERROR_NET_SSL_SEND_EXDEV = 0x80710c12,
CELL_HTTP_ERROR_NET_SSL_SEND_ENODEV = 0x80710c13,
CELL_HTTP_ERROR_NET_SSL_SEND_ENOTDIR = 0x80710c14,
CELL_HTTP_ERROR_NET_SSL_SEND_EISDIR = 0x80710c15,
CELL_HTTP_ERROR_NET_SSL_SEND_EINVAL = 0x80710c16,
CELL_HTTP_ERROR_NET_SSL_SEND_ENFILE = 0x80710c17,
CELL_HTTP_ERROR_NET_SSL_SEND_EMFILE = 0x80710c18,
CELL_HTTP_ERROR_NET_SSL_SEND_ENOTTY = 0x80710c19,
CELL_HTTP_ERROR_NET_SSL_SEND_ETXTBSY = 0x80710c1a,
CELL_HTTP_ERROR_NET_SSL_SEND_EFBIG = 0x80710c1b,
CELL_HTTP_ERROR_NET_SSL_SEND_ENOSPC = 0x80710c1c,
CELL_HTTP_ERROR_NET_SSL_SEND_ESPIPE = 0x80710c1d,
CELL_HTTP_ERROR_NET_SSL_SEND_EROFS = 0x80710c1e,
CELL_HTTP_ERROR_NET_SSL_SEND_EMLINK = 0x80710c1f,
CELL_HTTP_ERROR_NET_SSL_SEND_EPIPE = 0x80710c20,
CELL_HTTP_ERROR_NET_SSL_SEND_EDOM = 0x80710c21,
CELL_HTTP_ERROR_NET_SSL_SEND_ERANGE = 0x80710c22,
CELL_HTTP_ERROR_NET_SSL_SEND_EAGAIN = 0x80710c23,
CELL_HTTP_ERROR_NET_SSL_SEND_EWOULDBLOCK = 0x80710c23,
CELL_HTTP_ERROR_NET_SSL_SEND_EINPROGRESS = 0x80710c24,
CELL_HTTP_ERROR_NET_SSL_SEND_EALREADY = 0x80710c25,
CELL_HTTP_ERROR_NET_SSL_SEND_ENOTSOCK = 0x80710c26,
CELL_HTTP_ERROR_NET_SSL_SEND_EDESTADDRREQ = 0x80710c27,
CELL_HTTP_ERROR_NET_SSL_SEND_EMSGSIZE = 0x80710c28,
CELL_HTTP_ERROR_NET_SSL_SEND_EPROTOTYPE = 0x80710c29,
CELL_HTTP_ERROR_NET_SSL_SEND_ENOPROTOOPT = 0x80710c2a,
CELL_HTTP_ERROR_NET_SSL_SEND_EPROTONOSUPPORT = 0x80710c2b,
CELL_HTTP_ERROR_NET_SSL_SEND_ESOCKTNOSUPPORT = 0x80710c2c,
CELL_HTTP_ERROR_NET_SSL_SEND_EOPNOTSUPP = 0x80710c2d,
CELL_HTTP_ERROR_NET_SSL_SEND_EPFNOSUPPORT = 0x80710c2e,
CELL_HTTP_ERROR_NET_SSL_SEND_EAFNOSUPPORT = 0x80710c2f,
CELL_HTTP_ERROR_NET_SSL_SEND_EADDRINUSE = 0x80710c30,
CELL_HTTP_ERROR_NET_SSL_SEND_EADDRNOTAVAIL = 0x80710c31,
CELL_HTTP_ERROR_NET_SSL_SEND_ENETDOWN = 0x80710c32,
CELL_HTTP_ERROR_NET_SSL_SEND_ENETUNREACH = 0x80710c33,
CELL_HTTP_ERROR_NET_SSL_SEND_ENETRESET = 0x80710c34,
CELL_HTTP_ERROR_NET_SSL_SEND_ECONNABORTED = 0x80710c35,
CELL_HTTP_ERROR_NET_SSL_SEND_ECONNRESET = 0x80710c36,
CELL_HTTP_ERROR_NET_SSL_SEND_ENOBUFS = 0x80710c37,
CELL_HTTP_ERROR_NET_SSL_SEND_EISCONN = 0x80710c38,
CELL_HTTP_ERROR_NET_SSL_SEND_ENOTCONN = 0x80710c39,
CELL_HTTP_ERROR_NET_SSL_SEND_ESHUTDOWN = 0x80710c3a,
CELL_HTTP_ERROR_NET_SSL_SEND_ETOOMANYREFS = 0x80710c3b,
CELL_HTTP_ERROR_NET_SSL_SEND_ETIMEDOUT = 0x80710c3c,
CELL_HTTP_ERROR_NET_SSL_SEND_ECONNREFUSED = 0x80710c3d,
CELL_HTTP_ERROR_NET_SSL_SEND_ELOOP = 0x80710c3e,
CELL_HTTP_ERROR_NET_SSL_SEND_ENAMETOOLONG = 0x80710c3f,
CELL_HTTP_ERROR_NET_SSL_SEND_EHOSTDOWN = 0x80710c40,
CELL_HTTP_ERROR_NET_SSL_SEND_EHOSTUNREACH = 0x80710c41,
CELL_HTTP_ERROR_NET_SSL_SEND_ENOTEMPTY = 0x80710c42,
CELL_HTTP_ERROR_NET_SSL_SEND_EPROCLIM = 0x80710c43,
CELL_HTTP_ERROR_NET_SSL_SEND_EUSERS = 0x80710c44,
CELL_HTTP_ERROR_NET_SSL_SEND_EDQUOT = 0x80710c45,
CELL_HTTP_ERROR_NET_SSL_SEND_ESTALE = 0x80710c46,
CELL_HTTP_ERROR_NET_SSL_SEND_EREMOTE = 0x80710c47,
CELL_HTTP_ERROR_NET_SSL_SEND_EBADRPC = 0x80710c48,
CELL_HTTP_ERROR_NET_SSL_SEND_ERPCMISMATCH = 0x80710c49,
CELL_HTTP_ERROR_NET_SSL_SEND_EPROGUNAVAIL = 0x80710c4a,
CELL_HTTP_ERROR_NET_SSL_SEND_EPROGMISMATCH = 0x80710c4b,
CELL_HTTP_ERROR_NET_SSL_SEND_EPROCUNAVAIL = 0x80710c4c,
CELL_HTTP_ERROR_NET_SSL_SEND_ENOLCK = 0x80710c4d,
CELL_HTTP_ERROR_NET_SSL_SEND_ENOSYS = 0x80710c4e,
CELL_HTTP_ERROR_NET_SSL_SEND_EFTYPE = 0x80710c4f,
CELL_HTTP_ERROR_NET_SSL_SEND_EAUTH = 0x80710c50,
CELL_HTTP_ERROR_NET_SSL_SEND_ENEEDAUTH = 0x80710c51,
CELL_HTTP_ERROR_NET_SSL_SEND_EIDRM = 0x80710c52,
CELL_HTTP_ERROR_NET_SSL_SEND_ENOMSG = 0x80710c53,
CELL_HTTP_ERROR_NET_SSL_SEND_EOVERFLOW = 0x80710c54,
CELL_HTTP_ERROR_NET_SSL_SEND_EILSEQ = 0x80710c55,
CELL_HTTP_ERROR_NET_SSL_SEND_ENOTSUP = 0x80710c56,
CELL_HTTP_ERROR_NET_SSL_SEND_ECANCELED = 0x80710c57,
CELL_HTTP_ERROR_NET_SSL_SEND_EBADMSG = 0x80710c58,
CELL_HTTP_ERROR_NET_SSL_SEND_ENODATA = 0x80710c59,
CELL_HTTP_ERROR_NET_SSL_SEND_ENOSR = 0x80710c5a,
CELL_HTTP_ERROR_NET_SSL_SEND_ENOSTR = 0x80710c5b,
CELL_HTTP_ERROR_NET_SSL_SEND_ETIME = 0x80710c5c,
CELL_HTTP_ERROR_NET_SSL_RECV_EPERM = 0x80710d01,
CELL_HTTP_ERROR_NET_SSL_RECV_ENOENT = 0x80710d02,
CELL_HTTP_ERROR_NET_SSL_RECV_ESRCH = 0x80710d03,
CELL_HTTP_ERROR_NET_SSL_RECV_EINTR = 0x80710d04,
CELL_HTTP_ERROR_NET_SSL_RECV_EIO = 0x80710d05,
CELL_HTTP_ERROR_NET_SSL_RECV_ENXIO = 0x80710d06,
CELL_HTTP_ERROR_NET_SSL_RECV_E2BIG = 0x80710d07,
CELL_HTTP_ERROR_NET_SSL_RECV_ENOEXC = 0x80710d08,
CELL_HTTP_ERROR_NET_SSL_RECV_EBADF = 0x80710d09,
CELL_HTTP_ERROR_NET_SSL_RECV_ECHILD = 0x80710d0a,
CELL_HTTP_ERROR_NET_SSL_RECV_EDEADLK = 0x80710d0b,
CELL_HTTP_ERROR_NET_SSL_RECV_ENOMEM = 0x80710d0c,
CELL_HTTP_ERROR_NET_SSL_RECV_EACCES = 0x80710d0d,
CELL_HTTP_ERROR_NET_SSL_RECV_EFAULT = 0x80710d0e,
CELL_HTTP_ERROR_NET_SSL_RECV_ENOTBLK = 0x80710d0f,
CELL_HTTP_ERROR_NET_SSL_RECV_EBUSY = 0x80710d10,
CELL_HTTP_ERROR_NET_SSL_RECV_EEXIST = 0x80710d11,
CELL_HTTP_ERROR_NET_SSL_RECV_EXDEV = 0x80710d12,
CELL_HTTP_ERROR_NET_SSL_RECV_ENODEV = 0x80710d13,
CELL_HTTP_ERROR_NET_SSL_RECV_ENOTDIR = 0x80710d14,
CELL_HTTP_ERROR_NET_SSL_RECV_EISDIR = 0x80710d15,
CELL_HTTP_ERROR_NET_SSL_RECV_EINVAL = 0x80710d16,
CELL_HTTP_ERROR_NET_SSL_RECV_ENFILE = 0x80710d17,
CELL_HTTP_ERROR_NET_SSL_RECV_EMFILE = 0x80710d18,
CELL_HTTP_ERROR_NET_SSL_RECV_ENOTTY = 0x80710d19,
CELL_HTTP_ERROR_NET_SSL_RECV_ETXTBSY = 0x80710d1a,
CELL_HTTP_ERROR_NET_SSL_RECV_EFBIG = 0x80710d1b,
CELL_HTTP_ERROR_NET_SSL_RECV_ENOSPC = 0x80710d1c,
CELL_HTTP_ERROR_NET_SSL_RECV_ESPIPE = 0x80710d1d,
CELL_HTTP_ERROR_NET_SSL_RECV_EROFS = 0x80710d1e,
CELL_HTTP_ERROR_NET_SSL_RECV_EMLINK = 0x80710d1f,
CELL_HTTP_ERROR_NET_SSL_RECV_EPIPE = 0x80710d20,
CELL_HTTP_ERROR_NET_SSL_RECV_EDOM = 0x80710d21,
CELL_HTTP_ERROR_NET_SSL_RECV_ERANGE = 0x80710d22,
CELL_HTTP_ERROR_NET_SSL_RECV_EAGAIN = 0x80710d23,
CELL_HTTP_ERROR_NET_SSL_RECV_EWOULDBLOCK = 0x80710d23,
CELL_HTTP_ERROR_NET_SSL_RECV_EINPROGRESS = 0x80710d24,
CELL_HTTP_ERROR_NET_SSL_RECV_EALREADY = 0x80710d25,
CELL_HTTP_ERROR_NET_SSL_RECV_ENOTSOCK = 0x80710d26,
CELL_HTTP_ERROR_NET_SSL_RECV_EDESTADDRREQ = 0x80710d27,
CELL_HTTP_ERROR_NET_SSL_RECV_EMSGSIZE = 0x80710d28,
CELL_HTTP_ERROR_NET_SSL_RECV_EPROTOTYPE = 0x80710d29,
CELL_HTTP_ERROR_NET_SSL_RECV_ENOPROTOOPT = 0x80710d2a,
CELL_HTTP_ERROR_NET_SSL_RECV_EPROTONOSUPPORT = 0x80710d2b,
CELL_HTTP_ERROR_NET_SSL_RECV_ESOCKTNOSUPPORT = 0x80710d2c,
CELL_HTTP_ERROR_NET_SSL_RECV_EOPNOTSUPP = 0x80710d2d,
CELL_HTTP_ERROR_NET_SSL_RECV_EPFNOSUPPORT = 0x80710d2e,
CELL_HTTP_ERROR_NET_SSL_RECV_EAFNOSUPPORT = 0x80710d2f,
CELL_HTTP_ERROR_NET_SSL_RECV_EADDRINUSE = 0x80710d30,
CELL_HTTP_ERROR_NET_SSL_RECV_EADDRNOTAVAIL = 0x80710d31,
CELL_HTTP_ERROR_NET_SSL_RECV_ENETDOWN = 0x80710d32,
CELL_HTTP_ERROR_NET_SSL_RECV_ENETUNREACH = 0x80710d33,
CELL_HTTP_ERROR_NET_SSL_RECV_ENETRESET = 0x80710d34,
CELL_HTTP_ERROR_NET_SSL_RECV_ECONNABORTED = 0x80710d35,
CELL_HTTP_ERROR_NET_SSL_RECV_ECONNRESET = 0x80710d36,
CELL_HTTP_ERROR_NET_SSL_RECV_ENOBUFS = 0x80710d37,
CELL_HTTP_ERROR_NET_SSL_RECV_EISCONN = 0x80710d38,
CELL_HTTP_ERROR_NET_SSL_RECV_ENOTCONN = 0x80710d39,
CELL_HTTP_ERROR_NET_SSL_RECV_ESHUTDOWN = 0x80710d3a,
CELL_HTTP_ERROR_NET_SSL_RECV_ETOOMANYREFS = 0x80710d3b,
CELL_HTTP_ERROR_NET_SSL_RECV_ETIMEDOUT = 0x80710d3c,
CELL_HTTP_ERROR_NET_SSL_RECV_ECONNREFUSED = 0x80710d3d,
CELL_HTTP_ERROR_NET_SSL_RECV_ELOOP = 0x80710d3e,
CELL_HTTP_ERROR_NET_SSL_RECV_ENAMETOOLONG = 0x80710d3f,
CELL_HTTP_ERROR_NET_SSL_RECV_EHOSTDOWN = 0x80710d40,
CELL_HTTP_ERROR_NET_SSL_RECV_EHOSTUNREACH = 0x80710d41,
CELL_HTTP_ERROR_NET_SSL_RECV_ENOTEMPTY = 0x80710d42,
CELL_HTTP_ERROR_NET_SSL_RECV_EPROCLIM = 0x80710d43,
CELL_HTTP_ERROR_NET_SSL_RECV_EUSERS = 0x80710d44,
CELL_HTTP_ERROR_NET_SSL_RECV_EDQUOT = 0x80710d45,
CELL_HTTP_ERROR_NET_SSL_RECV_ESTALE = 0x80710d46,
CELL_HTTP_ERROR_NET_SSL_RECV_EREMOTE = 0x80710d47,
CELL_HTTP_ERROR_NET_SSL_RECV_EBADRPC = 0x80710d48,
CELL_HTTP_ERROR_NET_SSL_RECV_ERPCMISMATCH = 0x80710d49,
CELL_HTTP_ERROR_NET_SSL_RECV_EPROGUNAVAIL = 0x80710d4a,
CELL_HTTP_ERROR_NET_SSL_RECV_EPROGMISMATCH = 0x80710d4b,
CELL_HTTP_ERROR_NET_SSL_RECV_EPROCUNAVAIL = 0x80710d4c,
CELL_HTTP_ERROR_NET_SSL_RECV_ENOLCK = 0x80710d4d,
CELL_HTTP_ERROR_NET_SSL_RECV_ENOSYS = 0x80710d4e,
CELL_HTTP_ERROR_NET_SSL_RECV_EFTYPE = 0x80710d4f,
CELL_HTTP_ERROR_NET_SSL_RECV_EAUTH = 0x80710d50,
CELL_HTTP_ERROR_NET_SSL_RECV_ENEEDAUTH = 0x80710d51,
CELL_HTTP_ERROR_NET_SSL_RECV_EIDRM = 0x80710d52,
CELL_HTTP_ERROR_NET_SSL_RECV_ENOMSG = 0x80710d53,
CELL_HTTP_ERROR_NET_SSL_RECV_EOVERFLOW = 0x80710d54,
CELL_HTTP_ERROR_NET_SSL_RECV_EILSEQ = 0x80710d55,
CELL_HTTP_ERROR_NET_SSL_RECV_ENOTSUP = 0x80710d56,
CELL_HTTP_ERROR_NET_SSL_RECV_ECANCELED = 0x80710d57,
CELL_HTTP_ERROR_NET_SSL_RECV_EBADMSG = 0x80710d58,
CELL_HTTP_ERROR_NET_SSL_RECV_ENODATA = 0x80710d59,
CELL_HTTP_ERROR_NET_SSL_RECV_ENOSR = 0x80710d5a,
CELL_HTTP_ERROR_NET_SSL_RECV_ENOSTR = 0x80710d5b,
CELL_HTTP_ERROR_NET_SSL_RECV_ETIME = 0x80710d5c,
};
enum
{
CELL_HTTP_TRANSACTION_STATE_GETTING_CONNECTION = 1,
CELL_HTTP_TRANSACTION_STATE_PREPARING_REQUEST = 2,
CELL_HTTP_TRANSACTION_STATE_SENDING_REQUEST = 3,
CELL_HTTP_TRANSACTION_STATE_SENDING_BODY = 4,
CELL_HTTP_TRANSACTION_STATE_WAITING_FOR_REPLY = 5,
CELL_HTTP_TRANSACTION_STATE_READING_REPLY = 6,
CELL_HTTP_TRANSACTION_STATE_SETTING_REDIRECTION = 7,
CELL_HTTP_TRANSACTION_STATE_SETTING_AUTHENTICATION = 8,
};
enum
{
CELL_HTTP_STATUS_CODE_Continue = 100,
CELL_HTTP_STATUS_CODE_Switching_Protocols = 101,
CELL_HTTP_STATUS_CODE_Processing = 102,
// Success codes
CELL_HTTP_STATUS_CODE_OK = 200,
CELL_HTTP_STATUS_CODE_Created = 201,
CELL_HTTP_STATUS_CODE_Accepted = 202,
CELL_HTTP_STATUS_CODE_NonAuthoritive_Information = 203,
CELL_HTTP_STATUS_CODE_No_Content = 204,
CELL_HTTP_STATUS_CODE_Reset_Content = 205,
CELL_HTTP_STATUS_CODE_Partial_Content = 206,
CELL_HTTP_STATUS_CODE_MultiStatus = 207,
/* Redirection 3xx */
CELL_HTTP_STATUS_CODE_Multiple_Choices = 300,
CELL_HTTP_STATUS_CODE_Moved_Permanently = 301,
CELL_HTTP_STATUS_CODE_Moved_Temporarily = 302,
CELL_HTTP_STATUS_CODE_Found = CELL_HTTP_STATUS_CODE_Moved_Temporarily,
CELL_HTTP_STATUS_CODE_See_Other = 303,
CELL_HTTP_STATUS_CODE_Not_Modified = 304,
CELL_HTTP_STATUS_CODE_Use_Proxy = 305,
//CELL_HTTP_STATUS_CODE_UNUSED = 306,
CELL_HTTP_STATUS_CODE_Temporary_Redirect = 307,
// Client errors
CELL_HTTP_STATUS_CODE_Bad_Request = 400,
CELL_HTTP_STATUS_CODE_Unauthorized = 401,
CELL_HTTP_STATUS_CODE_Payment_Required = 402,
CELL_HTTP_STATUS_CODE_Forbidden = 403,
CELL_HTTP_STATUS_CODE_Not_Found = 404,
CELL_HTTP_STATUS_CODE_Method_Not_Allowed = 405,
CELL_HTTP_STATUS_CODE_Not_Acceptable = 406,
CELL_HTTP_STATUS_CODE_Proxy_Authentication_Required = 407,
CELL_HTTP_STATUS_CODE_Request_Timeout = 408,
CELL_HTTP_STATUS_CODE_Conflict = 409,
CELL_HTTP_STATUS_CODE_Gone = 410,
CELL_HTTP_STATUS_CODE_Length_Required = 411,
CELL_HTTP_STATUS_CODE_Precondition_Failed = 412,
CELL_HTTP_STATUS_CODE_Request_Entity_Too_Large = 413,
CELL_HTTP_STATUS_CODE_RequestURI_Too_Long = 414,
CELL_HTTP_STATUS_CODE_Unsupported_Media_Type = 415,
CELL_HTTP_STATUS_CODE_Requested_Range_Not_Satisfiable = 416,
CELL_HTTP_STATUS_CODE_Expectation_Failed = 417,
CELL_HTTP_STATUS_CODE_Unprocessable_Entity = 422,
CELL_HTTP_STATUS_CODE_Locked = 423,
CELL_HTTP_STATUS_CODE_Failed_Dependency = 424,
CELL_HTTP_STATUS_CODE_Upgrade_Required = 426,
// Server error
CELL_HTTP_STATUS_CODE_Internal_Server_Error = 500,
CELL_HTTP_STATUS_CODE_Not_Implemented = 501,
CELL_HTTP_STATUS_CODE_Bad_Gateway = 502,
CELL_HTTP_STATUS_CODE_Service_Unavailable = 503,
CELL_HTTP_STATUS_CODE_Gateway_Timeout = 504,
CELL_HTTP_STATUS_CODE_HTTP_Version_Not_Supported = 505,
CELL_HTTP_STATUS_CODE_Insufficient_Storage = 507,
};
enum
{
CELL_HTTPS_VERIFY_ERROR_NONE = 0x00000000U,
CELL_HTTPS_VERIFY_ERROR_NO_CERT = 0x00000001U,
CELL_HTTPS_VERIFY_ERROR_BAD_SSL = 0x00000002U,
CELL_HTTPS_VERIFY_ERROR_BAD_CLIENT = 0x00000004U,
CELL_HTTPS_VERIFY_ERROR_UNKNOWN_CA = 0x00000008U,
CELL_HTTPS_VERIFY_ERROR_BAD_CHAIN = 0x00000010U,
CELL_HTTPS_VERIFY_ERROR_NO_MEMORY = 0x00000020U,
CELL_HTTPS_VERIFY_ERROR_NOT_VERIFIABLE = 0x00000040U,
CELL_HTTPS_VERIFY_ERROR_INVALID_CERT = 0x00000080U,
CELL_HTTPS_VERIFY_ERROR_BAD_CONSTRAINT = 0x00000100U,
CELL_HTTPS_VERIFY_ERROR_VERIFY_FAILED = 0x00000200U,
CELL_HTTPS_VERIFY_ERROR_COMMON_NAME = 0x00000400U,
CELL_HTTPS_VERIFY_ERROR_EXPIRED = 0x00000800U,
CELL_HTTPS_VERIFY_ERROR_NOT_YET_VALID = 0x00001000U,
};
static constexpr const char* CELL_HTTP_METHOD_OPTIONS = "OPTIONS";
static constexpr const char* CELL_HTTP_METHOD_GET = "GET";
static constexpr const char* CELL_HTTP_METHOD_HEAD = "HEAD";
static constexpr const char* CELL_HTTP_METHOD_POST = "POST";
static constexpr const char* CELL_HTTP_METHOD_PUT = "PUT";
static constexpr const char* CELL_HTTP_METHOD_DELETE = "DELETE";
static constexpr const char* CELL_HTTP_METHOD_TRACE = "TRACE";
typedef u32 CellHttpClientId; //typedef struct CellHttpClient* CellHttpClientId;
typedef u32 CellHttpTransId; //typedef struct CellHttpTransaction* CellHttpTransId;
typedef const void* CellHttpSslId;
using CellHttpAuthenticationCallback = s32(CellHttpTransId transId, vm::cptr<char> realm, vm::cptr<CellHttpUri> uri, vm::ptr<char> username, vm::ptr<char> password, vm::ptr<bool> save, vm::ptr<void> userArg);
using CellHttpTransactionStateCallback = s32(CellHttpTransId transId, s32 state, vm::ptr<void> userArg);
using CellHttpRedirectCallback = s32(CellHttpTransId transId, vm::cptr<CellHttpStatusLine> response, vm::cptr<CellHttpUri> from, vm::cptr<CellHttpUri> to, vm::ptr<void> userArg);
using CellHttpsSslCallback = s32(u32 verifyErr, vm::cpptr<void> sslCerts, s32 certNum, vm::cptr<char> hostname, vm::cptr<void> id, vm::ptr<void> userArg);
using CellHttpCookieSendCallback = s32(CellHttpTransId transId, vm::cptr<CellHttpUri> uri, vm::cptr<char> cookieValue, vm::ptr<void> userArg);
using CellHttpCookieRecvCallback = s32(CellHttpTransId transId, vm::cptr<CellHttpUri> uri, vm::cptr<char> cookieValue, vm::ptr<void> userArg);
struct CellHttpsData
{
vm::bptr<char> ptr;
be_t<u32> size;
};
struct http_manager
{
shared_mutex mtx;
bool initialized = false;
bool cookie_initialized = false;
bool cache_initialized = false;
bool ext_cache_initialized = false;
bool https_initialized = false;
};
| 67,394
|
C++
|
.h
| 1,182
| 55.032995
| 210
| 0.689921
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,909
|
sys_lv2dbg.h
|
RPCS3_rpcs3/rpcs3/Emu/Cell/Modules/sys_lv2dbg.h
|
#pragma once
#include "Emu/Cell/lv2/sys_mutex.h"
#include "Emu/Cell/lv2/sys_cond.h"
#include "Emu/Cell/lv2/sys_rwlock.h"
#include "Emu/Cell/lv2/sys_event.h"
#include "Emu/Cell/lv2/sys_semaphore.h"
#include "Emu/Cell/lv2/sys_lwmutex.h"
#include "Emu/Cell/lv2/sys_lwcond.h"
#include "Emu/Cell/lv2/sys_event_flag.h"
#include "Emu/Memory/vm_ptr.h"
// Error Codes
enum CellLv2DbgError : u32
{
CELL_LV2DBG_ERROR_DEINVALIDPROCESSID = 0x80010401,
CELL_LV2DBG_ERROR_DEINVALIDTHREADID = 0x80010402,
CELL_LV2DBG_ERROR_DEILLEGALREGISTERTYPE = 0x80010403,
CELL_LV2DBG_ERROR_DEILLEGALREGISTERNUMBER = 0x80010404,
CELL_LV2DBG_ERROR_DEILLEGALTHREADSTATE = 0x80010405,
CELL_LV2DBG_ERROR_DEINVALIDEFFECTIVEADDRESS = 0x80010406,
CELL_LV2DBG_ERROR_DENOTFOUNDPROCESSID = 0x80010407,
CELL_LV2DBG_ERROR_DENOMEM = 0x80010408,
CELL_LV2DBG_ERROR_DEINVALIDARGUMENTS = 0x80010409,
CELL_LV2DBG_ERROR_DENOTFOUNDFILE = 0x8001040a,
CELL_LV2DBG_ERROR_DEINVALIDFILETYPE = 0x8001040b,
CELL_LV2DBG_ERROR_DENOTFOUNDTHREADID = 0x8001040c,
CELL_LV2DBG_ERROR_DEINVALIDTHREADSTATUS = 0x8001040d,
CELL_LV2DBG_ERROR_DENOAVAILABLEPROCESSID = 0x8001040e,
CELL_LV2DBG_ERROR_DENOTFOUNDEVENTHANDLER = 0x8001040f,
CELL_LV2DBG_ERROR_DESPNOROOM = 0x80010410,
CELL_LV2DBG_ERROR_DESPNOTFOUND = 0x80010411,
CELL_LV2DBG_ERROR_DESPINPROCESS = 0x80010412,
CELL_LV2DBG_ERROR_DEINVALIDPRIMARYSPUTHREADID = 0x80010413,
CELL_LV2DBG_ERROR_DETHREADSTATEISNOTSTOPPED = 0x80010414,
CELL_LV2DBG_ERROR_DEINVALIDTHREADTYPE = 0x80010415,
CELL_LV2DBG_ERROR_DECONTINUEFAILED = 0x80010416,
CELL_LV2DBG_ERROR_DESTOPFAILED = 0x80010417,
CELL_LV2DBG_ERROR_DENOEXCEPTION = 0x80010418,
CELL_LV2DBG_ERROR_DENOMOREEVENTQUE = 0x80010419,
CELL_LV2DBG_ERROR_DEEVENTQUENOTCREATED = 0x8001041a,
CELL_LV2DBG_ERROR_DEEVENTQUEOVERFLOWED = 0x8001041b,
CELL_LV2DBG_ERROR_DENOTIMPLEMENTED = 0x8001041c,
CELL_LV2DBG_ERROR_DEQUENOTREGISTERED = 0x8001041d,
CELL_LV2DBG_ERROR_DENOMOREEVENTPROCESS = 0x8001041e,
CELL_LV2DBG_ERROR_DEPROCESSNOTREGISTERED = 0x8001041f,
CELL_LV2DBG_ERROR_DEEVENTDISCARDED = 0x80010420,
CELL_LV2DBG_ERROR_DENOMORESYNCID = 0x80010421,
CELL_LV2DBG_ERROR_DESYNCIDALREADYADDED = 0x80010422,
CELL_LV2DBG_ERROR_DESYNCIDNOTFOUND = 0x80010423,
CELL_LV2DBG_ERROR_DESYNCIDNOTACQUIRED = 0x80010424,
CELL_LV2DBG_ERROR_DEPROCESSALREADYREGISTERED = 0x80010425,
CELL_LV2DBG_ERROR_DEINVALIDLSADDRESS = 0x80010426,
CELL_LV2DBG_ERROR_DEINVALIDOPERATION = 0x80010427,
CELL_LV2DBG_ERROR_DEINVALIDMODULEID = 0x80010428,
CELL_LV2DBG_ERROR_DEHANDLERALREADYREGISTERED = 0x80010429,
CELL_LV2DBG_ERROR_DEINVALIDHANDLER = 0x8001042a,
CELL_LV2DBG_ERROR_DEHANDLENOTREGISTERED = 0x8001042b,
CELL_LV2DBG_ERROR_DEOPERATIONDENIED = 0x8001042c,
CELL_LV2DBG_ERROR_DEHANDLERNOTINITIALIZED = 0x8001042d,
CELL_LV2DBG_ERROR_DEHANDLERALREADYINITIALIZED = 0x8001042e,
CELL_LV2DBG_ERROR_DEILLEGALCOREDUMPPARAMETER = 0x8001042f,
};
enum : u64
{
SYS_DBG_PPU_THREAD_STOP = 0x0000000000000001ull,
SYS_DBG_SPU_THREAD_GROUP_STOP = 0x0000000000000002ull,
SYS_DBG_SYSTEM_PPU_THREAD_NOT_STOP = 0x0000000000000004ull,
SYS_DBG_SYSTEM_SPU_THREAD_GROUP_NOT_STOP = 0x0000000000000008ull,
SYS_DBG_NOT_EXE_CTRL_BY_COREDUMP_EVENT = 0x0000000000000010ull,
};
enum : u64
{
SYS_DBG_PPU_EXCEPTION_TRAP = 0x0000000001000000ull,
SYS_DBG_PPU_EXCEPTION_PREV_INST = 0x0000000002000000ull,
SYS_DBG_PPU_EXCEPTION_ILL_INST = 0x0000000004000000ull,
SYS_DBG_PPU_EXCEPTION_TEXT_HTAB_MISS = 0x0000000008000000ull,
SYS_DBG_PPU_EXCEPTION_TEXT_SLB_MISS = 0x0000000010000000ull,
SYS_DBG_PPU_EXCEPTION_DATA_HTAB_MISS = 0x0000000020000000ull,
SYS_DBG_PPU_EXCEPTION_DATA_SLB_MISS = 0x0000000040000000ull,
SYS_DBG_PPU_EXCEPTION_FLOAT = 0x0000000080000000ull,
SYS_DBG_PPU_EXCEPTION_DABR_MATCH = 0x0000000100000000ull,
SYS_DBG_PPU_EXCEPTION_ALIGNMENT = 0x0000000200000000ull,
SYS_DBG_PPU_EXCEPTION_DATA_MAT = 0x0000002000000000ull,
};
enum : u64
{
SYS_DBG_EVENT_CORE_DUMPED = 0x0000000000001000ull,
SYS_DBG_EVENT_PPU_EXCEPTION_HANDLER_SIGNALED = 0x0000000000002000ull,
};
union sys_dbg_vr_t
{
u8 byte[16];
be_t<u16> halfword[8];
be_t<u32> word[8];
be_t<u64> dw[2];
};
struct sys_dbg_ppu_thread_context_t
{
be_t<u64> gpr[32];
be_t<u32> cr;
be_t<u64> xer;
be_t<u64> lr;
be_t<u64> ctr;
be_t<u64> pc;
be_t<u64> fpr[32];
be_t<u32> fpscr;
sys_dbg_vr_t vr[32];
sys_dbg_vr_t vscr;
};
union sys_dbg_spu_gpr_t
{
u8 byte[16];
be_t<u16> halfword[8];
be_t<u32> word[4];
be_t<u64> dw[2];
};
union sys_dbg_spu_fpscr_t
{
u8 byte[16];
be_t<u16> halfword[8];
be_t<u32> word[4];
be_t<u64> dw[2];
};
struct sys_dbg_spu_thread_context_t
{
sys_dbg_spu_gpr_t gpr[128];
be_t<u32> npc;
be_t<u32> fpscr;
be_t<u32> srr0;
be_t<u32> spu_status;
be_t<u64> spu_cfg;
be_t<u32> mb_stat;
be_t<u32> ppu_mb;
be_t<u32> spu_mb[4];
be_t<u32> decrementer;
be_t<u64> mfc_cq_sr[96];
};
struct sys_dbg_spu_thread_context2_t
{
sys_dbg_spu_gpr_t gpr[128];
be_t<u32> npc;
sys_dbg_spu_fpscr_t fpscr;
be_t<u32> srr0;
be_t<u32> spu_status;
be_t<u64> spu_cfg;
be_t<u32> mb_stat;
be_t<u32> ppu_mb;
be_t<u32> spu_mb[4];
be_t<u32> decrementer;
be_t<u64> mfc_cq_sr[96];
};
struct sys_dbg_mutex_information_t
{
sys_mutex_attribute_t attr;
be_t<u64> owner;
be_t<s32> lock_counter;
be_t<s32> cond_ref_counter;
be_t<u32> cond_id; // zero
vm::bptr<u64> wait_id_list;
be_t<u32> wait_threads_num;
be_t<u32> wait_all_threads_num;
};
struct sys_dbg_cond_information_t
{
sys_cond_attribute_t attr;
be_t<u32> mutex_id;
vm::bptr<u64> wait_id_list;
be_t<u32> wait_threads_num;
be_t<u32> wait_all_threads_num;
};
struct sys_dbg_rwlock_information_t
{
sys_rwlock_attribute_t attr;
be_t<u64> owner;
vm::bptr<u64> r_wait_id_list;
be_t<u32> r_wait_threads_num;
be_t<u32> r_wait_all_threads_num;
vm::bptr<u64> w_wait_id_list;
be_t<u32> w_wait_threads_num;
be_t<u32> w_wait_all_threads_num;
};
struct sys_dbg_event_queue_information_t
{
sys_event_queue_attribute_t attr;
be_t<u64> event_queue_key;
be_t<s32> queue_size;
vm::bptr<u64> wait_id_list;
be_t<u32> wait_threads_num;
be_t<u32> wait_all_threads_num;
vm::bptr<sys_event_t> equeue_list;
be_t<u32> readable_equeue_num;
be_t<u32> readable_all_equeue_num;
};
struct sys_dbg_semaphore_information_t
{
sys_semaphore_attribute_t attr;
be_t<s32> max_val;
be_t<s32> cur_val;
vm::bptr<u64> wait_id_list;
be_t<u32> wait_threads_num;
be_t<u32> wait_all_threads_num;
};
struct sys_dbg_lwmutex_information_t
{
sys_lwmutex_attribute_t attr;
be_t<u64> owner;
be_t<s32> lock_counter;
vm::bptr<u64> wait_id_list;
be_t<u32> wait_threads_num;
be_t<u32> wait_all_threads_num;
};
struct sys_dbg_lwcond_information_t
{
sys_lwcond_attribute_t attr;
vm::bptr<sys_lwmutex_t> lwmutex;
vm::bptr<u64> wait_id_list;
be_t<u32> wait_threads_num;
be_t<u32> wait_all_threads_num;
};
struct sys_dbg_event_flag_wait_information_t
{
be_t<u64> bitptn;
be_t<u32> mode;
};
struct sys_dbg_event_flag_information_t
{
sys_event_flag_attribute_t attr;
be_t<u64> cur_bitptn;
vm::bptr<u64> wait_id_list;
vm::bptr<sys_dbg_event_flag_wait_information_t> wait_info_list;
be_t<u32> wait_threads_num;
be_t<u32> wait_all_threads_num;
};
using dbg_exception_handler_t = void(u64 exception_type, u64 thread_id, u64 dar);
enum : u64
{
SYS_VM_STATE_LOCKED = 0x0008ull,
SYS_VM_STATE_DIRTY = 0x0010ull,
};
struct sys_vm_page_information_t
{
be_t<u64> state;
};
enum : u64
{
SYS_DBG_DABR_CTRL_READ = 0x0000000000000005ull,
SYS_DBG_DABR_CTRL_WRITE = 0x0000000000000006ull,
SYS_DBG_DABR_CTRL_CLEAR = 0x0000000000000000ull,
};
enum
{
SYS_DBG_MAT_TRANSPARENT = 1,
SYS_DBG_MAT_WRITE = 2,
SYS_DBG_MAT_READ_WRITE = 4,
SYS_MAT_GRANULARITY = 4096,
};
enum sys_dbg_coredump_parameter_t : s32
{
SYS_DBG_COREDUMP_OFF,
SYS_DBG_COREDUMP_ON_SAVE_TO_APP_HOME,
SYS_DBG_COREDUMP_ON_SAVE_TO_DEV_MS,
SYS_DBG_COREDUMP_ON_SAVE_TO_DEV_USB,
SYS_DBG_COREDUMP_ON_SAVE_TO_DEV_HDD0,
};
| 7,839
|
C++
|
.h
| 263
| 28.015209
| 81
| 0.770107
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,910
|
sceNp.h
|
RPCS3_rpcs3/rpcs3/Emu/Cell/Modules/sceNp.h
|
#pragma once
#include "cellRtc.h"
#include "Emu/Cell/ErrorCodes.h"
#include <set>
error_code sceNpInit(u32 poolsize, vm::ptr<void> poolptr);
error_code sceNpTerm();
using np_in_addr_t = u32;
using np_in_port_t = u16;
using np_sa_family_t = u8;
using np_socklen_t = u32;
struct np_in_addr
{
np_in_addr_t np_s_addr; // TODO: alignment?
};
using sys_memory_container_t = u32;
using system_time_t = u64; // s64 in documentation. But since this is in microseconds, it doesn't seem to make much sense.
using second_t = u32;
using usecond_t = u64;
using SceNpBasicAttachmentDataId = u32;
using SceNpBasicMessageId = u64;
using SceNpBasicMessageRecvAction = u32;
using SceNpClanId = u32;
using SceNpClansMessageId = u32;
using SceNpClansMemberStatus = s32;
using SceNpCustomMenuIndexMask = u32;
using SceNpCustomMenuSelectedType = u32;
using SceNpFriendlistCustomOptions = u64;
using SceNpPlatformType = s32;
using SceNpScoreBoardId = u32;
using SceNpScoreClansBoardId = u32;
using SceNpScorePcId = s32;
using SceNpScoreRankNumber = u32;
using SceNpScoreValue = s64;
using SceNpTime = s64;
// Error Codes
enum SceNpError : u32
{
// NP Manager Utility
SCE_NP_ERROR_NOT_INITIALIZED = 0x8002aa01,
SCE_NP_ERROR_ALREADY_INITIALIZED = 0x8002aa02,
SCE_NP_ERROR_INVALID_ARGUMENT = 0x8002aa03,
SCE_NP_ERROR_OUT_OF_MEMORY = 0x8002aa04,
SCE_NP_ERROR_ID_NO_SPACE = 0x8002aa05,
SCE_NP_ERROR_ID_NOT_FOUND = 0x8002aa06,
SCE_NP_ERROR_SESSION_RUNNING = 0x8002aa07,
SCE_NP_ERROR_LOGINID_ALREADY_EXISTS = 0x8002aa08,
SCE_NP_ERROR_INVALID_TICKET_SIZE = 0x8002aa09,
SCE_NP_ERROR_INVALID_STATE = 0x8002aa0a,
SCE_NP_ERROR_ABORTED = 0x8002aa0b,
SCE_NP_ERROR_OFFLINE = 0x8002aa0c,
SCE_NP_ERROR_VARIANT_ACCOUNT_ID = 0x8002aa0d,
SCE_NP_ERROR_GET_CLOCK = 0x8002aa0e,
SCE_NP_ERROR_INSUFFICIENT_BUFFER = 0x8002aa0f,
SCE_NP_ERROR_EXPIRED_TICKET = 0x8002aa10,
SCE_NP_ERROR_TICKET_PARAM_NOT_FOUND = 0x8002aa11,
SCE_NP_ERROR_UNSUPPORTED_TICKET_VERSION = 0x8002aa12,
SCE_NP_ERROR_TICKET_STATUS_CODE_INVALID = 0x8002aa13,
SCE_NP_ERROR_INVALID_TICKET_VERSION = 0x8002aa14,
SCE_NP_ERROR_ALREADY_USED = 0x8002aa15,
SCE_NP_ERROR_DIFFERENT_USER = 0x8002aa16,
SCE_NP_ERROR_ALREADY_DONE = 0x8002aa17,
// NP Basic Utility
SCE_NP_BASIC_ERROR_ALREADY_INITIALIZED = 0x8002a661,
SCE_NP_BASIC_ERROR_NOT_INITIALIZED = 0x8002a662,
SCE_NP_BASIC_ERROR_NOT_SUPPORTED = 0x8002a663,
SCE_NP_BASIC_ERROR_OUT_OF_MEMORY = 0x8002a664,
SCE_NP_BASIC_ERROR_INVALID_ARGUMENT = 0x8002a665,
SCE_NP_BASIC_ERROR_BAD_ID = 0x8002a666,
SCE_NP_BASIC_ERROR_IDS_DIFFER = 0x8002a667,
SCE_NP_BASIC_ERROR_PARSER_FAILED = 0x8002a668,
SCE_NP_BASIC_ERROR_TIMEOUT = 0x8002a669,
SCE_NP_BASIC_ERROR_NO_EVENT = 0x8002a66a,
SCE_NP_BASIC_ERROR_EXCEEDS_MAX = 0x8002a66b,
SCE_NP_BASIC_ERROR_INSUFFICIENT = 0x8002a66c,
SCE_NP_BASIC_ERROR_NOT_REGISTERED = 0x8002a66d,
SCE_NP_BASIC_ERROR_DATA_LOST = 0x8002a66e,
SCE_NP_BASIC_ERROR_BUSY = 0x8002a66f,
SCE_NP_BASIC_ERROR_STATUS = 0x8002a670,
SCE_NP_BASIC_ERROR_CANCEL = 0x8002a671,
SCE_NP_BASIC_ERROR_INVALID_MEMORY_CONTAINER = 0x8002a672,
SCE_NP_BASIC_ERROR_INVALID_DATA_ID = 0x8002a673,
SCE_NP_BASIC_ERROR_BROKEN_DATA = 0x8002a674,
SCE_NP_BASIC_ERROR_BLOCKLIST_ADD_FAILED = 0x8002a675,
SCE_NP_BASIC_ERROR_BLOCKLIST_IS_FULL = 0x8002a676,
SCE_NP_BASIC_ERROR_SEND_FAILED = 0x8002a677,
SCE_NP_BASIC_ERROR_NOT_CONNECTED = 0x8002a678,
SCE_NP_BASIC_ERROR_INSUFFICIENT_DISK_SPACE = 0x8002a679,
SCE_NP_BASIC_ERROR_INTERNAL_FAILURE = 0x8002a67a,
SCE_NP_BASIC_ERROR_DOES_NOT_EXIST = 0x8002a67b,
SCE_NP_BASIC_ERROR_INVALID = 0x8002a67c,
SCE_NP_BASIC_ERROR_UNKNOWN = 0x8002a6bf,
SCE_NP_EXT_ERROR_CONTEXT_DOES_NOT_EXIST = 0x8002a6a1,
SCE_NP_EXT_ERROR_CONTEXT_ALREADY_EXISTS = 0x8002a6a2,
SCE_NP_EXT_ERROR_NO_CONTEXT = 0x8002a6a3,
SCE_NP_EXT_ERROR_NO_ORIGIN = 0x8002a6a4,
// NP Common Utility
SCE_NP_UTIL_ERROR_INVALID_ARGUMENT = 0x8002ab01,
SCE_NP_UTIL_ERROR_OUT_OF_MEMORY = 0x8002ab02,
SCE_NP_UTIL_ERROR_INSUFFICIENT = 0x8002ab03,
SCE_NP_UTIL_ERROR_PARSER_FAILED = 0x8002ab04,
SCE_NP_UTIL_ERROR_INVALID_PROTOCOL_ID = 0x8002ab05,
SCE_NP_UTIL_ERROR_INVALID_NP_ID = 0x8002ab06,
SCE_NP_UTIL_ERROR_INVALID_NP_LOBBY_ID = 0x8002ab07,
SCE_NP_UTIL_ERROR_INVALID_NP_ROOM_ID = 0x8002ab08,
SCE_NP_UTIL_ERROR_INVALID_NP_ENV = 0x8002ab09,
SCE_NP_UTIL_ERROR_INVALID_TITLEID = 0x8002ab0a,
SCE_NP_UTIL_ERROR_INVALID_CHARACTER = 0x8002ab0b,
SCE_NP_UTIL_ERROR_INVALID_ESCAPE_STRING = 0x8002ab0c,
SCE_NP_UTIL_ERROR_UNKNOWN_TYPE = 0x8002ab0d,
SCE_NP_UTIL_ERROR_UNKNOWN = 0x8002ab0e,
SCE_NP_UTIL_ERROR_NOT_MATCH = 0x8002ab0f,
SCE_NP_UTIL_ERROR_UNKNOWN_PLATFORM_TYPE = 0x8002ab10,
// NP Friendlist Utility
SCE_NP_FRIENDLIST_ERROR_ALREADY_INITIALIZED = 0x8002ab20,
SCE_NP_FRIENDLIST_ERROR_NOT_INITIALIZED = 0x8002ab21,
SCE_NP_FRIENDLIST_ERROR_OUT_OF_MEMORY = 0x8002ab22,
SCE_NP_FRIENDLIST_ERROR_INVALID_MEMORY_CONTAINER = 0x8002ab23,
SCE_NP_FRIENDLIST_ERROR_INSUFFICIENT = 0x8002ab24,
SCE_NP_FRIENDLIST_ERROR_CANCEL = 0x8002ab25,
SCE_NP_FRIENDLIST_ERROR_STATUS = 0x8002ab26,
SCE_NP_FRIENDLIST_ERROR_BUSY = 0x8002ab27,
SCE_NP_FRIENDLIST_ERROR_INVALID_ARGUMENT = 0x8002ab28,
// NP Profile Utility
SCE_NP_PROFILE_ERROR_ALREADY_INITIALIZED = 0x8002ab40,
SCE_NP_PROFILE_ERROR_NOT_INITIALIZED = 0x8002ab41,
SCE_NP_PROFILE_ERROR_OUT_OF_MEMORY = 0x8002ab42,
SCE_NP_PROFILE_ERROR_NOT_SUPPORTED = 0x8002ab43,
SCE_NP_PROFILE_ERROR_INSUFFICIENT = 0x8002ab44,
SCE_NP_PROFILE_ERROR_CANCEL = 0x8002ab45,
SCE_NP_PROFILE_ERROR_STATUS = 0x8002ab46,
SCE_NP_PROFILE_ERROR_BUSY = 0x8002ab47,
SCE_NP_PROFILE_ERROR_INVALID_ARGUMENT = 0x8002ab48,
SCE_NP_PROFILE_ERROR_ABORT = 0x8002ab49,
// NP Community Utility
SCE_NP_COMMUNITY_ERROR_ALREADY_INITIALIZED = 0x8002a101,
SCE_NP_COMMUNITY_ERROR_NOT_INITIALIZED = 0x8002a102,
SCE_NP_COMMUNITY_ERROR_OUT_OF_MEMORY = 0x8002a103,
SCE_NP_COMMUNITY_ERROR_INVALID_ARGUMENT = 0x8002a104,
SCE_NP_COMMUNITY_ERROR_NO_TITLE_SET = 0x8002a105,
SCE_NP_COMMUNITY_ERROR_NO_LOGIN = 0x8002a106,
SCE_NP_COMMUNITY_ERROR_TOO_MANY_OBJECTS = 0x8002a107,
SCE_NP_COMMUNITY_ERROR_TRANSACTION_STILL_REFERENCED = 0x8002a108,
SCE_NP_COMMUNITY_ERROR_ABORTED = 0x8002a109,
SCE_NP_COMMUNITY_ERROR_NO_RESOURCE = 0x8002a10a,
SCE_NP_COMMUNITY_ERROR_BAD_RESPONSE = 0x8002a10b,
SCE_NP_COMMUNITY_ERROR_BODY_TOO_LARGE = 0x8002a10c,
SCE_NP_COMMUNITY_ERROR_HTTP_SERVER = 0x8002a10d,
SCE_NP_COMMUNITY_ERROR_INVALID_SIGNATURE = 0x8002a10e,
SCE_NP_COMMUNITY_ERROR_TIMEOUT = 0x8002a10f,
SCE_NP_COMMUNITY_ERROR_INSUFFICIENT_ARGUMENT = 0x8002a1a1,
SCE_NP_COMMUNITY_ERROR_UNKNOWN_TYPE = 0x8002a1a2,
SCE_NP_COMMUNITY_ERROR_INVALID_ID = 0x8002a1a3,
SCE_NP_COMMUNITY_ERROR_INVALID_ONLINE_ID = 0x8002a1a4,
SCE_NP_COMMUNITY_ERROR_INVALID_TICKET = 0x8002a1a5,
SCE_NP_COMMUNITY_ERROR_CLIENT_HANDLE_ALREADY_EXISTS = 0x8002a1a6,
SCE_NP_COMMUNITY_ERROR_INSUFFICIENT_BUFFER = 0x8002a1a7,
SCE_NP_COMMUNITY_ERROR_INVALID_TYPE = 0x8002a1a8,
SCE_NP_COMMUNITY_ERROR_TRANSACTION_ALREADY_END = 0x8002a1a9,
SCE_NP_COMMUNITY_ERROR_TRANSACTION_BEFORE_END = 0x8002a1aa,
SCE_NP_COMMUNITY_ERROR_BUSY_BY_ANOTEHR_TRANSACTION = 0x8002a1ab,
SCE_NP_COMMUNITY_ERROR_INVALID_ALIGNMENT = 0x8002a1ac,
SCE_NP_COMMUNITY_ERROR_TOO_MANY_NPID = 0x8002a1ad,
SCE_NP_COMMUNITY_ERROR_TOO_LARGE_RANGE = 0x8002a1ae,
SCE_NP_COMMUNITY_ERROR_INVALID_PARTITION = 0x8002a1af,
SCE_NP_COMMUNITY_ERROR_TOO_MANY_SLOTID = 0x8002a1b1,
// NP Community Server
SCE_NP_COMMUNITY_SERVER_ERROR_BAD_REQUEST = 0x8002a401,
SCE_NP_COMMUNITY_SERVER_ERROR_INVALID_TICKET = 0x8002a402,
SCE_NP_COMMUNITY_SERVER_ERROR_INVALID_SIGNATURE = 0x8002a403,
SCE_NP_COMMUNITY_SERVER_ERROR_EXPIRED_TICKET = 0x8002a404,
SCE_NP_COMMUNITY_SERVER_ERROR_INVALID_NPID = 0x8002a405,
SCE_NP_COMMUNITY_SERVER_ERROR_FORBIDDEN = 0x8002a406,
SCE_NP_COMMUNITY_SERVER_ERROR_INTERNAL_SERVER_ERROR = 0x8002a407,
SCE_NP_COMMUNITY_SERVER_ERROR_VERSION_NOT_SUPPORTED = 0x8002a408,
SCE_NP_COMMUNITY_SERVER_ERROR_SERVICE_UNAVAILABLE = 0x8002a409,
SCE_NP_COMMUNITY_SERVER_ERROR_PLAYER_BANNED = 0x8002a40a,
SCE_NP_COMMUNITY_SERVER_ERROR_CENSORED = 0x8002a40b,
SCE_NP_COMMUNITY_SERVER_ERROR_RANKING_RECORD_FORBIDDEN = 0x8002a40c,
SCE_NP_COMMUNITY_SERVER_ERROR_USER_PROFILE_NOT_FOUND = 0x8002a40d,
SCE_NP_COMMUNITY_SERVER_ERROR_UPLOADER_DATA_NOT_FOUND = 0x8002a40e,
SCE_NP_COMMUNITY_SERVER_ERROR_QUOTA_MASTER_NOT_FOUND = 0x8002a40f,
SCE_NP_COMMUNITY_SERVER_ERROR_RANKING_TITLE_NOT_FOUND = 0x8002a410,
SCE_NP_COMMUNITY_SERVER_ERROR_BLACKLISTED_USER_ID = 0x8002a411,
SCE_NP_COMMUNITY_SERVER_ERROR_GAME_RANKING_NOT_FOUND = 0x8002a412,
SCE_NP_COMMUNITY_SERVER_ERROR_RANKING_STORE_NOT_FOUND = 0x8002a414,
SCE_NP_COMMUNITY_SERVER_ERROR_NOT_BEST_SCORE = 0x8002a415,
SCE_NP_COMMUNITY_SERVER_ERROR_LATEST_UPDATE_NOT_FOUND = 0x8002a416,
SCE_NP_COMMUNITY_SERVER_ERROR_RANKING_BOARD_MASTER_NOT_FOUND = 0x8002a417,
SCE_NP_COMMUNITY_SERVER_ERROR_RANKING_GAME_DATA_MASTER_NOT_FOUND = 0x8002a418,
SCE_NP_COMMUNITY_SERVER_ERROR_INVALID_ANTICHEAT_DATA = 0x8002a419,
SCE_NP_COMMUNITY_SERVER_ERROR_TOO_LARGE_DATA = 0x8002a41a,
SCE_NP_COMMUNITY_SERVER_ERROR_NO_SUCH_USER_NPID = 0x8002a41b,
SCE_NP_COMMUNITY_SERVER_ERROR_INVALID_ENVIRONMENT = 0x8002a41d,
SCE_NP_COMMUNITY_SERVER_ERROR_INVALID_ONLINE_NAME_CHARACTER = 0x8002a41f,
SCE_NP_COMMUNITY_SERVER_ERROR_INVALID_ONLINE_NAME_LENGTH = 0x8002a420,
SCE_NP_COMMUNITY_SERVER_ERROR_INVALID_ABOUT_ME_CHARACTER = 0x8002a421,
SCE_NP_COMMUNITY_SERVER_ERROR_INVALID_ABOUT_ME_LENGTH = 0x8002a422,
SCE_NP_COMMUNITY_SERVER_ERROR_INVALID_SCORE = 0x8002a423,
SCE_NP_COMMUNITY_SERVER_ERROR_OVER_THE_RANKING_LIMIT = 0x8002a424,
SCE_NP_COMMUNITY_SERVER_ERROR_FAIL_TO_CREATE_SIGNATURE = 0x8002a426,
SCE_NP_COMMUNITY_SERVER_ERROR_RANKING_MASTER_INFO_NOT_FOUND = 0x8002a427,
SCE_NP_COMMUNITY_SERVER_ERROR_OVER_THE_GAME_DATA_LIMIT = 0x8002a428,
SCE_NP_COMMUNITY_SERVER_ERROR_SELF_DATA_NOT_FOUND = 0x8002a42a,
SCE_NP_COMMUNITY_SERVER_ERROR_USER_NOT_ASSIGNED = 0x8002a42b,
SCE_NP_COMMUNITY_SERVER_ERROR_GAME_DATA_ALREADY_EXISTS = 0x8002a42c,
SCE_NP_COMMUNITY_SERVER_ERROR_TOO_MANY_RESULTS = 0x8002a42d,
SCE_NP_COMMUNITY_SERVER_ERROR_NOT_RECORDABLE_VERSION = 0x8002a42e,
SCE_NP_COMMUNITY_SERVER_ERROR_USER_STORAGE_TITLE_MASTER_NOT_FOUND = 0x8002a448,
SCE_NP_COMMUNITY_SERVER_ERROR_INVALID_VIRTUAL_USER = 0x8002a449,
SCE_NP_COMMUNITY_SERVER_ERROR_USER_STORAGE_DATA_NOT_FOUND = 0x8002a44a,
SCE_NP_COMMUNITY_SERVER_ERROR_CONDITIONS_NOT_SATISFIED = 0x8002a473,
SCE_NP_COMMUNITY_SERVER_ERROR_MATCHING_BEFORE_SERVICE = 0x8002a4a0,
SCE_NP_COMMUNITY_SERVER_ERROR_MATCHING_END_OF_SERVICE = 0x8002a4a1,
SCE_NP_COMMUNITY_SERVER_ERROR_MATCHING_MAINTENANCE = 0x8002a4a2,
SCE_NP_COMMUNITY_SERVER_ERROR_RANKING_BEFORE_SERVICE = 0x8002a4a3,
SCE_NP_COMMUNITY_SERVER_ERROR_RANKING_END_OF_SERVICE = 0x8002a4a4,
SCE_NP_COMMUNITY_SERVER_ERROR_RANKING_MAINTENANCE = 0x8002a4a5,
SCE_NP_COMMUNITY_SERVER_ERROR_NO_SUCH_TITLE = 0x8002a4a6,
SCE_NP_COMMUNITY_SERVER_ERROR_TITLE_USER_STORAGE_BEFORE_SERVICE = 0x8002a4aa,
SCE_NP_COMMUNITY_SERVER_ERROR_TITLE_USER_STORAGE_END_OF_SERVICE = 0x8002a4ab,
SCE_NP_COMMUNITY_SERVER_ERROR_TITLE_USER_STORAGE_MAINTENANCE = 0x8002a4ac,
SCE_NP_COMMUNITY_SERVER_ERROR_UNSPECIFIED = 0x8002a4ff,
// COMMERCE
SCE_NP_COMMERCE_ERROR_NOT_INITIALIZED = 0x80029401,
SCE_NP_COMMERCE_ERROR_ALREADY_INITIALIZED = 0x80029402,
SCE_NP_COMMERCE_ERROR_OUT_OF_MEMORY = 0x80029403,
SCE_NP_COMMERCE_ERROR_UNSUPPORTED_VERSION = 0x80029404,
SCE_NP_COMMERCE_ERROR_CTX_MAX = 0x80029405,
SCE_NP_COMMERCE_ERROR_CTX_NOT_FOUND = 0x80029406,
SCE_NP_COMMERCE_ERROR_CTXID_NOT_AVAILABLE = 0x80029407,
SCE_NP_COMMERCE_ERROR_REQ_MAX = 0x80029408,
SCE_NP_COMMERCE_ERROR_REQ_NOT_FOUND = 0x80029409,
SCE_NP_COMMERCE_ERROR_REQID_NOT_AVAILABLE = 0x8002940a,
SCE_NP_COMMERCE_ERROR_INVALID_CATEGORY_ID = 0x8002940b,
SCE_NP_COMMERCE_ERROR_INVALID_LANG_CODE = 0x8002940c,
SCE_NP_COMMERCE_ERROR_REQ_BUSY = 0x8002940d,
SCE_NP_COMMERCE_ERROR_INSUFFICIENT_BUFFER = 0x8002940e,
SCE_NP_COMMERCE_ERROR_INVALID_REQ_STATE = 0x8002940f,
SCE_NP_COMMERCE_ERROR_INVALID_CTX_STATE = 0x80029410,
SCE_NP_COMMERCE_ERROR_UNKNOWN = 0x80029411,
SCE_NP_COMMERCE_ERROR_INVALID_REQ_TYPE = 0x80029412,
SCE_NP_COMMERCE_ERROR_INVALID_MEMORY_CONTAINER = 0x80029413,
SCE_NP_COMMERCE_ERROR_INSUFFICIENT_MEMORY_CONTAINER = 0x80029414,
SCE_NP_COMMERCE_ERROR_INVALID_DATA_FLAG_TYPE = 0x80029415,
SCE_NP_COMMERCE_ERROR_INVALID_DATA_FLAG_STATE = 0x80029416,
SCE_NP_COMMERCE_ERROR_DATA_FLAG_NUM_NOT_FOUND = 0x80029417,
SCE_NP_COMMERCE_ERROR_DATA_FLAG_INFO_NOT_FOUND = 0x80029418,
SCE_NP_COMMERCE_ERROR_INVALID_PROVIDER_ID = 0x80029419,
SCE_NP_COMMERCE_ERROR_INVALID_DATA_FLAG_NUM = 0x8002941a,
SCE_NP_COMMERCE_ERROR_INVALID_SKU_ID = 0x8002941b,
SCE_NP_COMMERCE_ERROR_INVALID_DATA_FLAG_ID = 0x8002941c,
SCE_NP_COMMERCE_ERROR_GPC_SEND_REQUEST = 0x8002941d,
SCE_NP_COMMERCE_ERROR_GDF_SEND_REQUEST = 0x8002941e,
SCE_NP_COMMERCE_ERROR_SDF_SEND_REQUEST = 0x8002941f,
SCE_NP_COMMERCE_ERROR_PARSE_PRODUCT_CATEGORY = 0x80029421,
SCE_NP_COMMERCE_ERROR_CURRENCY_INFO_NOT_FOUND = 0x80029422,
SCE_NP_COMMERCE_ERROR_CATEGORY_INFO_NOT_FOUND = 0x80029423,
SCE_NP_COMMERCE_ERROR_CHILD_CATEGORY_COUNT_NOT_FOUND = 0x80029424,
SCE_NP_COMMERCE_ERROR_CHILD_CATEGORY_INFO_NOT_FOUND = 0x80029425,
SCE_NP_COMMERCE_ERROR_SKU_COUNT_NOT_FOUND = 0x80029426,
SCE_NP_COMMERCE_ERROR_SKU_INFO_NOT_FOUND = 0x80029427,
SCE_NP_COMMERCE_ERROR_PLUGIN_LOAD_FAILURE = 0x80029428,
SCE_NP_COMMERCE_ERROR_INVALID_SKU_NUM = 0x80029429,
SCE_NP_COMMERCE_ERROR_INVALID_GPC_PROTOCOL_VERSION = 0x8002942a,
SCE_NP_COMMERCE_ERROR_CHECKOUT_UNEXPECTED = 0x80029430,
SCE_NP_COMMERCE_ERROR_CHECKOUT_OUT_OF_SERVICE = 0x80029431,
SCE_NP_COMMERCE_ERROR_CHECKOUT_INVALID_SKU = 0x80029432,
SCE_NP_COMMERCE_ERROR_CHECKOUT_SERVER_BUSY = 0x80029433,
SCE_NP_COMMERCE_ERROR_CHECKOUT_MAINTENANCE = 0x80029434,
SCE_NP_COMMERCE_ERROR_CHECKOUT_ACCOUNT_SUSPENDED = 0x80029435,
SCE_NP_COMMERCE_ERROR_CHECKOUT_OVER_SPENDING_LIMIT = 0x80029436,
SCE_NP_COMMERCE_ERROR_CHECKOUT_NOT_ENOUGH_MONEY = 0x80029437,
SCE_NP_COMMERCE_ERROR_CHECKOUT_UNKNOWN = 0x80029438,
SCE_NP_COMMERCE_BROWSE_SERVER_ERROR_UNKNOWN = 0x80029600,
SCE_NP_COMMERCE_BROWSE_SERVER_ERROR_INVALID_CREDENTIALS = 0x80029601,
SCE_NP_COMMERCE_BROWSE_SERVER_ERROR_INVALID_CATEGORY_ID = 0x80029602,
SCE_NP_COMMERCE_BROWSE_SERVER_ERROR_SERVICE_END = 0x80029603,
SCE_NP_COMMERCE_BROWSE_SERVER_ERROR_SERVICE_STOP = 0x80029604,
SCE_NP_COMMERCE_BROWSE_SERVER_ERROR_SERVICE_BUSY = 0x80029605,
SCE_NP_COMMERCE_BROWSE_SERVER_ERROR_UNSUPPORTED_VERSION = 0x80029606,
SCE_NP_COMMERCE_BROWSE_SERVER_ERROR_INTERNAL_SERVER = 0x80029680,
SCE_NP_COMMERCE_GDF_SERVER_ERROR_UNKNOWN = 0x80029d00,
SCE_NP_COMMERCE_GDF_SERVER_ERROR_INVALID_CREDENTIALS = 0x80029d01,
SCE_NP_COMMERCE_GDF_SERVER_ERROR_INVALID_FLAGLIST = 0x80029d02,
SCE_NP_COMMERCE_GDF_SERVER_ERROR_SERVICE_END = 0x80029d03,
SCE_NP_COMMERCE_GDF_SERVER_ERROR_SERVICE_STOP = 0x80029d04,
SCE_NP_COMMERCE_GDF_SERVER_ERROR_SERVICE_BUSY = 0x80029d05,
SCE_NP_COMMERCE_GDF_SERVER_ERROR_UNSUPPORTED_VERSION = 0x80029d06,
SCE_NP_COMMERCE_SDF_SERVER_ERROR_UNKNOWN = 0x80029e00,
SCE_NP_COMMERCE_SDF_SERVER_ERROR_INVALID_CREDENTIALS = 0x80029e01,
SCE_NP_COMMERCE_SDF_SERVER_ERROR_INVALID_FLAGLIST = 0x80029e02,
SCE_NP_COMMERCE_SDF_SERVER_ERROR_SERVICE_END = 0x80029e03,
SCE_NP_COMMERCE_SDF_SERVER_ERROR_SERVICE_STOP = 0x80029e04,
SCE_NP_COMMERCE_SDF_SERVER_ERROR_SERVICE_BUSY = 0x80029e05,
SCE_NP_COMMERCE_SDF_SERVER_ERROR_UNSUPPORTED_VERSION = 0x80029e06,
// DRM
SCE_NP_DRM_ERROR_OUT_OF_MEMORY = 0x80029501,
SCE_NP_DRM_ERROR_INVALID_PARAM = 0x80029502,
SCE_NP_DRM_ERROR_SERVER_RESPONSE = 0x80029509,
SCE_NP_DRM_ERROR_NO_ENTITLEMENT = 0x80029513,
SCE_NP_DRM_ERROR_BAD_ACT = 0x80029514,
SCE_NP_DRM_ERROR_BAD_FORMAT = 0x80029515,
SCE_NP_DRM_ERROR_NO_LOGIN = 0x80029516,
SCE_NP_DRM_ERROR_INTERNAL = 0x80029517,
SCE_NP_DRM_ERROR_BAD_PERM = 0x80029519,
SCE_NP_DRM_ERROR_UNKNOWN_VERSION = 0x8002951a,
SCE_NP_DRM_ERROR_TIME_LIMIT = 0x8002951b,
SCE_NP_DRM_ERROR_DIFFERENT_ACCOUNT_ID = 0x8002951c,
SCE_NP_DRM_ERROR_DIFFERENT_DRM_TYPE = 0x8002951d,
SCE_NP_DRM_ERROR_SERVICE_NOT_STARTED = 0x8002951e,
SCE_NP_DRM_ERROR_BUSY = 0x80029520,
SCE_NP_DRM_ERROR_LICENSE_NOT_FOUND = 0x80029521,
SCE_NP_DRM_ERROR_IO = 0x80029525,
SCE_NP_DRM_ERROR_FORMAT = 0x80029530,
SCE_NP_DRM_ERROR_FILENAME = 0x80029533,
SCE_NP_DRM_ERROR_K_LICENSEE = 0x80029534,
// DRM Server
SCE_NP_DRM_SERVER_ERROR_SERVICE_IS_END = 0x80029700,
SCE_NP_DRM_SERVER_ERROR_SERVICE_STOP_TEMPORARILY = 0x80029701,
SCE_NP_DRM_SERVER_ERROR_SERVICE_IS_BUSY = 0x80029702,
SCE_NP_DRM_SERVER_ERROR_INVALID_USER_CREDENTIAL = 0x80029721,
SCE_NP_DRM_SERVER_ERROR_INVALID_PRODUCT_ID = 0x80029722,
SCE_NP_DRM_SERVER_ERROR_ACCOUNT_IS_CLOSED = 0x80029730,
SCE_NP_DRM_SERVER_ERROR_ACCOUNT_IS_SUSPENDED = 0x80029731,
SCE_NP_DRM_SERVER_ERROR_ACTIVATED_CONSOLE_IS_FULL = 0x80029750,
SCE_NP_DRM_SERVER_ERROR_CONSOLE_NOT_ACTIVATED = 0x80029751,
SCE_NP_DRM_SERVER_ERROR_PRIMARY_CONSOLE_CANNOT_CHANGED = 0x80029752,
SCE_NP_DRM_SERVER_ERROR_UNKNOWN = 0x80029780,
// DRM Install
SCE_NP_DRM_INSTALL_ERROR_FORMAT = 0x80029563,
SCE_NP_DRM_INSTALL_ERROR_CHECK = 0x80029564,
SCE_NP_DRM_INSTALL_ERROR_UNSUPPORTED = 0x80029566,
// Game purchase processing
GAME_ERR_NOT_XMBBUY_CONTENT = 0x80028F81,
// Auth
SCE_NP_AUTH_EINVAL = 0x8002a002,
SCE_NP_AUTH_ENOMEM = 0x8002a004,
SCE_NP_AUTH_ESRCH = 0x8002a005,
SCE_NP_AUTH_EBUSY = 0x8002a00a,
SCE_NP_AUTH_EABORT = 0x8002a00c,
SCE_NP_AUTH_EEXIST = 0x8002a014,
SCE_NP_AUTH_EINVALID_ARGUMENT = 0x8002a015,
// Auth extended
SCE_NP_AUTH_ERROR_SERVICE_END = 0x8002a200,
SCE_NP_AUTH_ERROR_SERVICE_DOWN = 0x8002a201,
SCE_NP_AUTH_ERROR_SERVICE_BUSY = 0x8002a202,
SCE_NP_AUTH_ERROR_SERVER_MAINTENANCE = 0x8002a203,
SCE_NP_AUTH_ERROR_INVALID_DATA_LENGTH = 0x8002a210,
SCE_NP_AUTH_ERROR_INVALID_USER_AGENT = 0x8002a211,
SCE_NP_AUTH_ERROR_INVALID_VERSION = 0x8002a212,
SCE_NP_AUTH_ERROR_INVALID_SERVICE_ID = 0x8002a220,
SCE_NP_AUTH_ERROR_INVALID_CREDENTIAL = 0x8002a221,
SCE_NP_AUTH_ERROR_INVALID_ENTITLEMENT_ID = 0x8002a222,
SCE_NP_AUTH_ERROR_INVALID_CONSUMED_COUNT = 0x8002a223,
SCE_NP_AUTH_ERROR_INVALID_CONSOLE_ID = 0x8002a224,
SCE_NP_AUTH_ERROR_CONSOLE_ID_SUSPENDED = 0x8002a227,
SCE_NP_AUTH_ERROR_ACCOUNT_CLOSED = 0x8002a230,
SCE_NP_AUTH_ERROR_ACCOUNT_SUSPENDED = 0x8002a231,
SCE_NP_AUTH_ERROR_ACCOUNT_RENEW_EULA = 0x8002a232,
SCE_NP_AUTH_ERROR_ACCOUNT_RENEW_ACCOUNT1 = 0x8002a240,
SCE_NP_AUTH_ERROR_ACCOUNT_RENEW_ACCOUNT2 = 0x8002a241,
SCE_NP_AUTH_ERROR_ACCOUNT_RENEW_ACCOUNT3 = 0x8002a242,
SCE_NP_AUTH_ERROR_ACCOUNT_RENEW_ACCOUNT4 = 0x8002a243,
SCE_NP_AUTH_ERROR_ACCOUNT_RENEW_ACCOUNT5 = 0x8002a244,
SCE_NP_AUTH_ERROR_ACCOUNT_RENEW_ACCOUNT6 = 0x8002a245,
SCE_NP_AUTH_ERROR_ACCOUNT_RENEW_ACCOUNT7 = 0x8002a246,
SCE_NP_AUTH_ERROR_ACCOUNT_RENEW_ACCOUNT8 = 0x8002a247,
SCE_NP_AUTH_ERROR_ACCOUNT_RENEW_ACCOUNT9 = 0x8002a248,
SCE_NP_AUTH_ERROR_ACCOUNT_RENEW_ACCOUNT10 = 0x8002a249,
SCE_NP_AUTH_ERROR_ACCOUNT_RENEW_ACCOUNT11 = 0x8002a24a,
SCE_NP_AUTH_ERROR_ACCOUNT_RENEW_ACCOUNT12 = 0x8002a24b,
SCE_NP_AUTH_ERROR_ACCOUNT_RENEW_ACCOUNT13 = 0x8002a24c,
SCE_NP_AUTH_ERROR_ACCOUNT_RENEW_ACCOUNT14 = 0x8002a24d,
SCE_NP_AUTH_ERROR_ACCOUNT_RENEW_ACCOUNT15 = 0x8002a24e,
SCE_NP_AUTH_ERROR_ACCOUNT_RENEW_ACCOUNT16 = 0x8002a24f,
SCE_NP_AUTH_ERROR_UNKNOWN = 0x8002a280,
// Core Utility
SCE_NP_CORE_UTIL_ERROR_INVALID_ARGUMENT = 0x8002a501,
SCE_NP_CORE_UTIL_ERROR_OUT_OF_MEMORY = 0x8002a502,
SCE_NP_CORE_UTIL_ERROR_INSUFFICIENT = 0x8002a503,
SCE_NP_CORE_UTIL_ERROR_PARSER_FAILED = 0x8002a504,
SCE_NP_CORE_UTIL_ERROR_INVALID_PROTOCOL_ID = 0x8002a505,
SCE_NP_CORE_UTIL_ERROR_INVALID_EXTENSION = 0x8002a506,
SCE_NP_CORE_UTIL_ERROR_INVALID_TEXT = 0x8002a507,
SCE_NP_CORE_UTIL_ERROR_UNKNOWN_TYPE = 0x8002a508,
SCE_NP_CORE_UTIL_ERROR_UNKNOWN = 0x8002a509,
// Core Parser
SCE_NP_CORE_PARSER_ERROR_NOT_INITIALIZED = 0x8002a511,
SCE_NP_CORE_PARSER_ERROR_ALREADY_INITIALIZED = 0x8002a512,
SCE_NP_CORE_PARSER_ERROR_OUT_OF_MEMORY = 0x8002a513,
SCE_NP_CORE_PARSER_ERROR_INSUFFICIENT = 0x8002a514,
SCE_NP_CORE_PARSER_ERROR_INVALID_FORMAT = 0x8002a515,
SCE_NP_CORE_PARSER_ERROR_INVALID_ARGUMENT = 0x8002a516,
SCE_NP_CORE_PARSER_ERROR_INVALID_HANDLE = 0x8002a517,
SCE_NP_CORE_PARSER_ERROR_INVALID_ICON = 0x8002a518,
SCE_NP_CORE_PARSER_ERROR_UNKNOWN = 0x8002a519,
// Core Errors
SCE_NP_CORE_ERROR_ALREADY_INITIALIZED = 0x8002a521,
SCE_NP_CORE_ERROR_NOT_INITIALIZED = 0x8002a522,
SCE_NP_CORE_ERROR_INVALID_ARGUMENT = 0x8002a523,
SCE_NP_CORE_ERROR_OUT_OF_MEMORY = 0x8002a524,
SCE_NP_CORE_ERROR_ID_NOT_AVAILABLE = 0x8002a525,
SCE_NP_CORE_ERROR_USER_OFFLINE = 0x8002a526,
SCE_NP_CORE_ERROR_SESSION_RUNNING = 0x8002a527,
SCE_NP_CORE_ERROR_SESSION_NOT_ESTABLISHED = 0x8002a528,
SCE_NP_CORE_ERROR_SESSION_INVALID_STATE = 0x8002a529,
SCE_NP_CORE_ERROR_SESSION_ID_TOO_LONG = 0x8002a52a,
SCE_NP_CORE_ERROR_SESSION_INVALID_NAMESPACE = 0x8002a52b,
SCE_NP_CORE_ERROR_CONNECTION_TIMEOUT = 0x8002a52c,
SCE_NP_CORE_ERROR_GETSOCKOPT = 0x8002a52d,
SCE_NP_CORE_ERROR_SSL_NOT_INITIALIZED = 0x8002a52e,
SCE_NP_CORE_ERROR_SSL_ALREADY_INITIALIZED = 0x8002a52f,
SCE_NP_CORE_ERROR_SSL_NO_CERT = 0x8002a530,
SCE_NP_CORE_ERROR_SSL_NO_TRUSTWORTHY_CA = 0x8002a531,
SCE_NP_CORE_ERROR_SSL_INVALID_CERT = 0x8002a532,
SCE_NP_CORE_ERROR_SSL_CERT_VERIFY = 0x8002a533,
SCE_NP_CORE_ERROR_SSL_CN_CHECK = 0x8002a534,
SCE_NP_CORE_ERROR_SSL_HANDSHAKE_FAILED = 0x8002a535,
SCE_NP_CORE_ERROR_SSL_SEND = 0x8002a536,
SCE_NP_CORE_ERROR_SSL_RECV = 0x8002a537,
SCE_NP_CORE_ERROR_SSL_CREATE_CTX = 0x8002a538,
SCE_NP_CORE_ERROR_PARSE_PEM = 0x8002a539,
SCE_NP_CORE_ERROR_INVALID_INITIATE_STREAM = 0x8002a53a,
SCE_NP_CORE_ERROR_SASL_NOT_SUPPORTED = 0x8002a53b,
SCE_NP_CORE_ERROR_NAMESPACE_ALREADY_EXISTS = 0x8002a53c,
SCE_NP_CORE_ERROR_FROM_ALREADY_EXISTS = 0x8002a53d,
SCE_NP_CORE_ERROR_MODULE_NOT_REGISTERED = 0x8002a53e,
SCE_NP_CORE_ERROR_MODULE_FROM_NOT_FOUND = 0x8002a53f,
SCE_NP_CORE_ERROR_UNKNOWN_NAMESPACE = 0x8002a540,
SCE_NP_CORE_ERROR_INVALID_VERSION = 0x8002a541,
SCE_NP_CORE_ERROR_LOGIN_TIMEOUT = 0x8002a542,
SCE_NP_CORE_ERROR_TOO_MANY_SESSIONS = 0x8002a543,
SCE_NP_CORE_ERROR_SENDLIST_NOT_FOUND = 0x8002a544,
SCE_NP_CORE_ERROR_NO_ID = 0x8002a545,
SCE_NP_CORE_ERROR_LOAD_CERTS = 0x8002a546,
SCE_NP_CORE_ERROR_NET_SELECT = 0x8002a547,
SCE_NP_CORE_ERROR_DISCONNECTED = 0x8002a548,
SCE_NP_CORE_ERROR_TICKET_TOO_SMALL = 0x8002a549,
SCE_NP_CORE_ERROR_INVALID_TICKET = 0x8002a54a,
SCE_NP_CORE_ERROR_INVALID_ONLINEID = 0x8002a54b,
SCE_NP_CORE_ERROR_GETHOSTBYNAME = 0x8002a54c,
SCE_NP_CORE_ERROR_UNDEFINED_STREAM_ERROR = 0x8002a54d,
SCE_NP_CORE_ERROR_INTERNAL = 0x8002a5ff,
// Core DNS
SCE_NP_CORE_ERROR_DNS_HOST_NOT_FOUND = 0x8002af01,
SCE_NP_CORE_ERROR_DNS_TRY_AGAIN = 0x8002af02,
SCE_NP_CORE_ERROR_DNS_NO_RECOVERY = 0x8002af03,
SCE_NP_CORE_ERROR_DNS_NO_DATA = 0x8002af04,
SCE_NP_CORE_ERROR_DNS_NO_ADDRESS = 0x8002afff,
// Core Server
SCE_NP_CORE_SERVER_ERROR_CONFLICT = 0x8002a303,
SCE_NP_CORE_SERVER_ERROR_NOT_AUTHORIZED = 0x8002a30d,
SCE_NP_CORE_SERVER_ERROR_REMOTE_CONNECTION_FAILED = 0x8002a30f,
SCE_NP_CORE_SERVER_ERROR_RESOURCE_CONSTRAINT = 0x8002a310,
SCE_NP_CORE_SERVER_ERROR_SYSTEM_SHUTDOWN = 0x8002a313,
SCE_NP_CORE_SERVER_ERROR_UNSUPPORTED_CLIENT_VERSION = 0x8002a319,
// Signaling
SCE_NP_SIGNALING_ERROR_NOT_INITIALIZED = 0x8002a801,
SCE_NP_SIGNALING_ERROR_ALREADY_INITIALIZED = 0x8002a802,
SCE_NP_SIGNALING_ERROR_OUT_OF_MEMORY = 0x8002a803,
SCE_NP_SIGNALING_ERROR_CTXID_NOT_AVAILABLE = 0x8002a804,
SCE_NP_SIGNALING_ERROR_CTX_NOT_FOUND = 0x8002a805,
SCE_NP_SIGNALING_ERROR_REQID_NOT_AVAILABLE = 0x8002a806,
SCE_NP_SIGNALING_ERROR_REQ_NOT_FOUND = 0x8002a807,
SCE_NP_SIGNALING_ERROR_PARSER_CREATE_FAILED = 0x8002a808,
SCE_NP_SIGNALING_ERROR_PARSER_FAILED = 0x8002a809,
SCE_NP_SIGNALING_ERROR_INVALID_NAMESPACE = 0x8002a80a,
SCE_NP_SIGNALING_ERROR_NETINFO_NOT_AVAILABLE = 0x8002a80b,
SCE_NP_SIGNALING_ERROR_PEER_NOT_RESPONDING = 0x8002a80c,
SCE_NP_SIGNALING_ERROR_CONNID_NOT_AVAILABLE = 0x8002a80d,
SCE_NP_SIGNALING_ERROR_CONN_NOT_FOUND = 0x8002a80e,
SCE_NP_SIGNALING_ERROR_PEER_UNREACHABLE = 0x8002a80f,
SCE_NP_SIGNALING_ERROR_TERMINATED_BY_PEER = 0x8002a810,
SCE_NP_SIGNALING_ERROR_TIMEOUT = 0x8002a811,
SCE_NP_SIGNALING_ERROR_CTX_MAX = 0x8002a812,
SCE_NP_SIGNALING_ERROR_RESULT_NOT_FOUND = 0x8002a813,
SCE_NP_SIGNALING_ERROR_CONN_IN_PROGRESS = 0x8002a814,
SCE_NP_SIGNALING_ERROR_INVALID_ARGUMENT = 0x8002a815,
SCE_NP_SIGNALING_ERROR_OWN_NP_ID = 0x8002a816,
SCE_NP_SIGNALING_ERROR_TOO_MANY_CONN = 0x8002a817,
SCE_NP_SIGNALING_ERROR_TERMINATED_BY_MYSELF = 0x8002a818,
// Custom Menu
SCE_NP_CUSTOM_MENU_ERROR_ALREADY_INITIALIZED = 0x80023b01,
SCE_NP_CUSTOM_MENU_ERROR_NOT_INITIALIZED = 0x80023b02,
SCE_NP_CUSTOM_MENU_ERROR_OUT_OF_MEMORY = 0x80023b03,
SCE_NP_CUSTOM_MENU_ERROR_NOT_SUPPORTED = 0x80023b04,
SCE_NP_CUSTOM_MENU_ERROR_INSUFFICIENT = 0x80023b05,
SCE_NP_CUSTOM_MENU_ERROR_CANCEL = 0x80023b06,
SCE_NP_CUSTOM_MENU_ERROR_STATUS = 0x80023b07,
SCE_NP_CUSTOM_MENU_ERROR_BUSY = 0x80023b08,
SCE_NP_CUSTOM_MENU_ERROR_INVALID_ARGUMENT = 0x80023b09,
SCE_NP_CUSTOM_MENU_ERROR_ABORT = 0x80023b0a,
SCE_NP_CUSTOM_MENU_ERROR_NOT_REGISTERED = 0x80023b0b,
SCE_NP_CUSTOM_MENU_ERROR_EXCEEDS_MAX = 0x80023b0c,
SCE_NP_CUSTOM_MENU_ERROR_INVALID_CHARACTER = 0x80023b0d,
// EULA
SCE_NP_EULA_ERROR_UNKNOWN = 0x8002e500,
SCE_NP_EULA_ERROR_INVALID_ARGUMENT = 0x8002e501,
SCE_NP_EULA_ERROR_NOT_INITIALIZED = 0x8002e502,
SCE_NP_EULA_ERROR_ALREADY_INITIALIZED = 0x8002e503,
SCE_NP_EULA_ERROR_OUT_OF_MEMORY = 0x8002e504,
SCE_NP_EULA_ERROR_BUSY = 0x8002e505,
SCE_NP_EULA_ERROR_EULA_NOT_FOUND = 0x8002e5a0,
SCE_NP_EULA_ERROR_NET_OUT_OF_MEMORY = 0x8002e5a1,
SCE_NP_EULA_ERROR_CONF_FORMAT = 0x8002e5b0,
SCE_NP_EULA_ERROR_CONF_INVALID_FILENAME = 0x8002e5b1,
SCE_NP_EULA_ERROR_CONF_TOO_MANY_EULA_FILES = 0x8002e5b2,
SCE_NP_EULA_ERROR_CONF_INVALID_LANGUAGE = 0x8002e5b3,
SCE_NP_EULA_ERROR_CONF_INVALID_COUNTRY = 0x8002e5b4,
SCE_NP_EULA_ERROR_CONF_INVALID_NPCOMMID = 0x8002e5b5,
SCE_NP_EULA_ERROR_CONF_INVALID_EULA_VERSION = 0x8002e5b6,
// Matching
SCE_NP_MATCHING_ERROR_NOT_INITIALIZED = 0x8002a701,
SCE_NP_MATCHING_ERROR_ALREADY_INITIALIZED = 0x8002a702,
SCE_NP_MATCHING_ERROR_INVALID_ARG = 0x8002a703,
SCE_NP_MATCHING_ERROR_TERMINATED = 0x8002a704,
SCE_NP_MATCHING_ERROR_TIMEOUT = 0x8002a705,
SCE_NP_MATCHING_ERROR_OUT_OF_MEMORY = 0x8002a706,
SCE_NP_MATCHING_ERROR_CTXID_NOT_AVAIL = 0x8002a707,
SCE_NP_MATCHING_ERROR_CTX_ALREADY_EXIST = 0x8002a708,
SCE_NP_MATCHING_ERROR_CTX_NOT_FOUND = 0x8002a709,
SCE_NP_MATCHING_ERROR_LOBBY_NOT_FOUND = 0x8002a70a,
SCE_NP_MATCHING_ERROR_ROOM_NOT_FOUND = 0x8002a70b,
SCE_NP_MATCHING_ERROR_MEMBER_NOT_FOUND = 0x8002a70c,
SCE_NP_MATCHING_ERROR_TOO_BIG_VALUE = 0x8002a70d,
SCE_NP_MATCHING_ERROR_IVALID_ATTR_TYPE = 0x8002a70e,
SCE_NP_MATCHING_ERROR_INVALID_ATTR_ID = 0x8002a70f,
SCE_NP_MATCHING_ERROR_ALREADY_REQUESTED = 0x8002a710,
SCE_NP_MATCHING_ERROR_LIMITTED_SEATING = 0x8002a711,
SCE_NP_MATCHING_ERROR_LOCKED = 0x8002a712,
SCE_NP_MATCHING_ERROR_CTX_STILL_RUNNING = 0x8002a713,
SCE_NP_MATCHING_ERROR_INSUFFICIENT_BUFFER = 0x8002a714,
SCE_NP_MATCHING_ERROR_REQUEST_NOT_ALLOWED = 0x8002a715,
SCE_NP_MATCHING_ERROR_CTX_MAX = 0x8002a716,
SCE_NP_MATCHING_ERROR_INVALID_REQ_ID = 0x8002a717,
SCE_NP_MATCHING_ERROR_RESULT_NOT_FOUND = 0x8002a718,
SCE_NP_MATCHING_ERROR_BUSY = 0x8002a719,
SCE_NP_MATCHING_ERROR_ALREADY_JOINED_ROOM = 0x8002a71a,
SCE_NP_MATCHING_ERROR_ROOM_MAX = 0x8002a71b,
SCE_NP_MATCHING_ERROR_QUICK_MATCH_PLAYER_NOT_FOUND = 0x8002a71c,
SCE_NP_MATCHING_ERROR_COND_MAX = 0x8002a71d,
SCE_NP_MATCHING_ERROR_INVALID_COND = 0x8002a71e,
SCE_NP_MATCHING_ERROR_INVALID_ATTR = 0x8002a71f,
SCE_NP_MATCHING_ERROR_COMP_OP_INEQUALITY_MAX = 0x8002a720,
SCE_NP_MATCHING_ERROR_RESULT_OVERFLOWED = 0x8002a721,
SCE_NP_MATCHING_ERROR_HTTPXML_TIMEOUT = 0x8002a722,
SCE_NP_MATCHING_ERROR_CANCELED = 0x8002a723,
SCE_NP_MATCHING_ERROR_SEARCH_JOIN_ROOM_NOT_FOUND = 0x8002a724,
SCE_NP_MATCHING_ERROR_INVALID_COMP_OP = 0x8002a725,
SCE_NP_MATCHING_ERROR_INVALID_COMP_TYPE = 0x8002a726,
SCE_NP_MATCHING_ERROR_REQUEST_NOT_FOUND = 0x8002a727,
SCE_NP_MATCHING_ERROR_INTERNAL_ERROR = 0x8002a728,
SCE_NP_MATCHING_ERROR_INVALID_PROTOCOL_ID = 0x8002a729,
SCE_NP_MATCHING_ERROR_ATTR_NOT_SPECIFIED = 0x8002a72a,
SCE_NP_MATCHING_ERROR_SYSUTIL_INVALID_RESULT = 0x8002a72b,
SCE_NP_MATCHING_ERROR_PLUGIN_LOAD_FAILURE = 0x8002a72c,
SCE_NP_MATCHING_ERROR_INVALID_ATTR_VALUE = 0x8002a72d,
SCE_NP_MATCHING_ERROR_DUPLICATE = 0x8002a72e,
SCE_NP_MATCHING_ERROR_INVALID_MEMORY_CONTAINER = 0x8002a72f,
SCE_NP_MATCHING_ERROR_SHUTDOWN = 0x8002a730,
SCE_NP_MATCHING_ERROR_SYSUTIL_SERVER_BUSY = 0x8002a731,
SCE_NP_MATCHING_ERROR_SEND_INVITATION_PARTIALLY_FAILED = 0x8002a732,
SCE_NP_MATCHING_ERROR_UTILITY_UNAVAILABLE = 0x8002a733,
SCE_NP_MATCHING_SERVER_ERROR_OUT_OF_SERVICE = 0x8002a740,
SCE_NP_MATCHING_SERVER_ERROR_MAINTENANCE = 0x8002a741,
SCE_NP_MATCHING_SERVER_ERROR_SERVER_BUSY = 0x8002a742,
SCE_NP_MATCHING_SERVER_ERROR_ACCESS_FORBIDDEN = 0x8002a743,
SCE_NP_MATCHING_SERVER_ERROR_NO_SUCH_SERVER = 0x8002a744,
SCE_NP_MATCHING_SERVER_ERROR_NO_SUCH_LOBBY = 0x8002a745,
SCE_NP_MATCHING_SERVER_ERROR_NO_SUCH_ROOM = 0x8002a746,
SCE_NP_MATCHING_SERVER_ERROR_NO_SUCH_USER = 0x8002a747,
SCE_NP_MATCHING_SERVER_ERROR_NOT_ALLOWED = 0x8002a748,
SCE_NP_MATCHING_SERVER_ERROR_UNKNOWN = 0x8002a749,
SCE_NP_MATCHING_SERVER_ERROR_BAD_REQUEST_STANZA = 0x8002a74a,
SCE_NP_MATCHING_SERVER_ERROR_REQUEST_FORBIDDEN = 0x8002a74b,
SCE_NP_MATCHING_SERVER_ERROR_INTERNAL_ERROR = 0x8002a74c,
SCE_NP_MATCHING_SERVER_ERROR_ROOM_OVER = 0x8002a74d,
SCE_NP_MATCHING_SERVER_ERROR_ROOM_CLOSED = 0x8002a74e,
};
enum
{
SCE_NP_COMMERCE_CURRENCY_CODE_LEN = 4,
SCE_NP_COMMERCE_CATEGORY_ID_LEN = 56,
SCE_NP_COMMERCE_CATEGORY_NAME_LEN = 192,
SCE_NP_COMMERCE_CATEGORY_DESCRIPTION_LEN = 384,
SCE_NP_COMMERCE_CATEGORY_IMAGEURL_LEN = 128,
SCE_NP_COMMERCE_PRODUCT_ID_LEN = 48,
SCE_NP_COMMERCE_PRODUCT_NAME_LEN = 192,
SCE_NP_COMMERCE_SKU_ID_LEN = 56,
SCE_NP_COMMERCE_SKU_NAME_LEN = 64,
SCE_NP_COMMERCE_SKU_DESCRIPTION_LEN = 384,
SCE_NP_COMMERCE_SKU_IMAGEURL_LEN = 128,
SCE_NP_COMMERCE_SKU_USER_DATA_LEN = 128,
};
enum
{
SCE_NP_COMMERCE_EVENT_REQUEST_ERROR = 0x0001,
SCE_NP_COMMERCE_EVENT_PRODUCT_CATEGORY_READY = 0x0011,
SCE_NP_COMMERCE_EVENT_PRODUCT_CATEGORY_DONE = 0x0012,
SCE_NP_COMMERCE_EVENT_PRODUCT_CATEGORY_ABORT = 0x0013,
SCE_NP_COMMERCE_EVENT_DO_CHECKOUT_STARTED = 0x0021,
SCE_NP_COMMERCE_EVENT_DO_CHECKOUT_SUCCESS = 0x0022,
SCE_NP_COMMERCE_EVENT_DO_CHECKOUT_BACK = 0x0023,
SCE_NP_COMMERCE_EVENT_DO_CHECKOUT_FINISHED = 0x0025,
};
enum
{
SCE_NP_MATCHING_EVENT_ERROR = 0x0001,
SCE_NP_MATCHING_EVENT_LEAVE_ROOM_DONE = 0x0002,
SCE_NP_MATCHING_EVENT_RESERVED1 = 0x0003,
SCE_NP_MATCHING_EVENT_RESERVED2 = 0x0004,
SCE_NP_MATCHING_EVENT_ROOM_UPDATE_NEW_MEMBER = 0x0005,
SCE_NP_MATCHING_EVENT_ROOM_UPDATE_MEMBER_LEAVE = 0x0006,
SCE_NP_MATCHING_EVENT_ROOM_DISAPPEARED = 0x0007,
SCE_NP_MATCHING_EVENT_RESERVED3 = 0x0008,
SCE_NP_MATCHING_EVENT_GET_ROOM_INFO_DONE = 0x0009,
SCE_NP_MATCHING_EVENT_SET_ROOM_INFO_DONE = 0x000a,
SCE_NP_MATCHING_EVENT_GRANT_OWNER_DONE = 0x000b,
SCE_NP_MATCHING_EVENT_ROOM_UPDATE_OWNER_CHANGE = 0x000c,
SCE_NP_MATCHING_EVENT_KICK_MEMBER_DONE = 0x000d,
SCE_NP_MATCHING_EVENT_ROOM_KICKED = 0x000e,
SCE_NP_MATCHING_EVENT_GET_ROOM_SEARCH_FLAG_DONE = 0x000f,
SCE_NP_MATCHING_EVENT_SET_ROOM_SEARCH_FLAG_DONE = 0x0010,
};
enum
{
SCE_NP_MATCHING_ATTR_TYPE_BASIC_BIN = 1,
SCE_NP_MATCHING_ATTR_TYPE_BASIC_NUM = 2,
SCE_NP_MATCHING_ATTR_TYPE_GAME_BIN = 3,
SCE_NP_MATCHING_ATTR_TYPE_GAME_NUM = 4,
};
enum
{
SCE_NP_MATCHING_ATTR_ID_MIN = 1,
SCE_NP_MATCHING_ATTR_ID_MAX = 16,
SCE_NP_MATCHING_ATTR_ID_FOR_SEARCH_CONDITION_MAX = 8,
SCE_NP_MATCHING_ATTR_ID_FOR_GRLGLIMIT_SRCH_COND_MAX = 8,
SCE_NP_MATCHING_ATTR_BIN_BIG_SIZE_ID_MAX = 2,
SCE_NP_MATCHING_ATTR_BIN_MAX_SIZE_SMALL = 64,
SCE_NP_MATCHING_ATTR_BIN_MAX_SIZE_BIG = 256,
};
enum
{
SCE_NP_MATCHING_ROOM_ATTR_ID_TOTAL_SLOT = 1,
SCE_NP_MATCHING_ROOM_ATTR_ID_PRIVATE_SLOT = 2,
SCE_NP_MATCHING_ROOM_ATTR_ID_CUR_TOTAL_NUM = 3,
SCE_NP_MATCHING_ROOM_ATTR_ID_CUR_PUBLIC_NUM = 4,
SCE_NP_MATCHING_ROOM_ATTR_ID_CUR_PRIVATE_NUM = 5,
SCE_NP_MATCHING_ROOM_ATTR_ID_PRIVILEGE_TYPE = 6,
SCE_NP_MATCHING_ROOM_ATTR_ID_ROOM_SEARCH_FLAG = 7,
SCE_NP_MATCHING_ROOM_ATTR_ID_MAX = 8,
};
enum
{
SCE_NP_MATCHING_ROOM_SLOT_TYPE_PUBLIC = 0,
SCE_NP_MATCHING_ROOM_SLOT_TYPE_PRIVATE = 1,
};
enum
{
SCE_NP_MATCHING_ROOM_PRIVILEGE_TYPE_NO_AUTO_GRANT = 0,
SCE_NP_MATCHING_ROOM_PRIVILEGE_TYPE_AUTO_GRANT = 1,
};
enum
{
SCE_NP_MATCHING_ROOM_SEARCH_FLAG_OPEN = 0,
SCE_NP_MATCHING_ROOM_SEARCH_FLAG_STEALTH = 1,
};
enum
{
SCE_NP_MATCHING_COND_MAX = 9,
SCE_NP_MATCHING_GRLG_LIMIT_COND_MAX = 9,
SCE_NP_MATCHING_COMP_OP_INEQUALITY_MAX = 9,
};
enum
{
SCE_NP_MATCHING_CONDITION_SEARCH_EQ = 0,
SCE_NP_MATCHING_CONDITION_SEARCH_NE = 1,
SCE_NP_MATCHING_CONDITION_SEARCH_LT = 2,
SCE_NP_MATCHING_CONDITION_SEARCH_LE = 3,
SCE_NP_MATCHING_CONDITION_SEARCH_GT = 4,
SCE_NP_MATCHING_CONDITION_SEARCH_GE = 5,
SCE_NP_MATCHING_CONDITION_SEARCH_MAX = 6,
};
enum
{
SCE_NP_MATCHING_CONDITION_TYPE_VALUE = 0,
};
enum
{
SCE_NP_MATCHING_INVITATION_DESTINATION_MAX = 12,
SCE_NP_MATCHING_INVITATION_SUBJECT_MAX_CHARS = 16,
SCE_NP_MATCHING_INVITATION_BODY_MAX_CHARS = 128,
SCE_NP_MATCHING_KICK_OPT_MAX_LENGTH = 16,
SCE_NP_MATCHING_ROOM_MAX_SLOT = 16,
SCE_NP_MATCHING_CTX_MAX = 8,
};
enum
{
SCE_NP_MATCHING_SEND_INVITATION_MEMSIZE = 16 * 1024 * 1024,
SCE_NP_MATCHING_ACCEPT_INVITATION_MEMSIZE = 16 * 1024 * 1024,
};
// Basic presence options
enum
{
SCE_NP_BASIC_PRESENCE_OPTIONS_SET_DATA = 0x00000001,
SCE_NP_BASIC_PRESENCE_OPTIONS_SET_STATUS = 0x00000002,
SCE_NP_BASIC_PRESENCE_OPTIONS_ALL_OPTIONS = 0x00000003, // sum of all other options
};
// Basic presence states
enum
{
SCE_NP_BASIC_PRESENCE_STATE_OFFLINE = 0,
SCE_NP_BASIC_PRESENCE_STATE_OUT_OF_CONTEXT = 1,
SCE_NP_BASIC_PRESENCE_STATE_IN_CONTEXT = 2
};
// Basic player options
enum
{
SCE_NP_BASIC_PLAYERS_HISTORY_OPTIONS_BY_NP_COMM_ID = 0,
SCE_NP_BASIC_PLAYERS_HISTORY_OPTIONS_ALL = 1
};
// Custom menu selection types
enum : SceNpCustomMenuSelectedType
{
SCE_NP_CUSTOM_MENU_SELECTED_TYPE_ME = 1,
SCE_NP_CUSTOM_MENU_SELECTED_TYPE_FRIEND = 2,
SCE_NP_CUSTOM_MENU_SELECTED_TYPE_PLAYER = 3,
};
// Custom menu action masks
enum SceNpCustomMenuActionMask : u32
{
SCE_NP_CUSTOM_MENU_ACTION_MASK_ME = 0x00000001,
SCE_NP_CUSTOM_MENU_ACTION_MASK_FRIEND = 0x00000002,
SCE_NP_CUSTOM_MENU_ACTION_MASK_PLAYER = 0x00000004,
SCE_NP_CUSTOM_MENU_ACTION_MASK_ALL = 0x00000007 // sum of all other masks
};
// Custom menu index mask
enum
{
SCE_NP_CUSTOM_MENU_INDEX_BITS = (sizeof(SceNpCustomMenuIndexMask) * 8),
SCE_NP_CUSTOM_MENU_INDEX_BITS_ALL = (static_cast<SceNpCustomMenuIndexMask>(-1)),
SCE_NP_CUSTOM_MENU_INDEX_BITS_SHIFT = 5,
SCE_NP_CUSTOM_MENU_INDEX_BITS_MASK = (SCE_NP_CUSTOM_MENU_INDEX_BITS - 1),
SCE_NP_CUSTOM_MENU_INDEX_BITS_MAX = 127,
SCE_NP_CUSTOM_MENU_INDEX_SETSIZE = 128,
};
#define SCE_NP_CUSTOM_MENU_INDEX_SET(n, p) ((p)->index_bits[(n) >> SCE_NP_CUSTOM_MENU_INDEX_BITS_SHIFT] |= (1 << ((n) & SCE_NP_CUSTOM_MENU_INDEX_BITS_MASK)))
#define SCE_NP_CUSTOM_MENU_INDEX_CLR(n, p) ((p)->index_bits[(n) >> SCE_NP_CUSTOM_MENU_INDEX_BITS_SHIFT] &= ~(1 << ((n) & SCE_NP_CUSTOM_MENU_INDEX_BITS_MASK)))
#define SCE_NP_CUSTOM_MENU_INDEX_ISSET(n, p) ((p)->index_bits[(n) >> SCE_NP_CUSTOM_MENU_INDEX_BITS_SHIFT] & (1 << ((n) & SCE_NP_CUSTOM_MENU_INDEX_BITS_MASK)))
#define SCE_NP_CUSTOM_MENU_INDEX_ZERO(p) ( for (u32 i = 0; i < (SCE_NP_CUSTOM_MENU_INDEX_SETSIZE >> SCE_NP_CUSTOM_MENU_INDEX_BITS_SHIFT); i++) p->index_bits[i] = 0; )
#define SCE_NP_CUSTOM_MENU_INDEX_SET_ALL(p) ( for (u32 i = 0; i < (SCE_NP_CUSTOM_MENU_INDEX_SETSIZE >> SCE_NP_CUSTOM_MENU_INDEX_BITS_SHIFT); i++) p->index_bits[i] = SCE_NP_CUSTOM_MENU_INDEX_BITS_ALL; )
enum
{
SCE_NP_PORT = 3658,
SCE_NP_MIN_POOL_SIZE = 128 * 1024
};
enum
{
SCE_NP_DRM_OPEN_FLAG = 2,
};
enum : u64
{
SCE_NP_DRM_EXITSPAWN2_EXIT_WO_FINI = 0x4000000000000000ULL,
SCE_NP_DRM_TIME_INFO_ENDLESS = 0x7FFFFFFFFFFFFFFFULL
};
enum
{
SCE_NP_MANAGER_SUB_SIGNIN_MAX = 3,
};
enum
{
SCE_NP_MANAGER_SUB_SIGNIN_RESULT_OK = 0,
SCE_NP_MANAGER_SUB_SIGNIN_RESULT_CANCEL = 1,
};
// NP Manager Utility statuses
enum
{
SCE_NP_MANAGER_STATUS_OFFLINE = -1,
SCE_NP_MANAGER_STATUS_GETTING_TICKET = 0,
SCE_NP_MANAGER_STATUS_GETTING_PROFILE = 1,
SCE_NP_MANAGER_STATUS_LOGGING_IN = 2,
SCE_NP_MANAGER_STATUS_ONLINE = 3,
};
enum
{
SCE_NP_MANAGER_EVENT_GOT_TICKET = 255
};
// Event types
enum
{
SCE_NP_BASIC_EVENT_UNKNOWN = -1,
SCE_NP_BASIC_EVENT_OFFLINE = 0,
SCE_NP_BASIC_EVENT_PRESENCE = 1,
SCE_NP_BASIC_EVENT_MESSAGE = 2,
SCE_NP_BASIC_EVENT_ADD_FRIEND_RESULT = 3,
SCE_NP_BASIC_EVENT_INCOMING_ATTACHMENT = 4,
SCE_NP_BASIC_EVENT_INCOMING_INVITATION = 5,
SCE_NP_BASIC_EVENT_END_OF_INITIAL_PRESENCE = 6,
SCE_NP_BASIC_EVENT_SEND_ATTACHMENT_RESULT = 7,
SCE_NP_BASIC_EVENT_RECV_ATTACHMENT_RESULT = 8,
SCE_NP_BASIC_EVENT_OUT_OF_CONTEXT = 9,
SCE_NP_BASIC_EVENT_FRIEND_REMOVED = 10,
SCE_NP_BASIC_EVENT_ADD_BLOCKLIST_RESULT = 11,
SCE_NP_BASIC_EVENT_SEND_MESSAGE_RESULT = 12,
SCE_NP_BASIC_EVENT_SEND_INVITATION_RESULT = 13,
SCE_NP_BASIC_EVENT_RECV_INVITATION_RESULT = 14,
SCE_NP_BASIC_EVENT_MESSAGE_MARKED_AS_USED_RESULT = 15,
SCE_NP_BASIC_EVENT_INCOMING_CUSTOM_INVITATION = 16,
SCE_NP_BASIC_EVENT_INCOMING_CLAN_MESSAGE = 17,
SCE_NP_BASIC_EVENT_ADD_PLAYERS_HISTORY_RESULT = 18,
SCE_NP_BASIC_EVENT_SEND_CUSTOM_DATA_RESULT = 19,
SCE_NP_BASIC_EVENT_RECV_CUSTOM_DATA_RESULT = 20,
SCE_NP_BASIC_EVENT_INCOMING_CUSTOM_DATA_MESSAGE = 21,
SCE_NP_BASIC_EVENT_SEND_URL_ATTACHMENT_RESULT = 22,
SCE_NP_BASIC_EVENT_INCOMING_BOOTABLE_INVITATION = 23,
SCE_NP_BASIC_EVENT_BLOCKLIST_UPDATE = 24,
SCE_NP_BASIC_EVENT_INCOMING_BOOTABLE_CUSTOM_DATA_MESSAGE = 25,
};
// IDs for attachment data objects
enum : SceNpBasicAttachmentDataId
{
SCE_NP_BASIC_INVALID_ATTACHMENT_DATA_ID = 0,
SCE_NP_BASIC_INVALID_MESSAGE_ID = 0,
SCE_NP_BASIC_SELECTED_INVITATION_DATA = 1,
SCE_NP_BASIC_SELECTED_MESSAGE_DATA = 2,
};
// Actions made in system GUI
enum
{
SCE_NP_BASIC_MESSAGE_ACTION_UNKNOWN = 0,
SCE_NP_BASIC_MESSAGE_ACTION_USE = 1,
SCE_NP_BASIC_MESSAGE_ACTION_ACCEPT = 2,
SCE_NP_BASIC_MESSAGE_ACTION_DENY = 3,
};
// Main types of messages
enum SceNpBasicMessageMainType : u16
{
SCE_NP_BASIC_MESSAGE_MAIN_TYPE_DATA_ATTACHMENT = 0,
SCE_NP_BASIC_MESSAGE_MAIN_TYPE_GENERAL = 1,
SCE_NP_BASIC_MESSAGE_MAIN_TYPE_ADD_FRIEND = 2,
SCE_NP_BASIC_MESSAGE_MAIN_TYPE_INVITE = 3,
SCE_NP_BASIC_MESSAGE_MAIN_TYPE_CUSTOM_DATA = 4,
SCE_NP_BASIC_MESSAGE_MAIN_TYPE_URL_ATTACHMENT = 5,
};
// Sub types of messages
enum SceNpBasicMessageSubType : u16
{
SCE_NP_BASIC_MESSAGE_DATA_ATTACHMENT_SUBTYPE_ACTION_USE = 0,
SCE_NP_BASIC_MESSAGE_GENERAL_SUBTYPE_NONE = 0,
SCE_NP_BASIC_MESSAGE_ADD_FRIEND_SUBTYPE_NONE = 0,
SCE_NP_BASIC_MESSAGE_INVITE_SUBTYPE_ACTION_ACCEPT_DENY = 0,
SCE_NP_BASIC_MESSAGE_CUSTOM_DATA_SUBTYPE_ACTION_USE = 0,
SCE_NP_BASIC_MESSAGE_URL_ATTACHMENT_SUBTYPE_ACTION_USE = 0,
SCE_NP_BASIC_MESSAGE_INVITE_SUBTYPE_ACTION_ACCEPT = 1,
};
// Applicable features of messages
#define SCE_NP_BASIC_MESSAGE_FEATURES_EXP_MIN(min) (((static_cast<u32>(min) << 16) | (0 << 15)) & 0xFFFF8000)
enum SceNpBasicMessageFeatures : u32
{
SCE_NP_BASIC_MESSAGE_FEATURES_MULTI_RECEIPIENTS = 0x00000001,
SCE_NP_BASIC_MESSAGE_FEATURES_BOOTABLE = 0x00000002,
SCE_NP_BASIC_MESSAGE_FEATURES_ASSUME_SEND = 0x00000004,
SCE_NP_BASIC_MESSAGE_FEATURES_ALL_FEATURES =
SCE_NP_BASIC_MESSAGE_FEATURES_MULTI_RECEIPIENTS |
SCE_NP_BASIC_MESSAGE_FEATURES_BOOTABLE |
SCE_NP_BASIC_MESSAGE_FEATURES_ASSUME_SEND |
SCE_NP_BASIC_MESSAGE_FEATURES_EXP_MIN(0xffff)
};
// Types of messages
enum SceNpBasicMessageInfoType : u32
{
SCE_NP_BASIC_MESSAGE_INFO_TYPE_MESSAGE_ATTACHMENT = 0,
SCE_NP_BASIC_MESSAGE_INFO_TYPE_MATCHING_INVITATION = 1,
SCE_NP_BASIC_MESSAGE_INFO_TYPE_CLAN_MESSAGE = 3,
SCE_NP_BASIC_MESSAGE_INFO_TYPE_CUSTOM_DATA_MESSAGE = 4,
SCE_NP_BASIC_MESSAGE_INFO_TYPE_ANY_UNREAD_MESSAGE = 5,
SCE_NP_BASIC_MESSAGE_INFO_TYPE_BOOTABLE_INVITATION = 6,
SCE_NP_BASIC_MESSAGE_INFO_TYPE_BOOTABLE_CUSTOM_DATA_MESSAGE = 7,
};
// Context options (signaling)
enum
{
SCE_NP_SIGNALING_CTX_OPT_BANDWIDTH_PROBE_DISABLE = 0,
SCE_NP_SIGNALING_CTX_OPT_BANDWIDTH_PROBE_ENABLE = 1,
SCE_NP_SIGNALING_CTX_OPT_BANDWIDTH_PROBE = 1,
};
// Event types (including extended ones)
enum
{
SCE_NP_SIGNALING_EVENT_DEAD = 0,
SCE_NP_SIGNALING_EVENT_ESTABLISHED = 1,
SCE_NP_SIGNALING_EVENT_NETINFO_ERROR = 2,
SCE_NP_SIGNALING_EVENT_NETINFO_RESULT = 3,
SCE_NP_SIGNALING_EVENT_EXT_PEER_ACTIVATED = 10,
SCE_NP_SIGNALING_EVENT_EXT_PEER_DEACTIVATED = 11,
SCE_NP_SIGNALING_EVENT_EXT_MUTUAL_ACTIVATED = 12,
};
// Connection states
enum
{
SCE_NP_SIGNALING_CONN_STATUS_INACTIVE = 0,
SCE_NP_SIGNALING_CONN_STATUS_PENDING = 1,
SCE_NP_SIGNALING_CONN_STATUS_ACTIVE = 2,
};
// Connection information to obtain
enum
{
SCE_NP_SIGNALING_CONN_INFO_RTT = 1,
SCE_NP_SIGNALING_CONN_INFO_BANDWIDTH = 2,
SCE_NP_SIGNALING_CONN_INFO_PEER_NPID = 3,
SCE_NP_SIGNALING_CONN_INFO_PEER_ADDRESS = 4,
SCE_NP_SIGNALING_CONN_INFO_MAPPED_ADDRESS = 5,
SCE_NP_SIGNALING_CONN_INFO_PACKET_LOSS = 6,
};
// NAT status type
enum
{
SCE_NP_SIGNALING_NETINFO_NAT_STATUS_UNKNOWN = 0,
SCE_NP_SIGNALING_NETINFO_NAT_STATUS_TYPE1 = 1,
SCE_NP_SIGNALING_NETINFO_NAT_STATUS_TYPE2 = 2,
SCE_NP_SIGNALING_NETINFO_NAT_STATUS_TYPE3 = 3,
};
// UPnP status
enum
{
SCE_NP_SIGNALING_NETINFO_UPNP_STATUS_UNKNOWN = 0,
SCE_NP_SIGNALING_NETINFO_UPNP_STATUS_INVALID = 1,
SCE_NP_SIGNALING_NETINFO_UPNP_STATUS_VALID = 2,
};
// NP port status
enum
{
SCE_NP_SIGNALING_NETINFO_NPPORT_STATUS_CLOSED = 0,
SCE_NP_SIGNALING_NETINFO_NPPORT_STATUS_OPEN = 1,
};
// NP Receive message options
enum SceNpBasicMessageRecvOptions : u32
{
SCE_NP_BASIC_RECV_MESSAGE_OPTIONS_PRESERVE = 0x00000001,
SCE_NP_BASIC_RECV_MESSAGE_OPTIONS_INCLUDE_BOOTABLE = 0x00000002,
SCE_NP_BASIC_RECV_MESSAGE_OPTIONS_ASSUME_LATEST = 0x00000004,
SCE_NP_BASIC_RECV_MESSAGE_OPTIONS_ALL_OPTIONS = 0x00000007 // sum of all other options
};
// Constants for common NP functions and structures
enum
{
SCE_NET_NP_AVATAR_IMAGE_MAX_SIZE = 204800, // 200 * 1024
SCE_NET_NP_AVATAR_IMAGE_MAX_SIZE_LARGE = 204800, // 200 * 1024
SCE_NET_NP_AVATAR_IMAGE_MAX_SIZE_MIDDLE = 102400, // 100 * 1024
SCE_NET_NP_AVATAR_IMAGE_MAX_SIZE_SMALL = 10240, // 10 * 1024
SCE_NET_NP_AVATAR_URL_MAX_LENGTH = 127,
SCE_NET_NP_ONLINEID_MIN_LENGTH = 3,
SCE_NET_NP_ONLINEID_MAX_LENGTH = 16,
SCE_NET_NP_ONLINENAME_MAX_LENGTH = 48,
SCE_NET_NP_ABOUT_ME_MAX_LENGTH = 63,
SCE_NP_TSS_MAX_SIZE = 65536, // 64 * 1024
SCE_NET_NP_TSS_MAX_SIZE = SCE_NP_TSS_MAX_SIZE,
SCE_NP_TSS_EXTRA_SLOT_MAX_SIZE = 4194304, // 4 * 1024 * 1024
SCE_NP_FRIEND_MAX_NUM = 100,
SCE_NET_NP_COMMUNICATION_PASSPHRASE_SIZE = 128,
SCE_NP_COMMUNICATION_SIGNATURE_SIZE = 160,
SCE_NP_COMMUNICATION_PASSPHRASE_SIZE = SCE_NET_NP_COMMUNICATION_PASSPHRASE_SIZE,
SCE_NET_NP_PSHANDLE_MIN_LENGTH = SCE_NET_NP_ONLINEID_MIN_LENGTH,
SCE_NET_NP_PSHANDLE_MAX_LENGTH = SCE_NET_NP_ONLINEID_MAX_LENGTH,
SCE_NET_NP_SUBHANDLE_MAX_LENGTH = SCE_NET_NP_ONLINENAME_MAX_LENGTH,
SCE_NET_NP_ICON_URL_MAX_LENGTH = SCE_NET_NP_AVATAR_URL_MAX_LENGTH,
SCE_NP_UTIL_NPID_VERSION = 1,
SCE_NP_UTIL_NPLOBBYID_VERSION = 1,
SCE_NP_UTIL_NPROOMID_VERSION = 1,
SCE_NP_COMMERCE_VERSION = 1,
};
// Languages
enum
{
SCE_NP_LANG_JAPANESE = 0,
SCE_NP_LANG_ENGLISH = 1,
SCE_NP_LANG_ENGLISH_US = 1,
SCE_NP_LANG_FRENCH = 2,
SCE_NP_LANG_SPANISH = 3,
SCE_NP_LANG_GERMAN = 4,
SCE_NP_LANG_ITALIAN = 5,
SCE_NP_LANG_DUTCH = 6,
SCE_NP_LANG_PORTUGUESE = 7,
SCE_NP_LANG_PORTUGUESE_PT = 7,
SCE_NP_LANG_RUSSIAN = 8,
SCE_NP_LANG_KOREAN = 9,
SCE_NP_LANG_CHINESE_T = 10,
SCE_NP_LANG_CHINESE_S = 11,
SCE_NP_LANG_FINNISH = 12,
SCE_NP_LANG_SWEDISH = 13,
SCE_NP_LANG_DANISH = 14,
SCE_NP_LANG_NORWEGIAN = 15,
SCE_NP_LANG_POLISH = 16,
SCE_NP_LANG_PORTUGUESE_BR = 17,
SCE_NP_LANG_ENGLISH_GB = 18,
SCE_NP_LANG_TURKISH = 19,
SCE_NP_LANG_SPANISH_LA = 20,
SCE_NP_LANG_ARABIC = 21,
SCE_NP_LANG_FRENCH_CA = 22,
};
enum SceNpAvatarSizeType
{
SCE_NP_AVATAR_SIZE_LARGE,
SCE_NP_AVATAR_SIZE_MIDDLE,
SCE_NP_AVATAR_SIZE_SMALL
};
// Constants for basic NP functions and structures
enum
{
SCE_NP_BASIC_MAX_MESSAGE_SIZE = 512,
SCE_NP_BASIC_MAX_PRESENCE_SIZE = 128,
SCE_NP_BASIC_MAX_MESSAGE_ATTACHMENT_SIZE = 1048576,
SCE_NP_BASIC_SUBJECT_CHARACTER_MAX = 18,
SCE_NP_BASIC_BODY_CHARACTER_MAX = 512,
SCE_NP_BASIC_DESCRIPTION_CHARACTER_MAX = 341,
SCE_NP_BASIC_SEND_MESSAGE_MAX_RECIPIENTS = 12,
SCE_NP_BASIC_PRESENCE_TITLE_SIZE_MAX = 128,
SCE_NP_BASIC_PRESENCE_STATUS_SIZE_MAX = 64,
SCE_NP_BASIC_PRESENCE_STATUS_CHARACTER_MAX = 21,
SCE_NP_BASIC_PRESENCE_EXTENDED_STATUS_SIZE_MAX = 192,
SCE_NP_BASIC_PRESENCE_EXTENDED_STATUS_CHARACTER_MAX = 63,
SCE_NP_BASIC_PRESENCE_COMMENT_SIZE_MAX = 64,
SCE_NP_BASIC_MAX_INVITATION_DATA_SIZE = 1024,
SCE_NP_BASIC_MAX_URL_ATTACHMENT_SIZE = 2048,
SCE_NP_BASIC_PLAYER_HISTORY_MAX_PLAYERS = 8,
};
// Common constants of sceNpClans
enum
{
SCE_NP_CLANS_CLAN_NAME_MAX_LENGTH = 64,
SCE_NP_CLANS_CLAN_TAG_MAX_LENGTH = 8,
SCE_NP_CLANS_CLAN_DESCRIPTION_MAX_LENGTH = 255,
};
// Constants for custom menu functions and structures
enum
{
SCE_NP_CUSTOM_MENU_ACTION_CHARACTER_MAX = 21,
SCE_NP_CUSTOM_MENU_ACTION_ITEMS_MAX = 7,
SCE_NP_CUSTOM_MENU_ACTION_ITEMS_TOTAL_MAX = 16,
SCE_NP_CUSTOM_MENU_EXCEPTION_ITEMS_MAX = 256,
};
// Constants for manager functions and structures
enum
{
SCE_NP_COOKIE_MAX_SIZE = 1024,
SCE_NP_TICKET_MAX_SIZE = 65536,
SCE_NP_TICKET_PARAM_DATA_LEN = 256,
SCE_NP_ENTITLEMENT_ID_SIZE = 32,
};
enum
{
SCE_NP_ENTITLEMENT_TYPE_NON_CONSUMABLE = 0,
SCE_NP_ENTITLEMENT_TYPE_CONSUMABLE = 1
};
// Constants for ranking (score) functions and structures
enum
{
SCE_NP_SCORE_MAX_CTX_NUM = 32,
SCE_NP_SCORE_COMMENT_MAXLEN = 63,
SCE_NP_SCORE_GAMEDATA_ID_LEN = 63,
SCE_NP_SCORE_GAMEINFO_SIZE = 64,
SCE_NP_SCORE_PASSPHRASE_SIZE = 128,
SCE_NP_SCORE_CENSOR_COMMENT_MAXLEN = 255,
SCE_NP_SCORE_SANITIZE_COMMENT_MAXLEN = 255,
SCE_NP_SCORE_MAX_RANGE_NUM_PER_TRANS = 100,
SCE_NP_SCORE_MAX_NPID_NUM_PER_TRANS = 101,
SCE_NP_SCORE_MAX_CLAN_NUM_PER_TRANS = 101,
SCE_NP_SCORE_MAX_SELECTED_FRIENDS_NUM = 100,
SCE_NP_SCORE_VARIABLE_SIZE_GAMEINFO_MAXSIZE = 189,
};
enum
{
SCE_NP_SCORE_NORMAL_UPDATE = 0,
SCE_NP_SCORE_FORCE_UPDATE = 1
};
enum
{
SCE_NP_SCORE_DESCENDING_ORDER = 0,
SCE_NP_SCORE_ASCENDING_ORDER = 1
};
// Constants for signaling functions and structures
enum
{
SCE_NP_SIGNALING_CTX_MAX = 8,
};
enum : SceNpPlatformType
{
SCE_NP_PLATFORM_TYPE_NONE = 0,
SCE_NP_PLATFORM_TYPE_PS3 = 1,
SCE_NP_PLATFORM_TYPE_VITA = 2,
SCE_NP_PLATFORM_TYPE_PS4 = 3, // Note: unknown on which fw versions it appears, but sdk version is unchecked
};
enum
{
SCE_NP_MATCHING_GUI_EVENT_CREATE_ROOM = 0x0001,
SCE_NP_MATCHING_GUI_EVENT_JOIN_ROOM = 0x0002,
SCE_NP_MATCHING_GUI_EVENT_RESERVED2 = 0x0003,
SCE_NP_MATCHING_GUI_EVENT_SEARCH_JOIN = 0x0004,
SCE_NP_MATCHING_GUI_EVENT_QUICK_MATCH = 0x0005,
SCE_NP_MATCHING_GUI_EVENT_SEND_INVITATION = 0x0006,
SCE_NP_MATCHING_GUI_EVENT_ACCEPT_INVITATION = 0x0007,
SCE_NP_MATCHING_GUI_EVENT_COMMON_LOAD = 0x0008,
SCE_NP_MATCHING_GUI_EVENT_COMMON_UNLOAD = 0x0009,
SCE_NP_MATCHING_GUI_EVENT_GET_ROOM_LIST = 0x000a,
SCE_NP_MATCHING_GUI_EVENT_GET_ROOM_LIST_LIMIT = 0x000b
};
enum
{
SCE_NP_TICKET_PARAM_SERIAL_ID = 0,
SCE_NP_TICKET_PARAM_ISSUER_ID = 1,
SCE_NP_TICKET_PARAM_ISSUED_DATE = 2,
SCE_NP_TICKET_PARAM_EXPIRE_DATE = 3,
SCE_NP_TICKET_PARAM_SUBJECT_ACCOUNT_ID = 4,
SCE_NP_TICKET_PARAM_SUBJECT_ONLINE_ID = 5,
SCE_NP_TICKET_PARAM_SUBJECT_REGION = 6,
SCE_NP_TICKET_PARAM_SUBJECT_DOMAIN = 7,
SCE_NP_TICKET_PARAM_SERVICE_ID = 8,
SCE_NP_TICKET_PARAM_SUBJECT_STATUS = 9,
SCE_NP_TICKET_PARAM_STATUS_DURATION = 10,
SCE_NP_TICKET_PARAM_SUBJECT_DOB = 11,
};
enum
{
SCE_NP_TICKET_SERIAL_ID_SIZE = 20,
SCE_NP_SUBJECT_REGION_SIZE = 4,
SCE_NP_SUBJECT_DOMAIN_SIZE = 4,
SCE_NP_SERVICE_ID_SIZE = 24,
};
enum
{
SCE_NP_LOOKUP_MAX_CTX_NUM = 32
};
enum
{
SCE_NP_AUTH_OAUTH_REQUEST_ID_MAX = 4
};
struct SceNpDrmKey
{
u8 keydata[16];
};
struct SceNpDrmOpenArg
{
be_t<u64> flag;
};
// NP communication ID structure
struct SceNpCommunicationId
{
char data[9 + 1]; // char term;
u8 num;
char dummy;
};
// OnlineId structure
struct SceNpOnlineId
{
char data[16 + 1]; // char term;
char dummy[3];
};
// NP ID structure
struct SceNpId
{
SceNpOnlineId handle;
union
{
// This field (system reserved) seems to be combined of two parts
// The second is used by sceNpUtilSetPlatformType and sceNpUtilGetPlatformType
u8 opt[8];
nse_t<u32, 1> unk1[2];
};
u8 reserved[8];
};
CHECK_SIZE_ALIGN(SceNpId, 0x24, 1);
// Online Name structure
struct SceNpOnlineName
{
char data[48 + 1]; // char term;
char padding[3];
};
// Avatar structure
struct SceNpAvatarUrl
{
char data[127 + 1]; // char term;
};
// Avatar image structure
struct SceNpAvatarImage
{
u8 data[SCE_NET_NP_AVATAR_IMAGE_MAX_SIZE];
be_t<u32> size;
u8 reserved[12];
};
// Self introduction structure
struct SceNpAboutMe
{
char data[SCE_NET_NP_ABOUT_ME_MAX_LENGTH + 1]; // char term;
};
// User information structure
struct SceNpUserInfo
{
SceNpId userId;
SceNpOnlineName name;
SceNpAvatarUrl icon;
};
// User information structure
struct SceNpUserInfo2
{
SceNpId npId;
vm::bptr<SceNpOnlineName> onlineName;
vm::bptr<SceNpAvatarUrl> avatarUrl;
};
// Often used languages structure
struct SceNpMyLanguages
{
be_t<s32> language1;
be_t<s32> language2;
be_t<s32> language3;
u8 padding[4];
};
// NP communication passphrase
struct SceNpCommunicationPassphrase
{
u8 data[SCE_NP_COMMUNICATION_PASSPHRASE_SIZE];
};
// NP communication signature
struct SceNpCommunicationSignature
{
u8 data[SCE_NP_COMMUNICATION_SIGNATURE_SIZE];
};
// NP cache information structure
struct SceNpManagerCacheParam
{
be_t<u32> size;
SceNpOnlineId onlineId;
SceNpId npId;
SceNpOnlineName onlineName;
SceNpAvatarUrl avatarUrl;
};
// Message attachment data
struct SceNpBasicAttachmentData
{
be_t<SceNpBasicAttachmentDataId> id;
be_t<u32> size;
};
// Message extended attachment data
struct SceNpBasicExtendedAttachmentData
{
be_t<u64> flags;
be_t<u64> msgId;
SceNpBasicAttachmentData data;
be_t<u32> userAction;
u8 markedAsUsed;
u8 reserved[3];
};
// Message structure
struct SceNpBasicMessageDetails
{
be_t<u64> msgId;
be_t<u16> mainType;
be_t<u16> subType;
be_t<u32> msgFeatures;
vm::bptr<SceNpId> npids;
be_t<u32> count;
vm::bptr<char> subject;
vm::bptr<char> body;
vm::bptr<u8> data;
be_t<u32> size;
};
// Presence details of an user
struct SceNpBasicPresenceDetails
{
s8 title[SCE_NP_BASIC_PRESENCE_TITLE_SIZE_MAX];
s8 status[SCE_NP_BASIC_PRESENCE_STATUS_SIZE_MAX];
s8 comment[SCE_NP_BASIC_PRESENCE_COMMENT_SIZE_MAX];
u8 data[SCE_NP_BASIC_MAX_PRESENCE_SIZE];
be_t<u32> size;
be_t<s32> state;
};
// Extended presence details of an user
struct SceNpBasicPresenceDetails2
{
be_t<u32> struct_size;
be_t<s32> state;
s8 title[SCE_NP_BASIC_PRESENCE_TITLE_SIZE_MAX];
s8 status[SCE_NP_BASIC_PRESENCE_EXTENDED_STATUS_SIZE_MAX];
s8 comment[SCE_NP_BASIC_PRESENCE_COMMENT_SIZE_MAX];
u8 data[SCE_NP_BASIC_MAX_PRESENCE_SIZE];
be_t<u32> size;
};
// Country/region code
struct SceNpCountryCode
{
s8 data[2];
s8 term;
s8 padding[1];
};
// Date information
struct SceNpDate
{
be_t<u16> year;
u8 month;
u8 day;
};
// Entitlement ID (fixed-length)
struct SceNpEntitlementId
{
u8 data[SCE_NP_ENTITLEMENT_ID_SIZE]; // Unsigned char? What is the right type...?
};
// Callback for getting the connection status
using SceNpManagerCallback = void(s32 event, s32 result, vm::ptr<void> arg);
// Score data unique to the application
struct SceNpScoreGameInfo
{
u8 nativeData[SCE_NP_SCORE_GAMEINFO_SIZE];
};
// Ranking comment structure
struct SceNpScoreComment
{
s8 data[SCE_NP_SCORE_COMMENT_MAXLEN];
s8 term[1];
};
// Ranking information structure
struct SceNpScoreRankData
{
SceNpId npId;
SceNpOnlineName onlineName;
be_t<s32> pcId;
be_t<u32> serialRank;
be_t<u32> rank;
be_t<u32> highestRank;
be_t<s32> hasGameData;
u8 pad0[4];
be_t<s64> scoreValue;
CellRtcTick recordDate;
};
// Version of SceNpScoreRankData that was deprecated in 180.002
struct SceNpScoreRankData_deprecated
{
SceNpId npId;
SceNpOnlineName onlineName;
be_t<u32> serialRank;
be_t<u32> rank;
be_t<u32> highestRank;
be_t<s32> hasGameData;
be_t<s64> scoreValue;
CellRtcTick recordDate;
};
// Ranking information of a player or a clan member
struct SceNpScorePlayerRankData
{
be_t<s32> hasData;
u8 pad0[4];
SceNpScoreRankData rankData;
};
// Version of SceNpScorePlayerRankData that was deprecated in 180.002
struct SceNpScorePlayerRankData_deprecated
{
be_t<s32> hasData;
u8 pad0[4];
SceNpScoreRankData_deprecated rankData;
};
// Scoreboard information
struct SceNpScoreBoardInfo
{
be_t<u32> rankLimit;
be_t<u32> updateMode;
be_t<u32> sortMode;
be_t<u32> uploadNumLimit;
be_t<u32> uploadSizeLimit;
};
// NOTE: Use SceNpCommunicationPassphrase instead
// Authentication information per NP Communication ID for score ranking
// SceNpCommunicationPassphrase SceNpScorePassphrase;
// NP ID structure with player character ID
struct SceNpScoreNpIdPcId
{
SceNpId npId;
be_t<s32> pcId;
u8 pad[4];
};
// Basic clan information to be used in raking
struct SceNpScoreClanBasicInfo
{
s8 clanName[SCE_NP_CLANS_CLAN_NAME_MAX_LENGTH + 1];
s8 clanTag[SCE_NP_CLANS_CLAN_TAG_MAX_LENGTH + 1];
u8 reserved[10];
};
// Clan member information handled in ranking
struct SceNpScoreClansMemberDescription
{
s8 description[SCE_NP_CLANS_CLAN_DESCRIPTION_MAX_LENGTH + 1];
};
// Clan ranking information
struct SceNpScoreClanRankData
{
be_t<u32> clanId;
SceNpScoreClanBasicInfo clanInfo;
be_t<u32> regularMemberCount;
be_t<u32> recordMemberCount;
be_t<u32> serialRank;
be_t<u32> rank;
be_t<s64> scoreValue;
CellRtcTick recordDate;
SceNpId npId;
SceNpOnlineName onlineName;
u8 reserved[32];
};
// Clan ranking information to be obtained for a specified clan ID
struct SceNpScoreClanIdRankData
{
be_t<s32> hasData;
u8 pad0[4];
SceNpScoreClanRankData rankData;
};
// Union for connection information
union SceNpSignalingConnectionInfo
{
be_t<u32> rtt;
be_t<u32> bandwidth;
SceNpId npId;
struct
{
np_in_addr addr; // in_addr
np_in_port_t port; // in_port_t
} address;
be_t<u32> packet_loss;
};
// Network information structure
struct SceNpSignalingNetInfo
{
be_t<u32> size;
be_t<u32> local_addr; // in_addr
be_t<u32> mapped_addr; // in_addr
be_t<s32> nat_status;
be_t<s32> upnp_status;
be_t<s32> npport_status;
be_t<u16> npport;
};
struct SceNpCustomMenuAction
{
be_t<u32> options;
vm::bcptr<char> name;
be_t<SceNpCustomMenuActionMask> mask;
};
struct SceNpCustomMenu
{
be_t<u64> options;
vm::bptr<SceNpCustomMenuAction> actions;
be_t<u32> numActions;
};
struct SceNpCustomMenuIndexArray
{
be_t<SceNpCustomMenuIndexMask> index_bits[SCE_NP_CUSTOM_MENU_INDEX_SETSIZE >> SCE_NP_CUSTOM_MENU_INDEX_BITS_SHIFT];
};
struct SceNpCustomMenuActionExceptions
{
be_t<u32> options;
SceNpId npid;
SceNpCustomMenuIndexArray actions;
u8 reserved[4];
};
struct SceNpCommerceProductCategory
{
be_t<u32> version;
vm::bcptr<void> data;
be_t<u32> dataSize;
be_t<u32> dval;
u8 reserved[16];
};
struct SceNpCommerceProductSkuInfo
{
vm::bptr<SceNpCommerceProductCategory> pc;
vm::bcptr<void> data;
u8 reserved[8];
};
struct SceNpCommerceCategoryInfo
{
vm::bptr<SceNpCommerceProductCategory> pc;
vm::bcptr<void> data;
u8 reserved[8];
};
struct SceNpCommerceCurrencyInfo
{
vm::bptr<SceNpCommerceProductCategory> pc;
vm::bcptr<void> data;
u8 reserved[8];
};
struct SceNpCommercePrice
{
be_t<u32> integer;
be_t<u32> fractional;
};
struct SceNpTicketVersion
{
be_t<u16> major;
be_t<u16> minor;
};
union SceNpTicketParam
{
be_t<s32> i32;
be_t<s64> i64;
be_t<u32> ui32;
be_t<u64> ui64;
SceNpDate date;
u8 data[SCE_NP_TICKET_PARAM_DATA_LEN];
};
struct SceNpEntitlement
{
SceNpEntitlementId id;
be_t<SceNpTime> created_date;
be_t<SceNpTime> expire_date;
be_t<u32> type;
be_t<s32> remaining_count;
be_t<u32> consumed_count;
u8 padding[4];
};
struct SceNpLobbyId
{
u8 opt[28];
u8 reserved[8];
};
struct SceNpRoomId
{
u8 opt[28];
u8 reserved[8];
};
struct SceNpMatchingAttr
{
vm::bptr<SceNpMatchingAttr> next;
be_t<s32> type;
be_t<u32> id;
union
{
be_t<u32> num;
struct
{
vm::bptr<void> ptr;
be_t<u32> size;
} data;
} value;
};
struct SceNpMatchingSearchCondition
{
vm::bptr<SceNpMatchingSearchCondition> next;
be_t<s32> target_attr_type;
be_t<u32> target_attr_id;
be_t<s32> comp_op;
be_t<s32> comp_type;
SceNpMatchingAttr compared;
};
struct SceNpMatchingReqRange
{
be_t<u32> start;
be_t<u32> max;
};
struct SceNpScoreVariableSizeGameInfo
{
be_t<u32> infoSize;
u8 data[SCE_NP_SCORE_VARIABLE_SIZE_GAMEINFO_MAXSIZE];
u8 pad[3];
};
struct SceNpScoreRecordOptParam
{
be_t<u32> size;
vm::bptr<SceNpScoreVariableSizeGameInfo> vsInfo;
vm::bptr<CellRtcTick> reserved;
};
// Old GUI API structures
struct SceNpMatchingRoomMember
{
vm::bptr<SceNpMatchingRoomMember> next;
SceNpUserInfo user_info;
be_t<s32> owner;
};
struct SceNpMatchingRoomStatus
{
SceNpRoomId id;
vm::bptr<SceNpMatchingRoomMember> members;
be_t<s32> num;
vm::bptr<SceNpId> kick_actor;
vm::bptr<void> opt;
be_t<s32> opt_len;
};
struct SceNpMatchingJoinedRoomInfo
{
SceNpLobbyId lobbyid;
SceNpMatchingRoomStatus room_status;
};
struct SceNpMatchingRange
{
be_t<u32> start;
be_t<u32> results;
be_t<u32> total;
};
struct SceNpMatchingRoom
{
vm::bptr<SceNpMatchingRoom> next;
SceNpRoomId id;
vm::bptr<SceNpMatchingAttr> attr;
};
struct SceNpMatchingRoomList
{
SceNpLobbyId lobbyid;
SceNpMatchingRange range;
vm::bptr<SceNpMatchingRoom> head;
};
struct SceNpMatchingSearchJoinRoomInfo
{
SceNpLobbyId lobbyid;
SceNpMatchingRoomStatus room_status;
vm::bptr<SceNpMatchingAttr> attr;
};
// NP callback functions
using SceNpCustomMenuEventHandler = s32(s32 retCode, u32 index, vm::cptr<SceNpId> npid, SceNpCustomMenuSelectedType type, vm::ptr<void> arg);
using SceNpBasicEventHandler = s32(s32 event, s32 retCode, u32 reqId, vm::ptr<void> arg);
using SceNpCommerceHandler = void(u32 ctx_id, u32 subject_id, s32 event, s32 error_code, vm::ptr<void> arg);
using SceNpSignalingHandler = void(u32 ctx_id, u32 subject_id, s32 event, s32 error_code, vm::ptr<void> arg);
using SceNpFriendlistResultHandler = s32(s32 retCode, vm::ptr<void> arg);
using SceNpMatchingHandler = void(u32 ctx_id, u32 req_id, s32 event, s32 error_code, vm::ptr<void> arg);
using SceNpMatchingGUIHandler = void(u32 ctx_id, s32 event, s32 error_code, vm::ptr<void> arg);
using SceNpProfileResultHandler = s32(s32 result, vm::ptr<void> arg);
using SceNpManagerSubSigninCallback = void(s32 result, vm::ptr<SceNpId> npId, vm::ptr<void> cb_arg);
// Used to pass data to UI/RPCN
struct message_data
{
SceNpCommunicationId commId{};
u64 msgId = 0;
u16 mainType = 0;
u16 subType = 0;
u32 msgFeatures = 0;
std::string subject;
std::string body;
std::vector<u8> data;
void print() const;
};
struct np_state
{
atomic_t<bool> abort_gui_flag = false;
};
namespace rpcn
{
class rpcn_client;
}
class SendMessageDialogBase
{
public:
virtual ~SendMessageDialogBase() = default;
virtual error_code Exec(message_data& msg_data, std::set<std::string>& npids) = 0;
virtual void callback_handler(u16 ntype, const std::string& username, bool status) = 0;
protected:
std::shared_ptr<rpcn::rpcn_client> m_rpcn;
};
class RecvMessageDialogBase
{
public:
virtual ~RecvMessageDialogBase() = default;
virtual error_code Exec(SceNpBasicMessageMainType type, SceNpBasicMessageRecvOptions options, SceNpBasicMessageRecvAction& recv_result, u64& chosen_msg_id) = 0;
virtual void callback_handler(const std::shared_ptr<std::pair<std::string, message_data>> new_msg, u64 msg_id) = 0;
protected:
std::shared_ptr<rpcn::rpcn_client> m_rpcn;
};
// Generic functions, also used in SceNpMatchingInt.cpp
error_code matching_create_room(u32 ctx_id, vm::cptr<SceNpCommunicationId> communicationId, vm::cptr<SceNpMatchingAttr> attr, vm::ptr<SceNpMatchingGUIHandler> handler, vm::ptr<void> arg);
error_code matching_join_room(u32 ctx_id, vm::ptr<SceNpRoomId> room_id, vm::ptr<SceNpMatchingGUIHandler> handler, vm::ptr<void> arg);
error_code matching_get_room_list(u32 ctx_id, vm::ptr<SceNpCommunicationId> communicationId, vm::ptr<SceNpMatchingReqRange> range, vm::ptr<SceNpMatchingSearchCondition> cond,
vm::ptr<SceNpMatchingAttr> attr, vm::ptr<SceNpMatchingGUIHandler> handler, vm::ptr<void> arg, bool limit);
error_code matching_set_room_info(u32 ctx_id, vm::ptr<SceNpLobbyId> lobby_id, vm::ptr<SceNpRoomId> room_id, vm::ptr<SceNpMatchingAttr> attr, vm::ptr<u32> req_id, bool limit);
error_code matching_get_room_info(u32 ctx_id, vm::ptr<SceNpLobbyId> lobby_id, vm::ptr<SceNpRoomId> room_id, vm::ptr<SceNpMatchingAttr> attr, vm::ptr<u32> req_id, bool limit);
error_code matching_get_room_member_list(u32 ctx_id, vm::ptr<SceNpRoomId> room_id, vm::ptr<u32> buflen, vm::ptr<void> buf);
| 68,072
|
C++
|
.h
| 1,666
| 39.045618
| 201
| 0.692883
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,911
|
cellJpgEnc.h
|
RPCS3_rpcs3/rpcs3/Emu/Cell/Modules/cellJpgEnc.h
|
#pragma once
// Error Codes
enum CellJpgEncError : u32
{
CELL_JPGENC_ERROR_ARG = 0x80611191,
CELL_JPGENC_ERROR_SEQ = 0x80611192,
CELL_JPGENC_ERROR_BUSY = 0x80611193,
CELL_JPGENC_ERROR_EMPTY = 0x80611194,
CELL_JPGENC_ERROR_RESET = 0x80611195,
CELL_JPGENC_ERROR_FATAL = 0x80611196,
CELL_JPGENC_ERROR_STREAM_ABORT = 0x806111A1,
CELL_JPGENC_ERROR_STREAM_SKIP = 0x806111A2,
CELL_JPGENC_ERROR_STREAM_OVERFLOW = 0x806111A3,
CELL_JPGENC_ERROR_STREAM_FILE_OPEN = 0x806111A4,
};
// Definitions
enum
{
CELL_JPGENC_COLOR_SPACE_GRAYSCALE = 1,
CELL_JPGENC_COLOR_SPACE_RGB = 2,
CELL_JPGENC_COLOR_SPACE_YCbCr = 3,
CELL_JPGENC_COLOR_SPACE_RGBA = 10,
CELL_JPGENC_COLOR_SPACE_ARGB = 20,
CELL_JPGENC_SAMPLING_FMT_YCbCr444,
CELL_JPGENC_SAMPLING_FMT_YCbCr422,
CELL_JPGENC_SAMPLING_FMT_YCbCr420,
CELL_JPGENC_SAMPLING_FMT_YCbCr411,
CELL_JPGENC_SAMPLING_FMT_FULL,
CELL_JPGENC_DCT_METHOD_QUALITY = 0,
CELL_JPGENC_DCT_METHOD_FAST = 5,
CELL_JPGENC_COMPR_MODE_CONSTANT_QUALITY,
CELL_JPGENC_COMPR_MODE_STREAM_SIZE_LIMIT,
CELL_JPGENC_LOCATION_FILE,
CELL_JPGENC_LOCATION_BUFFER,
};
| 1,090
|
C++
|
.h
| 35
| 29.142857
| 49
| 0.782983
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,912
|
cellAtrac.h
|
RPCS3_rpcs3/rpcs3/Emu/Cell/Modules/cellAtrac.h
|
#pragma once
#include "Emu/Memory/vm_ptr.h"
// Return Codes
enum CellAtracError : u32
{
CELL_ATRAC_ERROR_API_FAIL = 0x80610301,
CELL_ATRAC_ERROR_READSIZE_OVER_BUFFER = 0x80610311,
CELL_ATRAC_ERROR_UNKNOWN_FORMAT = 0x80610312,
CELL_ATRAC_ERROR_READSIZE_IS_TOO_SMALL = 0x80610313,
CELL_ATRAC_ERROR_ILLEGAL_SAMPLING_RATE = 0x80610314,
CELL_ATRAC_ERROR_ILLEGAL_DATA = 0x80610315,
CELL_ATRAC_ERROR_NO_DECODER = 0x80610321,
CELL_ATRAC_ERROR_UNSET_DATA = 0x80610322,
CELL_ATRAC_ERROR_DECODER_WAS_CREATED = 0x80610323,
CELL_ATRAC_ERROR_ALLDATA_WAS_DECODED = 0x80610331,
CELL_ATRAC_ERROR_NODATA_IN_BUFFER = 0x80610332,
CELL_ATRAC_ERROR_NOT_ALIGNED_OUT_BUFFER = 0x80610333,
CELL_ATRAC_ERROR_NEED_SECOND_BUFFER = 0x80610334,
CELL_ATRAC_ERROR_ALLDATA_IS_ONMEMORY = 0x80610341,
CELL_ATRAC_ERROR_ADD_DATA_IS_TOO_BIG = 0x80610342,
CELL_ATRAC_ERROR_NONEED_SECOND_BUFFER = 0x80610351,
CELL_ATRAC_ERROR_UNSET_LOOP_NUM = 0x80610361,
CELL_ATRAC_ERROR_ILLEGAL_SAMPLE = 0x80610371,
CELL_ATRAC_ERROR_ILLEGAL_RESET_BYTE = 0x80610372,
CELL_ATRAC_ERROR_ILLEGAL_PPU_THREAD_PRIORITY = 0x80610381,
CELL_ATRAC_ERROR_ILLEGAL_SPU_THREAD_PRIORITY = 0x80610382,
};
// Remain Frame
enum : s32
{
CELL_ATRAC_ALLDATA_IS_ON_MEMORY = -1,
CELL_ATRAC_NONLOOP_STREAM_DATA_IS_ON_MEMORY = -2,
CELL_ATRAC_LOOP_STREAM_DATA_IS_ON_MEMORY = -3,
};
enum
{
CELL_ATRAC_HANDLE_SIZE = 512
};
struct alignas(8) CellAtracHandle
{
u8 ucWorkMem[CELL_ATRAC_HANDLE_SIZE];
};
struct CellAtracBufferInfo
{
vm::bptr<u8> pucWriteAddr;
be_t<u32> uiWritableByte;
be_t<u32> uiMinWriteByte;
be_t<u32> uiReadPosition;
};
struct CellAtracExtRes
{
vm::bptr<struct CellSpurs> pSpurs;
u8 priority[8];
};
| 1,883
|
C++
|
.h
| 54
| 33.148148
| 59
| 0.690999
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,913
|
cellMsgDialog.h
|
RPCS3_rpcs3/rpcs3/Emu/Cell/Modules/cellMsgDialog.h
|
#pragma once
#include "util/types.hpp"
#include "util/atomic.hpp"
#include "Utilities/BitField.h"
#include "Emu/Memory/vm_ptr.h"
#include "Emu/Cell/ErrorCodes.h"
#include <string>
#include <functional>
enum
{
CELL_MSGDIALOG_PROGRESSBAR_STRING_SIZE = 64,
CELL_MSGDIALOG_STRING_SIZE = 512,
};
enum CellMsgDialogError : u32
{
CELL_MSGDIALOG_ERROR_PARAM = 0x8002b301,
CELL_MSGDIALOG_ERROR_DIALOG_NOT_OPENED = 0x8002b302,
};
enum : u32
{
CELL_MSGDIALOG_TYPE_SE_TYPE_ERROR = 0 << 0,
CELL_MSGDIALOG_TYPE_SE_TYPE_NORMAL = 1 << 0,
CELL_MSGDIALOG_TYPE_SE_MUTE_OFF = 0 << 1,
CELL_MSGDIALOG_TYPE_SE_MUTE_ON = 1 << 1,
CELL_MSGDIALOG_TYPE_BG_VISIBLE = 0 << 2,
CELL_MSGDIALOG_TYPE_BG_INVISIBLE = 1 << 2,
CELL_MSGDIALOG_TYPE_BUTTON_TYPE_NONE = 0 << 4,
CELL_MSGDIALOG_TYPE_BUTTON_TYPE_YESNO = 1 << 4,
CELL_MSGDIALOG_TYPE_BUTTON_TYPE_OK = 2 << 4,
CELL_MSGDIALOG_TYPE_DISABLE_CANCEL_OFF = 0 << 7,
CELL_MSGDIALOG_TYPE_DISABLE_CANCEL_ON = 1 << 7,
CELL_MSGDIALOG_TYPE_DEFAULT_CURSOR_NONE = 0 << 8,
CELL_MSGDIALOG_TYPE_DEFAULT_CURSOR_YES = 0 << 8,
CELL_MSGDIALOG_TYPE_DEFAULT_CURSOR_NO = 1 << 8,
CELL_MSGDIALOG_TYPE_DEFAULT_CURSOR_OK = 0 << 8,
CELL_MSGDIALOG_TYPE_PROGRESSBAR_NONE = 0 << 12,
CELL_MSGDIALOG_TYPE_PROGRESSBAR_SINGLE = 1 << 12,
CELL_MSGDIALOG_TYPE_PROGRESSBAR_DOUBLE = 2 << 12,
};
// MsgDialog Button Type
enum : s32
{
CELL_MSGDIALOG_BUTTON_NONE = -1,
CELL_MSGDIALOG_BUTTON_INVALID = 0,
CELL_MSGDIALOG_BUTTON_OK = 1,
CELL_MSGDIALOG_BUTTON_YES = 1,
CELL_MSGDIALOG_BUTTON_NO = 2,
CELL_MSGDIALOG_BUTTON_ESCAPE = 3,
};
enum CellMsgDialogProgressBarIndex
{
CELL_MSGDIALOG_PROGRESSBAR_INDEX_SINGLE = 0, // the only bar in a single bar dialog
CELL_MSGDIALOG_PROGRESSBAR_INDEX_DOUBLE_UPPER = 0, // the upper bar in a double bar dialog
CELL_MSGDIALOG_PROGRESSBAR_INDEX_DOUBLE_LOWER = 1, // the lower bar in a double bar dialog
};
using CellMsgDialogCallback = void(s32 buttonType, vm::ptr<void> userData);
union MsgDialogType
{
u32 value;
bf_t<u32, 0, 1> se_normal;
bf_t<u32, 1, 1> se_mute_on;
bf_t<u32, 2, 1> bg_invisible;
bf_t<u32, 4, 3> button_type;
bf_t<u32, 7, 1> disable_cancel;
bf_t<u32, 8, 2> default_cursor;
bf_t<u32, 12, 2> progress_bar_count;
};
enum class MsgDialogState
{
Open,
Abort,
Close,
};
enum class msg_dialog_source
{
_cellMsgDialog,
_cellSaveData,
_cellGame,
_cellCrossController,
_sceNp,
_sceNpTrophy,
sys_progress,
shader_loading,
};
void close_msg_dialog();
error_code open_msg_dialog(bool is_blocking, u32 type, vm::cptr<char> msgString, msg_dialog_source source, vm::ptr<CellMsgDialogCallback> callback = vm::null, vm::ptr<void> userData = vm::null, vm::ptr<void> extParam = vm::null, s32* return_code = nullptr);
error_code open_exit_dialog(const std::string& message, bool is_exit_requested, msg_dialog_source source);
class MsgDialogBase
{
protected:
// the progressbar that will be represented in the taskbar. Use -1 to combine the progress.
s32 taskbar_index = 0;
public:
atomic_t<MsgDialogState> state{ MsgDialogState::Close };
MsgDialogType type{};
msg_dialog_source source = msg_dialog_source::_cellMsgDialog;
std::function<void(s32 status)> on_close = nullptr;
virtual ~MsgDialogBase();
virtual void Create(const std::string& msg, const std::string& title = "") = 0;
virtual void Close(bool success) = 0;
virtual void SetMsg(const std::string& msg) = 0;
virtual void ProgressBarSetMsg(u32 progressBarIndex, const std::string& msg) = 0;
virtual void ProgressBarReset(u32 progressBarIndex) = 0;
virtual void ProgressBarInc(u32 progressBarIndex, u32 delta) = 0;
virtual void ProgressBarSetValue(u32 progressBarIndex, u32 value) = 0;
virtual void ProgressBarSetLimit(u32 index, u32 limit) = 0;
void ProgressBarSetTaskbarIndex(s32 index)
{
taskbar_index = index;
}
};
| 3,891
|
C++
|
.h
| 111
| 33.198198
| 257
| 0.723835
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,914
|
cellSync2.h
|
RPCS3_rpcs3/rpcs3/Emu/Cell/Modules/cellSync2.h
|
#pragma once
#include "Emu/Memory/vm_ptr.h"
// Return Codes
enum CellSync2Error : u32
{
CELL_SYNC2_ERROR_AGAIN = 0x80410C01,
CELL_SYNC2_ERROR_INVAL = 0x80410C02,
CELL_SYNC2_ERROR_NOMEM = 0x80410C04,
CELL_SYNC2_ERROR_DEADLK = 0x80410C08,
CELL_SYNC2_ERROR_PERM = 0x80410C09,
CELL_SYNC2_ERROR_BUSY = 0x80410C0A,
CELL_SYNC2_ERROR_STAT = 0x80410C0F,
CELL_SYNC2_ERROR_ALIGN = 0x80410C10,
CELL_SYNC2_ERROR_NULL_POINTER = 0x80410C11,
CELL_SYNC2_ERROR_NOT_SUPPORTED_THREAD = 0x80410C12,
CELL_SYNC2_ERROR_NO_NOTIFIER = 0x80410C13,
CELL_SYNC2_ERROR_NO_SPU_CONTEXT_STORAGE = 0x80410C14,
};
// Constants
enum
{
CELL_SYNC2_NAME_MAX_LENGTH = 31,
CELL_SYNC2_THREAD_TYPE_PPU_THREAD = 1 << 0,
CELL_SYNC2_THREAD_TYPE_PPU_FIBER = 1 << 1,
CELL_SYNC2_THREAD_TYPE_SPURS_TASK = 1 << 2,
CELL_SYNC2_THREAD_TYPE_SPURS_JOBQUEUE_JOB = 1 << 3,
CELL_SYNC2_THREAD_TYPE_SPURS_JOB = 1 << 8,
};
struct CellSync2MutexAttribute
{
be_t<u32> sdkVersion;
be_t<u16> threadTypes;
be_t<u16> maxWaiters;
b8 recursive;
u8 padding;
char name[CELL_SYNC2_NAME_MAX_LENGTH + 1];
u8 reserved[86];
};
CHECK_SIZE(CellSync2MutexAttribute, 128);
struct CellSync2CondAttribute
{
be_t<u32> sdkVersion;
be_t<u16> maxWaiters;
char name[CELL_SYNC2_NAME_MAX_LENGTH + 1];
u8 reserved[90];
};
CHECK_SIZE(CellSync2CondAttribute, 128);
struct CellSync2SemaphoreAttribute
{
be_t<u32> sdkVersion;
be_t<u16> threadTypes;
be_t<u16> maxWaiters;
char name[CELL_SYNC2_NAME_MAX_LENGTH + 1];
u8 reserved[88];
};
CHECK_SIZE(CellSync2SemaphoreAttribute, 128);
struct CellSync2QueueAttribute
{
be_t<u32> sdkVersion;
be_t<u32> threadTypes;
be_t<u32> elementSize;
be_t<u32> depth;
be_t<u16> maxPushWaiters;
be_t<u16> maxPopWaiters;
char name[CELL_SYNC2_NAME_MAX_LENGTH + 1];
u8 reserved[76];
};
CHECK_SIZE(CellSync2QueueAttribute, 128);
struct CellSync2CallerThreadType
{
be_t<u16> threadTypeId;
vm::bptr<u64(u64)> self;
vm::bptr<s32(u64, s32, u64, u64)> waitSignal;
vm::bptr<s32(vm::ptr<u64>, s32, u64, u64)> allocateSignalReceiver;
vm::bptr<s32(u64, u64)> freeSignalReceiver;
be_t<u32> spinWaitNanoSec;
be_t<u64> callbackArg;
};
struct CellSync2Notifier
{
be_t<u16> threadTypeId;
vm::bptr<s32(u64, u64)> sendSignal;
be_t<u64> callbackArg;
};
struct alignas(128) CellSync2Mutex
{
u8 skip[128];
};
CHECK_SIZE_ALIGN(CellSync2Mutex, 128, 128);
struct alignas(128) CellSync2Cond
{
u8 skip[128];
};
CHECK_SIZE_ALIGN(CellSync2Cond, 128, 128);
struct alignas(128) CellSync2Semaphore
{
u8 skip[128];
};
CHECK_SIZE_ALIGN(CellSync2Semaphore, 128, 128);
struct alignas(128) CellSync2Queue
{
u8 skip[128];
};
CHECK_SIZE_ALIGN(CellSync2Queue, 128, 128);
struct CellSync2ThreadConfig
{
vm::bptr<CellSync2CallerThreadType> callerThreadType;
vm::bpptr<CellSync2Notifier> notifierTable;
be_t<u32> numNotifier;
};
| 2,799
|
C++
|
.h
| 110
| 23.709091
| 67
| 0.767904
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,915
|
cellAtracMulti.h
|
RPCS3_rpcs3/rpcs3/Emu/Cell/Modules/cellAtracMulti.h
|
#pragma once
#include "Emu/Memory/vm_ptr.h"
// Return Codes
enum CellAtracMultiError : u32
{
CELL_ATRACMULTI_ERROR_API_FAIL = 0x80610b01,
CELL_ATRACMULTI_ERROR_READSIZE_OVER_BUFFER = 0x80610b11,
CELL_ATRACMULTI_ERROR_UNKNOWN_FORMAT = 0x80610b12,
CELL_ATRACMULTI_ERROR_READSIZE_IS_TOO_SMALL = 0x80610b13,
CELL_ATRACMULTI_ERROR_ILLEGAL_SAMPLING_RATE = 0x80610b14,
CELL_ATRACMULTI_ERROR_ILLEGAL_DATA = 0x80610b15,
CELL_ATRACMULTI_ERROR_NO_DECODER = 0x80610b21,
CELL_ATRACMULTI_ERROR_UNSET_DATA = 0x80610b22,
CELL_ATRACMULTI_ERROR_DECODER_WAS_CREATED = 0x80610b23,
CELL_ATRACMULTI_ERROR_ALLDATA_WAS_DECODED = 0x80610b31,
CELL_ATRACMULTI_ERROR_NODATA_IN_BUFFER = 0x80610b32,
CELL_ATRACMULTI_ERROR_NOT_ALIGNED_OUT_BUFFER = 0x80610b33,
CELL_ATRACMULTI_ERROR_NEED_SECOND_BUFFER = 0x80610b34,
CELL_ATRACMULTI_ERROR_ALLDATA_IS_ONMEMORY = 0x80610b41,
CELL_ATRACMULTI_ERROR_ADD_DATA_IS_TOO_BIG = 0x80610b42,
CELL_ATRACMULTI_ERROR_NONEED_SECOND_BUFFER = 0x80610b51,
CELL_ATRACMULTI_ERROR_UNSET_LOOP_NUM = 0x80610b61,
CELL_ATRACMULTI_ERROR_ILLEGAL_SAMPLE = 0x80610b71,
CELL_ATRACMULTI_ERROR_ILLEGAL_RESET_BYTE = 0x80610b72,
CELL_ATRACMULTI_ERROR_ILLEGAL_PPU_THREAD_PRIORITY = 0x80610b81,
CELL_ATRACMULTI_ERROR_ILLEGAL_SPU_THREAD_PRIORITY = 0x80610b82,
CELL_ATRACMULTI_ERROR_API_PARAMETER = 0x80610b91,
};
// Remain Frame
enum : s32
{
CELL_ATRACMULTI_ALLDATA_IS_ON_MEMORY = -1,
CELL_ATRACMULTI_NONLOOP_STREAM_DATA_IS_ON_MEMORY = -2,
CELL_ATRACMULTI_LOOP_STREAM_DATA_IS_ON_MEMORY = -3,
};
enum
{
CELL_ATRACMULTI_HANDLE_SIZE = 512
};
struct alignas(8) CellAtracMultiHandle
{
u8 ucWorkMem[CELL_ATRACMULTI_HANDLE_SIZE];
};
struct CellAtracMultiBufferInfo
{
vm::bptr<u8> pucWriteAddr;
be_t<u32> uiWritableByte;
be_t<u32> uiMinWriteByte;
be_t<u32> uiReadPosition;
};
struct CellAtracMultiExtRes
{
vm::bptr<struct CellSpurs> pSpurs;
u8 priority[8];
};
| 2,098
|
C++
|
.h
| 55
| 36.418182
| 64
| 0.712181
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,916
|
cellVideoUpload.h
|
RPCS3_rpcs3/rpcs3/Emu/Cell/Modules/cellVideoUpload.h
|
#pragma once
#include "Emu/Memory/vm_ptr.h"
struct CellVideoUploadOption
{
be_t<s32> type;
be_t<u64> value;
};
struct CellVideoUploadParam
{
be_t<s32> siteID;
vm::bcptr<char> pFilePath;
union
{
struct
{
vm::bcptr<char> pClientId;
vm::bcptr<char> pDeveloperKey;
vm::bcptr<char> pTitle_UTF8;
vm::bcptr<char> pDescription_UTF8;
vm::bcptr<char> pKeyword_1_UTF8;
vm::bcptr<char> pKeyword_2_UTF8;
vm::bcptr<char> pKeyword_3_UTF8;
u8 isPrivate;
u8 rating;
} youtube;
} u;
be_t<s32> numOfOption;
vm::bptr<CellVideoUploadOption> pOption;
};
using CellVideoUploadCallback = void(s32 status, s32 errorCode, vm::cptr<char> pResultURL, vm::ptr<void> userdata);
enum
{
CELL_VIDEO_UPLOAD_MAX_FILE_PATH_LEN = 1023,
CELL_VIDEO_UPLOAD_MAX_YOUTUBE_CLIENT_ID_LEN = 64,
CELL_VIDEO_UPLOAD_MAX_YOUTUBE_DEVELOPER_KEY_LEN = 128,
CELL_VIDEO_UPLOAD_MAX_YOUTUBE_TITLE_LEN = 61,
CELL_VIDEO_UPLOAD_MAX_YOUTUBE_DESCRIPTION_LEN = 1024,
CELL_VIDEO_UPLOAD_MAX_YOUTUBE_KEYWORD_LEN = 25
};
// Return Codes
enum CellVideoUploadError : u32
{
CELL_VIDEO_UPLOAD_ERROR_CANCEL = 0x8002d000,
CELL_VIDEO_UPLOAD_ERROR_NETWORK = 0x8002d001,
CELL_VIDEO_UPLOAD_ERROR_SERVICE_STOP = 0x8002d002,
CELL_VIDEO_UPLOAD_ERROR_SERVICE_BUSY = 0x8002d003,
CELL_VIDEO_UPLOAD_ERROR_SERVICE_UNAVAILABLE = 0x8002d004,
CELL_VIDEO_UPLOAD_ERROR_SERVICE_QUOTA = 0x8002d005,
CELL_VIDEO_UPLOAD_ERROR_ACCOUNT_STOP = 0x8002d006,
CELL_VIDEO_UPLOAD_ERROR_OUT_OF_MEMORY = 0x8002d020,
CELL_VIDEO_UPLOAD_ERROR_FATAL = 0x8002d021,
CELL_VIDEO_UPLOAD_ERROR_INVALID_VALUE = 0x8002d022,
CELL_VIDEO_UPLOAD_ERROR_FILE_OPEN = 0x8002d023,
CELL_VIDEO_UPLOAD_ERROR_INVALID_STATE = 0x8002d024
};
enum
{
CELL_VIDEO_UPLOAD_STATUS_INITIALIZED = 1,
CELL_VIDEO_UPLOAD_STATUS_FINALIZED = 2
};
| 1,894
|
C++
|
.h
| 60
| 29.416667
| 115
| 0.713738
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
GPL-2.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
5,917
|
cellAdec.h
|
RPCS3_rpcs3/rpcs3/Emu/Cell/Modules/cellAdec.h
|
#pragma once
#include "Emu/Memory/vm_ptr.h"
// Error Codes
enum CellAdecError : u32
{
CELL_ADEC_ERROR_FATAL = 0x80610001,
CELL_ADEC_ERROR_SEQ = 0x80610002,
CELL_ADEC_ERROR_ARG = 0x80610003,
CELL_ADEC_ERROR_BUSY = 0x80610004,
CELL_ADEC_ERROR_EMPTY = 0x80610005,
CELL_ADEC_ERROR_CELP_BUSY = 0x80612e01,
CELL_ADEC_ERROR_CELP_EMPTY = 0x80612e02,
CELL_ADEC_ERROR_CELP_ARG = 0x80612e03,
CELL_ADEC_ERROR_CELP_SEQ = 0x80612e04,
CELL_ADEC_ERROR_CELP_CORE_FATAL = 0x80612e81,
CELL_ADEC_ERROR_CELP_CORE_ARG = 0x80612e82,
CELL_ADEC_ERROR_CELP_CORE_SEQ = 0x80612e83,
CELL_ADEC_ERROR_CELP8_BUSY = 0x80612ea1,
CELL_ADEC_ERROR_CELP8_EMPTY = 0x80612ea2,
CELL_ADEC_ERROR_CELP8_ARG = 0x80612ea3,
CELL_ADEC_ERROR_CELP8_SEQ = 0x80612ea4,
CELL_ADEC_ERROR_CELP8_CORE_FATAL = 0x80612eb1,
CELL_ADEC_ERROR_CELP8_CORE_ARG = 0x80612eb2,
CELL_ADEC_ERROR_CELP8_CORE_SEQ = 0x80612eb3,
CELL_ADEC_ERROR_M4AAC_FATAL = 0x80612401,
CELL_ADEC_ERROR_M4AAC_SEQ = 0x80612402,
CELL_ADEC_ERROR_M4AAC_ARG = 0x80612403,
CELL_ADEC_ERROR_M4AAC_BUSY = 0x80612404,
CELL_ADEC_ERROR_M4AAC_EMPTY = 0x80612405,
CELL_ADEC_ERROR_M4AAC_BUFFER_OVERFLOW = 0x80612406,
CELL_ADEC_ERROR_M4AAC_END_OF_BITSTREAM = 0x80612407,
/* Core */
CELL_ADEC_ERROR_M4AAC_CH_CONFIG_INCONSISTENCY = 0x80612410,
CELL_ADEC_ERROR_M4AAC_NO_CH_DEFAULT_POS = 0x80612411,
CELL_ADEC_ERROR_M4AAC_INVALID_CH_POS = 0x80612412,
CELL_ADEC_ERROR_M4AAC_UNANTICIPATED_COUPLING_CH = 0x80612413,
CELL_ADEC_ERROR_M4AAC_INVALID_LAYER_ID = 0x80612414,
CELL_ADEC_ERROR_M4AAC_ADTS_SYNCWORD_ERROR = 0x80612415,
CELL_ADEC_ERROR_M4AAC_INVALID_ADTS_ID = 0x80612416,
CELL_ADEC_ERROR_M4AAC_CH_CHANGED = 0x80612417,
CELL_ADEC_ERROR_M4AAC_SAMPLING_FREQ_CHANGED = 0x80612418,
CELL_ADEC_ERROR_M4AAC_WRONG_SBR_CH = 0x80612419,
CELL_ADEC_ERROR_M4AAC_WRONG_SCALE_FACTOR = 0x8061241a,
CELL_ADEC_ERROR_M4AAC_INVALID_BOOKS = 0x8061241b,
CELL_ADEC_ERROR_M4AAC_INVALID_SECTION_DATA = 0x8061241c,
CELL_ADEC_ERROR_M4AAC_PULSE_IS_NOT_LONG = 0x8061241d,
CELL_ADEC_ERROR_M4AAC_GC_IS_NOT_SUPPORTED = 0x8061241e,
CELL_ADEC_ERROR_M4AAC_INVALID_ELEMENT_ID = 0x8061241f,
CELL_ADEC_ERROR_M4AAC_NO_CH_CONFIG = 0x80612420,
CELL_ADEC_ERROR_M4AAC_UNEXPECTED_OVERLAP_CRC = 0x80612421,
CELL_ADEC_ERROR_M4AAC_CRC_BUFFER_EXCEEDED = 0x80612422,
CELL_ADEC_ERROR_M4AAC_INVALID_CRC = 0x80612423,
CELL_ADEC_ERROR_M4AAC_BAD_WINDOW_CODE = 0x80612424,
CELL_ADEC_ERROR_M4AAC_INVALID_ADIF_HEADER_ID = 0x80612425,
CELL_ADEC_ERROR_M4AAC_NOT_SUPPORTED_PROFILE = 0x80612426,
CELL_ADEC_ERROR_M4AAC_PROG_NUMBER_NOT_FOUND = 0x80612427,
CELL_ADEC_ERROR_M4AAC_INVALID_SAMP_RATE_INDEX = 0x80612428,
CELL_ADEC_ERROR_M4AAC_UNANTICIPATED_CH_CONFIG = 0x80612429,
CELL_ADEC_ERROR_M4AAC_PULSE_OVERFLOWED = 0x8061242a,
CELL_ADEC_ERROR_M4AAC_CAN_NOT_UNPACK_INDEX = 0x8061242b,
CELL_ADEC_ERROR_M4AAC_DEINTERLEAVE_FAILED = 0x8061242c,
CELL_ADEC_ERROR_M4AAC_CALC_BAND_OFFSET_FAILED = 0x8061242d,
CELL_ADEC_ERROR_M4AAC_GET_SCALE_FACTOR_FAILED = 0x8061242e,
CELL_ADEC_ERROR_M4AAC_GET_CC_GAIN_FAILED = 0x8061242f,
CELL_ADEC_ERROR_M4AAC_MIX_COUPLING_CH_FAILED = 0x80612430,
CELL_ADEC_ERROR_M4AAC_GROUP_IS_INVALID = 0x80612431,
CELL_ADEC_ERROR_M4AAC_PREDICT_FAILED = 0x80612432,
CELL_ADEC_ERROR_M4AAC_INVALID_PREDICT_RESET_PATTERN = 0x80612433,
CELL_ADEC_ERROR_M4AAC_INVALID_TNS_FRAME_INFO = 0x80612434,
CELL_ADEC_ERROR_M4AAC_GET_MASK_FAILED = 0x80612435,
CELL_ADEC_ERROR_M4AAC_GET_GROUP_FAILED = 0x80612436,
CELL_ADEC_ERROR_M4AAC_GET_LPFLAG_FAILED = 0x80612437,
CELL_ADEC_ERROR_M4AAC_INVERSE_QUANTIZATION_FAILED = 0x80612438,
CELL_ADEC_ERROR_M4AAC_GET_CB_MAP_FAILED = 0x80612439,
CELL_ADEC_ERROR_M4AAC_GET_PULSE_FAILED = 0x8061243a,
CELL_ADEC_ERROR_M4AAC_MONO_MIXDOWN_ELEMENT_IS_NOT_SUPPORTED = 0x8061243b,
CELL_ADEC_ERROR_M4AAC_STEREO_MIXDOWN_ELEMENT_IS_NOT_SUPPORTED = 0x8061243c,
CELL_ADEC_ERROR_M4AAC_SBR_CH_OVERFLOW = 0x80612480,
CELL_ADEC_ERROR_M4AAC_SBR_NOSYNCH = 0x80612481,
CELL_ADEC_ERROR_M4AAC_SBR_ILLEGAL_PROGRAM = 0x80612482,
CELL_ADEC_ERROR_M4AAC_SBR_ILLEGAL_TAG = 0x80612483,
CELL_ADEC_ERROR_M4AAC_SBR_ILLEGAL_CHN_CONFIG = 0x80612484,
CELL_ADEC_ERROR_M4AAC_SBR_ILLEGAL_SECTION = 0x80612485,
CELL_ADEC_ERROR_M4AAC_SBR_ILLEGAL_SCFACTORS = 0x80612486,
CELL_ADEC_ERROR_M4AAC_SBR_ILLEGAL_PULSE_DATA = 0x80612487,
CELL_ADEC_ERROR_M4AAC_SBR_MAIN_PROFILE_NOT_IMPLEMENTED = 0x80612488,
CELL_ADEC_ERROR_M4AAC_SBR_GC_NOT_IMPLEMENTED = 0x80612489,
CELL_ADEC_ERROR_M4AAC_SBR_ILLEGAL_PLUS_ELE_ID = 0x8061248a,
CELL_ADEC_ERROR_M4AAC_SBR_CREATE_ERROR = 0x8061248b,
CELL_ADEC_ERROR_M4AAC_SBR_NOT_INITIALIZED = 0x8061248c,
CELL_ADEC_ERROR_M4AAC_SBR_INVALID_ENVELOPE = 0x8061248d,
CELL_ADEC_ERROR_AC3_BUSY = 0x80612500,
CELL_ADEC_ERROR_AC3_EMPTY = 0x80612501,
CELL_ADEC_ERROR_AC3_PARAM = 0x80612502,
CELL_ADEC_ERROR_AC3_FRAME = 0x80612503,
CELL_ADEC_ERROR_AT3_OFFSET = 0x80612100,
CELL_ADEC_ERROR_AT3_OK = 0x80612100,
CELL_ADEC_ERROR_AT3_BUSY = 0x80612164,
CELL_ADEC_ERROR_AT3_EMPTY = 0x80612165,
CELL_ADEC_ERROR_AT3_ERROR = 0x80612180,
CELL_ADEC_ERROR_LPCM_FATAL = 0x80612001,
CELL_ADEC_ERROR_LPCM_SEQ = 0x80612002,
CELL_ADEC_ERROR_LPCM_ARG = 0x80612003,
CELL_ADEC_ERROR_LPCM_BUSY = 0x80612004,
CELL_ADEC_ERROR_LPCM_EMPTY = 0x80612005,
CELL_ADEC_ERROR_MP3_OFFSET = 0x80612700U,
CELL_ADEC_ERROR_MP3_OK = 0x80612700,
CELL_ADEC_ERROR_MP3_BUSY = 0x80612764,
CELL_ADEC_ERROR_MP3_EMPTY = 0x80612765,
CELL_ADEC_ERROR_MP3_ERROR = 0x80612781,
CELL_ADEC_ERROR_MP3_LOST_SYNC = 0x80612782,
CELL_ADEC_ERROR_MP3_NOT_L3 = 0x80612783,
CELL_ADEC_ERROR_MP3_BAD_BITRATE = 0x80612784,
CELL_ADEC_ERROR_MP3_BAD_SFREQ = 0x80612785,
CELL_ADEC_ERROR_MP3_BAD_EMPHASIS = 0x80612786,
CELL_ADEC_ERROR_MP3_BAD_BLKTYPE = 0x80612787,
CELL_ADEC_ERROR_MP3_BAD_VERSION = 0x8061278c,
CELL_ADEC_ERROR_MP3_BAD_MODE = 0x8061278d,
CELL_ADEC_ERROR_MP3_BAD_MODE_EXT = 0x8061278e,
CELL_ADEC_ERROR_MP3_HUFFMAN_NUM = 0x80612796,
CELL_ADEC_ERROR_MP3_HUFFMAN_CASE_ID = 0x80612797,
CELL_ADEC_ERROR_MP3_SCALEFAC_COMPRESS = 0x80612798,
CELL_ADEC_ERROR_MP3_HGETBIT = 0x80612799,
CELL_ADEC_ERROR_MP3_FLOATING_EXCEPTION = 0x8061279a,
CELL_ADEC_ERROR_MP3_ARRAY_OVERFLOW = 0x8061279b,
CELL_ADEC_ERROR_MP3_STEREO_PROCESSING = 0x8061279c,
CELL_ADEC_ERROR_MP3_JS_BOUND = 0x8061279d,
CELL_ADEC_ERROR_MP3_PCMOUT = 0x8061279e,
CELL_ADEC_ERROR_M2BC_FATAL = 0x80612b01,
CELL_ADEC_ERROR_M2BC_SEQ = 0x80612b02,
CELL_ADEC_ERROR_M2BC_ARG = 0x80612b03,
CELL_ADEC_ERROR_M2BC_BUSY = 0x80612b04,
CELL_ADEC_ERROR_M2BC_EMPTY = 0x80612b05,
CELL_ADEC_ERROR_M2BC_SYNCF = 0x80612b11,
CELL_ADEC_ERROR_M2BC_LAYER = 0x80612b12,
CELL_ADEC_ERROR_M2BC_BITRATE = 0x80612b13,
CELL_ADEC_ERROR_M2BC_SAMPLEFREQ = 0x80612b14,
CELL_ADEC_ERROR_M2BC_VERSION = 0x80612b15,
CELL_ADEC_ERROR_M2BC_MODE_EXT = 0x80612b16,
CELL_ADEC_ERROR_M2BC_UNSUPPORT = 0x80612b17,
CELL_ADEC_ERROR_M2BC_OPENBS_EX = 0x80612b21,
CELL_ADEC_ERROR_M2BC_SYNCF_EX = 0x80612b22,
CELL_ADEC_ERROR_M2BC_CRCGET_EX = 0x80612b23,
CELL_ADEC_ERROR_M2BC_CRC_EX = 0x80612b24,
CELL_ADEC_ERROR_M2BC_CRCGET = 0x80612b31,
CELL_ADEC_ERROR_M2BC_CRC = 0x80612b32,
CELL_ADEC_ERROR_M2BC_BITALLOC = 0x80612b33,
CELL_ADEC_ERROR_M2BC_SCALE = 0x80612b34,
CELL_ADEC_ERROR_M2BC_SAMPLE = 0x80612b35,
CELL_ADEC_ERROR_M2BC_OPENBS = 0x80612b36,
CELL_ADEC_ERROR_M2BC_MC_CRCGET = 0x80612b41,
CELL_ADEC_ERROR_M2BC_MC_CRC = 0x80612b42,
CELL_ADEC_ERROR_M2BC_MC_BITALLOC = 0x80612b43,
CELL_ADEC_ERROR_M2BC_MC_SCALE = 0x80612b44,
CELL_ADEC_ERROR_M2BC_MC_SAMPLE = 0x80612b45,
CELL_ADEC_ERROR_M2BC_MC_HEADER = 0x80612b46,
CELL_ADEC_ERROR_M2BC_MC_STATUS = 0x80612b47,
CELL_ADEC_ERROR_M2BC_AG_CCRCGET = 0x80612b51,
CELL_ADEC_ERROR_M2BC_AG_CRC = 0x80612b52,
CELL_ADEC_ERROR_M2BC_AG_BITALLOC = 0x80612b53,
CELL_ADEC_ERROR_M2BC_AG_SCALE = 0x80612b54,
CELL_ADEC_ERROR_M2BC_AG_SAMPLE = 0x80612b55,
CELL_ADEC_ERROR_M2BC_AG_STATUS = 0x80612b57,
};
// Audio Codec Type
enum AudioCodecType : s32
{
CELL_ADEC_TYPE_INVALID1,
CELL_ADEC_TYPE_LPCM_PAMF,
CELL_ADEC_TYPE_AC3,
CELL_ADEC_TYPE_ATRACX,
CELL_ADEC_TYPE_MP3,
CELL_ADEC_TYPE_ATRAC3,
CELL_ADEC_TYPE_MPEG_L2,
CELL_ADEC_TYPE_M2AAC,
CELL_ADEC_TYPE_EAC3,
CELL_ADEC_TYPE_TRUEHD,
CELL_ADEC_TYPE_DTS, // Removed in firmware 4.00, integrated into DTSHD
CELL_ADEC_TYPE_CELP,
CELL_ADEC_TYPE_LPCM_BLURAY,
CELL_ADEC_TYPE_ATRACX_2CH,
CELL_ADEC_TYPE_ATRACX_6CH,
CELL_ADEC_TYPE_ATRACX_8CH,
CELL_ADEC_TYPE_M4AAC,
CELL_ADEC_TYPE_LPCM_DVD,
CELL_ADEC_TYPE_WMA,
CELL_ADEC_TYPE_DTSLBR,
CELL_ADEC_TYPE_M4AAC_2CH,
CELL_ADEC_TYPE_DTSHD,
CELL_ADEC_TYPE_MPEG_L1,
CELL_ADEC_TYPE_MP3S,
CELL_ADEC_TYPE_M4AAC_2CH_MOD,
CELL_ADEC_TYPE_CELP8,
CELL_ADEC_TYPE_INVALID2,
CELL_ADEC_TYPE_INVALID3,
CELL_ADEC_TYPE_RESERVED22, // Either WMA Pro or WMA Lossless, was never released
CELL_ADEC_TYPE_RESERVED23, // Either WMA Pro or WMA Lossless, was never released
CELL_ADEC_TYPE_DTSHDCORE, // Removed in firmware 4.00, integrated into DTSHD
CELL_ADEC_TYPE_ATRAC3MULTI,
};
inline bool adecIsAtracX(s32 type)
{
return type == CELL_ADEC_TYPE_ATRACX
|| type == CELL_ADEC_TYPE_ATRACX_2CH
|| type == CELL_ADEC_TYPE_ATRACX_6CH
|| type == CELL_ADEC_TYPE_ATRACX_8CH;
}
// Output Channel Number
enum CellAdecChannel : s32
{
CELL_ADEC_CH_RESERVED1,
CELL_ADEC_CH_MONO,
CELL_ADEC_CH_RESERVED2,
CELL_ADEC_CH_STEREO,
CELL_ADEC_CH_3_0,
CELL_ADEC_CH_2_1,
CELL_ADEC_CH_3_1,
CELL_ADEC_CH_2_2,
CELL_ADEC_CH_3_2,
CELL_ADEC_CH_3_2_LFE,
CELL_ADEC_CH_3_4,
CELL_ADEC_CH_3_4_LFE,
CELL_ADEC_CH_RESERVED3,
};
// Sampling Rate
enum CellAdecSampleRate : s32
{
CELL_ADEC_FS_RESERVED1,
CELL_ADEC_FS_48kHz,
CELL_ADEC_FS_16kHz,
CELL_ADEC_FS_96kHz,
CELL_ADEC_FS_192kHz,
CELL_ADEC_FS_8kHz,
};
enum CellAdecBitLength : s32
{
CELL_ADEC_BIT_LENGTH_RESERVED1,
CELL_ADEC_BIT_LENGTH_16,
CELL_ADEC_BIT_LENGTH_20,
CELL_ADEC_BIT_LENGTH_24,
};
struct CellAdecType
{
be_t<s32> audioCodecType; // AudioCodecType
};
struct CellAdecAttr
{
be_t<u32> workMemSize;
be_t<u32> adecVerUpper;
be_t<u32> adecVerLower;
};
struct CellAdecResource
{
be_t<u32> totalMemSize;
be_t<u32> startAddr;
be_t<u32> ppuThreadPriority;
be_t<u32> spuThreadPriority;
be_t<u32> ppuThreadStackSize;
};
struct CellAdecResourceEx
{
be_t<u32> totalMemSize;
be_t<u32> startAddr;
be_t<u32> ppuThreadPriority;
be_t<u32> ppuThreadStackSize;
be_t<u32> spurs_addr;
u8 priority[8];
be_t<u32> maxContention;
};
struct CellAdecResourceSpurs
{
be_t<u32> spurs_addr; // CellSpurs*
u8 priority[8];
be_t<u32> maxContention;
};
// Callback Messages
enum CellAdecMsgType : s32
{
CELL_ADEC_MSG_TYPE_AUDONE,
CELL_ADEC_MSG_TYPE_PCMOUT,
CELL_ADEC_MSG_TYPE_ERROR,
CELL_ADEC_MSG_TYPE_SEQDONE,
};
using CellAdecCbMsg = s32(u32 handle, CellAdecMsgType msgType, s32 msgData, u32 cbArg);
// Used for internal callbacks as well
template <typename F>
struct AdecCb
{
vm::bptr<F> cbFunc;
vm::bptr<void> cbArg;
};
using CellAdecCb = AdecCb<CellAdecCbMsg>;
// AU Info
struct CellAdecAuInfo
{
vm::bcptr<u8> startAddr;
be_t<u32> size;
CellCodecTimeStamp pts;
be_t<u64> userData;
};
// BSI Info
struct CellAdecPcmAttr
{
be_t<u32> bsiInfo_addr;
};
struct CellAdecPcmItem
{
be_t<u32> pcmHandle;
be_t<u32> status;
be_t<u32> startAddr;
be_t<u32> size;
CellAdecPcmAttr pcmAttr;
CellAdecAuInfo auInfo;
};
// Controls how much is added to the presentation time stamp of the previous frame if the game didn't set a pts itself in CellAdecAuInfo when calling cellAdecDecodeAu()
enum AdecCorrectPtsValueType : s8
{
ADEC_CORRECT_PTS_VALUE_TYPE_UNSPECIFIED = -1,
// Adds a fixed amount
ADEC_CORRECT_PTS_VALUE_TYPE_LPCM = 0,
// 1
ADEC_CORRECT_PTS_VALUE_TYPE_ATRACX_48000Hz = 2,
ADEC_CORRECT_PTS_VALUE_TYPE_ATRACX_44100Hz = 3,
ADEC_CORRECT_PTS_VALUE_TYPE_ATRACX_32000Hz = 4,
// 5: Dolby Digital
// 6: ATRAC3
// 7: MP3
// 8: MP3
// 9: MP3
// 39: ATRAC3 multi-track
// Calls a decoder function (_SceAdecCorrectPtsValue_codec())
// 17: Dolby Digital Plus
// 18
// 19
// 20
// 21: DTS HD
// 22
// 23
// 24: CELP
// 25: MPEG-2 AAC
// 26: MPEG-2 BC
// 27: Dolby TrueHD
// 28: DTS
// 29: MPEG-4 AAC
// 30: Windows Media Audio
// 31: DTS Express
// 32: MP1
// 33: MP3 Surround
// 34: CELP8
// 35: Windows Media Audio Professional
// 36: Windows Media Audio Lossless
// 37: DTS HD Core
// 38: DTS HD Core
};
// Internal callbacks
using AdecNotifyAuDone = error_code(s32 pcmHandle, vm::ptr<void> cbArg);
using AdecNotifyPcmOut = error_code(s32 pcmHandle, vm::ptr<void> pcmAddr, u32 pcmSize, vm::ptr<void> cbArg, vm::cpptr<void> bsiInfo, AdecCorrectPtsValueType correctPtsValueType, s32 errorCode);
using AdecNotifyError = error_code(s32 errorCode, vm::ptr<void> cbArg);
using AdecNotifySeqDone = error_code(vm::ptr<void> cbArg);
// Decoder functions
using CellAdecCoreOpGetMemSize = error_code(vm::ptr<CellAdecAttr> attr);
using CellAdecCoreOpOpen = error_code(vm::ptr<void> coreHandle, vm::ptr<AdecNotifyAuDone> cbFuncAuDone, vm::ptr<void> cbArgAuDone, vm::ptr<AdecNotifyPcmOut> cbFuncPcmOut, vm::ptr<void> cbArgPcmOut,
vm::ptr<AdecNotifyError> cbFuncError, vm::ptr<void> cbArgError, vm::ptr<AdecNotifySeqDone> cbFuncSeqDone, vm::ptr<void> cbArgSeqDone, vm::cptr<CellAdecResource> res);
using CellAdecCoreOpClose = error_code(vm::ptr<void> coreHandle);
using CellAdecCoreOpStartSeq = error_code(vm::ptr<void> coreHandle, vm::cptr<void> param);
using CellAdecCoreOpEndSeq = error_code(vm::ptr<void> coreHandle);
using CellAdecCoreOpDecodeAu = error_code(vm::ptr<void> coreHandle, s32 pcmHandle, vm::cptr<CellAdecAuInfo> auInfo);
using CellAdecCoreOpGetVersion = void(vm::ptr<be_t<u32, 1>> version);
using CellAdecCoreOpRealign = error_code(vm::ptr<void> coreHandle, vm::ptr<void> outBuffer, vm::cptr<void> pcmStartAddr);
using CellAdecCoreOpReleasePcm = error_code(vm::ptr<void> coreHandle, s32 pcmHandle, vm::cptr<void> outBuffer);
using CellAdecCoreOpGetPcmHandleNum = s32();
using CellAdecCoreOpGetBsiInfoSize = u32();
using CellAdecCoreOpOpenExt = error_code(vm::ptr<void> coreHandle, vm::ptr<AdecNotifyAuDone> cbFuncAuDone, vm::ptr<void> cbArgAuDone, vm::ptr<AdecNotifyPcmOut> cbFuncPcmOut, vm::ptr<void> cbArgPcmOut,
vm::ptr<AdecNotifyError> cbFuncError, vm::ptr<void> cbArgError, vm::ptr<AdecNotifySeqDone> cbFuncSeqDone, vm::ptr<void> cbArgSeqDone, vm::cptr<CellAdecResource> res, vm::cptr<CellAdecResourceSpurs> spursRes);
// Decoders export a pointer to this struct
struct CellAdecCoreOps
{
vm::bptr<CellAdecCoreOpGetMemSize> getMemSize;
vm::bptr<CellAdecCoreOpOpen> open;
vm::bptr<CellAdecCoreOpClose> close;
vm::bptr<CellAdecCoreOpStartSeq> startSeq;
vm::bptr<CellAdecCoreOpEndSeq> endSeq;
vm::bptr<CellAdecCoreOpDecodeAu> decodeAu;
vm::bptr<CellAdecCoreOpGetVersion> getVersion;
vm::bptr<CellAdecCoreOpRealign> realign;
vm::bptr<CellAdecCoreOpReleasePcm> releasePcm;
vm::bptr<CellAdecCoreOpGetPcmHandleNum> getPcmHandleNum;
vm::bptr<CellAdecCoreOpGetBsiInfoSize> getBsiInfoSize;
vm::bptr<CellAdecCoreOpOpenExt> openExt;
};
// Used by several decoders as command queue
template <typename T>
struct AdecCmdQueue
{
T elements[4];
be_t<s32> front = 0;
be_t<s32> back = 0;
be_t<s32> size = 0;
template <bool is_peek = false>
void pop(T& cmd)
{
// LLE returns uninitialized stack memory if the queue is empty
cmd = elements[front];
if constexpr (!is_peek)
{
elements[front].pcm_handle = 0xff;
front = (front + 1) & 3;
size--;
}
}
void emplace(auto&&... args)
{
new (&elements[back]) T(std::forward<decltype(args)>(args)...);
back = (back + 1) & 3;
size++;
}
void peek(T& cmd) const { return pop<true>(cmd); }
bool empty() const { return size == 0; }
bool full() const { return size >= 4; }
};
struct CellAdecParamLpcm
{
be_t<u32> channelNumber;
be_t<u32> sampleRate;
be_t<u32> sizeOfWord;
be_t<u32> audioPayloadSize;
};
// LPCM BSI
struct CellAdecLpcmInfo
{
be_t<u32> channelNumber;
be_t<u32> sampleRate;
be_t<u32> outputDataSize;
};
// CELP Excitation Mode
enum CELP_ExcitationMode : s32
{
CELL_ADEC_CELP_EXCITATION_MODE_RPE = 1,
};
// CELP RPE Configuration
enum CELP_RPEConfig : s32
{
CELL_ADEC_CELP_RPE_CONFIG_0,
CELL_ADEC_CELP_RPE_CONFIG_1,
CELL_ADEC_CELP_RPE_CONFIG_2,
CELL_ADEC_CELP_RPE_CONFIG_3,
};
// CELP Word Size
enum CELP_WordSize : s32
{
CELL_ADEC_CELP_WORD_SZ_INT16_LE,
CELL_ADEC_CELP_WORD_SZ_FLOAT,
};
// CELP Parameters
struct CellAdecParamCelp
{
be_t<u32> excitationMode;
be_t<u32> sampleRate; // CELL_ADEC_FS_16kHz
be_t<u32> configuration;
be_t<u32> wordSize;
};
// CELP BSI (same as CellAdecParamCelp ???)
struct CellAdecCelpInfo
{
be_t<u32> excitationMode;
be_t<u32> sampleRate; // CELL_ADEC_FS_16kHz
be_t<u32> configuration;
be_t<u32> wordSize;
};
// CELP8 Excitation Mode
enum CELP8_ExcitationMode : s32
{
CELL_ADEC_CELP8_EXCITATION_MODE_MPE = 0,
};
// CELP8 MPE Configuration
enum CELP8_MPEConfig : s32
{
CELL_ADEC_CELP8_MPE_CONFIG_0 = 0,
CELL_ADEC_CELP8_MPE_CONFIG_2 = 2,
CELL_ADEC_CELP8_MPE_CONFIG_6 = 6,
CELL_ADEC_CELP8_MPE_CONFIG_9 = 9,
CELL_ADEC_CELP8_MPE_CONFIG_12 = 12,
CELL_ADEC_CELP8_MPE_CONFIG_15 = 15,
CELL_ADEC_CELP8_MPE_CONFIG_18 = 18,
CELL_ADEC_CELP8_MPE_CONFIG_21 = 21,
CELL_ADEC_CELP8_MPE_CONFIG_24 = 24,
CELL_ADEC_CELP8_MPE_CONFIG_26 = 26,
};
// CELP8 Word Size
enum CELP8_WordSize : s32
{
CELL_ADEC_CELP8_WORD_SZ_FLOAT,
};
// CELP8 Parameters
struct CellAdecParamCelp8
{
be_t<u32> excitationMode;
be_t<u32> sampleRate; // CELL_ADEC_FS_8kHz
be_t<u32> configuration;
be_t<u32> wordSize;
};
// CELP8 BSI
struct CellAdecCelp8Info
{
be_t<u32> excitationMode;
be_t<u32> sampleRate; // CELL_ADEC_FS_8kHz
be_t<u32> configuration;
be_t<u32> wordSize;
};
enum MPEG4AAC_ConfigType : s32
{
ADIFHeader = 0,
ADTSHeader = 1,
RawDataBlockOnly = 2,
};
enum MPEG4AAC_SamplingFreq : s32
{
SF_96000 = 0,
SF_88200 = 1,
SF_64000 = 2,
SF_48000 = 3,
SF_44100 = 4,
SF_32000 = 5,
SF_24000 = 6,
SF_22050 = 7,
SF_16000 = 8,
SF_12000 = 9,
SF_11025 = 10,
SF_8000 = 11,
};
// MPEG4 AAC Parameters
struct CellAdecParamM4Aac
{
be_t<s32> configNumber; // MPEG4AAC_ConfigType
union
{
struct
{
be_t<u32> programNumber;
}
adifConfig;
struct
{
be_t<s32> samplingFreqIndex; // MPEG4AAC_SamplingFreq
be_t<u32> profile; // LC profile (1)
}
rawDataBlockConfig;
}
configInfo;
be_t<u32> enableDownmix; // enable downmix to 2.0 (if (enableDownmix))
};
// MPEG4 AAC BSI
struct alignas(16) CellAdecM4AacInfo
{
be_t<u32> samplingFreq; // [Hz]
be_t<u32> numberOfChannels;
be_t<u32> numberOfFrontChannels;
be_t<u32> numberOfFrontMonoChannels;
be_t<u32> numberOfSideChannels;
be_t<u32> numberOfBackChannels;
be_t<u32> numberOfLfeChannels;
be_t<u32> enableSBR;
be_t<u32> SBRUpsamplingFactor;
be_t<u32> isBsiValid;
be_t<s32> configNumber; // MPEG4AAC_ConfigType
union
{
struct
{
be_t<u32> copyrightIdPresent;
char copyrightId[9];
be_t<u32> originalCopy;
be_t<u32> home;
be_t<u32> bitstreamType;
be_t<u32> bitrate;
be_t<u32> numberOfProgramConfigElements;
be_t<u32> bufferFullness;
}
adif;
struct mp8
{
be_t<u32> id;
be_t<u32> layer;
be_t<u32> protectionAbsent;
be_t<u32> profile;
be_t<u32> samplingFreqIndex;
be_t<u32> privateBit;
be_t<u32> channelConfiguration;
be_t<u32> originalCopy;
be_t<u32> home;
be_t<u32> copyrightIdBit;
be_t<u32> copyrightIdStart;
be_t<u32> frameLength;
be_t<u32> bufferFullness;
be_t<u32> numberOfRawDataBlocks;
be_t<u32> crcCheck;
}
adts;
}
bsi;
struct
{
be_t<u32> matrixMixdownPresent;
be_t<u32> mixdownIndex;
be_t<u32> pseudoSurroundEnable;
}
matrixMixdown;
be_t<u32> reserved;
};
enum AC3_WordSize : u8
{
CELL_ADEC_AC3_WORD_SZ_INT16 = 0,
CELL_ADEC_AC3_WORD_SZ_FLOAT = 1,
};
enum AC3_OutputMode : u8
{
CELL_ADEC_AC3_OUTPUT_MODE_RESERVED = 0,
CELL_ADEC_AC3_OUTPUT_MODE_1_0 = 1,
CELL_ADEC_AC3_OUTPUT_MODE_2_0 = 2,
CELL_ADEC_AC3_OUTPUT_MODE_3_0 = 3,
CELL_ADEC_AC3_OUTPUT_MODE_2_1 = 4,
CELL_ADEC_AC3_OUTPUT_MODE_3_1 = 5,
CELL_ADEC_AC3_OUTPUT_MODE_2_2 = 6,
CELL_ADEC_AC3_OUTPUT_MODE_3_2 = 7,
};
enum AC3_LFE : u8
{
CELL_ADEC_AC3_LFE_NOT_PRESENT = 0,
CELL_ADEC_AC3_LFE_PRESENT = 1,
};
enum AC3_CompressionMode : u8
{
CELL_ADEC_AC3_COMPRESSION_MODE_CUSTOM_ANALOG = 0,
CELL_ADEC_AC3_COMPRESSION_MODE_CUSTOM_DIGITAL = 1,
CELL_ADEC_AC3_COMPRESSION_MODE_LINE_OUT = 2,
CELL_ADEC_AC3_COMPRESSION_MODE_RF_REMOD = 3,
};
enum AC3_StereoMode : u8
{
CELL_ADEC_AC3_STEREO_MODE_AUTO_DETECT = 0,
CELL_ADEC_AC3_STEREO_MODE_DOLBY_SURROUND_COMPATIBLE = 1,
CELL_ADEC_AC3_STEREO_MODE_STEREO = 2,
};
enum AC3_DualmonoMode : u8
{
CELL_ADEC_AC3_DUALMONO_MODE_STEREO = 0,
CELL_ADEC_AC3_DUALMONO_MODE_LEFT_MONO = 1,
CELL_ADEC_AC3_DUALMONO_MODE_RIGHT_MONO = 2,
CELL_ADEC_AC3_DUALMONO_MODE_MIXED_MONO = 3,
};
enum AC3_KaraokeCapableMode : u8
{
CELL_ADEC_AC3_KARAOKE_CAPABLE_MODE_NO_VOCAL = 0,
CELL_ADEC_AC3_KARAOKE_CAPABLE_MODE_LEFT_VOCAL = 1,
CELL_ADEC_AC3_KARAOKE_CAPABLE_MODE_RIGHT_VOCAL = 2,
CELL_ADEC_AC3_KARAOKE_CAPABLE_MODE_BOTH_VOCAL = 3,
};
enum AC3_InputChannel : u8
{
CELL_ADEC_AC3_INPUT_CHANNEL_L = 0,
CELL_ADEC_AC3_INPUT_CHANNEL_C = 1,
CELL_ADEC_AC3_INPUT_CHANNEL_R = 2,
CELL_ADEC_AC3_INPUT_CHANNEL_l = 3,
CELL_ADEC_AC3_INPUT_CHANNEL_r = 4,
CELL_ADEC_AC3_INPUT_CHANNEL_s = 5,
};
struct CellAdecParamAc3
{
AC3_WordSize wordSize;
AC3_OutputMode outputMode;
AC3_LFE outLfeOn;
be_t<float> drcCutScaleFactor;
be_t<float> drcBoostScaleFactor;
AC3_CompressionMode compressionMode;
AC3_InputChannel numberOfChannels;
AC3_StereoMode stereoMode;
AC3_DualmonoMode dualmonoMode;
AC3_KaraokeCapableMode karaokeCapableMode;
be_t<float> pcmScaleFactor;
be_t<s32> channelPointer0;
be_t<s32> channelPointer1;
be_t<s32> channelPointer2;
be_t<s32> channelPointer3;
be_t<s32> channelPointer4;
be_t<s32> channelPointer5;
};
struct CellAdecBsiAc3
{
be_t<u32> codecType;
be_t<u32> versionInfo;
be_t<u32> totalCallCarryRun;
be_t<u32> totalCallNum;
be_t<u32> bitrateValue;
be_t<u32> pcmSize;
be_t<u32> esSizeBit;
be_t<s32> errorCode;
u8 libInfoFlag;
u8 validity;
u8 channelValue;
u8 fsIndex;
u8 outputQuantization;
u8 outputChannel;
u8 monoFlag;
be_t<u32> bsi[2];
be_t<u16> frmSizeCod;
u8 acmod;
u8 lfeOn;
u8 karaokeMode;
u8 cmixlev;
u8 surmixlev;
u8 dsurmod;
u8 copyright;
u8 original;
u8 bsmod;
u8 bsid;
u8 xbsi1e;
u8 dmixmod;
u8 xbsi2e;
u8 dsurexmod;
u8 dheadphonmod;
u8 adconvtyp;
u8 crcErrorFlag;
u8 execDmixType;
};
enum ATRAC3_WordSize : s32
{
CELL_ADEC_ATRAC3_WORD_SZ_16BIT = 0x02,
CELL_ADEC_ATRAC3_WORD_SZ_24BIT = 0x03,
CELL_ADEC_ATRAC3_WORD_SZ_32BIT = 0x04,
CELL_ADEC_ATRAC3_WORD_SZ_FLOAT = 0x84,
};
enum ATRAC3_JointType : s32
{
ATRAC3_DUAL_STEREO = 0,
ATRAC3_JOINT_STEREO = 1,
};
struct CellAdecParamAtrac3
{
be_t<s32> nch; // channel count
be_t<s32> isJoint; // ATRAC3_JointType
be_t<s32> nbytes; // byte count of single AU (???)
be_t<s32> bw_pcm; // ATRAC3_WordSize, bit length of output PCM sample
};
struct CellAdecAtrac3Info
{
be_t<s32> nch;
be_t<s32> isJoint; // ATRAC3_JointType
be_t<s32> nbytes;
};
enum MP3_WordSize : s32
{
CELL_ADEC_MP3_WORD_SZ_16BIT = 3,
CELL_ADEC_MP3_WORD_SZ_FLOAT = 4,
};
enum MP3_ChannelMode : u8
{
MP3_STEREO = 0,
MP3_JOINT_STEREO = 1,
MP3_DUAL = 2,
MP3_MONO = 3,
};
enum MP3_CRCMode : u8
{
MP3_CRC = 0,
MP3_NO_CRC = 1,
};
struct CellAdecParamMP3
{
be_t<s32> bw_pcm; // MP3_WordSize
};
struct CellAdecMP3Info
{
be_t<u32> ui_header;
be_t<u32> ui_main_data_begin;
be_t<u32> ui_main_data_remain_size;
be_t<u32> ui_main_data_now_size;
MP3_CRCMode uc_crc;
MP3_ChannelMode uc_mode;
u8 uc_mode_extension;
u8 uc_copyright;
u8 uc_original;
u8 uc_emphasis;
u8 uc_crc_error_flag;
be_t<s32> i_error_code;
};
enum M2BC_SampleFrequency : s32
{
CELL_ADEC_BSI_M2BC_SAMPLE_FREQUENCY_44 = 0,
CELL_ADEC_BSI_M2BC_SAMPLE_FREQUENCY_48 = 1,
CELL_ADEC_BSI_M2BC_SAMPLE_FREQUENCY_32 = 2,
};
enum M2BC_ErrorProtection : s32
{
CELL_ADEC_BSI_M2BC_ERROR_PROTECTION_NONE = 0,
CELL_ADEC_BSI_M2BC_ERROR_PROTECTION_EXIST = 1,
};
enum M2BC_BitrateIndex : s32
{
CELL_ADEC_BSI_M2BC_BITRATE_32 = 1,
CELL_ADEC_BSI_M2BC_BITRATE_48 = 2,
CELL_ADEC_BSI_M2BC_BITRATE_56 = 3,
CELL_ADEC_BSI_M2BC_BITRATE_64 = 4,
CELL_ADEC_BSI_M2BC_BITRATE_80 = 5,
CELL_ADEC_BSI_M2BC_BITRATE_96 = 6,
CELL_ADEC_BSI_M2BC_BITRATE_112 = 7,
CELL_ADEC_BSI_M2BC_BITRATE_128 = 8,
CELL_ADEC_BSI_M2BC_BITRATE_160 = 9,
CELL_ADEC_BSI_M2BC_BITRATE_192 = 10,
CELL_ADEC_BSI_M2BC_BITRATE_224 = 11,
CELL_ADEC_BSI_M2BC_BITRATE_256 = 12,
CELL_ADEC_BSI_M2BC_BITRATE_320 = 13,
CELL_ADEC_BSI_M2BC_BITRATE_384 = 14,
};
enum M2BC_StereoMode : s32
{
CELL_ADEC_BSI_M2BC_STEREO_MODE_STERO = 0,
CELL_ADEC_BSI_M2BC_STEREO_MODE_JOINTSTERO = 1,
CELL_ADEC_BSI_M2BC_STEREO_MODE_DUAL = 2,
CELL_ADEC_BSI_M2BC_STEREO_MODE_MONO = 3,
};
enum M2BC_StereoModeEx : s32
{
CELL_ADEC_BSI_M2BC_STEREO_EXMODE_0 = 0,
CELL_ADEC_BSI_M2BC_STEREO_EXMODE_1 = 1,
CELL_ADEC_BSI_M2BC_STEREO_EXMODE_2 = 2,
CELL_ADEC_BSI_M2BC_STEREO_EXMODE_3 = 3,
};
enum M2BC_Emphasis : s32
{
CELL_ADEC_BSI_M2BC_EMPHASIS_NONE = 0,
CELL_ADEC_BSI_M2BC_EMPHASIS_50_15 = 1,
CELL_ADEC_BSI_M2BC_EMPHASIS_CCITT = 3,
};
enum M2BC_CopyrightBit : s32
{
CELL_ADEC_BSI_M2BC_COPYRIGHT_NONE = 0,
CELL_ADEC_BSI_M2BC_COPYRIGHT_ON = 1,
};
enum M2BC_OriginalBit : s32
{
CELL_ADEC_BSI_M2BC_ORIGINAL_COPY = 0,
CELL_ADEC_BSI_M2BC_ORIGINAL_ORIGINAL = 1,
};
enum M2BC_SurroundMode : s32
{
CELL_ADEC_BSI_M2BC_SURROUND_NONE = 0,
CELL_ADEC_BSI_M2BC_SURROUND_MONO = 1,
CELL_ADEC_BSI_M2BC_SURROUND_STEREO = 2,
CELL_ADEC_BSI_M2BC_SURROUND_SECOND = 3,
};
enum M2BC_CenterMode : s32
{
CELL_ADEC_BSI_M2BC_CENTER_NONE = 0,
CELL_ADEC_BSI_M2BC_CENTER_EXIST = 1,
CELL_ADEC_BSI_M2BC_CENTER_PHANTOM = 3,
};
enum M2BC_LFE : s32
{
CELL_ADEC_BSI_M2BC_LFE_NONE = 0,
CELL_ADEC_BSI_M2BC_LFE_EXIST = 1,
};
enum M2BC_AudioMixMode : s32
{
CELL_ADEC_BSI_M2BC_AUDIOMIX_LARGE = 0,
CELL_ADEC_BSI_M2BC_AUDIOMIX_SMALLE = 1,
};
enum M2BC_MCExtension : s32
{
CELL_ADEC_BSI_M2BC_MCEXTENSION_2CH = 0,
CELL_ADEC_BSI_M2BC_MCEXTENSION_5CH = 1,
CELL_ADEC_BSI_M2BC_MCEXTENSION_7CH = 2,
};
enum M2BC_ChannelConfig : s32
{
CELL_ADEC_BSI_M2BC_CH_CONFIG_MONO = 0,
CELL_ADEC_BSI_M2BC_CH_CONFIG_DUAL = 1,
CELL_ADEC_BSI_M2BC_CH_CONFIG_L_R = 2,
CELL_ADEC_BSI_M2BC_CH_CONFIG_L_R_S = 3,
CELL_ADEC_BSI_M2BC_CH_CONFIG_L_R_C = 4,
CELL_ADEC_BSI_M2BC_CH_CONFIG_L_R_LS_RS = 5,
CELL_ADEC_BSI_M2BC_CH_CONFIG_L_R_C_S = 6,
CELL_ADEC_BSI_M2BC_CH_CONFIG_L_R_C_LS_RS = 7,
CELL_ADEC_BSI_M2BC_CH_CONFIG_LL_RR_CC_LS_RS_LC_RC = 8,
CELL_ADEC_BSI_M2BC_CH_CONFIG_MONO_SECONDSTEREO = 9,
CELL_ADEC_BSI_M2BC_CH_CONFIG_L_R_SECONDSTEREO = 10,
CELL_ADEC_BSI_M2BC_CH_CONFIG_L_R_C_SECONDSTEREO = 11,
};
struct CellAdecParamMpmc
{
be_t<u32> channelNumber;
be_t<u32> downmix;
be_t<u32> lfeUpSample;
};
struct CellAdecMpmcInfo
{
be_t<u32> channelNumber;
be_t<u32> sampleFreq;
be_t<u32> errorPprotection;
be_t<u32> bitrateIndex;
be_t<u32> stereoMode;
be_t<u32> stereoModeEextention;
be_t<u32> emphasis;
be_t<u32> copyright;
be_t<u32> original;
be_t<u32> surroundMode;
be_t<u32> centerMode;
be_t<u32> audioMmix;
be_t<u32> outputFramSize;
be_t<u32> multiCodecMode;
be_t<u32> lfePresent;
be_t<u32> channelCoufiguration;
};
/* Audio Decoder Thread Classes */
enum AdecJobType : u32
{
adecStartSeq,
adecEndSeq,
adecDecodeAu,
adecClose,
};
struct AdecTask
{
AdecJobType type;
union
{
struct
{
u32 auInfo_addr;
u32 addr;
u32 size;
u64 pts;
u64 userdata;
} au;
struct
{
s32 sample_rate;
s32 channel_config;
s32 channels;
s32 frame_size;
std::array<u8, 4> extra_config;
s32 output;
u8 downmix;
u8 ats_header;
} at3p;
};
AdecTask(AdecJobType type)
: type(type)
{
}
AdecTask()
{
}
};
struct AdecFrame
{
struct AVFrame* data;
u64 pts;
u64 userdata;
u32 auAddr;
u32 auSize;
u32 size;
};
int adecRead(void* opaque, u8* buf, int buf_size);
static const u32 at3freq[8] = { 32000, 44100, 48000, 88200, 96000, 0, 0, 0 };
struct OMAHeader // OMA Header
{
u32 magic; // 0x01334145
u16 size; // 96 << 8
u16 unk0; // 0xffff
u64 unk1; // 0x00500f0100000000ULL
u64 unk2; // 0xcef5000000000400ULL
u64 unk3; // 0x1c458024329192d2ULL
u8 codecId; // 1 for ATRAC3P
u8 code0; // 0
u8 code1;
u8 code2;
u32 reserved[15]; // 0
OMAHeader(u8 codec_id, u32 freq, u8 channel_count, u32 frame_size)
: magic(0x01334145)
, size(96 << 8)
, unk0(0xffff)
, unk1(0x00500f0100000000ULL)
, unk2(0xcef5000000000400ULL)
, unk3(0x1c458024329192d2ULL)
, codecId(codec_id)
, code0(0)
{
memset(reserved, 0, sizeof(reserved));
u8 freq_code;
for (freq_code = 0; freq_code < 5; freq_code++)
{
if (at3freq[freq_code] == freq)
{
break;
}
}
u32 prepared_frame_size = (frame_size - 8) / 8;
code1 = ((prepared_frame_size >> 8) & 0x3) | ((channel_count & 0x7) << 2) | (freq_code << 5);
code2 = prepared_frame_size & 0xff;
}
};
CHECK_SIZE(OMAHeader, 96);
| 30,637
|
C++
|
.h
| 1,002
| 28.576846
| 209
| 0.70242
|
RPCS3/rpcs3
| 15,204
| 1,895
| 1,021
|
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.