mirrors/rpcs3
1
0
Fork 0
mirror of https://github.com/RPCS3/rpcs3.git synced 2025-04-20 03:25:16 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 2

be_t constructor implemented, make() eliminated

Browse source 
be_t enums are forbidden, le_t improved, some operators cleaned.
This commit is contained in:
Nekotekina 2015-06-24 14:53:47 +03:00
parent a800d21a31
commit ef6f9f6ded
47 changed files with 917 additions and 1046 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

350
Utilities/BEType.h
View file

@ -1,6 +1,6 @@
#pragma once
#define IS_LE_MACHINE
#define IS_LE_MACHINE // only draft
union u128
{
@ -334,26 +334,6 @@ union u128
return (_u64[0] != right._u64[0]) || (_u64[1] != right._u64[1]);
}
force_inline u128 operator | (const u128& right) const
{
return fromV(_mm_or_si128(vi, right.vi));
}
force_inline u128 operator & (const u128& right) const
{
return fromV(_mm_and_si128(vi, right.vi));
}
force_inline u128 operator ^ (const u128& right) const
{
return fromV(_mm_xor_si128(vi, right.vi));
}
u128 operator ~ () const
{
return from64(~_u64[0], ~_u64[1]);
}
force_inline bool is_any_1() const // check if any bit is 1
{
return _u64[0] || _u64[1];
@ -381,15 +361,32 @@ union u128
static force_inline u128 byteswap(const u128 val)
{
u128 ret;
ret._u64[0] = _byteswap_uint64(val._u64[1]);
ret._u64[1] = _byteswap_uint64(val._u64[0]);
return ret;
return fromV(_mm_shuffle_epi8(val.vi, _mm_set_epi8(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15)));
}
};
CHECK_SIZE_ALIGN(u128, 16, 16);
inline u128 operator |(const u128& left, const u128& right)
{
return u128::fromV(_mm_or_si128(left.vi, right.vi));
}
inline u128 operator &(const u128& left, const u128& right)
{
return u128::fromV(_mm_and_si128(left.vi, right.vi));
}
inline u128 operator ^(const u128& left, const u128& right)
{
return u128::fromV(_mm_xor_si128(left.vi, right.vi));
}
inline u128 operator ~(const u128& other)
{
return u128::from64(~other._u64[0], ~other._u64[1]);
}
static force_inline u128 sync_val_compare_and_swap(volatile u128* dest, u128 comp, u128 exch)
{
#if !defined(_MSC_VER)
@ -583,22 +580,8 @@ template<typename T> struct be_storage<T, 16>
template<typename T> using be_storage_t = typename be_storage<T>::type;
template<typename T>
struct be_t
template<typename T> class be_t
{
using type = std::remove_cv_t<T>;
using stype = be_storage_t<std::remove_cv_t<T>>;
stype m_data;
static_assert(!std::is_class<type>::value, "be_t<> error: invalid type (class or structure)");
static_assert(!std::is_union<type>::value || std::is_same<type, u128>::value, "be_t<> error: invalid type (union)");
static_assert(!std::is_pointer<type>::value, "be_t<> error: invalid type (pointer)");
static_assert(!std::is_reference<type>::value, "be_t<> error: invalid type (reference)");
static_assert(!std::is_array<type>::value, "be_t<> error: invalid type (array)");
static_assert(__alignof(type) == __alignof(stype), "be_t<> error: unexpected alignment");
private:
template<typename Tto, typename Tfrom, int mode>
struct _convert
{
@ -624,69 +607,63 @@ private:
{
static force_inline be_t<Tto>& func(Tfrom& be_value)
{
Tto res = be_value >> ((sizeof(Tfrom)-sizeof(Tto)) * 8);
Tto res = be_value >> ((sizeof(Tfrom) - sizeof(Tto)) * 8);
return (be_t<Tto>&)res;
}
};
const stype& ToBE() const
{
return m_data;
}
type ToLE() const
{
return se_t<type, sizeof(stype)>::from_be(m_data);
}
void FromBE(const stype& value)
{
m_data = value;
}
void FromLE(const type& value)
{
m_data = se_t<type, sizeof(stype)>::to_be(value);
}
static be_t MakeFromLE(const type& value)
{
stype data = se_t<type, sizeof(stype)>::to_be(value);
return (be_t&)data;
}
static be_t MakeFromBE(const stype& value)
{
return (be_t&)value;
}
public:
//make be_t from current machine byte ordering
static be_t make(const type& value)
{
using type = std::remove_cv_t<T>;
using stype = be_storage_t<std::remove_cv_t<T>>;
#ifdef IS_LE_MACHINE
return MakeFromLE(value);
stype m_data;
#else
return MakeFromBE(value);
type m_data;
#endif
static_assert(!std::is_class<type>::value, "be_t<> error: invalid type (class or structure)");
static_assert(!std::is_union<type>::value || std::is_same<type, u128>::value, "be_t<> error: invalid type (union)");
static_assert(!std::is_pointer<type>::value, "be_t<> error: invalid type (pointer)");
static_assert(!std::is_reference<type>::value, "be_t<> error: invalid type (reference)");
static_assert(!std::is_array<type>::value, "be_t<> error: invalid type (array)");
static_assert(!std::is_enum<type>::value, "be_t<> error: invalid type (enumeration), use integral type instead");
static_assert(__alignof(type) == __alignof(stype), "be_t<> error: unexpected alignment");
be_t() = default;
be_t(const be_t&) = default;
template<typename CT, typename = std::enable_if_t<std::is_constructible<type, CT>::value>> be_t(const CT& value)
#ifdef IS_LE_MACHINE
: m_data(se_t<type, sizeof(stype)>::to_be(value))
#else
: m_data(value)
#endif
{
}
//get value in current machine byte ordering
// get value in current machine byte ordering
force_inline type value() const
{
#ifdef IS_LE_MACHINE
return ToLE();
return se_t<type, sizeof(stype)>::from_be(m_data);
#else
return ToBE();
return m_data;
#endif
}
// get underlying data without any byte order manipulation
const stype& data() const
{
return ToBE();
#ifdef IS_LE_MACHINE
return m_data;
#else
return reinterpret_cast<const stype&>(m_data);
#endif
}
be_t& operator =(const be_t& value) = default;
be_t& operator =(const be_t&) = default;
template<typename CT> std::enable_if_t<std::is_assignable<type&, CT>::value, be_t&> operator =(const CT& value)
{
@ -695,7 +672,7 @@ public:
return *this;
}
//template<typename CT, std::enable_if_t<std::is_convertible<type, CT>::value>> operator CT() const
//template<typename CT, typename = std::enable_if_t<std::is_convertible<type, CT>::value>> operator CT() const
//{
// return value();
//}
@ -708,56 +685,69 @@ public:
// conversion to another be_t type
template<typename T1> operator be_t<T1>() const
{
return be_t<T1>::make(value());
return value();
// TODO (complicated cases like int-float conversions are not handled correctly)
//return _convert<T1, T, ((sizeof(T1) > sizeof(T)) ? 1 : (sizeof(T1) < sizeof(T) ? 2 : 0))>::func(m_data);
}
template<typename T1> be_t& operator += (T1 right) { return *this = value() + right; }
template<typename T1> be_t& operator -= (T1 right) { return *this = value() - right; }
template<typename T1> be_t& operator *= (T1 right) { return *this = value() * right; }
template<typename T1> be_t& operator /= (T1 right) { return *this = value() / right; }
template<typename T1> be_t& operator %= (T1 right) { return *this = value() % right; }
template<typename T1> be_t& operator &= (T1 right) { return *this = value() & right; }
template<typename T1> be_t& operator |= (T1 right) { return *this = value() | right; }
template<typename T1> be_t& operator ^= (T1 right) { return *this = value() ^ right; }
template<typename T1> be_t& operator <<= (T1 right) { return *this = value() << right; }
template<typename T1> be_t& operator >>= (T1 right) { return *this = value() >> right; }
template<typename T1> be_t& operator +=(const T1& right) { return *this = value() + right; }
template<typename T1> be_t& operator -=(const T1& right) { return *this = value() - right; }
template<typename T1> be_t& operator *=(const T1& right) { return *this = value() * right; }
template<typename T1> be_t& operator /=(const T1& right) { return *this = value() / right; }
template<typename T1> be_t& operator %=(const T1& right) { return *this = value() % right; }
template<typename T1> be_t& operator += (const be_t<T1>& right) { return *this = ToLE() + right.ToLE(); }
template<typename T1> be_t& operator -= (const be_t<T1>& right) { return *this = ToLE() - right.ToLE(); }
template<typename T1> be_t& operator *= (const be_t<T1>& right) { return *this = ToLE() * right.ToLE(); }
template<typename T1> be_t& operator /= (const be_t<T1>& right) { return *this = ToLE() / right.ToLE(); }
template<typename T1> be_t& operator %= (const be_t<T1>& right) { return *this = ToLE() % right.ToLE(); }
template<typename T1> be_t& operator &= (const be_t<T1>& right) { return *this = ToBE() & right.ToBE(); }
template<typename T1> be_t& operator |= (const be_t<T1>& right) { return *this = ToBE() | right.ToBE(); }
template<typename T1> be_t& operator ^= (const be_t<T1>& right) { return *this = ToBE() ^ right.ToBE(); }
template<typename T1> be_t& operator <<=(const T1& right) { return *this = value() << right; }
template<typename T1> be_t& operator >>=(const T1& right) { return *this = value() >> right; }
template<typename T1> be_t operator & (const be_t<T1>& right) const { be_t res; res.FromBE(ToBE() & right.ToBE()); return res; }
template<typename T1> be_t operator | (const be_t<T1>& right) const { be_t res; res.FromBE(ToBE() | right.ToBE()); return res; }
template<typename T1> be_t operator ^ (const be_t<T1>& right) const { be_t res; res.FromBE(ToBE() ^ right.ToBE()); return res; }
template<typename T1> be_t& operator &=(const T1& right) { return m_data &= be_t(right).data(), *this; }
template<typename T1> be_t& operator |=(const T1& right) { return m_data |= be_t(right).data(), *this; }
template<typename T1> be_t& operator ^=(const T1& right) { return m_data ^= be_t(right).data(), *this; }
template<typename T1> bool operator == (T1 right) const { return (T1)ToLE() == right; }
template<typename T1> bool operator != (T1 right) const { return !(*this == right); }
template<typename T1> bool operator > (T1 right) const { return (T1)ToLE() > right; }
template<typename T1> bool operator < (T1 right) const { return (T1)ToLE() < right; }
template<typename T1> bool operator >= (T1 right) const { return (T1)ToLE() >= right; }
template<typename T1> bool operator <= (T1 right) const { return (T1)ToLE() <= right; }
template<typename T1> bool operator == (const be_t<T1>& right) const { return ToBE() == right.ToBE(); }
template<typename T1> bool operator != (const be_t<T1>& right) const { return !(*this == right); }
template<typename T1> bool operator > (const be_t<T1>& right) const { return (T1)ToLE() > right.ToLE(); }
template<typename T1> bool operator < (const be_t<T1>& right) const { return (T1)ToLE() < right.ToLE(); }
template<typename T1> bool operator >= (const be_t<T1>& right) const { return (T1)ToLE() >= right.ToLE(); }
template<typename T1> bool operator <= (const be_t<T1>& right) const { return (T1)ToLE() <= right.ToLE(); }
be_t operator++ (int) { be_t res = *this; *this += 1; return res; }
be_t operator-- (int) { be_t res = *this; *this -= 1; return res; }
be_t& operator++ () { *this += 1; return *this; }
be_t& operator-- () { *this -= 1; return *this; }
be_t operator ++(int) { be_t res = *this; *this += 1; return res; }
be_t operator --(int) { be_t res = *this; *this -= 1; return res; }
be_t& operator ++() { *this += 1; return *this; }
be_t& operator --() { *this -= 1; return *this; }
};
template<typename T1, typename T2> inline std::enable_if_t<std::is_same<T1, T2>::value, bool> operator ==(const be_t<T1>& left, const be_t<T2>& right)
{
return left.data() == right.data();
}
template<typename T1, typename T2> inline std::enable_if_t<std::is_same<T1, T2>::value, bool> operator !=(const be_t<T1>& left, const be_t<T2>& right)
{
return left.data() != right.data();
}
template<typename T1, typename T2> inline std::enable_if_t<std::is_same<T1, T2>::value, be_t<T1>> operator &(const be_t<T1>& left, const be_t<T2>& right)
{
be_t<T1> result;
result.m_data = left.data() & right.data();
return result;
}
template<typename T1, typename T2> inline std::enable_if_t<std::is_same<T1, T2>::value, be_t<T1>> operator |(const be_t<T1>& left, const be_t<T2>& right)
{
be_t<T1> result;
result.m_data = left.data() | right.data();
return result;
}
template<typename T1, typename T2> inline std::enable_if_t<std::is_same<T1, T2>::value, be_t<T1>> operator ^(const be_t<T1>& left, const be_t<T2>& right)
{
be_t<T1> result;
result.m_data = left.data() ^ right.data();
return result;
}
template<typename T1> inline std::enable_if_t<true, be_t<T1>> operator ~(const be_t<T1>& other)
{
be_t<T1> result;
result.m_data = ~other.data();
return result;
}
template<typename T> struct is_be_t : public std::integral_constant<bool, false>
{
};
@ -804,95 +794,79 @@ template<> struct to_be<s8> { using type = s8; };
template<typename T, typename T1, T1 value> struct _se : public const_se_t<T, value> {};
template<typename T, typename T1, T1 value> struct _se<be_t<T>, T1, value> : public const_se_t<T, value> {};
//#define se(t, x) _se<decltype(t), decltype(x), x>::value
#define se16(x) _se<u16, decltype(x), x>::value
#define se32(x) _se<u32, decltype(x), x>::value
#define se64(x) _se<u64, decltype(x), x>::value
template<typename Tto, typename Tfrom>
struct convert_le_be_t
{
static Tto func(Tfrom value)
{
return (Tto)value;
}
};
template<typename Tt, typename Tfrom>
struct convert_le_be_t<be_t<Tt>, Tfrom>
{
static be_t<Tt> func(Tfrom value)
{
return be_t<Tt>::make(value);
}
};
template<typename Tt, typename Tf>
struct convert_le_be_t<be_t<Tt>, be_t<Tf>>
{
static be_t<Tt> func(be_t<Tf> value)
{
return value;
}
};
template<typename Tto, typename Tf>
struct convert_le_be_t<Tto, be_t<Tf>>
{
static Tto func(be_t<Tf> value)
{
return value.value();
}
};
template<typename Tto, typename Tfrom>
force_inline Tto convert_le_be(Tfrom value)
{
return convert_le_be_t<Tto, Tfrom>::func(value);
}
template<typename Tto, typename Tfrom>
force_inline void convert_le_be(Tto& dst, Tfrom src)
{
dst = convert_le_be_t<Tto, Tfrom>::func(src);
}
template<typename T> struct le_t
template<typename T> class le_t
{
public:
using type = std::remove_cv_t<T>;
using stype = be_storage_t<std::remove_cv_t<T>>;
stype m_data;
type m_data;
static_assert(!std::is_class<type>::value, "le_t<> error: invalid type (class or structure)");
static_assert(!std::is_union<type>::value || std::is_same<type, u128>::value, "le_t<> error: invalid type (union)");
static_assert(!std::is_pointer<type>::value, "le_t<> error: invalid type (pointer)");
static_assert(!std::is_reference<type>::value, "le_t<> error: invalid type (reference)");
static_assert(!std::is_array<type>::value, "le_t<> error: invalid type (array)");
static_assert(!std::is_enum<type>::value, "le_t<> error: invalid type (enumeration), use integral type instead");
static_assert(__alignof(type) == __alignof(stype), "le_t<> error: unexpected alignment");
le_t() = default;
le_t(const le_t&) = default;
template<typename CT, typename = std::enable_if_t<std::is_constructible<type, CT>::value>> le_t(const CT& value)
: m_data(value)
{
}
type value() const
{
return reinterpret_cast<const type&>(m_data);
return m_data;
}
const stype& data() const
{
return reinterpret_cast<const stype&>(m_data);
}
le_t& operator =(const le_t& value) = default;
template<typename CT> std::enable_if_t<std::is_assignable<type&, CT>::value, le_t&> operator =(const CT& value)
{
m_data = reinterpret_cast<const stype&>(value);
m_data = value;
return *this;
}
//template<typename CT> operator std::enable_if_t<std::is_convertible<type, CT>::value, CT>() const
//{
// return value();
//}
operator type() const
{
return value();
}
// conversion to another le_t type
//template<typename T1> operator const le_t<T1>() const
//{
// return le_t<T1>::make(value());
//}
template<typename T1> operator le_t<T1>() const
{
return value();
}
template<typename T1> le_t& operator +=(const T1& right) { return *this = value() + right; }
template<typename T1> le_t& operator -=(const T1& right) { return *this = value() - right; }
template<typename T1> le_t& operator *=(const T1& right) { return *this = value() * right; }
template<typename T1> le_t& operator /=(const T1& right) { return *this = value() / right; }
template<typename T1> le_t& operator %=(const T1& right) { return *this = value() % right; }
template<typename T1> le_t& operator <<=(const T1& right) { return *this = value() << right; }
template<typename T1> le_t& operator >>=(const T1& right) { return *this = value() >> right; }
template<typename T1> le_t& operator &=(const T1& right) { return m_data &= le_t(right).data(), *this; }
template<typename T1> le_t& operator |=(const T1& right) { return m_data |= le_t(right).data(), *this; }
template<typename T1> le_t& operator ^=(const T1& right) { return m_data ^= le_t(right).data(), *this; }
le_t operator ++(int) { le_t res = *this; *this += 1; return res; }
le_t operator --(int) { le_t res = *this; *this -= 1; return res; }
le_t& operator ++() { *this += 1; return *this; }
le_t& operator --() { *this -= 1; return *this; }
};
template<typename T> struct is_le_t : public std::integral_constant<bool, false>

6
Utilities/Thread.cpp
View file

@ -1060,9 +1060,9 @@ bool handle_access_violation(u32 addr, bool is_writing, x64_context* context)
switch (d_size)
{
case 1: value = vm::priv_ref<atomic<u8>>(addr) &= value; break;
case 2: value = vm::priv_ref<atomic<u16>>(addr) &= value; break;
case 4: value = vm::priv_ref<atomic<u32>>(addr) &= value; break;
case 1: value = vm::priv_ref<atomic<u8>>(addr) &= static_cast<u8>(value); break;
case 2: value = vm::priv_ref<atomic<u16>>(addr) &= static_cast<u16>(value); break;
case 4: value = vm::priv_ref<atomic<u32>>(addr) &= static_cast<u32>(value); break;
case 8: value = vm::priv_ref<atomic<u64>>(addr) &= value; break;
default: return false;
}

4
rpcs3/Crypto/unself.cpp
View file

@ -935,9 +935,9 @@ bool SELFDecrypter::DecryptNPDRM(u8 *metadata, u32 metadata_size)
bool SELFDecrypter::LoadMetadata()
{
aes_context aes;
u32 metadata_info_size = sizeof(meta_info);
u32 metadata_info_size = sizeof32(meta_info);
u8 *metadata_info = (u8 *)malloc(metadata_info_size);
u32 metadata_headers_size = sce_hdr.se_hsize - (sizeof(sce_hdr) + sce_hdr.se_meta + sizeof(meta_info));
u32 metadata_headers_size = sce_hdr.se_hsize - (sizeof32(sce_hdr) + sce_hdr.se_meta + sizeof32(meta_info));
u8 *metadata_headers = (u8 *)malloc(metadata_headers_size);
// Locate and read the encrypted metadata info.

2
rpcs3/Emu/ARMv7/ARMv7Decoder.cpp
View file

@ -1280,7 +1280,7 @@ void armv7_decoder_initialize(u32 addr, u32 end_addr, bool dump)
const u32 i2 = (code.data >> 11) & 0x1 ^ s ^ 1;
const u32 target = (addr + 4 & ~3) + sign<25, u32>(s << 24 | i2 << 23 | i1 << 22 | (code.data & 0x3ff0000) >> 4 | (code.data & 0x7ff) << 1);
const u32 instr = vm::check_addr(target, 4) ? vm::psv::read32(target) : 0;
const u32 instr = vm::check_addr(target, 4) ? vm::psv::read32(target).value() : 0;
// possibly a call to imported function:
if (target >= end_addr && ((target - end_addr) % 16) == 0 && (instr & 0xfff000f0) == 0xe0700090)

25
rpcs3/Emu/ARMv7/Modules/sceFiber.h
View file

@ -2,35 +2,28 @@
using SceFiberEntry = func_def<void(u32 argOnInitialize, u32 argOnRun)>;
struct SceFiber
struct set_alignment(8) SceFiber
{
le_t<u64> padding[16];
};
CHECK_SIZE_ALIGN(SceFiber, 128, 8);
struct SceFiberOptParam
struct set_alignment(8) SceFiberOptParam
{
le_t<u64> padding[16];
};
CHECK_SIZE_ALIGN(SceFiberOptParam, 128, 8);
struct SceFiberInfo
struct set_alignment(8) SceFiberInfo
{
union
{
le_t<u64> padding[16];
struct
{
vm::lptr<SceFiberEntry> entry;
le_t<u32> argOnInitialize;
vm::lptr<void> addrContext;
le_t<s32> sizeContext;
char name[32];
};
};
vm::lptr<SceFiberEntry> entry;
le_t<u32> argOnInitialize;
vm::lptr<void> addrContext;
le_t<s32> sizeContext;
char name[32];
u8 padding[80];
};
CHECK_SIZE_ALIGN(SceFiberInfo, 128, 8);

3
rpcs3/Emu/ARMv7/Modules/sceLibKernel.h
View file

@ -271,7 +271,8 @@ union SceKernelSysClock
{
le_t<u32> low;
le_t<u32> hi;
};
}
u;
le_t<u64> quad;
};

6
rpcs3/Emu/ARMv7/Modules/sceLocation.cpp
View file

@ -19,7 +19,7 @@ s32 sceLocationReopen(u8 handle, SceLocationLocationMethod lmethod, SceLocationH
throw __FUNCTION__;
}
s32 sceLocationGetMethod(u8 handle, vm::ptr<SceLocationLocationMethod> lmethod, vm::ptr<SceLocationHeadingMethod> hmethod)
s32 sceLocationGetMethod(u8 handle, vm::ptr<s32> lmethod, vm::ptr<s32> hmethod)
{
throw __FUNCTION__;
}
@ -64,12 +64,12 @@ s32 sceLocationConfirm(u8 handle)
throw __FUNCTION__;
}
s32 sceLocationConfirmGetStatus(u8 handle, vm::ptr<SceLocationDialogStatus> status)
s32 sceLocationConfirmGetStatus(u8 handle, vm::ptr<s32> status)
{
throw __FUNCTION__;
}
s32 sceLocationConfirmGetResult(u8 handle, vm::ptr<SceLocationDialogResult> result)
s32 sceLocationConfirmGetResult(u8 handle, vm::ptr<s32> result)
{
throw __FUNCTION__;
}

2
rpcs3/Emu/ARMv7/Modules/sceNpBasic.cpp
View file

@ -29,7 +29,7 @@ s32 sceNpBasicCheckCallback()
throw __FUNCTION__;
}
s32 sceNpBasicGetFriendOnlineStatus(vm::cptr<SceNpId> friendId, vm::ptr<SceNpBasicFriendOnlineStatus> status)
s32 sceNpBasicGetFriendOnlineStatus(vm::cptr<SceNpId> friendId, vm::ptr<s32> status)
{
throw __FUNCTION__;
}

2
rpcs3/Emu/ARMv7/Modules/sceNpManager.cpp
View file

@ -19,7 +19,7 @@ s32 sceNpCheckCallback()
throw __FUNCTION__;
}
s32 sceNpGetServiceState(vm::ptr<SceNpServiceState> state)
s32 sceNpGetServiceState(vm::ptr<s32> state)
{
throw __FUNCTION__;
}

4
rpcs3/Emu/Cell/PPUInterpreter.cpp
View file

@ -2080,7 +2080,7 @@ void ppu_interpreter::STWCX_(PPUThread& CPU, ppu_opcode_t op)
{
const u64 addr = op.ra ? CPU.GPR[op.ra] + CPU.GPR[op.rb] : CPU.GPR[op.rb];
const be_t<u32> value = be_t<u32>::make((u32)CPU.GPR[op.rs]);
const be_t<u32> value = (u32)CPU.GPR[op.rs];
CPU.SetCR_EQ(0, vm::reservation_update(vm::cast(addr), &value, sizeof(value)));
}
@ -2140,7 +2140,7 @@ void ppu_interpreter::STDCX_(PPUThread& CPU, ppu_opcode_t op)
{
const u64 addr = op.ra ? CPU.GPR[op.ra] + CPU.GPR[op.rb] : CPU.GPR[op.rb];
const be_t<u64> value = be_t<u64>::make(CPU.GPR[op.rs]);
const be_t<u64> value = CPU.GPR[op.rs];
CPU.SetCR_EQ(0, vm::reservation_update(vm::cast(addr), &value, sizeof(value)));
}

4
rpcs3/Emu/Cell/PPUInterpreter.h
View file

@ -2754,7 +2754,7 @@ private:
{
const u64 addr = ra ? CPU.GPR[ra] + CPU.GPR[rb] : CPU.GPR[rb];
const be_t<u32> value = be_t<u32>::make((u32)CPU.GPR[rs]);
const be_t<u32> value = (u32)CPU.GPR[rs];
CPU.SetCR_EQ(0, vm::reservation_update(vm::cast(addr), &value, sizeof(value)));
}
void STWX(u32 rs, u32 ra, u32 rb)
@ -2806,7 +2806,7 @@ private:
{
const u64 addr = ra ? CPU.GPR[ra] + CPU.GPR[rb] : CPU.GPR[rb];
const be_t<u64> value = be_t<u64>::make(CPU.GPR[rs]);
const be_t<u64> value = CPU.GPR[rs];
CPU.SetCR_EQ(0, vm::reservation_update(vm::cast(addr), &value, sizeof(value)));
}
void STBX(u32 rs, u32 ra, u32 rb)

6
rpcs3/Emu/Cell/PPUThread.cpp
View file

@ -520,8 +520,8 @@ void PPUThread::DoReset()
void PPUThread::InitRegs()
{
const u32 pc = entry ? vm::read32(entry) : 0;
const u32 rtoc = entry ? vm::read32(entry + 4) : 0;
const u32 pc = entry ? vm::read32(entry).value() : 0;
const u32 rtoc = entry ? vm::read32(entry + 4).value() : 0;
SetPc(pc);
@ -764,7 +764,7 @@ cpu_thread& ppu_thread::args(std::initializer_list<std::string> values)
const u32 arg_size = align(u32(arg.size() + 1), stack_align);
const u32 arg_addr = vm::alloc(arg_size, vm::main);
std::strcpy(vm::get_ptr<char>(arg_addr), arg.c_str());
std::memcpy(vm::get_ptr(arg_addr), arg.c_str(), arg.size() + 1);
argv[argc++] = arg_addr;
}

2
rpcs3/Emu/Cell/SPUThread.cpp
View file

@ -355,7 +355,7 @@ void SPUThread::do_dma_list_cmd(u32 cmd, spu_mfc_arg_t args)
args.lsa += std::max<u32>(size, 16);
}
if (rec->sb.data() & se16(0x8000))
if (rec->sb & 0x8000)
{
ch_stall_stat.push_bit_or(1 << args.tag);

18
rpcs3/Emu/Memory/vm_ptr.h
View file

@ -52,9 +52,9 @@ namespace vm
m_addr = value;
}
template<typename AT2 = AT> static std::enable_if_t<std::is_assignable<AT&, AT2>::value, _ptr_base> make(const AT2& addr)
template<typename AT2 = AT> static std::enable_if_t<std::is_constructible<AT, AT2>::value, _ptr_base> make(const AT2& addr)
{
return{ convert_le_be<AT>(addr) };
return{ addr };
}
T* get_ptr() const
@ -82,7 +82,7 @@ namespace vm
// enable only the conversions which are originally possible between pointer types
template<typename T2, typename AT2, typename = std::enable_if_t<std::is_convertible<T*, T2*>::value>> operator _ptr_base<T2, AT2>() const
{
return{ convert_le_be<AT2>(vm::cast(m_addr)) };
return{ vm::cast(m_addr) };
}
template<typename T2, typename = std::enable_if_t<std::is_convertible<T*, T2*>::value>> explicit operator T2*() const
@ -127,9 +127,9 @@ namespace vm
m_addr = value;
}
template<typename AT2 = AT> static _ptr_base make(const AT2& addr)
template<typename AT2 = AT> static std::enable_if_t<std::is_constructible<AT, AT2>::value, _ptr_base> make(const AT2& addr)
{
return{ convert_le_be<AT>(addr) };
return{ addr };
}
// defined in CB_FUNC.h, passing context is mandatory
@ -141,7 +141,7 @@ namespace vm
// conversion to another function pointer
template<typename AT2> operator _ptr_base<type, AT2>() const
{
return{ convert_le_be<AT2>(vm::cast(m_addr)) };
return{ vm::cast(m_addr) };
}
explicit operator bool() const
@ -315,19 +315,19 @@ template<typename T, typename AT> inline vm::if_arithmetical_ptr_t<T, vm::_ptr_b
// addition operator for vm::_ptr_base (pointer + integer)
template<typename T, typename AT> inline vm::if_arithmetical_ptr_t<T, vm::_ptr_base<T, AT>> operator +(const vm::_ptr_base<T, AT>& ptr, to_ne_t<AT> count)
{
return{ convert_le_be<AT>(ptr.m_addr + count * sizeof32(T)) };
return{ ptr.m_addr + count * sizeof32(T) };
}
// addition operator for vm::_ptr_base (integer + pointer)
template<typename T, typename AT> inline vm::if_arithmetical_ptr_t<T, vm::_ptr_base<T, AT>> operator +(to_ne_t<AT> count, const vm::_ptr_base<T, AT>& ptr)
{
return{ convert_le_be<AT>(ptr.m_addr + count * sizeof32(T)) };
return{ ptr.m_addr + count * sizeof32(T) };
}
// subtraction operator for vm::_ptr_base (pointer - integer)
template<typename T, typename AT> inline vm::if_arithmetical_ptr_t<T, vm::_ptr_base<T, AT>> operator -(const vm::_ptr_base<T, AT>& ptr, to_ne_t<AT> count)
{
return{ convert_le_be<AT>(ptr.m_addr - count * sizeof32(T)) };
return{ ptr.m_addr - count * sizeof32(T) };
}
// pointer difference operator for vm::_ptr_base

4
rpcs3/Emu/Memory/vm_ref.h
View file

@ -17,9 +17,9 @@ namespace vm
return m_addr;
}
template<typename AT2 = AT> static _ref_base make(const AT2& addr)
template<typename AT2 = AT> static std::enable_if_t<std::is_constructible<AT, AT2>::value, _ref_base> make(const AT2& addr)
{
return{ convert_le_be<AT>(addr) };
return{ addr };
}
T& get_ref() const

2
rpcs3/Emu/RSX/Common/FragmentProgramDecompiler.cpp
View file

@ -114,7 +114,7 @@ std::string FragmentProgramDecompiler::AddConst()
return name;
}
auto data = vm::ps3::ptr<u32>::make(m_addr + m_size + 4 * sizeof(u32));
auto data = vm::ps3::ptr<u32>::make(m_addr + m_size + 4 * sizeof32(u32));
m_offset = 2 * 4 * sizeof(u32);
u32 x = GetData(data[0]);

8
rpcs3/Emu/RSX/RSXThread.cpp
View file

@ -188,7 +188,7 @@ void RSXThread::DoCmd(const u32 fcmd, const u32 cmd, const u32 args_addr, const
// NV406E
case NV406E_SET_REFERENCE:
{
m_ctrl->ref.exchange(be_t<u32>::make(ARGS(0)));
m_ctrl->ref.exchange(ARGS(0));
break;
}
@ -2523,7 +2523,7 @@ void RSXThread::Task()
{
u32 offs = cmd & 0x1fffffff;
//LOG_WARNING(RSX, "rsx jump(0x%x) #addr=0x%x, cmd=0x%x, get=0x%x, put=0x%x", offs, m_ioAddress + get, cmd, get, put);
m_ctrl->get.exchange(be_t<u32>::make(offs));
m_ctrl->get.exchange(offs);
continue;
}
if (cmd & CELL_GCM_METHOD_FLAG_CALL)
@ -2531,7 +2531,7 @@ void RSXThread::Task()
m_call_stack.push(get + 4);
u32 offs = cmd & ~3;
//LOG_WARNING(RSX, "rsx call(0x%x) #0x%x - 0x%x", offs, cmd, get);
m_ctrl->get.exchange(be_t<u32>::make(offs));
m_ctrl->get.exchange(offs);
continue;
}
if (cmd == CELL_GCM_METHOD_FLAG_RETURN)
@ -2539,7 +2539,7 @@ void RSXThread::Task()
u32 get = m_call_stack.top();
m_call_stack.pop();
//LOG_WARNING(RSX, "rsx return(0x%x)", get);
m_ctrl->get.exchange(be_t<u32>::make(get));
m_ctrl->get.exchange(get);
continue;
}
if (cmd & CELL_GCM_METHOD_FLAG_NON_INCREMENT)

18
rpcs3/Emu/RSX/sysutil_video.h
View file

@ -229,15 +229,15 @@ enum CellVideoOutRGBOutputRange
static const CellVideoOutResolution ResolutionTable[] =
{
{ be_t<u16>::make(0xffff), be_t<u16>::make(0xffff) }, //0 - 0
{ be_t<u16>::make(1920), be_t<u16>::make(1080) }, //1 - 1
{ be_t<u16>::make(1280), be_t<u16>::make(720) }, //2 - 2
{ be_t<u16>::make(720), be_t<u16>::make(480) }, //4 - 3
{ be_t<u16>::make(720), be_t<u16>::make(576) }, //5 - 4
{ be_t<u16>::make(1600), be_t<u16>::make(1080) }, //10 - 5
{ be_t<u16>::make(1440), be_t<u16>::make(1080) }, //11 - 6
{ be_t<u16>::make(1280), be_t<u16>::make(1080) }, //12 - 7
{ be_t<u16>::make(960), be_t<u16>::make(1080) }, //13 - 8
{ 0xffff, 0xffff }, //0 - 0
{ 1920, 1080 }, //1 - 1
{ 1280, 720 }, //2 - 2
{ 720, 480 }, //4 - 3
{ 720, 576 }, //5 - 4
{ 1600, 1080 }, //10 - 5
{ 1440, 1080 }, //11 - 6
{ 1280, 1080 }, //12 - 7
{ 960, 1080 }, //13 - 8
};
inline static u32 ResolutionIdToNum(u32 id)

10
rpcs3/Emu/SysCalls/Modules/cellAdec.cpp
View file

@ -22,7 +22,7 @@ extern Module cellAdec;
#define ADEC_ERROR(...) { cellAdec.Error(__VA_ARGS__); Emu.Pause(); return; } // only for decoder thread
AudioDecoder::AudioDecoder(AudioCodecType type, u32 addr, u32 size, vm::ptr<CellAdecCbMsg> func, u32 arg)
AudioDecoder::AudioDecoder(s32 type, u32 addr, u32 size, vm::ptr<CellAdecCbMsg> func, u32 arg)
: type(type)
, memAddr(addr)
, memSize(size)
@ -478,7 +478,7 @@ void adecOpen(u32 adec_id) // TODO: call from the constructor
});
}
bool adecCheckType(AudioCodecType type)
bool adecCheckType(s32 type)
{
switch (type)
{
@ -825,8 +825,8 @@ s32 cellAdecGetPcmItem(u32 handle, vm::pptr<CellAdecPcmItem> pcmItem)
pcm->startAddr = 0x00000312; // invalid address (no output)
pcm->size = af.size;
pcm->status = CELL_OK;
pcm->auInfo.pts.lower = (u32)af.pts;
pcm->auInfo.pts.upper = af.pts >> 32;
pcm->auInfo.pts.lower = (u32)(af.pts);
pcm->auInfo.pts.upper = (u32)(af.pts >> 32);
pcm->auInfo.size = af.auSize;
pcm->auInfo.startAddr = af.auAddr;
pcm->auInfo.userData = af.userdata;
@ -836,7 +836,7 @@ s32 cellAdecGetPcmItem(u32 handle, vm::pptr<CellAdecPcmItem> pcmItem)
auto atx = vm::ptr<CellAdecAtracXInfo>::make(pcm.addr() + sizeof32(CellAdecPcmItem));
atx->samplingFreq = frame->sample_rate;
atx->nbytes = frame->nb_samples * sizeof(float);
atx->nbytes = frame->nb_samples * sizeof32(float);
if (frame->channels == 1)
{
atx->channelConfigIndex = 1;

181
rpcs3/Emu/SysCalls/Modules/cellAdec.h
View file

@ -248,7 +248,7 @@ enum
};
// Audio Codec Type
enum AudioCodecType
enum AudioCodecType : s32
{
CELL_ADEC_TYPE_RESERVED1,
CELL_ADEC_TYPE_LPCM_PAMF,
@ -284,7 +284,7 @@ enum AudioCodecType
CELL_ADEC_TYPE_RESERVED25,
};
static bool adecIsAtracX(const AudioCodecType type)
inline bool adecIsAtracX(s32 type)
{
return type == CELL_ADEC_TYPE_ATRACX
|| type == CELL_ADEC_TYPE_ATRACX_2CH
@ -293,7 +293,7 @@ static bool adecIsAtracX(const AudioCodecType type)
}
// Output Channel Number
enum CellAdecChannel
enum CellAdecChannel : s32
{
CELL_ADEC_CH_RESERVED1,
CELL_ADEC_CH_MONO,
@ -311,7 +311,7 @@ enum CellAdecChannel
};
// Sampling Rate
enum CellAdecSampleRate
enum CellAdecSampleRate : s32
{
CELL_ADEC_FS_RESERVED1 = 0,
CELL_ADEC_FS_48kHz = 1,
@ -319,7 +319,7 @@ enum CellAdecSampleRate
CELL_ADEC_FS_8kHz = 5,
};
enum CellAdecBitLength
enum CellAdecBitLength : s32
{
CELL_ADEC_BIT_LENGTH_RESERVED1,
CELL_ADEC_BIT_LENGTH_16,
@ -329,7 +329,7 @@ enum CellAdecBitLength
struct CellAdecType
{
be_t<AudioCodecType> audioCodecType;
be_t<s32> audioCodecType; // AudioCodecType
};
struct CellAdecAttr
@ -360,7 +360,7 @@ struct CellAdecResourceEx
};
// Callback Messages
enum CellAdecMsgType
enum CellAdecMsgType : s32
{
CELL_ADEC_MSG_TYPE_AUDONE,
CELL_ADEC_MSG_TYPE_PCMOUT,
@ -368,7 +368,7 @@ enum CellAdecMsgType
CELL_ADEC_MSG_TYPE_SEQDONE,
};
typedef s32(CellAdecCbMsg)(u32 handle, CellAdecMsgType msgType, s32 msgData, u32 cbArg);
using CellAdecCbMsg = func_def<s32(u32 handle, CellAdecMsgType msgType, s32 msgData, u32 cbArg)>;
struct CellAdecCb
{
@ -376,8 +376,6 @@ struct CellAdecCb
be_t<u32> cbArg;
};
typedef CellCodecTimeStamp CellAdecTimeStamp;
// AU Info
struct CellAdecAuInfo
{
@ -420,13 +418,13 @@ struct CellAdecLpcmInfo
};
// CELP Excitation Mode
enum CELP_ExcitationMode
enum CELP_ExcitationMode : s32
{
CELL_ADEC_CELP_EXCITATION_MODE_RPE = 1,
};
// CELP RPE Configuration
enum CELP_RPEConfig
enum CELP_RPEConfig : s32
{
CELL_ADEC_CELP_RPE_CONFIG_0,
CELL_ADEC_CELP_RPE_CONFIG_1,
@ -435,7 +433,7 @@ enum CELP_RPEConfig
};
// CELP Word Size
enum CELP_WordSize
enum CELP_WordSize : s32
{
CELL_ADEC_CELP_WORD_SZ_INT16_LE,
CELL_ADEC_CELP_WORD_SZ_FLOAT,
@ -460,13 +458,13 @@ struct CellAdecCelpInfo
};
// CELP8 Excitation Mode
enum CELP8_ExcitationMode
enum CELP8_ExcitationMode : s32
{
CELL_ADEC_CELP8_EXCITATION_MODE_MPE = 0,
};
// CELP8 MPE Configuration
enum CELP8_MPEConfig
enum CELP8_MPEConfig : s32
{
CELL_ADEC_CELP8_MPE_CONFIG_0 = 0,
CELL_ADEC_CELP8_MPE_CONFIG_2 = 2,
@ -481,7 +479,7 @@ enum CELP8_MPEConfig
};
// CELP8 Word Size
enum CELP8_WordSize
enum CELP8_WordSize : s32
{
CELL_ADEC_CELP8_WORD_SZ_FLOAT,
};
@ -504,14 +502,14 @@ struct CellAdecCelp8Info
be_t<u32> wordSize;
};
enum MPEG4AAC_ConfigType
enum MPEG4AAC_ConfigType : s32
{
ADIFHeader = 0,
ADTSHeader = 1,
RawDataBlockOnly = 2,
};
enum MPEG4AAC_SamplingFreq
enum MPEG4AAC_SamplingFreq : s32
{
SF_96000 = 0,
SF_88200 = 1,
@ -530,26 +528,30 @@ enum MPEG4AAC_SamplingFreq
// MPEG4 AAC Parameters
struct CellAdecParamM4Aac
{
be_t<MPEG4AAC_ConfigType> configNumber;
be_t<s32> configNumber; // MPEG4AAC_ConfigType
union {
struct mp { struct mp2
union
{
struct
{
be_t<u32> adifProgramNumber; // 0
} adifConfig; };
be_t<u32> programNumber;
}
adifConfig;
struct mp3 { struct mp4
struct
{
be_t<MPEG4AAC_SamplingFreq> samplingFreqIndex;
be_t<s32> samplingFreqIndex; // MPEG4AAC_SamplingFreq
be_t<u32> profile; // LC profile (1)
} rawDataBlockConfig; };
} configInfo;
}
rawDataBlockConfig;
}
configInfo;
be_t<u32> enableDownmix; // enable downmix to 2.0 (if (enableDownmix))
};
// MPEG4 AAC BSI
struct CellAdecM4AacInfo
struct set_alignment(16) CellAdecM4AacInfo
{
be_t<u32> samplingFreq; // [Hz]
be_t<u32> numberOfChannels;
@ -561,55 +563,52 @@ struct CellAdecM4AacInfo
be_t<u32> enableSBR;
be_t<u32> SBRUpsamplingFactor;
be_t<u32> isBsiValid;
be_t<MPEG4AAC_ConfigType> configNumber;
be_t<u32> pad1; // TODO: check alignment
be_t<s32> configNumber; // MPEG4AAC_ConfigType
union {
struct mp5 {
struct m6
{
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;
};
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 mp7 {
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 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;
be_t<u32> pad2; // TODO: check alignment
struct mp9
struct
{
be_t<u32> matrixMixdownPresent;
be_t<u32> mixdownIndex;
be_t<u32> pseudoSurroundEnable;
} matrixMixdown;
}
matrixMixdown;
be_t<u32> reserved;
};
@ -760,15 +759,15 @@ enum ATRAC3_JointType : s32
struct CellAdecParamAtrac3
{
be_t<s32> nch; // channel count
be_t<ATRAC3_JointType> isJoint;
be_t<s32> isJoint; // ATRAC3_JointType
be_t<s32> nbytes; // byte count of single AU (???)
be_t<ATRAC3_WordSize> bw_pcm; // bit length of output PCM sample
be_t<s32> bw_pcm; // ATRAC3_WordSize, bit length of output PCM sample
};
struct CellAdecAtrac3Info
{
be_t<s32> nch;
be_t<ATRAC3_JointType> isJoint;
be_t<s32> isJoint; // ATRAC3_JointType
be_t<s32> nbytes;
};
@ -799,7 +798,7 @@ struct CellAdecParamAtracX
be_t<s32> nch_out;
be_t<s32> nbytes;
std::array<u8, 4> extra_config_data; // downmix coefficients
be_t<ATRACX_WordSize> bw_pcm;
be_t<s32> bw_pcm; // ATRACX_WordSize
ATRACX_DownmixFlag downmix_flag;
ATRACX_ATSHeaderInclude au_includes_ats_hdr_flg;
};
@ -833,7 +832,7 @@ enum MP3_CRCMode : u8
struct CellAdecParamMP3
{
be_t<MP3_WordSize> bw_pcm;
be_t<s32> bw_pcm; // MP3_WordSize
};
struct CellAdecMP3Info
@ -852,20 +851,20 @@ struct CellAdecMP3Info
be_t<s32> i_error_code;
};
enum M2BC_SampleFrequency
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
enum M2BC_ErrorProtection : s32
{
CELL_ADEC_BSI_M2BC_ERROR_PROTECTION_NONE = 0,
CELL_ADEC_BSI_M2BC_ERROR_PROTECTION_EXIST = 1,
};
enum M2BC_BitrateIndex
enum M2BC_BitrateIndex : s32
{
CELL_ADEC_BSI_M2BC_BITRATE_32 = 1,
CELL_ADEC_BSI_M2BC_BITRATE_48 = 2,
@ -883,7 +882,7 @@ enum M2BC_BitrateIndex
CELL_ADEC_BSI_M2BC_BITRATE_384 = 14,
};
enum M2BC_StereoMode
enum M2BC_StereoMode : s32
{
CELL_ADEC_BSI_M2BC_STEREO_MODE_STERO = 0,
CELL_ADEC_BSI_M2BC_STEREO_MODE_JOINTSTERO = 1,
@ -891,7 +890,7 @@ enum M2BC_StereoMode
CELL_ADEC_BSI_M2BC_STEREO_MODE_MONO = 3,
};
enum M2BC_StereoModeEx
enum M2BC_StereoModeEx : s32
{
CELL_ADEC_BSI_M2BC_STEREO_EXMODE_0 = 0,
CELL_ADEC_BSI_M2BC_STEREO_EXMODE_1 = 1,
@ -899,26 +898,26 @@ enum M2BC_StereoModeEx
CELL_ADEC_BSI_M2BC_STEREO_EXMODE_3 = 3,
};
enum M2BC_Emphasis
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
enum M2BC_CopyrightBit : s32
{
CELL_ADEC_BSI_M2BC_COPYRIGHT_NONE = 0,
CELL_ADEC_BSI_M2BC_COPYRIGHT_ON = 1,
};
enum M2BC_OriginalBit
enum M2BC_OriginalBit : s32
{
CELL_ADEC_BSI_M2BC_ORIGINAL_COPY = 0,
CELL_ADEC_BSI_M2BC_ORIGINAL_ORIGINAL = 1,
};
enum M2BC_SurroundMode
enum M2BC_SurroundMode : s32
{
CELL_ADEC_BSI_M2BC_SURROUND_NONE = 0,
CELL_ADEC_BSI_M2BC_SURROUND_MONO = 1,
@ -926,33 +925,33 @@ enum M2BC_SurroundMode
CELL_ADEC_BSI_M2BC_SURROUND_SECOND = 3,
};
enum M2BC_CenterMode
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
enum M2BC_LFE : s32
{
CELL_ADEC_BSI_M2BC_LFE_NONE = 0,
CELL_ADEC_BSI_M2BC_LFE_EXIST = 1,
};
enum M2BC_AudioMixMode
enum M2BC_AudioMixMode : s32
{
CELL_ADEC_BSI_M2BC_AUDIOMIX_LARGE = 0,
CELL_ADEC_BSI_M2BC_AUDIOMIX_SMALLE = 1,
};
enum M2BC_MCExtension
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
enum M2BC_ChannelConfig : s32
{
CELL_ADEC_BSI_M2BC_CH_CONFIG_MONO = 0,
CELL_ADEC_BSI_M2BC_CH_CONFIG_DUAL = 1,
@ -1130,7 +1129,7 @@ public:
squeue_t<AdecFrame> frames;
const AudioCodecType type;
const s32 type;
const u32 memAddr;
const u32 memSize;
const vm::ptr<CellAdecCbMsg> cbFunc;
@ -1148,7 +1147,7 @@ public:
PPUThread* adecCb;
AudioDecoder(AudioCodecType type, u32 addr, u32 size, vm::ptr<CellAdecCbMsg> func, u32 arg);
AudioDecoder(s32 type, u32 addr, u32 size, vm::ptr<CellAdecCbMsg> func, u32 arg);
~AudioDecoder();
};

6
rpcs3/Emu/SysCalls/Modules/cellAudio.cpp
View file

@ -881,7 +881,7 @@ s32 cellAudioAddData(u32 portNum, vm::ptr<float> src, u32 samples, float volume)
const AudioPortConfig& port = g_audio.ports[portNum];
const auto dst = vm::ptr<float>::make(port.addr + (port.tag % port.block) * port.channel * 256 * sizeof(float));
const auto dst = vm::ptr<float>::make(port.addr + u32(port.tag % port.block) * port.channel * 256 * sizeof32(float));
for (u32 i = 0; i < samples * port.channel; i++)
{
@ -914,7 +914,7 @@ s32 cellAudioAdd2chData(u32 portNum, vm::ptr<float> src, u32 samples, float volu
const AudioPortConfig& port = g_audio.ports[portNum];
const auto dst = vm::ptr<float>::make(port.addr + (port.tag % port.block) * port.channel * 256 * sizeof(float));
const auto dst = vm::ptr<float>::make(port.addr + s32(port.tag % port.block) * port.channel * 256 * sizeof32(float));
if (port.channel == 2)
{
@ -970,7 +970,7 @@ s32 cellAudioAdd6chData(u32 portNum, vm::ptr<float> src, float volume)
const AudioPortConfig& port = g_audio.ports[portNum];
const auto dst = vm::ptr<float>::make(port.addr + (port.tag % port.block) * port.channel * 256 * sizeof(float));
const auto dst = vm::ptr<float>::make(port.addr + s32(port.tag % port.block) * port.channel * 256 * sizeof32(float));
if (port.channel == 2 || port.channel == 6)
{

582
rpcs3/Emu/SysCalls/Modules/cellCamera.cpp
View file

@ -6,16 +6,16 @@
#include "cellCamera.h"
extern Module cellCamera;
const char* attributes[] = {"GAIN", "REDBLUEGAIN", "SATURATION", "EXPOSURE", "BRIGHTNESS", "AEC", "AGC", "AWB", "ABC", "LED", "AUDIOGAIN", "QS", "NONZEROCOEFFS", "YUVFLAG",
"JPEGFLAG", "BACKLIGHTCOMP", "MIRRORFLAG", "MEASUREDQS", "422FLAG", "USBLOAD", "GAMMA", "GREENGAIN", "AGCLIMIT", "DENOISE", "FRAMERATEADJUST",
"PIXELOUTLIERFILTER", "AGCLOW", "AGCHIGH", "DEVICELOCATION", "FORMATCAP", "FORMATINDEX", "NUMFRAME", "FRAMEINDEX", "FRAMESIZE", "INTERVALTYPE",
"INTERVALINDEX", "INTERVALVALUE", "COLORMATCHING", "PLFREQ", "DEVICEID", "DEVICECAP", "DEVICESPEED", "UVCREQCODE", "UVCREQDATA", "DEVICEID2",
"READMODE", "GAMEPID", "PBUFFER", "READFINISH", "ATTRIBUTE_UNKNOWN"};
//const char* attributes[] = {"GAIN", "REDBLUEGAIN", "SATURATION", "EXPOSURE", "BRIGHTNESS", "AEC", "AGC", "AWB", "ABC", "LED", "AUDIOGAIN", "QS", "NONZEROCOEFFS", "YUVFLAG",
// "JPEGFLAG", "BACKLIGHTCOMP", "MIRRORFLAG", "MEASUREDQS", "422FLAG", "USBLOAD", "GAMMA", "GREENGAIN", "AGCLIMIT", "DENOISE", "FRAMERATEADJUST",
// "PIXELOUTLIERFILTER", "AGCLOW", "AGCHIGH", "DEVICELOCATION", "FORMATCAP", "FORMATINDEX", "NUMFRAME", "FRAMEINDEX", "FRAMESIZE", "INTERVALTYPE",
// "INTERVALINDEX", "INTERVALVALUE", "COLORMATCHING", "PLFREQ", "DEVICEID", "DEVICECAP", "DEVICESPEED", "UVCREQCODE", "UVCREQDATA", "DEVICEID2",
// "READMODE", "GAMEPID", "PBUFFER", "READFINISH", "ATTRIBUTE_UNKNOWN"};
struct cellCameraInternal
{
bool m_bInitialized;
CellCamera m_camera;
//CellCamera m_camera;
cellCameraInternal()
: m_bInitialized(false)
@ -25,7 +25,7 @@ struct cellCameraInternal
cellCameraInternal cellCameraInstance;
int cellCameraInit()
s32 cellCameraInit()
{
cellCamera.Warning("cellCameraInit()");
@ -37,43 +37,43 @@ int cellCameraInit()
if (Ini.CameraType.GetValue() == 1)
{
CellCamera camera;
camera.attributes.SATURATION = 164;
camera.attributes.BRIGHTNESS = 96;
camera.attributes.AEC = 1;
camera.attributes.AGC = 1;
camera.attributes.AWB = 1;
camera.attributes.ABC = 0;
camera.attributes.LED = 1;
camera.attributes.QS = 0;
camera.attributes.NONZEROCOEFFS[0] = 32;
camera.attributes.NONZEROCOEFFS[1] = 32;
camera.attributes.YUVFLAG = 0;
camera.attributes.BACKLIGHTCOMP = 0;
camera.attributes.MIRRORFLAG = 1;
camera.attributes._422FLAG = 1;
camera.attributes.USBLOAD = 4;
cellCameraInstance.m_camera = camera;
//CellCamera camera;
//camera.attributes.SATURATION = 164;
//camera.attributes.BRIGHTNESS = 96;
//camera.attributes.AEC = 1;
//camera.attributes.AGC = 1;
//camera.attributes.AWB = 1;
//camera.attributes.ABC = 0;
//camera.attributes.LED = 1;
//camera.attributes.QS = 0;
//camera.attributes.NONZEROCOEFFS[0] = 32;
//camera.attributes.NONZEROCOEFFS[1] = 32;
//camera.attributes.YUVFLAG = 0;
//camera.attributes.BACKLIGHTCOMP = 0;
//camera.attributes.MIRRORFLAG = 1;
//camera.attributes._422FLAG = 1;
//camera.attributes.USBLOAD = 4;
//cellCameraInstance.m_camera = camera;
}
else if (Ini.CameraType.GetValue() == 2)
{
CellCamera camera;
camera.attributes.SATURATION = 64;
camera.attributes.BRIGHTNESS = 8;
camera.attributes.AEC = 1;
camera.attributes.AGC = 1;
camera.attributes.AWB = 1;
camera.attributes.LED = 1;
camera.attributes.BACKLIGHTCOMP = 0;
camera.attributes.MIRRORFLAG = 1;
camera.attributes.GAMMA = 1;
camera.attributes.AGCLIMIT = 4;
camera.attributes.DENOISE = 0;
camera.attributes.FRAMERATEADJUST = 0;
camera.attributes.PIXELOUTLIERFILTER = 1;
camera.attributes.AGCLOW = 48;
camera.attributes.AGCHIGH = 64;
cellCameraInstance.m_camera = camera;
//CellCamera camera;
//camera.attributes.SATURATION = 64;
//camera.attributes.BRIGHTNESS = 8;
//camera.attributes.AEC = 1;
//camera.attributes.AGC = 1;
//camera.attributes.AWB = 1;
//camera.attributes.LED = 1;
//camera.attributes.BACKLIGHTCOMP = 0;
//camera.attributes.MIRRORFLAG = 1;
//camera.attributes.GAMMA = 1;
//camera.attributes.AGCLIMIT = 4;
//camera.attributes.DENOISE = 0;
//camera.attributes.FRAMERATEADJUST = 0;
//camera.attributes.PIXELOUTLIERFILTER = 1;
//camera.attributes.AGCLOW = 48;
//camera.attributes.AGCHIGH = 64;
//cellCameraInstance.m_camera = camera;
}
// TODO: Some other default attributes? Need to check the actual behaviour on a real PS3.
@ -82,7 +82,7 @@ int cellCameraInit()
return CELL_OK;
}
int cellCameraEnd()
s32 cellCameraEnd()
{
cellCamera.Warning("cellCameraEnd()");
@ -94,13 +94,13 @@ int cellCameraEnd()
return CELL_OK;
}
int cellCameraOpen()
s32 cellCameraOpen()
{
UNIMPLEMENTED_FUNC(cellCamera);
return CELL_OK;
}
int cellCameraOpenEx()
s32 cellCameraOpenEx()
{
UNIMPLEMENTED_FUNC(cellCamera);
@ -110,7 +110,7 @@ int cellCameraOpenEx()
return CELL_OK;
}
int cellCameraClose()
s32 cellCameraClose()
{
UNIMPLEMENTED_FUNC(cellCamera);
@ -120,7 +120,7 @@ int cellCameraClose()
return CELL_OK;
}
int cellCameraGetDeviceGUID()
s32 cellCameraGetDeviceGUID()
{
UNIMPLEMENTED_FUNC(cellCamera);
@ -130,9 +130,9 @@ int cellCameraGetDeviceGUID()
return CELL_OK;
}
int cellCameraGetType(s32 dev_num, vm::ptr<CellCameraType> type)
s32 cellCameraGetType(s32 dev_num, vm::ptr<s32> type)
{
cellCamera.Warning("cellCameraGetType(dev_num=%d, type_addr=0x%x)", dev_num, type.addr());
cellCamera.Warning("cellCameraGetType(dev_num=%d, type=*0x%x)", dev_num, type);
if (!cellCameraInstance.m_bInitialized)
return CELL_CAMERA_ERROR_NOT_INIT;
@ -148,271 +148,271 @@ int cellCameraGetType(s32 dev_num, vm::ptr<CellCameraType> type)
return CELL_OK;
}
int cellCameraIsAvailable()
s32 cellCameraIsAvailable()
{
UNIMPLEMENTED_FUNC(cellCamera);
return CELL_OK;
}
int cellCameraIsAttached()
s32 cellCameraIsAttached()
{
UNIMPLEMENTED_FUNC(cellCamera);
return CELL_OK;
}
int cellCameraIsOpen()
s32 cellCameraIsOpen()
{
UNIMPLEMENTED_FUNC(cellCamera);
return CELL_OK;
}
int cellCameraIsStarted()
s32 cellCameraIsStarted()
{
UNIMPLEMENTED_FUNC(cellCamera);
return CELL_OK;
}
int cellCameraGetAttribute(s32 dev_num, CellCameraAttribute attrib, vm::ptr<u32> arg1, vm::ptr<u32> arg2)
s32 cellCameraGetAttribute(s32 dev_num, s32 attrib, vm::ptr<u32> arg1, vm::ptr<u32> arg2)
{
cellCamera.Warning("cellCameraGetAttribute(dev_num=%d, attrib=%s(%d), arg1=0x%x, arg2=0x%x)", dev_num, attributes[attrib], arg1.addr(), arg2.addr());
cellCamera.Warning("cellCameraGetAttribute(dev_num=%d, attrib=%d, arg1=*0x%x, arg2=*0x%x)", dev_num, attrib, arg1, arg2);
if (!cellCameraInstance.m_bInitialized)
return CELL_CAMERA_ERROR_NOT_INIT;
switch (attrib)
{
case 0:
*arg1 = cellCameraInstance.m_camera.attributes.GAIN; break;
case 1:
*arg1 = cellCameraInstance.m_camera.attributes.REDBLUEGAIN; break;
case 2:
*arg1 = cellCameraInstance.m_camera.attributes.SATURATION; break;
case 3:
*arg1 = cellCameraInstance.m_camera.attributes.EXPOSURE; break;
case 4:
*arg1 = cellCameraInstance.m_camera.attributes.BRIGHTNESS; break;
case 5:
*arg1 = cellCameraInstance.m_camera.attributes.AEC; break;
case 6:
*arg1 = cellCameraInstance.m_camera.attributes.AGC; break;
case 7:
*arg1 = cellCameraInstance.m_camera.attributes.AWB; break;
case 8:
*arg1 = cellCameraInstance.m_camera.attributes.ABC; break;
case 9:
*arg1 = cellCameraInstance.m_camera.attributes.LED; break;
case 10:
*arg1 = cellCameraInstance.m_camera.attributes.AUDIOGAIN; break;
case 11:
*arg1 = cellCameraInstance.m_camera.attributes.QS; break;
case 12:
{
*arg1 = cellCameraInstance.m_camera.attributes.NONZEROCOEFFS[0];
*arg2 = cellCameraInstance.m_camera.attributes.NONZEROCOEFFS[1];
break;
}
case 13:
*arg1 = cellCameraInstance.m_camera.attributes.YUVFLAG; break;
case 14:
*arg1 = cellCameraInstance.m_camera.attributes.JPEGFLAG; break;
case 15:
*arg1 = cellCameraInstance.m_camera.attributes.BACKLIGHTCOMP; break;
case 16:
*arg1 = cellCameraInstance.m_camera.attributes.MIRRORFLAG; break;
case 17:
*arg1 = cellCameraInstance.m_camera.attributes.MEASUREDQS; break;
case 18:
*arg1 = cellCameraInstance.m_camera.attributes._422FLAG; break;
case 19:
*arg1 = cellCameraInstance.m_camera.attributes.USBLOAD; break;
case 20:
*arg1 = cellCameraInstance.m_camera.attributes.GAMMA; break;
case 21:
*arg1 = cellCameraInstance.m_camera.attributes.GREENGAIN; break;
case 22:
*arg1 = cellCameraInstance.m_camera.attributes.AGCLIMIT; break;
case 23:
*arg1 = cellCameraInstance.m_camera.attributes.DENOISE; break;
case 24:
*arg1 = cellCameraInstance.m_camera.attributes.FRAMERATEADJUST; break;
case 25:
*arg1 = cellCameraInstance.m_camera.attributes.PIXELOUTLIERFILTER; break;
case 26:
*arg1 = cellCameraInstance.m_camera.attributes.AGCLOW; break;
case 27:
*arg1 = cellCameraInstance.m_camera.attributes.AGCHIGH; break;
case 28:
*arg1 = cellCameraInstance.m_camera.attributes.DEVICELOCATION; break;
case 29:
*arg1 = cellCameraInstance.m_camera.attributes.FORMATCAP; break;
case 30:
*arg1 = cellCameraInstance.m_camera.attributes.FORMATINDEX; break;
case 31:
*arg1 = cellCameraInstance.m_camera.attributes.NUMFRAME; break;
case 32:
*arg1 = cellCameraInstance.m_camera.attributes.FRAMEINDEX; break;
case 33:
*arg1 = cellCameraInstance.m_camera.attributes.FRAMESIZE; break;
case 34:
*arg1 = cellCameraInstance.m_camera.attributes.INTERVALTYPE; break;
case 35:
*arg1 = cellCameraInstance.m_camera.attributes.INTERVALINDEX; break;
case 36:
*arg1 = cellCameraInstance.m_camera.attributes.INTERVALVALUE; break;
case 37:
*arg1 = cellCameraInstance.m_camera.attributes.COLORMATCHING; break;
case 38:
*arg1 = cellCameraInstance.m_camera.attributes.PLFREQ; break;
case 39:
*arg1 = cellCameraInstance.m_camera.attributes.DEVICEID; break;
case 40:
*arg1 = cellCameraInstance.m_camera.attributes.DEVICECAP; break;
case 41:
*arg1 = cellCameraInstance.m_camera.attributes.DEVICESPEED; break;
case 42:
*arg1 = cellCameraInstance.m_camera.attributes.UVCREQCODE; break;
case 43:
*arg1 = cellCameraInstance.m_camera.attributes.UVCREQDATA; break;
case 44:
*arg1 = cellCameraInstance.m_camera.attributes.DEVICEID2; break;
case 45:
*arg1 = cellCameraInstance.m_camera.attributes.READMODE; break;
case 46:
*arg1 = cellCameraInstance.m_camera.attributes.GAMEPID; break;
case 47:
*arg1 = cellCameraInstance.m_camera.attributes.PBUFFER; break;
case 48:
*arg1 = cellCameraInstance.m_camera.attributes.READFINISH; break;
case 49:
*arg1 = cellCameraInstance.m_camera.attributes.ATTRIBUTE_UNKNOWN; break;
default:
cellCamera.Error("Unexpected cellCameraGetAttribute attribute: %d", attrib); break;
}
//switch (attrib)
//{
//case 0:
// *arg1 = cellCameraInstance.m_camera.attributes.GAIN; break;
//case 1:
// *arg1 = cellCameraInstance.m_camera.attributes.REDBLUEGAIN; break;
//case 2:
// *arg1 = cellCameraInstance.m_camera.attributes.SATURATION; break;
//case 3:
// *arg1 = cellCameraInstance.m_camera.attributes.EXPOSURE; break;
//case 4:
// *arg1 = cellCameraInstance.m_camera.attributes.BRIGHTNESS; break;
//case 5:
// *arg1 = cellCameraInstance.m_camera.attributes.AEC; break;
//case 6:
// *arg1 = cellCameraInstance.m_camera.attributes.AGC; break;
//case 7:
// *arg1 = cellCameraInstance.m_camera.attributes.AWB; break;
//case 8:
// *arg1 = cellCameraInstance.m_camera.attributes.ABC; break;
//case 9:
// *arg1 = cellCameraInstance.m_camera.attributes.LED; break;
//case 10:
// *arg1 = cellCameraInstance.m_camera.attributes.AUDIOGAIN; break;
//case 11:
// *arg1 = cellCameraInstance.m_camera.attributes.QS; break;
//case 12:
//{
// *arg1 = cellCameraInstance.m_camera.attributes.NONZEROCOEFFS[0];
// *arg2 = cellCameraInstance.m_camera.attributes.NONZEROCOEFFS[1];
// break;
//}
//case 13:
// *arg1 = cellCameraInstance.m_camera.attributes.YUVFLAG; break;
//case 14:
// *arg1 = cellCameraInstance.m_camera.attributes.JPEGFLAG; break;
//case 15:
// *arg1 = cellCameraInstance.m_camera.attributes.BACKLIGHTCOMP; break;
//case 16:
// *arg1 = cellCameraInstance.m_camera.attributes.MIRRORFLAG; break;
//case 17:
// *arg1 = cellCameraInstance.m_camera.attributes.MEASUREDQS; break;
//case 18:
// *arg1 = cellCameraInstance.m_camera.attributes._422FLAG; break;
//case 19:
// *arg1 = cellCameraInstance.m_camera.attributes.USBLOAD; break;
//case 20:
// *arg1 = cellCameraInstance.m_camera.attributes.GAMMA; break;
//case 21:
// *arg1 = cellCameraInstance.m_camera.attributes.GREENGAIN; break;
//case 22:
// *arg1 = cellCameraInstance.m_camera.attributes.AGCLIMIT; break;
//case 23:
// *arg1 = cellCameraInstance.m_camera.attributes.DENOISE; break;
//case 24:
// *arg1 = cellCameraInstance.m_camera.attributes.FRAMERATEADJUST; break;
//case 25:
// *arg1 = cellCameraInstance.m_camera.attributes.PIXELOUTLIERFILTER; break;
//case 26:
// *arg1 = cellCameraInstance.m_camera.attributes.AGCLOW; break;
//case 27:
// *arg1 = cellCameraInstance.m_camera.attributes.AGCHIGH; break;
//case 28:
// *arg1 = cellCameraInstance.m_camera.attributes.DEVICELOCATION; break;
//case 29:
// *arg1 = cellCameraInstance.m_camera.attributes.FORMATCAP; break;
//case 30:
// *arg1 = cellCameraInstance.m_camera.attributes.FORMATINDEX; break;
//case 31:
// *arg1 = cellCameraInstance.m_camera.attributes.NUMFRAME; break;
//case 32:
// *arg1 = cellCameraInstance.m_camera.attributes.FRAMEINDEX; break;
//case 33:
// *arg1 = cellCameraInstance.m_camera.attributes.FRAMESIZE; break;
//case 34:
// *arg1 = cellCameraInstance.m_camera.attributes.INTERVALTYPE; break;
//case 35:
// *arg1 = cellCameraInstance.m_camera.attributes.INTERVALINDEX; break;
//case 36:
// *arg1 = cellCameraInstance.m_camera.attributes.INTERVALVALUE; break;
//case 37:
// *arg1 = cellCameraInstance.m_camera.attributes.COLORMATCHING; break;
//case 38:
// *arg1 = cellCameraInstance.m_camera.attributes.PLFREQ; break;
//case 39:
// *arg1 = cellCameraInstance.m_camera.attributes.DEVICEID; break;
//case 40:
// *arg1 = cellCameraInstance.m_camera.attributes.DEVICECAP; break;
//case 41:
// *arg1 = cellCameraInstance.m_camera.attributes.DEVICESPEED; break;
//case 42:
// *arg1 = cellCameraInstance.m_camera.attributes.UVCREQCODE; break;
//case 43:
// *arg1 = cellCameraInstance.m_camera.attributes.UVCREQDATA; break;
//case 44:
// *arg1 = cellCameraInstance.m_camera.attributes.DEVICEID2; break;
//case 45:
// *arg1 = cellCameraInstance.m_camera.attributes.READMODE; break;
//case 46:
// *arg1 = cellCameraInstance.m_camera.attributes.GAMEPID; break;
//case 47:
// *arg1 = cellCameraInstance.m_camera.attributes.PBUFFER; break;
//case 48:
// *arg1 = cellCameraInstance.m_camera.attributes.READFINISH; break;
//case 49:
// *arg1 = cellCameraInstance.m_camera.attributes.ATTRIBUTE_UNKNOWN; break;
//default:
// cellCamera.Error("Unexpected cellCameraGetAttribute attribute: %d", attrib); break;
//}
return CELL_OK;
}
int cellCameraSetAttribute(s32 dev_num, CellCameraAttribute attrib, u32 arg1, u32 arg2)
s32 cellCameraSetAttribute(s32 dev_num, s32 attrib, u32 arg1, u32 arg2)
{
cellCamera.Warning("cellCameraSetAttribute(dev_num=%d, attrib=%s(%d), arg1=%d, arg2=%d)", dev_num, attributes[attrib], attrib, arg1, arg2);
cellCamera.Warning("cellCameraSetAttribute(dev_num=%d, attrib=%d, arg1=%d, arg2=%d)", dev_num, attrib, arg1, arg2);
if (!cellCameraInstance.m_bInitialized)
return CELL_CAMERA_ERROR_NOT_INIT;
switch (attrib)
{
case 0:
cellCameraInstance.m_camera.attributes.GAIN = arg1; break;
case 1:
cellCameraInstance.m_camera.attributes.REDBLUEGAIN = arg1; break;
case 2:
cellCameraInstance.m_camera.attributes.SATURATION = arg1; break;
case 3:
cellCameraInstance.m_camera.attributes.EXPOSURE = arg1; break;
case 4:
cellCameraInstance.m_camera.attributes.BRIGHTNESS = arg1; break;
case 5:
cellCameraInstance.m_camera.attributes.AEC = arg1; break;
case 6:
cellCameraInstance.m_camera.attributes.AGC = arg1; break;
case 7:
cellCameraInstance.m_camera.attributes.AWB = arg1; break;
case 8:
cellCameraInstance.m_camera.attributes.ABC = arg1; break;
case 9:
cellCameraInstance.m_camera.attributes.LED = arg1; break;
case 10:
cellCameraInstance.m_camera.attributes.AUDIOGAIN = arg1; break;
case 11:
cellCameraInstance.m_camera.attributes.QS = arg1; break;
case 12:
{
cellCameraInstance.m_camera.attributes.NONZEROCOEFFS[0] = arg1;
cellCameraInstance.m_camera.attributes.NONZEROCOEFFS[1] = arg2;
break;
}
case 13:
cellCameraInstance.m_camera.attributes.YUVFLAG = arg1; break;
case 14:
cellCameraInstance.m_camera.attributes.JPEGFLAG = arg1; break;
case 15:
cellCameraInstance.m_camera.attributes.BACKLIGHTCOMP = arg1; break;
case 16:
cellCameraInstance.m_camera.attributes.MIRRORFLAG = arg1; break;
case 17:
return CELL_CAMERA_ERROR_PARAM; break;
case 18:
cellCameraInstance.m_camera.attributes._422FLAG = arg1; break;
case 19:
cellCameraInstance.m_camera.attributes.USBLOAD = arg1; break;
case 20:
cellCameraInstance.m_camera.attributes.GAMMA = arg1; break;
case 21:
cellCameraInstance.m_camera.attributes.GREENGAIN = arg1; break;
case 22:
cellCameraInstance.m_camera.attributes.AGCLIMIT = arg1; break;
case 23:
cellCameraInstance.m_camera.attributes.DENOISE = arg1; break;
case 24:
cellCameraInstance.m_camera.attributes.FRAMERATEADJUST = arg1; break;
case 25:
cellCameraInstance.m_camera.attributes.PIXELOUTLIERFILTER = arg1; break;
case 26:
cellCameraInstance.m_camera.attributes.AGCLOW = arg1; break;
case 27:
cellCameraInstance.m_camera.attributes.AGCHIGH = arg1; break;
case 28:
cellCameraInstance.m_camera.attributes.DEVICELOCATION = arg1; break;
case 29:
cellCamera.Error("Tried to write to read-only (?) value: FORMATCAP"); break;
case 30:
cellCameraInstance.m_camera.attributes.FORMATINDEX = arg1; break;
case 31:
cellCameraInstance.m_camera.attributes.NUMFRAME = arg1; break;
case 32:
cellCameraInstance.m_camera.attributes.FRAMEINDEX = arg1; break;
case 33:
cellCameraInstance.m_camera.attributes.FRAMESIZE = arg1; break;
case 34:
cellCameraInstance.m_camera.attributes.INTERVALTYPE = arg1; break;
case 35:
cellCameraInstance.m_camera.attributes.INTERVALINDEX = arg1; break;
case 36:
cellCameraInstance.m_camera.attributes.INTERVALVALUE = arg1; break;
case 37:
cellCameraInstance.m_camera.attributes.COLORMATCHING = arg1; break;
case 38:
cellCameraInstance.m_camera.attributes.PLFREQ = arg1; break;
case 39:
return CELL_CAMERA_ERROR_PARAM; break;
case 40:
cellCameraInstance.m_camera.attributes.DEVICECAP = arg1; break;
case 41:
cellCameraInstance.m_camera.attributes.DEVICESPEED = arg1; break;
case 42:
cellCameraInstance.m_camera.attributes.UVCREQCODE = arg1; break;
case 43:
cellCameraInstance.m_camera.attributes.UVCREQDATA = arg1; break;
case 44:
return CELL_CAMERA_ERROR_PARAM; break;
case 45:
cellCamera.Error("Tried to write to read-only (?) value: READMODE"); break;
case 46:
cellCameraInstance.m_camera.attributes.GAMEPID = arg1; break;
case 47:
cellCameraInstance.m_camera.attributes.PBUFFER = arg1; break;
case 48:
cellCameraInstance.m_camera.attributes.READFINISH = arg1; break;
case 49:
cellCamera.Error("Tried to write to read-only (?) value: ATTRIBUTE_UNKNOWN"); break;
default:
cellCamera.Error("Unexpected cellCameraGetAttribute attribute: %d", attrib); break;
}
//switch (attrib)
//{
//case 0:
// cellCameraInstance.m_camera.attributes.GAIN = arg1; break;
//case 1:
// cellCameraInstance.m_camera.attributes.REDBLUEGAIN = arg1; break;
//case 2:
// cellCameraInstance.m_camera.attributes.SATURATION = arg1; break;
//case 3:
// cellCameraInstance.m_camera.attributes.EXPOSURE = arg1; break;
//case 4:
// cellCameraInstance.m_camera.attributes.BRIGHTNESS = arg1; break;
//case 5:
// cellCameraInstance.m_camera.attributes.AEC = arg1; break;
//case 6:
// cellCameraInstance.m_camera.attributes.AGC = arg1; break;
//case 7:
// cellCameraInstance.m_camera.attributes.AWB = arg1; break;
//case 8:
// cellCameraInstance.m_camera.attributes.ABC = arg1; break;
//case 9:
// cellCameraInstance.m_camera.attributes.LED = arg1; break;
//case 10:
// cellCameraInstance.m_camera.attributes.AUDIOGAIN = arg1; break;
//case 11:
// cellCameraInstance.m_camera.attributes.QS = arg1; break;
//case 12:
//{
// cellCameraInstance.m_camera.attributes.NONZEROCOEFFS[0] = arg1;
// cellCameraInstance.m_camera.attributes.NONZEROCOEFFS[1] = arg2;
// break;
//}
//case 13:
// cellCameraInstance.m_camera.attributes.YUVFLAG = arg1; break;
//case 14:
// cellCameraInstance.m_camera.attributes.JPEGFLAG = arg1; break;
//case 15:
// cellCameraInstance.m_camera.attributes.BACKLIGHTCOMP = arg1; break;
//case 16:
// cellCameraInstance.m_camera.attributes.MIRRORFLAG = arg1; break;
//case 17:
// return CELL_CAMERA_ERROR_PARAM; break;
//case 18:
// cellCameraInstance.m_camera.attributes._422FLAG = arg1; break;
//case 19:
// cellCameraInstance.m_camera.attributes.USBLOAD = arg1; break;
//case 20:
// cellCameraInstance.m_camera.attributes.GAMMA = arg1; break;
//case 21:
// cellCameraInstance.m_camera.attributes.GREENGAIN = arg1; break;
//case 22:
// cellCameraInstance.m_camera.attributes.AGCLIMIT = arg1; break;
//case 23:
// cellCameraInstance.m_camera.attributes.DENOISE = arg1; break;
//case 24:
// cellCameraInstance.m_camera.attributes.FRAMERATEADJUST = arg1; break;
//case 25:
// cellCameraInstance.m_camera.attributes.PIXELOUTLIERFILTER = arg1; break;
//case 26:
// cellCameraInstance.m_camera.attributes.AGCLOW = arg1; break;
//case 27:
// cellCameraInstance.m_camera.attributes.AGCHIGH = arg1; break;
//case 28:
// cellCameraInstance.m_camera.attributes.DEVICELOCATION = arg1; break;
//case 29:
// cellCamera.Error("Tried to write to read-only (?) value: FORMATCAP"); break;
//case 30:
// cellCameraInstance.m_camera.attributes.FORMATINDEX = arg1; break;
//case 31:
// cellCameraInstance.m_camera.attributes.NUMFRAME = arg1; break;
//case 32:
// cellCameraInstance.m_camera.attributes.FRAMEINDEX = arg1; break;
//case 33:
// cellCameraInstance.m_camera.attributes.FRAMESIZE = arg1; break;
//case 34:
// cellCameraInstance.m_camera.attributes.INTERVALTYPE = arg1; break;
//case 35:
// cellCameraInstance.m_camera.attributes.INTERVALINDEX = arg1; break;
//case 36:
// cellCameraInstance.m_camera.attributes.INTERVALVALUE = arg1; break;
//case 37:
// cellCameraInstance.m_camera.attributes.COLORMATCHING = arg1; break;
//case 38:
// cellCameraInstance.m_camera.attributes.PLFREQ = arg1; break;
//case 39:
// return CELL_CAMERA_ERROR_PARAM; break;
//case 40:
// cellCameraInstance.m_camera.attributes.DEVICECAP = arg1; break;
//case 41:
// cellCameraInstance.m_camera.attributes.DEVICESPEED = arg1; break;
//case 42:
// cellCameraInstance.m_camera.attributes.UVCREQCODE = arg1; break;
//case 43:
// cellCameraInstance.m_camera.attributes.UVCREQDATA = arg1; break;
//case 44:
// return CELL_CAMERA_ERROR_PARAM; break;
//case 45:
// cellCamera.Error("Tried to write to read-only (?) value: READMODE"); break;
//case 46:
// cellCameraInstance.m_camera.attributes.GAMEPID = arg1; break;
//case 47:
// cellCameraInstance.m_camera.attributes.PBUFFER = arg1; break;
//case 48:
// cellCameraInstance.m_camera.attributes.READFINISH = arg1; break;
//case 49:
// cellCamera.Error("Tried to write to read-only (?) value: ATTRIBUTE_UNKNOWN"); break;
//default:
// cellCamera.Error("Unexpected cellCameraGetAttribute attribute: %d", attrib); break;
//}
return CELL_OK;
}
int cellCameraGetBufferSize()
s32 cellCameraGetBufferSize()
{
UNIMPLEMENTED_FUNC(cellCamera);
@ -422,13 +422,13 @@ int cellCameraGetBufferSize()
return CELL_OK;
}
int cellCameraGetBufferInfo()
s32 cellCameraGetBufferInfo()
{
UNIMPLEMENTED_FUNC(cellCamera);
return CELL_OK;
}
int cellCameraGetBufferInfoEx()
s32 cellCameraGetBufferInfoEx()
{
UNIMPLEMENTED_FUNC(cellCamera);
@ -438,31 +438,31 @@ int cellCameraGetBufferInfoEx()
return CELL_OK;
}
int cellCameraPrepExtensionUnit()
s32 cellCameraPrepExtensionUnit()
{
UNIMPLEMENTED_FUNC(cellCamera);
return CELL_OK;
}
int cellCameraCtrlExtensionUnit()
s32 cellCameraCtrlExtensionUnit()
{
UNIMPLEMENTED_FUNC(cellCamera);
return CELL_OK;
}
int cellCameraGetExtensionUnit()
s32 cellCameraGetExtensionUnit()
{
UNIMPLEMENTED_FUNC(cellCamera);
return CELL_OK;
}
int cellCameraSetExtensionUnit()
s32 cellCameraSetExtensionUnit()
{
UNIMPLEMENTED_FUNC(cellCamera);
return CELL_OK;
}
int cellCameraReset()
s32 cellCameraReset()
{
UNIMPLEMENTED_FUNC(cellCamera);
@ -472,7 +472,7 @@ int cellCameraReset()
return CELL_OK;
}
int cellCameraStart()
s32 cellCameraStart()
{
UNIMPLEMENTED_FUNC(cellCamera);
@ -482,7 +482,7 @@ int cellCameraStart()
return CELL_OK;
}
int cellCameraRead()
s32 cellCameraRead()
{
UNIMPLEMENTED_FUNC(cellCamera);
@ -492,7 +492,7 @@ int cellCameraRead()
return CELL_OK;
}
int cellCameraReadEx()
s32 cellCameraReadEx()
{
UNIMPLEMENTED_FUNC(cellCamera);
@ -502,7 +502,7 @@ int cellCameraReadEx()
return CELL_OK;
}
int cellCameraReadComplete()
s32 cellCameraReadComplete()
{
UNIMPLEMENTED_FUNC(cellCamera);
@ -512,7 +512,7 @@ int cellCameraReadComplete()
return CELL_OK;
}
int cellCameraStop()
s32 cellCameraStop()
{
UNIMPLEMENTED_FUNC(cellCamera);
@ -522,7 +522,7 @@ int cellCameraStop()
return CELL_OK;
}
int cellCameraSetNotifyEventQueue()
s32 cellCameraSetNotifyEventQueue()
{
UNIMPLEMENTED_FUNC(cellCamera);
@ -532,7 +532,7 @@ int cellCameraSetNotifyEventQueue()
return CELL_OK;
}
int cellCameraRemoveNotifyEventQueue()
s32 cellCameraRemoveNotifyEventQueue()
{
UNIMPLEMENTED_FUNC(cellCamera);
@ -542,7 +542,7 @@ int cellCameraRemoveNotifyEventQueue()
return CELL_OK;
}
int cellCameraSetNotifyEventQueue2()
s32 cellCameraSetNotifyEventQueue2()
{
UNIMPLEMENTED_FUNC(cellCamera);
@ -552,7 +552,7 @@ int cellCameraSetNotifyEventQueue2()
return CELL_OK;
}
int cellCameraRemoveNotifyEventQueue2()
s32 cellCameraRemoveNotifyEventQueue2()
{
UNIMPLEMENTED_FUNC(cellCamera);

96
rpcs3/Emu/SysCalls/Modules/cellCamera.h
View file

@ -194,7 +194,7 @@ enum
};
// Camera types
enum CellCameraType
enum CellCameraType : s32
{
CELL_CAMERA_TYPE_UNKNOWN,
CELL_CAMERA_EYETOY,
@ -203,7 +203,7 @@ enum CellCameraType
};
// Image format
enum CellCameraFormat
enum CellCameraFormat : s32
{
CELL_CAMERA_FORMAT_UNKNOWN,
CELL_CAMERA_JPG,
@ -217,7 +217,7 @@ enum CellCameraFormat
};
// Image resolution
enum CellCameraResolution
enum CellCameraResolution : s32
{
CELL_CAMERA_RESOLUTION_UNKNOWN,
CELL_CAMERA_VGA,
@ -227,7 +227,7 @@ enum CellCameraResolution
};
// Camera attributes
enum CellCameraAttribute
enum CellCameraAttribute : s32
{
CELL_CAMERA_GAIN,
CELL_CAMERA_REDBLUEGAIN,
@ -286,84 +286,21 @@ enum CellCameraAttribute
struct CellCameraInfoEx
{
CellCameraFormat format;
CellCameraResolution resolution;
be_t<s32> format; // CellCameraFormat
be_t<s32> resolution; // CellCameraResolution
be_t<s32> framerate;
be_t<u32> buffer;
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;
be_t<s32> info_ver;
be_t<u32> container;
be_t<s32> read_mode;
be_t<u32> pbuf[2];
};
// Custom struct for keeping track of camera attributes
struct CellCameraAttributes
{
u32 GAIN;
u32 REDBLUEGAIN;
u32 SATURATION;
u32 EXPOSURE;
u32 BRIGHTNESS;
u32 AEC;
u32 AGC;
u32 AWB;
u32 ABC;
u32 LED;
u32 AUDIOGAIN;
u32 QS;
u32 NONZEROCOEFFS[2];
u32 YUVFLAG;
u32 JPEGFLAG;
u32 BACKLIGHTCOMP;
u32 MIRRORFLAG;
u32 MEASUREDQS;
u32 _422FLAG;
u32 USBLOAD;
u32 GAMMA;
u32 GREENGAIN;
u32 AGCLIMIT;
u32 DENOISE;
u32 FRAMERATEADJUST;
u32 PIXELOUTLIERFILTER;
u32 AGCLOW;
u32 AGCHIGH;
u32 DEVICELOCATION;
u32 FORMATCAP = 100;
u32 FORMATINDEX;
u32 NUMFRAME;
u32 FRAMEINDEX;
u32 FRAMESIZE;
u32 INTERVALTYPE;
u32 INTERVALINDEX;
u32 INTERVALVALUE;
u32 COLORMATCHING;
u32 PLFREQ;
u32 DEVICEID;
u32 DEVICECAP;
u32 DEVICESPEED;
u32 UVCREQCODE;
u32 UVCREQDATA;
u32 DEVICEID2;
u32 READMODE = 300;
u32 GAMEPID;
u32 PBUFFER;
u32 READFINISH;
u32 ATTRIBUTE_UNKNOWN = 500;
};
// Custom struct to keep track of cameras
struct CellCamera
{
CellCameraAttributes attributes;
CellCameraInfoEx info;
vm::bptr<u8> pbuf[2];
};
struct CellCameraReadEx
@ -371,6 +308,13 @@ struct CellCameraReadEx
be_t<s32> version;
be_t<u32> frame;
be_t<u32> bytesread;
//system_time_t timestamp; // TODO: Replace this with something
be_t<u32> pbuf;
};
be_t<s64> timestamp;
vm::bptr<u8> pbuf;
};
// Custom struct to keep track of cameras
struct Camera
{
u32 attr[512];
//CellCameraInfoEx info;
};

2
rpcs3/Emu/SysCalls/Modules/cellDmux.cpp
View file

@ -169,7 +169,7 @@ void ElementaryStream::push_au(u32 size, u64 dts, u64 pts, u64 userdata, bool ra
info->reserved = 0;
info->userData = userdata;
auto spec = vm::ptr<u32>::make(put + sizeof(CellDmuxAuInfoEx));
auto spec = vm::ptr<u32>::make(put + sizeof32(CellDmuxAuInfoEx));
*spec = specific;
auto inf = vm::ptr<CellDmuxAuInfo>::make(put + 64);

34
rpcs3/Emu/SysCalls/Modules/cellDmux.h
View file

@ -12,27 +12,27 @@ enum
CELL_DMUX_ERROR_FATAL = 0x80610205,
};
enum CellDmuxStreamType
enum CellDmuxStreamType : s32
{
CELL_DMUX_STREAM_TYPE_UNDEF = 0,
CELL_DMUX_STREAM_TYPE_PAMF = 1,
CELL_DMUX_STREAM_TYPE_TERMINATOR = 2,
};
enum CellDmuxMsgType
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
enum CellDmuxEsMsgType : s32
{
CELL_DMUX_ES_MSG_TYPE_AU_FOUND = 0,
CELL_DMUX_ES_MSG_TYPE_FLUSH_DONE = 1,
};
enum CellDmuxPamfM2vLevel
enum CellDmuxPamfM2vLevel : s32
{
CELL_DMUX_PAMF_M2V_MP_LL = 0,
CELL_DMUX_PAMF_M2V_MP_ML,
@ -40,7 +40,7 @@ enum CellDmuxPamfM2vLevel
CELL_DMUX_PAMF_M2V_MP_HL,
};
enum CellDmuxPamfAvcLevel
enum CellDmuxPamfAvcLevel : s32
{
CELL_DMUX_PAMF_AVC_LEVEL_2P1 = 21,
CELL_DMUX_PAMF_AVC_LEVEL_3P0 = 30,
@ -114,18 +114,18 @@ struct CellDmuxPamfEsSpecificInfoUserData
be_t<u32> reserved1;
};
enum CellDmuxPamfSamplingFrequency
enum CellDmuxPamfSamplingFrequency : s32
{
CELL_DMUX_PAMF_FS_48K = 48000,
};
enum CellDmuxPamfBitsPerSample
enum CellDmuxPamfBitsPerSample : s32
{
CELL_DMUX_PAMF_BITS_PER_SAMPLE_16 = 16,
CELL_DMUX_PAMF_BITS_PER_SAMPLE_24 = 24,
};
enum CellDmuxPamfLpcmChannelAssignmentInfo
enum CellDmuxPamfLpcmChannelAssignmentInfo : s32
{
CELL_DMUX_PAMF_LPCM_CH_M1 = 1,
CELL_DMUX_PAMF_LPCM_CH_LR = 3,
@ -133,12 +133,12 @@ enum CellDmuxPamfLpcmChannelAssignmentInfo
CELL_DMUX_PAMF_LPCM_CH_LRCLSCS1CS2RSLFE = 11,
};
enum CellDmuxPamfLpcmFs
enum CellDmuxPamfLpcmFs : s32
{
CELL_DMUX_PAMF_LPCM_FS_48K = 1,
};
enum CellDmuxPamfLpcmBitsPerSamples
enum CellDmuxPamfLpcmBitsPerSamples : s32
{
CELL_DMUX_PAMF_LPCM_BITS_PER_SAMPLE_16 = 1,
CELL_DMUX_PAMF_LPCM_BITS_PER_SAMPLE_24 = 3,
@ -146,20 +146,20 @@ enum CellDmuxPamfLpcmBitsPerSamples
struct CellDmuxMsg
{
be_t<CellDmuxMsgType> msgType; //CellDmuxMsgType enum
be_t<s32> msgType; // CellDmuxMsgType
be_t<u64> supplementalInfo;
};
struct CellDmuxEsMsg
{
be_t<CellDmuxEsMsgType> msgType; //CellDmuxEsMsgType enum
be_t<s32> msgType; // CellDmuxEsMsgType
be_t<u64> supplementalInfo;
};
struct CellDmuxType
{
be_t<CellDmuxStreamType> streamType;
be_t<u32> reserved[2]; //0
be_t<s32> streamType; // CellDmuxStreamType
be_t<u32> reserved[2];
};
struct CellDmuxPamfSpecificInfo
@ -170,7 +170,7 @@ struct CellDmuxPamfSpecificInfo
struct CellDmuxType2
{
be_t<CellDmuxStreamType> streamType;
be_t<s32> streamType; // CellDmuxStreamType
be_t<u32> streamSpecificInfo;
};
@ -219,7 +219,7 @@ struct CellDmuxResource2
be_t<u32> shit[4];
};
typedef u32(CellDmuxCbMsg)(u32 demuxerHandle, vm::ptr<CellDmuxMsg> demuxerMsg, u32 cbArg);
using CellDmuxCbMsg = func_def<u32(u32 demuxerHandle, vm::ptr<CellDmuxMsg> demuxerMsg, u32 cbArg)>;
struct CellDmuxCb
{
@ -227,7 +227,7 @@ struct CellDmuxCb
be_t<u32> cbArg;
};
typedef u32(CellDmuxCbEsMsg)(u32 demuxerHandle, u32 esHandle, vm::ptr<CellDmuxEsMsg> esMsg, u32 cbArg);
using CellDmuxCbEsMsg = func_def<u32(u32 demuxerHandle, u32 esHandle, vm::ptr<CellDmuxEsMsg> esMsg, u32 cbArg)>;
struct CellDmuxEsCb
{

8
rpcs3/Emu/SysCalls/Modules/cellFont.cpp
View file

@ -417,11 +417,11 @@ int cellFontGetCharGlyphMetrics(vm::ptr<CellFont> font, u32 code, vm::ptr<CellFo
metrics->width = (x1-x0) * scale;
metrics->height = (y1-y0) * scale;
metrics->Horizontal.bearingX = (float)leftSideBearing * scale;
metrics->Horizontal.bearingY = 0;
metrics->Horizontal.bearingY = 0.f;
metrics->Horizontal.advance = (float)advanceWidth * scale;
metrics->Vertical.bearingX = 0;
metrics->Vertical.bearingY = 0;
metrics->Vertical.advance = 0;
metrics->Vertical.bearingX = 0.f;
metrics->Vertical.bearingY = 0.f;
metrics->Vertical.advance = 0.f;
return CELL_FONT_OK;
}

2
rpcs3/Emu/SysCalls/Modules/cellFs.cpp
View file

@ -320,7 +320,7 @@ s32 cellFsStReadInit(u32 fd, vm::cptr<CellFsRingBuffer> ringbuf)
return CELL_FS_EINVAL;
}
if (ringbuf->block_size.data() & se64(0xfff)) // check if a multiple of sector size
if (ringbuf->block_size & 0xfff) // check if a multiple of sector size
{
return CELL_FS_EINVAL;
}

24
rpcs3/Emu/SysCalls/Modules/cellGcmSys.cpp
View file

@ -63,8 +63,8 @@ CellGcmOffsetTable offsetTable;
void InitOffsetTable()
{
offsetTable.ioAddress.set(be_t<u32>::make((u32)Memory.Alloc(3072 * sizeof(u16), 1)));
offsetTable.eaAddress.set(be_t<u32>::make((u32)Memory.Alloc(512 * sizeof(u16), 1)));
offsetTable.ioAddress.set((u32)Memory.Alloc(3072 * sizeof(u16), 1));
offsetTable.eaAddress.set((u32)Memory.Alloc(512 * sizeof(u16), 1));
memset(offsetTable.ioAddress.get_ptr(), 0xFF, 3072 * sizeof(u16));
memset(offsetTable.eaAddress.get_ptr(), 0xFF, 512 * sizeof(u16));
@ -317,7 +317,7 @@ void _cellGcmFunc15(vm::ptr<CellGcmContextData> context)
return;
}
size_t g_defaultCommandBufferBegin, g_defaultCommandBufferFragmentCount;
u32 g_defaultCommandBufferBegin, g_defaultCommandBufferFragmentCount;
// Called by cellGcmInit
s32 _cellGcmInitBody(vm::ptr<CellGcmContextData> context, u32 cmdSize, u32 ioSize, u32 ioAddress)
@ -368,7 +368,7 @@ s32 _cellGcmInitBody(vm::ptr<CellGcmContextData> context, u32 cmdSize, u32 ioSiz
current_context.begin = g_defaultCommandBufferBegin + 4096; // 4 kb reserved at the beginning
current_context.end = g_defaultCommandBufferBegin + 32 * 1024 - 4; // 4b at the end for jump
current_context.current = current_context.begin;
current_context.callback.set(be_t<u32>::make(Emu.GetRSXCallback() - 4));
current_context.callback.set(Emu.GetRSXCallback() - 4);
gcm_info.context_addr = Memory.MainMem.AllocAlign(0x1000);
gcm_info.control_addr = gcm_info.context_addr + 0x40;
@ -379,9 +379,9 @@ s32 _cellGcmInitBody(vm::ptr<CellGcmContextData> context, u32 cmdSize, u32 ioSiz
vm::write32(context.addr(), gcm_info.context_addr);
auto& ctrl = vm::get_ref<CellGcmControl>(gcm_info.control_addr);
ctrl.put.write_relaxed(be_t<u32>::make(0));
ctrl.get.write_relaxed(be_t<u32>::make(0));
ctrl.ref.write_relaxed(be_t<u32>::make(-1));
ctrl.put.write_relaxed(0);
ctrl.get.write_relaxed(0);
ctrl.ref.write_relaxed(-1);
auto& render = Emu.GetGSManager().GetRender();
render.m_ctxt_addr = context.addr();
@ -1164,7 +1164,7 @@ s32 cellGcmSetTile(u8 index, u8 location, u32 offset, u32 size, u32 pitch, u8 co
*/
static std::pair<u32, u32> getNextCommandBufferBeginEnd(u32 current)
{
size_t currentRange = (current - g_defaultCommandBufferBegin) / (32 * 1024);
u32 currentRange = (current - g_defaultCommandBufferBegin) / (32 * 1024);
if (currentRange >= g_defaultCommandBufferFragmentCount - 1)
return std::make_pair(g_defaultCommandBufferBegin + 4096, g_defaultCommandBufferBegin + 32 * 1024 - 4);
return std::make_pair(g_defaultCommandBufferBegin + (currentRange + 1) * 32 * 1024,
@ -1206,7 +1206,7 @@ s32 cellGcmCallback(vm::ptr<CellGcmContextData> context, u32 count)
auto& ctrl = vm::get_ref<CellGcmControl>(gcm_info.control_addr);
const std::chrono::time_point<std::chrono::system_clock> enterWait = std::chrono::system_clock::now();
// Flush command buffer (ie allow RSX to read up to context->current)
ctrl.put.exchange(be_t<u32>::make(getOffsetFromAddress(context->current)));
ctrl.put.exchange(getOffsetFromAddress(context->current));
std::pair<u32, u32> newCommandBuffer = getNextCommandBufferBeginEnd(context->current);
u32 offset = getOffsetFromAddress(newCommandBuffer.first);
@ -1235,7 +1235,7 @@ s32 cellGcmCallback(vm::ptr<CellGcmContextData> context, u32 count)
//if (0)
//{
// auto& ctrl = vm::get_ref<CellGcmControl>(gcm_info.control_addr);
// be_t<u32> res = be_t<u32>::make(context->current - context->begin - ctrl.put.read_relaxed());
// be_t<u32> res = context->current - context->begin - ctrl.put.read_relaxed();
// if (res != 0)
// {
@ -1246,7 +1246,7 @@ s32 cellGcmCallback(vm::ptr<CellGcmContextData> context, u32 count)
// context->current = context->begin + res;
// ctrl.put.write_relaxed(res);
// ctrl.get.write_relaxed(be_t<u32>::make(0));
// ctrl.get.write_relaxed(0);
// return CELL_OK;
//}
@ -1270,7 +1270,7 @@ s32 cellGcmCallback(vm::ptr<CellGcmContextData> context, u32 count)
// vm::write32(context->current, CELL_GCM_METHOD_FLAG_JUMP | offset); // set JUMP cmd
// auto& ctrl = vm::get_ref<CellGcmControl>(gcm_info.control_addr);
// ctrl.put.exchange(be_t<u32>::make(offset));
// ctrl.put.exchange(offset);
//}
//else
//{

2
rpcs3/Emu/SysCalls/Modules/cellPad.cpp
View file

@ -75,7 +75,7 @@ s32 cellPadPeriphGetInfo(vm::ptr<CellPadPeriphInfo> info)
sys_io.Warning("cellPadPeriphGetInfo(info_addr=0x%x)", info.addr());
// TODO: Support other types of controllers
for (int i = 0; i < info->now_connect; i++)
for (u32 i = 0; i < info->now_connect; i++)
{
info->pclass_type[i] = CELL_PAD_PCLASS_TYPE_STANDARD;
}

4
rpcs3/Emu/SysCalls/Modules/cellPamf.cpp
View file

@ -486,8 +486,8 @@ s32 cellPamfReaderGetStreamInfo(vm::ptr<CellPamfReader> pSelf, u32 pInfo_addr, u
if (header.AVC.aspectRatioIdc == 0xff)
{
info->sarWidth = header.AVC.sarWidth;
info->sarHeight = header.AVC.sarHeight;
info->sarWidth = header.AVC.sarInfo.width;
info->sarHeight = header.AVC.sarInfo.height;
}
else
{

22
rpcs3/Emu/SysCalls/Modules/cellPamf.h
View file

@ -284,13 +284,16 @@ struct PamfStreamHeader
be_t<u16> frameCropRightOffset;
be_t<u16> frameCropTopOffset;
be_t<u16> frameCropBottomOffset;
union
{
struct
{
be_t<u16> sarWidth;
be_t<u16> sarHeight;
};
be_t<u16> width;
be_t<u16> height;
}
sarInfo;
struct
{
u8 x14; // contains videoFormat and videoFullRangeFlag
@ -299,10 +302,11 @@ struct PamfStreamHeader
u8 matrixCoefficients;
};
};
u8 x18; // contains entropyCodingModeFlag, deblockingFilterFlag, minNumSlicePerPictureIdc, nfwIdc
u8 maxMeanBitrate;
} AVC;
}
AVC;
// M2V specific information
struct
@ -322,8 +326,8 @@ struct PamfStreamHeader
u8 colourPrimaries;
u8 transferCharacteristics;
u8 matrixCoefficients;
} M2V;
}
M2V;
// Audio specific information
struct
@ -332,8 +336,8 @@ struct PamfStreamHeader
u8 channels; // number of channels (1, 2, 6, 8)
u8 freq; // 1 (always 48000)
u8 bps; // LPCM only
} audio;
}
audio;
};
};

8
rpcs3/Emu/SysCalls/Modules/cellPng.h
View file

@ -2,7 +2,7 @@
namespace vm { using namespace ps3; }
enum CellPngTxtType
enum CellPngTxtType : s32
{
CELL_PNG_TEXT = 0,
CELL_PNG_ZTXT = 1,
@ -33,7 +33,7 @@ struct CellPngSPLTentry
be_t<u32> paletteEntriesNumber;
};
enum CellPngUnknownLocation
enum CellPngUnknownLocation : s32
{
CELL_PNG_BEFORE_PLTE = 1,
CELL_PNG_BEFORE_IDAT = 2,
@ -42,7 +42,7 @@ enum CellPngUnknownLocation
struct CellPngTextInfo
{
be_t<CellPngTxtType> txtType;
be_t<s32> txtType; // CellPngTxtType
vm::bptr<char> keyword;
vm::bptr<char> text;
be_t<u32> textLength;
@ -172,5 +172,5 @@ struct CellPngUnknownChunk
char chunkType[5];
vm::bptr<char> chunkData;
be_t<u32> length;
be_t<CellPngUnknownLocation> location;
be_t<s32> location; // CellPngUnknownLocation
};

47
rpcs3/Emu/SysCalls/Modules/cellSearch.h
View file

@ -5,7 +5,6 @@ namespace vm { using namespace ps3; }
// Error Codes
enum
{
CELL_SEARCH_OK = 0,
CELL_SEARCH_CANCELED = 1,
CELL_SEARCH_ERROR_PARAM = 0x8002C801,
CELL_SEARCH_ERROR_BUSY = 0x8002C802,
@ -41,7 +40,7 @@ enum
};
// Sort keys
enum
enum : s32
{
CELL_SEARCH_SORTKEY_NONE = 0,
CELL_SEARCH_SORTKEY_DEFAULT = 1,
@ -57,7 +56,7 @@ enum
};
// Sort order
enum
enum : s32
{
CELL_SEARCH_SORTORDER_NONE = 0,
CELL_SEARCH_SORTORDER_ASCENDING = 1,
@ -65,7 +64,7 @@ enum
};
// Content types
enum
enum : s32
{
CELL_SEARCH_CONTENTTYPE_NONE = 0,
CELL_SEARCH_CONTENTTYPE_MUSIC = 1,
@ -78,7 +77,7 @@ enum
};
// Codecs
enum CellSearchCodec
enum CellSearchCodec : s32
{
CELL_SEARCH_CODEC_UNKNOWN = 0,
CELL_SEARCH_CODEC_MPEG2 = 1,
@ -112,7 +111,7 @@ enum CellSearchCodec
};
// Scene types
enum CellSearchSceneType
enum CellSearchSceneType : s32
{
CELL_SEARCH_SCENETYPE_NONE = 0,
CELL_SEARCH_SCENETYPE_CHAPTER = 1,
@ -121,7 +120,7 @@ enum CellSearchSceneType
};
// List types
enum CellSearchListType
enum CellSearchListType : s32
{
CELL_SEARCH_LISTTYPE_MUSIC_ALBUM = 1,
CELL_SEARCH_LISTTYPE_MUSIC_GENRE = 2,
@ -130,7 +129,7 @@ enum CellSearchListType
};
// Content status
enum CellSearchContentStatus
enum CellSearchContentStatus : s32
{
CELL_SEARCH_CONTENTSTATUS_AVAILABLE,
CELL_SEARCH_CONTENTSTATUS_NOT_SUPPORTED,
@ -138,7 +137,7 @@ enum CellSearchContentStatus
};
// Search orientation
enum CellSearchOrientation
enum CellSearchOrientation : s32
{
CELL_SEARCH_ORIENTATION_UNKNOWN,
CELL_SEARCH_ORIENTATION_TOP_LEFT,
@ -148,13 +147,13 @@ enum CellSearchOrientation
};
// Search modes
enum CellSearchMode
enum CellSearchMode : s32
{
CELL_SEARCH_MODE_NORMAL = 0,
};
// Search events
enum CellSearchEvent
enum CellSearchEvent : s32
{
CELL_SEARCH_EVENT_NOTIFICATION = 0,
CELL_SEARCH_EVENT_INITIALIZE_RESULT,
@ -181,7 +180,7 @@ struct CellSearchResultParam
struct CellSearchMusicListInfo
{
be_t<CellSearchListType> listType;
be_t<s32> listType; // CellSearchListType
be_t<u32> numOfItems;
be_t<s64> duration;
char title[CELL_SEARCH_TITLE_LEN_MAX + 1];
@ -192,7 +191,7 @@ struct CellSearchMusicListInfo
struct CellSearchPhotoListInfo
{
be_t<CellSearchListType> listType;
be_t<s32> listType; // CellSearchListType
be_t<u32> numOfItems;
char title[CELL_SEARCH_TITLE_LEN_MAX + 1];
char reserved[3];
@ -200,7 +199,7 @@ struct CellSearchPhotoListInfo
struct CellSearchVideoListInfo
{
be_t<CellSearchListType> listType;
be_t<s32> listType; // CellSearchListType
be_t<u32> numOfItems;
be_t<s64> duration;
char title[CELL_SEARCH_TITLE_LEN_MAX + 1];
@ -220,8 +219,8 @@ struct CellSearchMusicInfo
be_t<s32> quantizationBitrate;
be_t<s32> playCount;
be_t<s32> drmEncrypted;
be_t<CellSearchCodec> codec;
be_t<CellSearchContentStatus> status;
be_t<s32> codec; // CellSearchCodec
be_t<s32> status; // CellSearchContentStatus
char diskNumber[8];
char title[CELL_SEARCH_TITLE_LEN_MAX + 1];
char reserved[3];
@ -240,9 +239,9 @@ struct CellSearchPhotoInfo
be_t<s64> takenDate;
be_t<s32> width;
be_t<s32> height;
be_t<CellSearchOrientation> orientation;
be_t<CellSearchCodec> codec;
be_t<CellSearchContentStatus> status;
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];
@ -259,9 +258,9 @@ struct CellSearchVideoInfo
be_t<s32> audioBitrate;
be_t<s32> playCount;
be_t<s32> drmEncrypted;
be_t<CellSearchCodec> videoCodec;
be_t<CellSearchCodec> audioCodec;
be_t<CellSearchContentStatus> status;
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];
@ -270,7 +269,7 @@ struct CellSearchVideoInfo
struct CellSearchVideoSceneInfo
{
be_t<CellSearchSceneType> sceneType;
be_t<s32> sceneType; // CellSearchSceneType
be_t<s64> startTime_ms;
be_t<s64> endTime_ms;
CellSearchContentId videoId;
@ -301,4 +300,4 @@ struct CellSearchTimeInfo
be_t<s64> takenDate;
be_t<s64> importedDate;
be_t<s64> modifiedDate;
};
};

55
rpcs3/Emu/SysCalls/Modules/cellSpurs.cpp
View file

@ -144,7 +144,7 @@ s32 cellSpursTasksetAttributeSetName(vm::ptr<CellSpursTasksetAttribute> attr, vm
s32 cellSpursTasksetAttributeSetTasksetSize(vm::ptr<CellSpursTasksetAttribute> attr, u32 size);
s32 cellSpursTasksetAttributeEnableClearLS(vm::ptr<CellSpursTasksetAttribute> attr, s32 enable);
s32 _cellSpursTasksetAttribute2Initialize(vm::ptr<CellSpursTasksetAttribute2> attribute, u32 revision);
s32 cellSpursCreateTaskset2(PPUThread& CPU, vm::ptr<CellSpurs> spurs, vm::ptr<CellSpursTaskset2> taskset, vm::ptr<CellSpursTasksetAttribute2> attr);
s32 cellSpursCreateTaskset2(PPUThread& CPU, vm::ptr<CellSpurs> spurs, vm::ptr<CellSpursTaskset> taskset, vm::ptr<CellSpursTasksetAttribute2> attr);
s32 cellSpursDestroyTaskset2();
s32 cellSpursTasksetSetExceptionEventHandler(vm::ptr<CellSpursTaskset> taskset, vm::ptr<CellSpursTasksetExceptionEventHandler> handler, vm::ptr<u64> arg);
s32 cellSpursTasksetUnsetExceptionEventHandler(vm::ptr<CellSpursTaskset> taskset);
@ -376,7 +376,7 @@ s32 spursAttachLv2EventQueue(PPUThread& CPU, vm::ptr<CellSpurs> spurs, u32 queue
*port = connectedPort;
if (!spursCreated)
{
spurs->spuPortBits |= be_t<u64>::make(1ull << connectedPort);
spurs->spuPortBits |= 1ull << connectedPort;
}
return CELL_OK;
@ -417,7 +417,7 @@ s32 spursDetachLv2EventQueue(vm::ptr<CellSpurs> spurs, u8 spuPort, bool spursCre
}
}
spurs->spuPortBits &= be_t<u64>::make(~mask);
spurs->spuPortBits &= ~mask;
}
return CELL_OK;
@ -578,7 +578,7 @@ s32 spursCreateHandler(vm::ptr<CellSpurs> spurs, u32 ppuPriority)
/// Invoke event handlers
s32 spursInvokeEventHandlers(PPUThread& CPU, vm::ptr<CellSpurs::EventPortMux> eventPortMux)
{
if (eventPortMux->reqPending.exchange(be_t<u32>::make(0)).data())
if (eventPortMux->reqPending.exchange(0).data())
{
const vm::ptr<CellSpurs::EventHandlerListNode> handlerList = eventPortMux->handlerList.exchange(vm::null);
@ -1028,7 +1028,7 @@ s32 spursInit(
if (!isSecond)
{
spurs->wklEnabled.write_relaxed(be_t<u32>::make(0xffff));
spurs->wklEnabled.write_relaxed(0xffff);
}
// Initialise trace
@ -1045,7 +1045,6 @@ s32 spursInit(
spurs->wklInfoSysSrv.arg = 0;
spurs->wklInfoSysSrv.uniqueId.write_relaxed(0xff);
auto sys_semaphore_attribute_initialize = [](vm::ptr<sys_semaphore_attribute_t> attr)
{
attr->protocol = SYS_SYNC_PRIORITY;
@ -1223,7 +1222,7 @@ s32 spursInit(
spurs->flags1 = (flags & SAF_EXIT_IF_NO_WORK ? SF1_EXIT_IF_NO_WORK : 0) | (isSecond ? SF1_32_WORKLOADS : 0);
spurs->wklFlagReceiver.write_relaxed(0xff);
spurs->wklFlag.flag.write_relaxed(be_t<u32>::make(-1));
spurs->wklFlag.flag.write_relaxed(-1);
spurs->handlerDirty.write_relaxed(0);
spurs->handlerWaiting.write_relaxed(0);
spurs->handlerExiting.write_relaxed(0);
@ -1809,7 +1808,7 @@ s32 cellSpursEnableExceptionEventHandler(vm::ptr<CellSpurs> spurs, bool flag)
}
s32 rc = CELL_OK;
auto oldEnableEH = spurs->enableEH.exchange(be_t<u32>::make(flag ? 1u : 0u));
auto oldEnableEH = spurs->enableEH.exchange(flag ? 1u : 0u);
if (flag)
{
if (oldEnableEH == 0)
@ -1848,14 +1847,14 @@ s32 cellSpursSetGlobalExceptionEventHandler(vm::ptr<CellSpurs> spurs, vm::ptr<Ce
return CELL_SPURS_CORE_ERROR_STAT;
}
auto handler = spurs->globalSpuExceptionHandler.compare_and_swap(be_t<u64>::make(0), be_t<u64>::make(1));
auto handler = spurs->globalSpuExceptionHandler.compare_and_swap(0, 1);
if (handler)
{
return CELL_SPURS_CORE_ERROR_BUSY;
}
spurs->globalSpuExceptionHandlerArgs = arg.addr();
spurs->globalSpuExceptionHandler.exchange(be_t<u64>::make(eaHandler.addr()));
spurs->globalSpuExceptionHandler.exchange(eaHandler.addr());
return CELL_OK;
}
@ -1866,7 +1865,7 @@ s32 cellSpursUnsetGlobalExceptionEventHandler(vm::ptr<CellSpurs> spurs)
cellSpurs.Warning("cellSpursUnsetGlobalExceptionEventHandler(spurs=*0x%x)", spurs);
spurs->globalSpuExceptionHandlerArgs = 0;
spurs->globalSpuExceptionHandler.exchange(be_t<u64>::make(0));
spurs->globalSpuExceptionHandler.exchange(0);
return CELL_OK;
}
@ -2312,7 +2311,7 @@ s32 spursAddWorkload(
v &= ~0xf;
v |= (maxContention > 8 ? 8 : maxContention);
});
spurs->wklSignal1._and_not({ be_t<u16>::make(0x8000 >> index) }); // clear bit in wklFlag1
spurs->wklSignal1._and_not({ 0x8000 >> index }); // clear bit in wklFlag1
}
else
{
@ -2321,7 +2320,7 @@ s32 spursAddWorkload(
v &= ~0xf0;
v |= (maxContention > 8 ? 8 : maxContention) << 4;
});
spurs->wklSignal2._and_not({ be_t<u16>::make(0x8000 >> index) }); // clear bit in wklFlag2
spurs->wklSignal2._and_not({ 0x8000 >> index }); // clear bit in wklFlag2
}
spurs->wklFlagReceiver.compare_and_swap(wnum, 0xff);
@ -2483,11 +2482,11 @@ s32 cellSpursSendWorkloadSignal(vm::ptr<CellSpurs> spurs, u32 wid)
if (wid >= CELL_SPURS_MAX_WORKLOAD)
{
spurs->wklSignal2 |= be_t<u16>::make(0x8000 >> (wid & 0x0F));
spurs->wklSignal2 |= 0x8000 >> (wid & 0x0F);
}
else
{
spurs->wklSignal1 |= be_t<u16>::make(0x8000 >> wid);
spurs->wklSignal1 |= 0x8000 >> wid;
}
return CELL_OK;
@ -2787,7 +2786,7 @@ s32 cellSpursEventFlagClear(vm::ptr<CellSpursEventFlag> eventFlag, u16 bits)
return CELL_SPURS_TASK_ERROR_ALIGN;
}
eventFlag->events &= be_t<u16>::make(~bits);
eventFlag->events &= ~bits;
return CELL_OK;
}
@ -3299,7 +3298,7 @@ s32 cellSpursEventFlagGetTasksetAddress(vm::ptr<CellSpursEventFlag> eventFlag, v
return CELL_SPURS_TASK_ERROR_ALIGN;
}
taskset->set(eventFlag->isIwl ? 0 : eventFlag->addr);
taskset->set(eventFlag->isIwl ? 0u : vm::cast(eventFlag->addr));
return CELL_OK;
}
@ -3691,17 +3690,17 @@ s32 _cellSpursSendSignal(PPUThread& CPU, vm::ptr<CellSpursTaskset> taskset, u32
return CELL_SPURS_TASK_ERROR_INVAL;
}
auto _0 = be_t<u128>::make(u128::from32(0));
auto disabled = taskset->enabled.value()._bit[taskId] ? false : true;
be_t<u128> _0(u128::from32(0));
bool disabled = taskset->enabled.value()._bit[taskId];
auto invalid = (taskset->ready & taskset->pending_ready) != _0 || (taskset->running & taskset->waiting) != _0 || disabled ||
((taskset->running | taskset->ready | taskset->pending_ready | taskset->waiting | taskset->signalled) & be_t<u128>::make(~taskset->enabled.value())) != _0;
((taskset->running | taskset->ready | taskset->pending_ready | taskset->waiting | taskset->signalled) & ~taskset->enabled) != _0;
if (invalid)
{
return CELL_SPURS_TASK_ERROR_SRCH;
}
auto shouldSignal = (taskset->waiting & be_t<u128>::make(~taskset->signalled.value()) & be_t<u128>::make(u128::fromBit(taskId))) != _0 ? true : false;
auto shouldSignal = ((taskset->waiting & ~taskset->signalled) & be_t<u128>(u128::fromBit(taskId))) != _0 ? true : false;
auto signalled = taskset->signalled.value();
signalled._bit[taskId] = true;
taskset->signalled = signalled;
@ -3880,23 +3879,19 @@ s32 cellSpursTaskGetContextSaveAreaSize()
return CELL_OK;
}
s32 cellSpursCreateTaskset2(PPUThread& CPU, vm::ptr<CellSpurs> spurs, vm::ptr<CellSpursTaskset2> taskset, vm::ptr<CellSpursTasksetAttribute2> attr)
s32 cellSpursCreateTaskset2(PPUThread& CPU, vm::ptr<CellSpurs> spurs, vm::ptr<CellSpursTaskset> taskset, vm::ptr<CellSpursTasksetAttribute2> attr)
{
cellSpurs.Warning("%s(spurs=0x%x, taskset=0x%x, attr=0x%x)", __FUNCTION__, spurs.addr(), taskset.addr(), attr.addr());
cellSpurs.Warning("cellSpursCreateTaskset2(spurs=*0x%x, taskset=*0x%x, attr=*0x%x)", spurs, taskset, attr);
vm::ptr<CellSpursTasksetAttribute2> tmp_attr;
vm::stackvar<CellSpursTasksetAttribute2> tmp_attr(CPU);
if (!attr)
{
attr.set(tmp_attr.addr());
attr = tmp_attr;
_cellSpursTasksetAttribute2Initialize(attr, 0);
}
auto rc = spursCreateTaskset(CPU, spurs, vm::ptr<CellSpursTaskset>::make(taskset.addr()), attr->args,
vm::cptr<u8[8]>::make(attr.addr() + offsetof(CellSpursTasksetAttribute, priority)),
attr->max_contention, attr->name, sizeof32(CellSpursTaskset2), (u8)attr->enable_clear_ls);
if (rc != CELL_OK)
if (s32 rc = spursCreateTaskset(CPU, spurs, taskset, attr->args, attr.of(&CellSpursTasksetAttribute2::priority), attr->max_contention, attr->name, sizeof32(CellSpursTaskset2), attr->enable_clear_ls))
{
return rc;
}

17
rpcs3/Emu/SysCalls/Modules/cellSpurs.h
View file

@ -143,7 +143,7 @@ enum SpursFlags1 : u8
SF1_EXIT_IF_NO_WORK = 0x80,
};
enum SpursWorkloadConstants : u64
enum SpursWorkloadConstants : u32
{
// Workload states
SPURS_WKL_STATE_NON_EXISTENT = 0,
@ -153,15 +153,18 @@ enum SpursWorkloadConstants : u64
SPURS_WKL_STATE_REMOVABLE = 4,
SPURS_WKL_STATE_INVALID = 5,
// GUID
SPURS_GUID_SYS_WKL = 0x1BB841BF38F89D33ull,
SPURS_GUID_TASKSET_PM = 0x836E915B2E654143ull,
// 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,
@ -617,8 +620,8 @@ struct set_alignment(128) CellSpursEventFlag
union
{
atomic_be_t<ControlSyncVar> ctrl;// 0x00
atomic_be_t<u16> events; // 0x00
atomic_be_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

44
rpcs3/Emu/SysCalls/Modules/cellSpursSpu.cpp
View file

@ -138,19 +138,19 @@ bool spursDma(SPUThread & spu, u32 cmd, u64 ea, u32 lsa, u32 size, u32 tag) {
u32 spursDmaGetCompletionStatus(SPUThread & spu, u32 tagMask) {
spu.set_ch_value(MFC_WrTagMask, tagMask);
spu.set_ch_value(MFC_WrTagUpdate, MFC_TAG_UPDATE_IMMEDIATE);
return spu.get_ch_value(MFC_RdTagStat);
return spu.get_ch_value(MFC_RdTagStat);
}
/// Wait for DMA operations to complete
u32 spursDmaWaitForCompletion(SPUThread & spu, u32 tagMask, bool waitForAll) {
spu.set_ch_value(MFC_WrTagMask, tagMask);
spu.set_ch_value(MFC_WrTagUpdate, waitForAll ? MFC_TAG_UPDATE_ALL : MFC_TAG_UPDATE_ANY);
return spu.get_ch_value(MFC_RdTagStat);
return spu.get_ch_value(MFC_RdTagStat);
}
/// Halt the SPU
void spursHalt(SPUThread & spu) {
spu.halt();
spu.halt();
}
//----------------------------------------------------------------------------
@ -253,12 +253,12 @@ bool spursKernel1SelectWorkload(SPUThread & spu) {
if (!isPoll || wklSelectedId == ctxt->wklCurrentId) {
// Clear workload signal for the selected workload
spurs->wklSignal1.write_relaxed(be_t<u16>::make(spurs->wklSignal1.read_relaxed() & ~(0x8000 >> wklSelectedId)));
spurs->wklSignal2.write_relaxed(be_t<u16>::make(spurs->wklSignal1.read_relaxed() & ~(0x80000000u >> wklSelectedId)));
spurs->wklSignal1.write_relaxed(spurs->wklSignal1.read_relaxed() & ~(0x8000 >> wklSelectedId));
spurs->wklSignal2.write_relaxed(spurs->wklSignal1.read_relaxed() & ~(0x80000000u >> wklSelectedId));
// If the selected workload is the wklFlag workload then pull the wklFlag to all 1s
if (wklSelectedId == spurs->wklFlagReceiver.read_relaxed()) {
spurs->wklFlag.flag.write_relaxed(be_t<u32>::make(0xFFFFFFFF));
spurs->wklFlag.flag.write_relaxed(0xFFFFFFFF);
}
}
}
@ -405,12 +405,12 @@ bool spursKernel2SelectWorkload(SPUThread & spu) {
if (!isPoll || wklSelectedId == ctxt->wklCurrentId) {
// Clear workload signal for the selected workload
spurs->wklSignal1.write_relaxed(be_t<u16>::make(spurs->wklSignal1.read_relaxed() & ~(0x8000 >> wklSelectedId)));
spurs->wklSignal2.write_relaxed(be_t<u16>::make(spurs->wklSignal1.read_relaxed() & ~(0x80000000u >> wklSelectedId)));
spurs->wklSignal1.write_relaxed(spurs->wklSignal1.read_relaxed() & ~(0x8000 >> wklSelectedId));
spurs->wklSignal2.write_relaxed(spurs->wklSignal1.read_relaxed() & ~(0x80000000u >> wklSelectedId));
// If the selected workload is the wklFlag workload then pull the wklFlag to all 1s
if (wklSelectedId == spurs->wklFlagReceiver.read_relaxed()) {
spurs->wklFlag.flag.write_relaxed(be_t<u32>::make(0xFFFFFFFF));
spurs->wklFlag.flag.write_relaxed(0xFFFFFFFF);
}
}
}
@ -1179,15 +1179,15 @@ s32 spursTasksetProcessRequest(SPUThread & spu, s32 request, u32 * taskId, u32 *
auto taskset = ctxt->taskset.priv_ptr();
// Verify taskset state is valid
auto _0 = be_t<u128>::make(u128::from32(0));
be_t<u128> _0(u128::from32(0));
if ((taskset->waiting & taskset->running) != _0 || (taskset->ready & taskset->pending_ready) != _0 ||
((taskset->running | taskset->ready | taskset->pending_ready | taskset->signalled | taskset->waiting) & be_t<u128>::make(~taskset->enabled.value())) != _0) {
((taskset->running | taskset->ready | taskset->pending_ready | taskset->signalled | taskset->waiting) & ~taskset->enabled) != _0) {
assert(!"Invalid taskset state");
spursHalt(spu);
}
// Find the number of tasks that have become ready since the last iteration
auto newlyReadyTasks = (taskset->signalled | taskset->pending_ready).value() & ~taskset->ready.value();
auto newlyReadyTasks = (taskset->signalled | taskset->pending_ready) & ~taskset->ready.value();
numNewlyReadyTasks = 0;
for (auto i = 0; i < 128; i++) {
if (newlyReadyTasks._bit[i]) {
@ -1197,11 +1197,11 @@ s32 spursTasksetProcessRequest(SPUThread & spu, s32 request, u32 * taskId, u32 *
u128 readyButNotRunning;
u8 selectedTaskId;
auto running = taskset->running.value();
auto waiting = taskset->waiting.value();
auto enabled = taskset->enabled.value();
auto signalled = (taskset->signalled & (taskset->ready | taskset->pending_ready)).value();
auto ready = (taskset->signalled | taskset->ready | taskset->pending_ready).value();
u128 running = taskset->running.value();
u128 waiting = taskset->waiting.value();
u128 enabled = taskset->enabled.value();
u128 signalled = (taskset->signalled & (taskset->ready | taskset->pending_ready));
u128 ready = (taskset->signalled | taskset->ready | taskset->pending_ready);
switch (request) {
case SPURS_TASKSET_REQUEST_POLL_SIGNAL:
@ -1420,8 +1420,8 @@ s32 spursTasketSaveTaskContext(SPUThread & spu) {
u128 r;
spu.FPSCR.Read(r);
ctxt->savedContextFpscr = r;
ctxt->savedSpuWriteEventMask = spu.get_ch_value(SPU_RdEventMask);
ctxt->savedWriteTagGroupQueryMask = spu.get_ch_value(MFC_RdTagMask);
ctxt->savedSpuWriteEventMask = spu.get_ch_value(SPU_RdEventMask);
ctxt->savedWriteTagGroupQueryMask = spu.get_ch_value(MFC_RdTagMask);
// Store the processor context
const u32 contextSaveStorage = vm::cast(taskInfo->context_save_storage_and_alloc_ls_blocks & -0x80);
@ -1577,8 +1577,8 @@ s32 spursTasksetProcessSyscall(SPUThread & spu, u32 syscallNum, u32 args) {
spursTasksetProcessRequest(spu, SPURS_TASKSET_REQUEST_DESTROY_TASK, nullptr, nullptr);
}
auto addr = ctxt->x2FD4 == 4 ? taskset->x78 : ctxt->x2FC0;
auto args = ctxt->x2FD4 == 4 ? 0 : ctxt->x2FC8;
const u64 addr = ctxt->x2FD4 == 4 ? taskset->x78 : ctxt->x2FC0;
const u64 args = ctxt->x2FD4 == 4 ? 0 : ctxt->x2FC8.value();
spursTasksetOnTaskExit(spu, addr, ctxt->taskId, ctxt->taskExitCode, args);
}
@ -1695,7 +1695,7 @@ s32 spursTasksetLoadElf(SPUThread & spu, u32 * entryPoint, u32 * lowestLoadAddr,
return CELL_SPURS_TASK_ERROR_FAULT;
}
_lowestLoadAddr = _lowestLoadAddr > phdr.data_be.p_vaddr ? phdr.data_be.p_vaddr : _lowestLoadAddr;
_lowestLoadAddr > phdr.data_be.p_vaddr ? _lowestLoadAddr = phdr.data_be.p_vaddr : _lowestLoadAddr;
}
}
}

34
rpcs3/Emu/SysCalls/Modules/cellSync.cpp
View file

@ -58,12 +58,12 @@ s32 cellSyncMutexLock(vm::ptr<CellSyncMutex> mutex)
}
// prx: increase acquire_count and remember its old value
const auto order = mutex->acquire_count++;
const auto order = mutex->cnt.acq++;
// prx: wait until release_count is equal to old acquire_count
g_sync_mutex_wm.wait_op(mutex.addr(), [mutex, order]()
{
return order == mutex->release_count.read_relaxed();
return order == mutex->cnt.rel.read_relaxed();
});
mutex->sync_var.read_sync();
@ -88,7 +88,7 @@ s32 cellSyncMutexTryLock(vm::ptr<CellSyncMutex> mutex)
// prx: lock only if acquire_count and release_count are equal
return mutex->sync_var.atomic_op(CELL_OK, [](CellSyncMutex::sync_t& mutex) -> s32
{
return (mutex.acquire_count++ != mutex.release_count) ? CELL_SYNC_ERROR_BUSY : CELL_OK;
return (mutex.cnt_acq++ != mutex.cnt_rel) ? CELL_SYNC_ERROR_BUSY : CELL_OK;
});
}
@ -106,7 +106,7 @@ s32 cellSyncMutexUnlock(vm::ptr<CellSyncMutex> mutex)
}
// prx: increase release count
mutex->release_count++;
mutex->cnt.rel++;
g_sync_mutex_wm.notify(mutex.addr());
@ -129,7 +129,7 @@ s32 syncBarrierInitialize(vm::ptr<CellSyncBarrier> barrier, u16 total_count)
}
// prx: zeroize first u16, write total_count in second u16 and sync
barrier->data.exchange({ be_t<s16>::make(0), be_t<s16>::make(total_count) });
barrier->data.exchange({ 0, total_count });
return CELL_OK;
}
@ -452,7 +452,7 @@ s32 cellSyncRwmTryWrite(vm::ptr<CellSyncRwm> rwm, vm::cptr<void> buffer)
}
// prx: compare m_readers | m_writers with 0, return if not zero, set m_writers to 1
if (!rwm->data.compare_and_swap_test({}, { be_t<u16>::make(0), be_t<u16>::make(1) }))
if (!rwm->data.compare_and_swap_test({ 0, 0 }, { 0, 1 }))
{
return CELL_SYNC_ERROR_BUSY;
}
@ -556,7 +556,7 @@ s32 cellSyncQueuePush(vm::ptr<CellSyncQueue> queue, vm::cptr<void> buffer)
memcpy(&queue->m_buffer[position * size], buffer.get_ptr(), size);
// prx: atomically insert 0 in 5th u8
queue->data &= { be_t<u32>::make(~0), be_t<u32>::make(0xffffff) };
queue->data &= { 0xffffffffu, 0x00ffffff };
g_sync_queue_wm.notify(queue.addr());
@ -593,7 +593,7 @@ s32 cellSyncQueueTryPush(vm::ptr<CellSyncQueue> queue, vm::cptr<void> buffer)
memcpy(&queue->m_buffer[position * size], buffer.get_ptr(), size);
queue->data &= { be_t<u32>::make(~0), be_t<u32>::make(0xffffff) };
queue->data &= { 0xffffffffu, 0x00ffffff };
g_sync_queue_wm.notify(queue.addr());
@ -653,7 +653,7 @@ s32 cellSyncQueuePop(vm::ptr<CellSyncQueue> queue, vm::ptr<void> buffer)
memcpy(buffer.get_ptr(), &queue->m_buffer[position * size], size);
// prx: atomically insert 0 in first u8
queue->data &= { be_t<u32>::make(0xffffff), be_t<u32>::make(~0) };
queue->data &= { 0x00ffffff, 0xffffffffu };
g_sync_queue_wm.notify(queue.addr());
@ -690,7 +690,7 @@ s32 cellSyncQueueTryPop(vm::ptr<CellSyncQueue> queue, vm::ptr<void> buffer)
memcpy(buffer.get_ptr(), &queue->m_buffer[position * size], size);
queue->data &= { be_t<u32>::make(0xffffff), be_t<u32>::make(~0) };
queue->data &= { 0x00ffffff, 0xffffffffu };
g_sync_queue_wm.notify(queue.addr());
@ -742,7 +742,7 @@ s32 cellSyncQueuePeek(vm::ptr<CellSyncQueue> queue, vm::ptr<void> buffer)
memcpy(buffer.get_ptr(), &queue->m_buffer[position * size], size);
queue->data &= { be_t<u32>::make(0xffffff), be_t<u32>::make(~0) };
queue->data &= { 0x00ffffff, 0xffffffffu };
g_sync_queue_wm.notify(queue.addr());
@ -779,7 +779,7 @@ s32 cellSyncQueueTryPeek(vm::ptr<CellSyncQueue> queue, vm::ptr<void> buffer)
memcpy(buffer.get_ptr(), &queue->m_buffer[position * size], size);
queue->data &= { be_t<u32>::make(0xffffff), be_t<u32>::make(~0) };
queue->data &= { 0x00ffffff, 0xffffffffu };
g_sync_queue_wm.notify(queue.addr());
@ -890,13 +890,13 @@ void syncLFQueueInit(vm::ptr<CellSyncLFQueue> queue, vm::ptr<u8> buffer, u32 siz
//m_bs[2]
//m_bs[3]
queue->m_v1 = -1;
queue->push2 = { { be_t<u16>::make(-1) } };
queue->pop2 = { { be_t<u16>::make(-1) } };
queue->push2 = { { 0xffff } };
queue->pop2 = { { 0xffff } };
}
else
{
queue->pop1 = { { be_t<u16>::make(0), be_t<u16>::make(0), queue->pop1.read_relaxed().m_h3, be_t<u16>::make(0) } };
queue->push1 = { { be_t<u16>::make(0), be_t<u16>::make(0), queue->push1.read_relaxed().m_h7, be_t<u16>::make(0) } };
queue->pop1 = { { 0, 0, queue->pop1.read_relaxed().m_h3, 0 } };
queue->push1 = { { 0, 0, queue->push1.read_relaxed().m_h7, 0 } };
queue->m_bs[0] = -1; // written as u32
queue->m_bs[1] = -1;
queue->m_bs[2] = -1;
@ -1829,7 +1829,7 @@ s32 _cellSyncLFQueueGetSignalAddress(vm::cptr<CellSyncLFQueue> queue, vm::pptr<v
return CELL_OK;
}
s32 cellSyncLFQueueGetDirection(vm::cptr<CellSyncLFQueue> queue, vm::ptr<CellSyncQueueDirection> direction)
s32 cellSyncLFQueueGetDirection(vm::cptr<CellSyncLFQueue> queue, vm::ptr<u32> direction)
{
cellSync.Log("cellSyncLFQueueGetDirection(queue=*0x%x, direction=*0x%x)", queue, direction);

15
rpcs3/Emu/SysCalls/Modules/cellSync.h
View file

@ -35,15 +35,16 @@ union set_alignment(4) CellSyncMutex
{
struct sync_t
{
be_t<u16> release_count; // increased when mutex is unlocked
be_t<u16> acquire_count; // increased when mutex is locked
be_t<u16> cnt_rel; // increased when mutex is unlocked
be_t<u16> cnt_acq; // increased when mutex is locked
};
struct
{
atomic_be_t<u16> release_count;
atomic_be_t<u16> acquire_count;
};
atomic_be_t<u16> rel;
atomic_be_t<u16> acq;
}
cnt;
atomic_be_t<sync_t> sync_var;
};
@ -157,9 +158,9 @@ struct set_alignment(128) CellSyncLFQueue
be_t<u32> m_size; // 0x10
be_t<u32> m_depth; // 0x14
vm::bptr<u8, u64> m_buffer; // 0x18
vm::bptr<u8, u64> m_buffer; // 0x18
u8 m_bs[4]; // 0x20
be_t<CellSyncQueueDirection> m_direction; // 0x24
be_t<u32> m_direction; // 0x24 CellSyncQueueDirection
be_t<u32> m_v1; // 0x28
atomic_be_t<u32> init; // 0x2C
atomic_be_t<push2_t> push2; // 0x30

20
rpcs3/Emu/SysCalls/Modules/cellVdec.cpp
View file

@ -23,7 +23,7 @@ extern Module cellVdec;
#define VDEC_ERROR(...) { cellVdec.Error(__VA_ARGS__); Emu.Pause(); return; } // only for decoder thread
VideoDecoder::VideoDecoder(CellVdecCodecType type, u32 profile, u32 addr, u32 size, vm::ptr<CellVdecCbMsg> func, u32 arg)
VideoDecoder::VideoDecoder(s32 type, u32 profile, u32 addr, u32 size, vm::ptr<CellVdecCbMsg> func, u32 arg)
: type(type)
, profile(profile)
, memAddr(addr)
@ -189,7 +189,7 @@ next:
}
}
u32 vdecQueryAttr(CellVdecCodecType type, u32 profile, u32 spec_addr /* may be 0 */, vm::ptr<CellVdecAttr> attr)
u32 vdecQueryAttr(s32 type, u32 profile, u32 spec_addr /* may be 0 */, vm::ptr<CellVdecAttr> attr)
{
switch (type) // TODO: check profile levels
{
@ -827,23 +827,23 @@ s32 cellVdecGetPicItem(u32 handle, vm::pptr<CellVdecPicItem> picItem)
info->startAddr = 0x00000123; // invalid value (no address for picture)
info->size = align(av_image_get_buffer_size(vdec->ctx->pix_fmt, vdec->ctx->width, vdec->ctx->height, 1), 128);
info->auNum = 1;
info->auPts[0].lower = (u32)vf.pts;
info->auPts[0].upper = vf.pts >> 32;
info->auPts[0].lower = (u32)(vf.pts);
info->auPts[0].upper = (u32)(vf.pts >> 32);
info->auPts[1].lower = (u32)CODEC_TS_INVALID;
info->auPts[1].upper = (u32)CODEC_TS_INVALID;
info->auDts[0].lower = (u32)vf.dts;
info->auDts[0].upper = vf.dts >> 32;
info->auDts[0].lower = (u32)(vf.dts);
info->auDts[0].upper = (u32)(vf.dts >> 32);
info->auDts[1].lower = (u32)CODEC_TS_INVALID;
info->auDts[1].upper = (u32)CODEC_TS_INVALID;
info->auUserData[0] = vf.userdata;
info->auUserData[1] = 0;
info->status = CELL_OK;
info->attr = CELL_VDEC_PICITEM_ATTR_NORMAL;
info->picInfo_addr = info.addr() + sizeof(CellVdecPicItem);
info->picInfo_addr = info.addr() + sizeof32(CellVdecPicItem);
if (vdec->type == CELL_VDEC_CODEC_TYPE_AVC)
{
auto avc = vm::ptr<CellVdecAvcInfo>::make(info.addr() + sizeof(CellVdecPicItem));
auto avc = vm::ptr<CellVdecAvcInfo>::make(info.addr() + sizeof32(CellVdecPicItem));
avc->horizontalSize = frame.width;
avc->verticalSize = frame.height;
@ -897,7 +897,7 @@ s32 cellVdecGetPicItem(u32 handle, vm::pptr<CellVdecPicItem> picItem)
}
else if (vdec->type == CELL_VDEC_CODEC_TYPE_DIVX)
{
auto dvx = vm::ptr<CellVdecDivxInfo>::make(info.addr() + sizeof(CellVdecPicItem));
auto dvx = vm::ptr<CellVdecDivxInfo>::make(info.addr() + sizeof32(CellVdecPicItem));
switch (frame.pict_type)
{
@ -931,7 +931,7 @@ s32 cellVdecGetPicItem(u32 handle, vm::pptr<CellVdecPicItem> picItem)
}
else if (vdec->type == CELL_VDEC_CODEC_TYPE_MPEG2)
{
auto mp2 = vm::ptr<CellVdecMpeg2Info>::make(info.addr() + sizeof(CellVdecPicItem));
auto mp2 = vm::ptr<CellVdecMpeg2Info>::make(info.addr() + sizeof32(CellVdecPicItem));
cellVdec.Fatal("cellVdecGetPicItem(MPEG2)");
}

49
rpcs3/Emu/SysCalls/Modules/cellVdec.h
View file

@ -14,15 +14,15 @@ enum
CELL_VDEC_ERROR_FATAL = 0x80610180,
};
enum CellVdecCodecType : u32
enum CellVdecCodecType : s32
{
CELL_VDEC_CODEC_TYPE_MPEG2 = 0x00000000,
CELL_VDEC_CODEC_TYPE_AVC = 0x00000001,
CELL_VDEC_CODEC_TYPE_DIVX = 0x00000005,
CELL_VDEC_CODEC_TYPE_MPEG2 = 0,
CELL_VDEC_CODEC_TYPE_AVC = 1,
CELL_VDEC_CODEC_TYPE_DIVX = 5,
};
// Callback Messages
enum CellVdecMsgType : u32
enum CellVdecMsgType : s32
{
CELL_VDEC_MSG_TYPE_AUDONE, // decoding finished
CELL_VDEC_MSG_TYPE_PICOUT, // picture done
@ -31,7 +31,7 @@ enum CellVdecMsgType : u32
};
// Decoder Operation Mode
enum CellVdecDecodeMode : u32
enum CellVdecDecodeMode : s32
{
CELL_VDEC_DEC_MODE_NORMAL,
CELL_VDEC_DEC_MODE_B_SKIP,
@ -39,7 +39,7 @@ enum CellVdecDecodeMode : u32
};
// Output Picture Format Type
enum CellVdecPicFormatType : u32
enum CellVdecPicFormatType : s32
{
CELL_VDEC_PICFMT_ARGB32_ILV,
CELL_VDEC_PICFMT_RGBA32_ILV,
@ -48,13 +48,13 @@ enum CellVdecPicFormatType : u32
};
// Output Color Matrix Coef
enum CellVdecColorMatrixType : u32
enum CellVdecColorMatrixType : s32
{
CELL_VDEC_COLOR_MATRIX_TYPE_BT601,
CELL_VDEC_COLOR_MATRIX_TYPE_BT709,
};
enum CellVdecPicAttr : u32
enum CellVdecPicAttr : s32
{
CELL_VDEC_PICITEM_ATTR_NORMAL,
CELL_VDEC_PICITEM_ATTR_SKIPPED,
@ -76,14 +76,14 @@ enum CellVdecFrameRate : u8
// Codec Type Information
struct CellVdecType
{
be_t<CellVdecCodecType> codecType;
be_t<s32> codecType; // CellVdecCodecType
be_t<u32> profileLevel;
};
// Extended Codec Type Information
struct CellVdecTypeEx
{
be_t<CellVdecCodecType> codecType;
be_t<s32> codecType; // CellVdecCodecType
be_t<u32> profileLevel;
be_t<u32> codecSpecificInfo_addr;
};
@ -128,9 +128,6 @@ struct CellVdecResourceEx
be_t<u32> spursResource_addr;
};
// Presentation Time Stamp
typedef CellCodecTimeStamp CellVdecTimeStamp;
// Access Unit Information
struct CellVdecAuInfo
{
@ -145,7 +142,7 @@ struct CellVdecAuInfo
// Output Picture Information
struct CellVdecPicItem
{
be_t<CellVdecCodecType> codecType;
be_t<s32> codecType; // CellVdecCodecType
be_t<u32> startAddr;
be_t<u32> size;
u8 auNum;
@ -153,28 +150,28 @@ struct CellVdecPicItem
CellCodecTimeStamp auDts[2];
be_t<u64> auUserData[2];
be_t<s32> status;
be_t<CellVdecPicAttr> attr;
be_t<s32> attr; // CellVdecPicAttr
be_t<u32> picInfo_addr;
};
// Output Picture Format
struct CellVdecPicFormat
{
be_t<CellVdecPicFormatType> formatType;
be_t<CellVdecColorMatrixType> colorMatrixType;
be_t<s32> formatType; // CellVdecPicFormatType
be_t<s32> colorMatrixType; // CellVdecColorMatrixType
u8 alpha;
};
struct CellVdecPicFormat2
{
be_t<CellVdecPicFormatType> formatType;
be_t<CellVdecColorMatrixType> colorMatrixType;
be_t<s32> formatType; // CellVdecPicFormatType
be_t<s32> colorMatrixType; // CellVdecColorMatrixType
be_t<u32> unk0;
u8 alpha;
be_t<u32> unk1;
};
typedef u32(CellVdecCbMsg)(u32 handle, CellVdecMsgType msgType, s32 msgData, u32 cbArg);
using CellVdecCbMsg = func_def<u32(u32 handle, CellVdecMsgType msgType, s32 msgData, u32 cbArg)>;
// Callback Function Information
struct CellVdecCb
@ -470,7 +467,7 @@ struct CellVdecDivxInfo
DIVX_transferCharacteristics transferCharacteristics;
DIVX_matrixCoefficients matrixCoefficients;
DIVX_pictureStruct pictureStruct;
be_t<DIVX_frameRateCode> frameRateCode;
be_t<u16> frameRateCode; // DIVX_frameRateCode
};
enum MPEG2_level
@ -640,8 +637,8 @@ struct CellVdecMpeg2Info
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<MPEG2_headerFlags> headerPresentFlags;
be_t<MPEG2_headerFlags> headerRetentionFlags;
be_t<u32> headerPresentFlags; // MPEG2_headerFlags
be_t<u32> headerRetentionFlags; // MPEG2_headerFlags
bool mpeg1Flag;
u8 ccDataLength[2];
u8 ccData[2][128];
@ -719,7 +716,7 @@ public:
squeue_t<VdecFrame> frames;
const CellVdecCodecType type;
const s32 type;
const u32 profile;
const u32 memAddr;
const u32 memSize;
@ -734,7 +731,7 @@ public:
PPUThread* vdecCb;
VideoDecoder(CellVdecCodecType type, u32 profile, u32 addr, u32 size, vm::ptr<CellVdecCbMsg> func, u32 arg);
VideoDecoder(s32 type, u32 profile, u32 addr, u32 size, vm::ptr<CellVdecCbMsg> func, u32 arg);
~VideoDecoder();
};

70
rpcs3/Emu/SysCalls/Modules/cellVpost.h
View file

@ -139,23 +139,23 @@ enum
CELL_VPOST_CSC_ERROR_E_FATAL_SPUCORE_FAIL = 0x806184c2,
};
enum CellVpostPictureDepth
enum CellVpostPictureDepth : s32
{
CELL_VPOST_PIC_DEPTH_8,
};
enum CellVpostPictureFormatIn
enum CellVpostPictureFormatIn : s32
{
CELL_VPOST_PIC_FMT_IN_YUV420_PLANAR,
};
enum CellVpostPictureFormatOut
enum CellVpostPictureFormatOut : s32
{
CELL_VPOST_PIC_FMT_OUT_RGBA_ILV,
CELL_VPOST_PIC_FMT_OUT_YUV420_PLANAR,
};
enum CellVpostPictureStructure
enum CellVpostPictureStructure : s32
{
CELL_VPOST_PIC_STRUCT_PFRM,
CELL_VPOST_PIC_STRUCT_IFRM,
@ -163,7 +163,7 @@ enum CellVpostPictureStructure
CELL_VPOST_PIC_STRUCT_IBTM,
};
enum CellVpostExecType
enum CellVpostExecType : s32
{
CELL_VPOST_EXEC_TYPE_PFRM_PFRM,
CELL_VPOST_EXEC_TYPE_PTOP_ITOP,
@ -175,31 +175,31 @@ enum CellVpostExecType
CELL_VPOST_EXEC_TYPE_IBTM_IBTM,
};
enum CellVpostChromaPositionType
enum CellVpostChromaPositionType : s32
{
CELL_VPOST_CHROMA_POS_TYPE_A,
CELL_VPOST_CHROMA_POS_TYPE_B,
};
enum CellVpostScanType
enum CellVpostScanType : s32
{
CELL_VPOST_SCAN_TYPE_P,
CELL_VPOST_SCAN_TYPE_I,
};
enum CellVpostQuantRange
enum CellVpostQuantRange : s32
{
CELL_VPOST_QUANT_RANGE_FULL,
CELL_VPOST_QUANT_RANGE_BROADCAST,
};
enum CellVpostColorMatrix
enum CellVpostColorMatrix : s32
{
CELL_VPOST_COLOR_MATRIX_BT601,
CELL_VPOST_COLOR_MATRIX_BT709,
};
enum CellVpostScalerType
enum CellVpostScalerType : s32
{
CELL_VPOST_SCALER_TYPE_BILINEAR,
CELL_VPOST_SCALER_TYPE_LINEAR_SHARP,
@ -207,7 +207,7 @@ enum CellVpostScalerType
CELL_VPOST_SCALER_TYPE_8X4TAP,
};
enum CellVpostIpcType
enum CellVpostIpcType : s32
{
CELL_VPOST_IPC_TYPE_DOUBLING,
CELL_VPOST_IPC_TYPE_LINEAR,
@ -218,13 +218,13 @@ struct CellVpostCfgParam
{
be_t<u32> inMaxWidth;
be_t<u32> inMaxHeight;
be_t<CellVpostPictureDepth> inDepth;
be_t<CellVpostPictureFormatIn> inPicFmt;
be_t<s32> inDepth; // CellVpostPictureDepth
be_t<s32> inPicFmt; // CellVpostPictureFormatIn
be_t<u32> outMaxWidth;
be_t<u32> outMaxHeight;
be_t<CellVpostPictureDepth> outDepth;
be_t<CellVpostPictureFormatOut> outPicFmt;
be_t<s32> outDepth; // CellVpostPictureDepth
be_t<s32> outPicFmt; // CellVpostPictureFormatOut
be_t<u32> reserved1;
be_t<u32> reserved2;
@ -267,16 +267,16 @@ struct CellVpostWindow
struct CellVpostCtrlParam
{
be_t<CellVpostExecType> execType;
be_t<s32> execType; // CellVpostExecType
be_t<CellVpostScalerType> scalerType;
be_t<CellVpostIpcType> ipcType;
be_t<s32> scalerType; // CellVpostScalerType
be_t<s32> ipcType; // CellVpostIpcType
be_t<u32> inWidth;
be_t<u32> inHeight;
be_t<CellVpostChromaPositionType> inChromaPosType;
be_t<CellVpostQuantRange> inQuantRange;
be_t<CellVpostColorMatrix> inColorMatrix;
be_t<s32> inChromaPosType; // CellVpostChromaPositionType
be_t<s32> inQuantRange; // CellVpostQuantRange
be_t<s32> inColorMatrix; // CellVpostColorMatrix
CellVpostWindow inWindow;
be_t<u32> outWidth;
@ -294,23 +294,23 @@ struct CellVpostPictureInfo
{
be_t<u32> inWidth;
be_t<u32> inHeight;
be_t<CellVpostPictureDepth> inDepth;
be_t<CellVpostScanType> inScanType;
be_t<CellVpostPictureFormatIn> inPicFmt;
be_t<CellVpostChromaPositionType> inChromaPosType;
be_t<CellVpostPictureStructure> inPicStruct;
be_t<CellVpostQuantRange> inQuantRange;
be_t<CellVpostColorMatrix> inColorMatrix;
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<CellVpostPictureDepth> outDepth;
be_t<CellVpostScanType> outScanType;
be_t<CellVpostPictureFormatOut> outPicFmt;
be_t<CellVpostChromaPositionType> outChromaPosType;
be_t<CellVpostPictureStructure> outPicStruct;
be_t<CellVpostQuantRange> outQuantRange;
be_t<CellVpostColorMatrix> outColorMatrix;
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;

62
rpcs3/Emu/SysCalls/Modules/sysPrxForUser.cpp
View file

@ -112,7 +112,7 @@ s32 sys_lwmutex_create(vm::ptr<sys_lwmutex_t> lwmutex, vm::ptr<sys_lwmutex_attri
default: sysPrxForUser.Error("sys_lwmutex_create(): invalid protocol (0x%x)", protocol); return CELL_EINVAL;
}
lwmutex->lock_var = { { lwmutex::free, lwmutex::zero } };
lwmutex->lock_var = { { lwmutex_free, 0 } };
lwmutex->attribute = attr->recursive | attr->protocol;
lwmutex->recursive_count = 0;
lwmutex->sleep_queue = Emu.GetIdManager().make<lv2_lwmutex_t>(protocol, attr->name_u64);
@ -125,7 +125,7 @@ s32 sys_lwmutex_destroy(PPUThread& CPU, vm::ptr<sys_lwmutex_t> lwmutex)
sysPrxForUser.Log("sys_lwmutex_destroy(lwmutex=*0x%x)", lwmutex);
// check to prevent recursive locking in the next call
if (lwmutex->owner.read_relaxed() == CPU.GetId())
if (lwmutex->vars.owner.read_relaxed() == CPU.GetId())
{
return CELL_EBUSY;
}
@ -146,7 +146,7 @@ s32 sys_lwmutex_destroy(PPUThread& CPU, vm::ptr<sys_lwmutex_t> lwmutex)
}
// deleting succeeded
lwmutex->owner.exchange(lwmutex::dead);
lwmutex->vars.owner.exchange(lwmutex_dead);
return CELL_OK;
}
@ -155,10 +155,10 @@ s32 sys_lwmutex_lock(PPUThread& CPU, vm::ptr<sys_lwmutex_t> lwmutex, u64 timeout
{
sysPrxForUser.Log("sys_lwmutex_lock(lwmutex=*0x%x, timeout=0x%llx)", lwmutex, timeout);
const be_t<u32> tid = be_t<u32>::make(CPU.GetId());
const be_t<u32> tid = CPU.GetId();
// try to lock lightweight mutex
const be_t<u32> old_owner = lwmutex->owner.compare_and_swap(lwmutex::free, tid);
const be_t<u32> old_owner = lwmutex->vars.owner.compare_and_swap(lwmutex_free, tid);
if (old_owner.data() == se32(lwmutex_free))
{
@ -197,9 +197,9 @@ s32 sys_lwmutex_lock(PPUThread& CPU, vm::ptr<sys_lwmutex_t> lwmutex, u64 timeout
for (u32 i = 0; i < 300; i++)
{
if (lwmutex->owner.read_relaxed().data() == se32(lwmutex_free))
if (lwmutex->vars.owner.read_relaxed().data() == se32(lwmutex_free))
{
if (lwmutex->owner.compare_and_swap_test(lwmutex::free, tid))
if (lwmutex->vars.owner.compare_and_swap_test(lwmutex_free, tid))
{
// locking succeeded
return CELL_OK;
@ -210,7 +210,7 @@ s32 sys_lwmutex_lock(PPUThread& CPU, vm::ptr<sys_lwmutex_t> lwmutex, u64 timeout
// atomically increment waiter value using 64 bit op
lwmutex->all_info++;
if (lwmutex->owner.compare_and_swap_test(lwmutex::free, tid))
if (lwmutex->vars.owner.compare_and_swap_test(lwmutex_free, tid))
{
// locking succeeded
lwmutex->all_info--;
@ -226,7 +226,7 @@ s32 sys_lwmutex_lock(PPUThread& CPU, vm::ptr<sys_lwmutex_t> lwmutex, u64 timeout
if (res == CELL_OK)
{
// locking succeeded
auto old = lwmutex->owner.exchange(tid);
auto old = lwmutex->vars.owner.exchange(tid);
if (old.data() != se32(lwmutex_reserved) && !Emu.IsStopped())
{
@ -249,10 +249,10 @@ s32 sys_lwmutex_trylock(PPUThread& CPU, vm::ptr<sys_lwmutex_t> lwmutex)
{
sysPrxForUser.Log("sys_lwmutex_trylock(lwmutex=*0x%x)", lwmutex);
const be_t<u32> tid = be_t<u32>::make(CPU.GetId());
const be_t<u32> tid = CPU.GetId();
// try to lock lightweight mutex
const be_t<u32> old_owner = lwmutex->owner.compare_and_swap(lwmutex::free, tid);
const be_t<u32> old_owner = lwmutex->vars.owner.compare_and_swap(lwmutex_free, tid);
if (old_owner.data() == se32(lwmutex_free))
{
@ -297,7 +297,7 @@ s32 sys_lwmutex_trylock(PPUThread& CPU, vm::ptr<sys_lwmutex_t> lwmutex)
if (res == CELL_OK)
{
// locking succeeded
auto old = lwmutex->owner.exchange(tid);
auto old = lwmutex->vars.owner.exchange(tid);
if (old.data() != se32(lwmutex_reserved) && !Emu.IsStopped())
{
@ -316,10 +316,10 @@ s32 sys_lwmutex_unlock(PPUThread& CPU, vm::ptr<sys_lwmutex_t> lwmutex)
{
sysPrxForUser.Log("sys_lwmutex_unlock(lwmutex=*0x%x)", lwmutex);
const be_t<u32> tid = be_t<u32>::make(CPU.GetId());
const be_t<u32> tid = CPU.GetId();
// check owner
if (lwmutex->owner.read_relaxed() != tid)
if (lwmutex->vars.owner.read_relaxed() != tid)
{
return CELL_EPERM;
}
@ -333,7 +333,7 @@ s32 sys_lwmutex_unlock(PPUThread& CPU, vm::ptr<sys_lwmutex_t> lwmutex)
}
// ensure that waiter is zero
if (lwmutex->lock_var.compare_and_swap_test({ tid, lwmutex::zero }, { lwmutex::free, lwmutex::zero }))
if (lwmutex->lock_var.compare_and_swap_test({ tid, 0 }, { lwmutex_free, 0 }))
{
// unlocking succeeded
return CELL_OK;
@ -345,7 +345,7 @@ s32 sys_lwmutex_unlock(PPUThread& CPU, vm::ptr<sys_lwmutex_t> lwmutex)
}
// set special value
lwmutex->owner.exchange(lwmutex::reserved);
lwmutex->vars.owner.exchange(lwmutex_reserved);
// call the syscall
if (_sys_lwmutex_unlock(lwmutex->sleep_queue) == CELL_ESRCH)
@ -392,7 +392,7 @@ s32 sys_lwcond_signal(PPUThread& CPU, vm::ptr<sys_lwcond_t> lwcond)
//return _sys_lwcond_signal(lwcond->lwcond_queue, 0, -1, 2);
}
if (lwmutex->owner.read_relaxed() == CPU.GetId())
if (lwmutex->vars.owner.read_relaxed() == CPU.GetId())
{
// if owns the mutex
lwmutex->all_info++;
@ -450,7 +450,7 @@ s32 sys_lwcond_signal_all(PPUThread& CPU, vm::ptr<sys_lwcond_t> lwcond)
//return _sys_lwcond_signal_all(lwcond->lwcond_queue, lwmutex->sleep_queue, 2);
}
if (lwmutex->owner.read_relaxed() == CPU.GetId())
if (lwmutex->vars.owner.read_relaxed() == CPU.GetId())
{
// if owns the mutex, call the syscall
const s32 res = _sys_lwcond_signal_all(lwcond->lwcond_queue, lwmutex->sleep_queue, 1);
@ -507,7 +507,7 @@ s32 sys_lwcond_signal_to(PPUThread& CPU, vm::ptr<sys_lwcond_t> lwcond, u32 ppu_t
//return _sys_lwcond_signal(lwcond->lwcond_queue, 0, ppu_thread_id, 2);
}
if (lwmutex->owner.read_relaxed() == CPU.GetId())
if (lwmutex->vars.owner.read_relaxed() == CPU.GetId())
{
// if owns the mutex
lwmutex->all_info++;
@ -557,11 +557,11 @@ s32 sys_lwcond_wait(PPUThread& CPU, vm::ptr<sys_lwcond_t> lwcond, u64 timeout)
{
sysPrxForUser.Log("sys_lwcond_wait(lwcond=*0x%x, timeout=0x%llx)", lwcond, timeout);
const be_t<u32> tid = be_t<u32>::make(CPU.GetId());
const be_t<u32> tid = CPU.GetId();
const vm::ptr<sys_lwmutex_t> lwmutex = lwcond->lwmutex;
if (lwmutex->owner.read_relaxed() != tid)
if (lwmutex->vars.owner.read_relaxed() != tid)
{
// if not owner of the mutex
return CELL_EPERM;
@ -571,7 +571,7 @@ s32 sys_lwcond_wait(PPUThread& CPU, vm::ptr<sys_lwcond_t> lwcond, u64 timeout)
const be_t<u32> recursive_value = lwmutex->recursive_count;
// set special value
lwmutex->owner = { lwmutex::reserved };
lwmutex->vars.owner = { lwmutex_reserved };
lwmutex->recursive_count = 0;
// call the syscall
@ -585,7 +585,7 @@ s32 sys_lwcond_wait(PPUThread& CPU, vm::ptr<sys_lwcond_t> lwcond, u64 timeout)
}
// restore owner and recursive value
const auto old = lwmutex->owner.exchange(tid);
const auto old = lwmutex->vars.owner.exchange(tid);
lwmutex->recursive_count = recursive_value;
if (old.data() != se32(lwmutex_reserved) && !Emu.IsStopped())
@ -614,7 +614,7 @@ s32 sys_lwcond_wait(PPUThread& CPU, vm::ptr<sys_lwcond_t> lwcond, u64 timeout)
if (res == CELL_EDEADLK)
{
// restore owner and recursive value
const auto old = lwmutex->owner.exchange(tid);
const auto old = lwmutex->vars.owner.exchange(tid);
lwmutex->recursive_count = recursive_value;
if (old.data() != se32(lwmutex_reserved) && !Emu.IsStopped())
@ -743,7 +743,7 @@ std::string ps3_fmt(PPUThread& context, vm::cptr<char> fmt, u32 g_count, u32 f_c
case 's':
{
// string
auto string = vm::cptr<char>::make(context.get_next_gpr_arg(g_count, f_count, v_count));
auto string = vm::cptr<char, u64>::make(context.get_next_gpr_arg(g_count, f_count, v_count));
if (plus_sign || minus_sign || space_sign || number_sign || zero_padding || width || prec) break;
@ -904,7 +904,7 @@ s32 sys_raw_spu_image_load(s32 id, vm::ptr<sys_spu_image> img)
const auto stamp1 = get_system_time();
vm::write32(RAW_SPU_BASE_ADDR + RAW_SPU_OFFSET * id + RAW_SPU_PROB_OFFSET + SPU_NPC_offs, img->entry_point | be_t<u32>::make(1));
vm::write32(RAW_SPU_BASE_ADDR + RAW_SPU_OFFSET * id + RAW_SPU_PROB_OFFSET + SPU_NPC_offs, img->entry_point | 1);
const auto stamp2 = get_system_time();
@ -1179,7 +1179,7 @@ void sys_spinlock_initialize(vm::ptr<atomic_be_t<u32>> lock)
sysPrxForUser.Log("sys_spinlock_initialize(lock=*0x%x)", lock);
// prx: set 0 and sync
lock->exchange(be_t<u32>::make(0));
lock->exchange(0);
}
void sys_spinlock_lock(vm::ptr<atomic_be_t<u32>> lock)
@ -1187,7 +1187,7 @@ void sys_spinlock_lock(vm::ptr<atomic_be_t<u32>> lock)
sysPrxForUser.Log("sys_spinlock_lock(lock=*0x%x)", lock);
// prx: exchange with 0xabadcafe, repeat until exchanged with 0
while (lock->exchange(be_t<u32>::make(0xabadcafe)).data())
while (lock->exchange(0xabadcafe).data())
{
g_sys_spinlock_wm.wait_op(lock.addr(), [lock](){ return lock->read_relaxed().data() == 0; });
@ -1204,7 +1204,7 @@ s32 sys_spinlock_trylock(vm::ptr<atomic_be_t<u32>> lock)
sysPrxForUser.Log("sys_spinlock_trylock(lock=*0x%x)", lock);
// prx: exchange with 0xabadcafe, translate exchanged value
if (lock->exchange(be_t<u32>::make(0xabadcafe)).data())
if (lock->exchange(0xabadcafe).data())
{
return CELL_EBUSY;
}
@ -1217,7 +1217,7 @@ void sys_spinlock_unlock(vm::ptr<atomic_be_t<u32>> lock)
sysPrxForUser.Log("sys_spinlock_unlock(lock=*0x%x)", lock);
// prx: sync and set 0
lock->exchange(be_t<u32>::make(0));
lock->exchange(0);
g_sys_spinlock_wm.notify(lock.addr());
}
@ -1274,7 +1274,7 @@ void sys_ppu_thread_once(PPUThread& CPU, vm::ptr<atomic_be_t<u32>> once_ctrl, vm
std::lock_guard<std::mutex> lock(g_once_mutex);
if (once_ctrl->compare_and_swap_test(be_t<u32>::make(SYS_PPU_THREAD_ONCE_INIT), be_t<u32>::make(SYS_PPU_THREAD_DONE_INIT)))
if (once_ctrl->compare_and_swap_test(SYS_PPU_THREAD_ONCE_INIT, SYS_PPU_THREAD_DONE_INIT))
{
// call init function using current thread context
init(CPU);

27
rpcs3/Emu/SysCalls/lv2/sys_lwmutex.h
View file

@ -16,29 +16,11 @@ struct sys_lwmutex_attribute_t
enum : u32
{
lwmutex_zero = 0u,
lwmutex_free = 0u - 1u,
lwmutex_dead = 0u - 2u,
lwmutex_reserved = 0u - 3u,
lwmutex_free = 0xffffffffu,
lwmutex_dead = 0xfffffffeu,
lwmutex_reserved = 0xfffffffdu,
};
namespace lwmutex
{
template<u32 _value>
struct const_be_u32_t
{
operator const be_t<u32>() const
{
return be_t<u32>::make(_value);
}
};
static const_be_u32_t<lwmutex_zero> zero;
static const_be_u32_t<lwmutex_free> free;
static const_be_u32_t<lwmutex_dead> dead;
static const_be_u32_t<lwmutex_reserved> reserved;
}
struct sys_lwmutex_t
{
struct sync_var_t
@ -55,7 +37,8 @@ struct sys_lwmutex_t
{
atomic_be_t<u32> owner;
atomic_be_t<u32> waiter;
};
}
vars;
atomic_be_t<u64> all_info;
};

4
rpcs3/Emu/SysCalls/lv2/sys_prx.cpp
View file

@ -192,7 +192,7 @@ s32 sys_prx_start_module(s32 id, u64 flags, vm::ptr<sys_prx_start_module_option_
// return CELL_PRX_ERROR_ALREADY_STARTED;
//prx->is_started = true;
pOpt->entry_point.set(be_t<u64>::make(prx->start ? prx->start.addr() : ~0ull));
pOpt->entry_point.set(prx->start ? prx->start.addr() : ~0ull);
return CELL_OK;
}
@ -212,7 +212,7 @@ s32 sys_prx_stop_module(s32 id, u64 flags, vm::ptr<sys_prx_stop_module_option_t>
// return CELL_PRX_ERROR_ALREADY_STOPPED;
//prx->is_started = false;
pOpt->entry_point.set(be_t<u64>::make(prx->stop ? prx->stop.addr() : -1));
pOpt->entry_point.set(prx->stop ? prx->stop.addr() : -1);
return CELL_OK;
}

38
rpcs3/Loader/ELF32.cpp
View file

@ -36,23 +36,23 @@ namespace loader
return bad_file;
}
if (m_ehdr.data_le.e_phnum && (m_ehdr.is_le() ? m_ehdr.data_le.e_phentsize : m_ehdr.data_be.e_phentsize) != sizeof(phdr))
if (m_ehdr.data_le.e_phnum && (m_ehdr.is_le() ? m_ehdr.data_le.e_phentsize != sizeof(phdr) : m_ehdr.data_be.e_phentsize != sizeof(phdr)))
{
return broken_file;
}
if (m_ehdr.data_le.e_shnum && (m_ehdr.is_le() ? m_ehdr.data_le.e_shentsize : m_ehdr.data_be.e_shentsize) != sizeof(shdr))
if (m_ehdr.data_le.e_shnum && (m_ehdr.is_le() ? m_ehdr.data_le.e_shentsize != sizeof(shdr) : m_ehdr.data_be.e_shentsize != sizeof(shdr)))
{
return broken_file;
}
LOG_WARNING(LOADER, "m_ehdr.e_type = 0x%x", (u16)(m_ehdr.is_le() ? m_ehdr.data_le.e_type : m_ehdr.data_be.e_type));
LOG_WARNING(LOADER, "m_ehdr.e_type = 0x%x", m_ehdr.is_le() ? m_ehdr.data_le.e_type : m_ehdr.data_be.e_type.value());
if (m_ehdr.data_le.e_phnum)
{
m_phdrs.resize(m_ehdr.is_le() ? m_ehdr.data_le.e_phnum : m_ehdr.data_be.e_phnum);
m_stream->Seek(handler::get_stream_offset() + (m_ehdr.is_le() ? m_ehdr.data_le.e_phoff : m_ehdr.data_be.e_phoff));
size_t size = (m_ehdr.is_le() ? m_ehdr.data_le.e_phnum : m_ehdr.data_be.e_phnum) * sizeof(phdr);
m_phdrs.resize(m_ehdr.is_le() ? m_ehdr.data_le.e_phnum : m_ehdr.data_be.e_phnum.value());
m_stream->Seek(handler::get_stream_offset() + (m_ehdr.is_le() ? m_ehdr.data_le.e_phoff : m_ehdr.data_be.e_phoff.value()));
size_t size = (m_ehdr.is_le() ? m_ehdr.data_le.e_phnum : m_ehdr.data_be.e_phnum.value()) * sizeof(phdr);
if (m_stream->Read(m_phdrs.data(), size) != size)
return broken_file;
@ -60,9 +60,9 @@ namespace loader
if (m_ehdr.data_le.e_shnum)
{
m_shdrs.resize(m_ehdr.is_le() ? m_ehdr.data_le.e_shnum : m_ehdr.data_be.e_shnum);
m_stream->Seek(handler::get_stream_offset() + (m_ehdr.is_le() ? m_ehdr.data_le.e_shoff : m_ehdr.data_be.e_shoff));
size_t size = (m_ehdr.is_le() ? m_ehdr.data_le.e_shnum : m_ehdr.data_be.e_shnum) * sizeof(shdr);
m_shdrs.resize(m_ehdr.is_le() ? m_ehdr.data_le.e_shnum : m_ehdr.data_be.e_shnum.value());
m_stream->Seek(handler::get_stream_offset() + (m_ehdr.is_le() ? m_ehdr.data_le.e_shoff : m_ehdr.data_be.e_shoff.value()));
size_t size = (m_ehdr.is_le() ? m_ehdr.data_le.e_shnum : m_ehdr.data_be.e_shnum.value()) * sizeof(shdr);
if (m_stream->Read(m_shdrs.data(), size) != size)
return broken_file;
@ -74,7 +74,7 @@ namespace loader
handler::error_code elf32::load()
{
Elf_Machine machine;
switch (machine = (Elf_Machine)(u16)(m_ehdr.is_le() ? m_ehdr.data_le.e_machine : m_ehdr.data_be.e_machine))
switch (machine = (Elf_Machine)(u16)(m_ehdr.is_le() ? m_ehdr.data_le.e_machine : m_ehdr.data_be.e_machine.value()))
{
case MACHINE_MIPS: vm::psp::init(); break;
case MACHINE_ARM: vm::psv::init(); break;
@ -401,13 +401,13 @@ namespace loader
armv7_decoder_initialize(code_start, code_end);
const std::string& thread_name = proc_param->sceUserMainThreadName ? proc_param->sceUserMainThreadName.get_ptr() : "main_thread";
const u32 stack_size = proc_param->sceUserMainThreadStackSize ? *proc_param->sceUserMainThreadStackSize : 256 * 1024;
const u32 priority = proc_param->sceUserMainThreadPriority ? *proc_param->sceUserMainThreadPriority : 160;
const u32 stack_size = proc_param->sceUserMainThreadStackSize ? proc_param->sceUserMainThreadStackSize->value() : 256 * 1024;
const u32 priority = proc_param->sceUserMainThreadPriority ? proc_param->sceUserMainThreadPriority->value() : 160;
armv7_thread(entry, thread_name, stack_size, priority).args({ Emu.GetPath(), "-emu" }).run();
break;
}
case MACHINE_SPU: spu_thread(m_ehdr.is_le() ? m_ehdr.data_le.e_entry : m_ehdr.data_be.e_entry, "main_thread").args({ Emu.GetPath()/*, "-emu"*/ }).run(); break;
case MACHINE_SPU: spu_thread(m_ehdr.is_le() ? m_ehdr.data_le.e_entry : m_ehdr.data_be.e_entry.value(), "main_thread").args({ Emu.GetPath()/*, "-emu"*/ }).run(); break;
}
return ok;
@ -415,16 +415,16 @@ namespace loader
handler::error_code elf32::load_data(u32 offset, bool skip_writeable)
{
Elf_Machine machine = (Elf_Machine)(u16)(m_ehdr.is_le() ? m_ehdr.data_le.e_machine : m_ehdr.data_be.e_machine);
Elf_Machine machine = (Elf_Machine)(u16)(m_ehdr.is_le() ? m_ehdr.data_le.e_machine : m_ehdr.data_be.e_machine.value());
for (auto &phdr : m_phdrs)
{
u32 memsz = m_ehdr.is_le() ? phdr.data_le.p_memsz : phdr.data_be.p_memsz;
u32 filesz = m_ehdr.is_le() ? phdr.data_le.p_filesz : phdr.data_be.p_filesz;
u32 vaddr = offset + (m_ehdr.is_le() ? phdr.data_le.p_vaddr : phdr.data_be.p_vaddr);
u32 offset = m_ehdr.is_le() ? phdr.data_le.p_offset : phdr.data_be.p_offset;
u32 memsz = m_ehdr.is_le() ? phdr.data_le.p_memsz : phdr.data_be.p_memsz.value();
u32 filesz = m_ehdr.is_le() ? phdr.data_le.p_filesz : phdr.data_be.p_filesz.value();
u32 vaddr = offset + (m_ehdr.is_le() ? phdr.data_le.p_vaddr : phdr.data_be.p_vaddr.value());
u32 offset = m_ehdr.is_le() ? phdr.data_le.p_offset : phdr.data_be.p_offset.value();
switch (m_ehdr.is_le() ? phdr.data_le.p_type : phdr.data_be.p_type)
switch (m_ehdr.is_le() ? phdr.data_le.p_type : phdr.data_be.p_type.value())
{
case 0x00000001: //LOAD
if (phdr.data_le.p_memsz)

4
rpcs3/Loader/ELF64.cpp
View file

@ -117,7 +117,7 @@ namespace loader
return loading_error;
}
segment.initial_addr.set(phdr.p_vaddr.addr());
segment.initial_addr = phdr.p_vaddr;
LOG_WARNING(LOADER, "segment addr=0x%x, initial addr = 0x%x", segment.begin.addr(), segment.initial_addr.addr());
if (phdr.p_filesz)
@ -365,7 +365,7 @@ namespace loader
{
for (auto &e : m.second.exports)
{
auto code = vm::cptr<u32>::make(vm::check_addr(e.second, 8) ? vm::read32(e.second) : 0);
auto code = vm::cptr<u32>::make(vm::check_addr(e.second, 8) ? vm::read32(e.second).value() : 0);
bool is_empty = !code || (code[0] == 0x38600000 && code[1] == BLR());

30
rpcs3/Loader/TROPUSR.cpp
View file

@ -140,20 +140,8 @@ bool TROPUSRLoader::Generate(const std::string& filepath, const std::string& con
default: trophy_grade = 0;
}
TROPUSREntry4 entry4 = {
be_t<u32>::make(4),
be_t<u32>::make(sizeof(TROPUSREntry4) - 0x10),
be_t<u32>::make((u32)m_table4.size()),
be_t<u32>::make(0),
be_t<u32>::make(trophy_id),
be_t<u32>::make(trophy_grade),
be_t<u32>::make(0xFFFFFFFF) };
TROPUSREntry6 entry6 = {
be_t<u32>::make(6),
be_t<u32>::make(sizeof(TROPUSREntry6) - 0x10),
be_t<u32>::make((u32)m_table6.size()),
be_t<u32>::make(0),
be_t<u32>::make(trophy_id) };
TROPUSREntry4 entry4 = { 4, sizeof32(TROPUSREntry4) - 0x10, (u32)m_table4.size(), 0, trophy_id, trophy_grade, 0xFFFFFFFF };
TROPUSREntry6 entry6 = { 6, sizeof32(TROPUSREntry6) - 0x10, (u32)m_table6.size(), 0, trophy_id };
m_table4.push_back(entry4);
m_table6.push_back(entry6);
@ -161,19 +149,9 @@ bool TROPUSRLoader::Generate(const std::string& filepath, const std::string& con
}
u64 offset = sizeof(TROPUSRHeader) + 2 * sizeof(TROPUSRTableHeader);
TROPUSRTableHeader table4header = {
be_t<u32>::make(4),
be_t<u32>::make(sizeof(TROPUSREntry4) - 0x10),
be_t<u32>::make(1),
be_t<u32>::make((u32)m_table4.size()),
be_t<u64>::make(offset) };
TROPUSRTableHeader table4header = { 4, sizeof32(TROPUSREntry4) - 0x10, 1, (u32)m_table4.size(), offset };
offset += m_table4.size() * sizeof(TROPUSREntry4);
TROPUSRTableHeader table6header = {
be_t<u32>::make(6),
be_t<u32>::make(sizeof(TROPUSREntry6) - 0x10),
be_t<u32>::make(1),
be_t<u32>::make((u32)m_table6.size()),
be_t<u64>::make(offset) };
TROPUSRTableHeader table6header = { 6, sizeof32(TROPUSREntry6) - 0x10, 1, (u32)m_table6.size(), offset };
offset += m_table6.size() * sizeof(TROPUSREntry6);
m_tableHeaders.clear();