split rpcs3 and hle libraries

merge rpcs3 utilities

ps3fw/include/rpcsx/fw/ps3/StaticHLE.h

@@ -0,0 +1,35 @@
+#pragma once
+
+#include "util/types.hpp"
+#include "Emu/Memory/vm_ptr.h"
+#include <vector>
+
+struct shle_pattern
+{
+	u16 start_pattern[32];
+	u8 crc16_length;
+	u16 crc16;
+	u16 total_length;
+	std::string _module;
+	std::string name;
+
+	u32 fnid;
+};
+
+class statichle_handler
+{
+public:
+	statichle_handler(int);
+	~statichle_handler();
+
+	statichle_handler(const statichle_handler&) = delete;
+	statichle_handler& operator=(const statichle_handler&) = delete;
+
+	bool load_patterns();
+	bool check_against_patterns(vm::cptr<u8>& data, u32 size, u32 addr);
+
+protected:
+	static u16 gen_CRC16(const u8* data_p, usz length);
+
+	std::vector<shle_pattern> hle_patterns;
+};

ps3fw/include/rpcsx/fw/ps3/cellAtrac.h

@@ -0,0 +1,61 @@
+#pragma once
+
+#include "Emu/Memory/vm_ptr.h"
+
+// Return Codes
+enum CellAtracError : u32
+{
+	CELL_ATRAC_ERROR_API_FAIL = 0x80610301,
+	CELL_ATRAC_ERROR_READSIZE_OVER_BUFFER = 0x80610311,
+	CELL_ATRAC_ERROR_UNKNOWN_FORMAT = 0x80610312,
+	CELL_ATRAC_ERROR_READSIZE_IS_TOO_SMALL = 0x80610313,
+	CELL_ATRAC_ERROR_ILLEGAL_SAMPLING_RATE = 0x80610314,
+	CELL_ATRAC_ERROR_ILLEGAL_DATA = 0x80610315,
+	CELL_ATRAC_ERROR_NO_DECODER = 0x80610321,
+	CELL_ATRAC_ERROR_UNSET_DATA = 0x80610322,
+	CELL_ATRAC_ERROR_DECODER_WAS_CREATED = 0x80610323,
+	CELL_ATRAC_ERROR_ALLDATA_WAS_DECODED = 0x80610331,
+	CELL_ATRAC_ERROR_NODATA_IN_BUFFER = 0x80610332,
+	CELL_ATRAC_ERROR_NOT_ALIGNED_OUT_BUFFER = 0x80610333,
+	CELL_ATRAC_ERROR_NEED_SECOND_BUFFER = 0x80610334,
+	CELL_ATRAC_ERROR_ALLDATA_IS_ONMEMORY = 0x80610341,
+	CELL_ATRAC_ERROR_ADD_DATA_IS_TOO_BIG = 0x80610342,
+	CELL_ATRAC_ERROR_NONEED_SECOND_BUFFER = 0x80610351,
+	CELL_ATRAC_ERROR_UNSET_LOOP_NUM = 0x80610361,
+	CELL_ATRAC_ERROR_ILLEGAL_SAMPLE = 0x80610371,
+	CELL_ATRAC_ERROR_ILLEGAL_RESET_BYTE = 0x80610372,
+	CELL_ATRAC_ERROR_ILLEGAL_PPU_THREAD_PRIORITY = 0x80610381,
+	CELL_ATRAC_ERROR_ILLEGAL_SPU_THREAD_PRIORITY = 0x80610382,
+};
+
+// Remain Frame
+enum : s32
+{
+	CELL_ATRAC_ALLDATA_IS_ON_MEMORY = -1,
+	CELL_ATRAC_NONLOOP_STREAM_DATA_IS_ON_MEMORY = -2,
+	CELL_ATRAC_LOOP_STREAM_DATA_IS_ON_MEMORY = -3,
+};
+
+enum
+{
+	CELL_ATRAC_HANDLE_SIZE = 512
+};
+
+struct alignas(8) CellAtracHandle
+{
+	u8 ucWorkMem[CELL_ATRAC_HANDLE_SIZE];
+};
+
+struct CellAtracBufferInfo
+{
+	vm::bptr<u8> pucWriteAddr;
+	be_t<u32> uiWritableByte;
+	be_t<u32> uiMinWriteByte;
+	be_t<u32> uiReadPosition;
+};
+
+struct CellAtracExtRes
+{
+	vm::bptr<struct CellSpurs> pSpurs;
+	u8 priority[8];
+};

ps3fw/include/rpcsx/fw/ps3/cellAtracMulti.h

@@ -0,0 +1,62 @@
+#pragma once
+
+#include "Emu/Memory/vm_ptr.h"
+
+// Return Codes
+enum CellAtracMultiError : u32
+{
+	CELL_ATRACMULTI_ERROR_API_FAIL = 0x80610b01,
+	CELL_ATRACMULTI_ERROR_READSIZE_OVER_BUFFER = 0x80610b11,
+	CELL_ATRACMULTI_ERROR_UNKNOWN_FORMAT = 0x80610b12,
+	CELL_ATRACMULTI_ERROR_READSIZE_IS_TOO_SMALL = 0x80610b13,
+	CELL_ATRACMULTI_ERROR_ILLEGAL_SAMPLING_RATE = 0x80610b14,
+	CELL_ATRACMULTI_ERROR_ILLEGAL_DATA = 0x80610b15,
+	CELL_ATRACMULTI_ERROR_NO_DECODER = 0x80610b21,
+	CELL_ATRACMULTI_ERROR_UNSET_DATA = 0x80610b22,
+	CELL_ATRACMULTI_ERROR_DECODER_WAS_CREATED = 0x80610b23,
+	CELL_ATRACMULTI_ERROR_ALLDATA_WAS_DECODED = 0x80610b31,
+	CELL_ATRACMULTI_ERROR_NODATA_IN_BUFFER = 0x80610b32,
+	CELL_ATRACMULTI_ERROR_NOT_ALIGNED_OUT_BUFFER = 0x80610b33,
+	CELL_ATRACMULTI_ERROR_NEED_SECOND_BUFFER = 0x80610b34,
+	CELL_ATRACMULTI_ERROR_ALLDATA_IS_ONMEMORY = 0x80610b41,
+	CELL_ATRACMULTI_ERROR_ADD_DATA_IS_TOO_BIG = 0x80610b42,
+	CELL_ATRACMULTI_ERROR_NONEED_SECOND_BUFFER = 0x80610b51,
+	CELL_ATRACMULTI_ERROR_UNSET_LOOP_NUM = 0x80610b61,
+	CELL_ATRACMULTI_ERROR_ILLEGAL_SAMPLE = 0x80610b71,
+	CELL_ATRACMULTI_ERROR_ILLEGAL_RESET_BYTE = 0x80610b72,
+	CELL_ATRACMULTI_ERROR_ILLEGAL_PPU_THREAD_PRIORITY = 0x80610b81,
+	CELL_ATRACMULTI_ERROR_ILLEGAL_SPU_THREAD_PRIORITY = 0x80610b82,
+	CELL_ATRACMULTI_ERROR_API_PARAMETER = 0x80610b91,
+};
+
+// Remain Frame
+enum : s32
+{
+	CELL_ATRACMULTI_ALLDATA_IS_ON_MEMORY = -1,
+	CELL_ATRACMULTI_NONLOOP_STREAM_DATA_IS_ON_MEMORY = -2,
+	CELL_ATRACMULTI_LOOP_STREAM_DATA_IS_ON_MEMORY = -3,
+};
+
+enum
+{
+	CELL_ATRACMULTI_HANDLE_SIZE = 512
+};
+
+struct alignas(8) CellAtracMultiHandle
+{
+	u8 ucWorkMem[CELL_ATRACMULTI_HANDLE_SIZE];
+};
+
+struct CellAtracMultiBufferInfo
+{
+	vm::bptr<u8> pucWriteAddr;
+	be_t<u32> uiWritableByte;
+	be_t<u32> uiMinWriteByte;
+	be_t<u32> uiReadPosition;
+};
+
+struct CellAtracMultiExtRes
+{
+	vm::bptr<struct CellSpurs> pSpurs;
+	u8 priority[8];
+};

ps3fw/include/rpcsx/fw/ps3/cellAtracXdec.h

@@ -0,0 +1,308 @@
+#pragma once
+
+#ifdef _MSC_VER
+#pragma warning(push, 0)
+#else
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wall"
+#pragma GCC diagnostic ignored "-Wextra"
+#pragma GCC diagnostic ignored "-Wold-style-cast"
+#endif
+extern "C"
+{
+#include "libavcodec/avcodec.h"
+}
+
+constexpr int averror_eof = AVERROR_EOF; // Workaround for old-style-cast error
+#ifdef _MSC_VER
+#pragma warning(pop)
+#else
+#pragma GCC diagnostic pop
+#endif
+
+#include "cellPamf.h"
+#include "cellAdec.h"
+
+enum CellAtracXdecError : u32
+{
+	CELL_ADEC_ERROR_ATX_OFFSET = 0x80612200,
+	CELL_ADEC_ERROR_ATX_NONE = 0x80612200,
+	CELL_ADEC_ERROR_ATX_OK = 0x80612200,
+	CELL_ADEC_ERROR_ATX_BUSY = 0x80612264,
+	CELL_ADEC_ERROR_ATX_EMPTY = 0x80612265,
+	CELL_ADEC_ERROR_ATX_ATSHDR = 0x80612266,
+	CELL_ADEC_ERROR_ATX_NON_FATAL = 0x80612281,
+	CELL_ADEC_ERROR_ATX_NOT_IMPLE = 0x80612282,
+	CELL_ADEC_ERROR_ATX_PACK_CE_OVERFLOW = 0x80612283,
+	CELL_ADEC_ERROR_ATX_ILLEGAL_NPROCQUS = 0x80612284,
+	CELL_ADEC_ERROR_ATX_FATAL = 0x8061228c,
+	CELL_ADEC_ERROR_ATX_ENC_OVERFLOW = 0x8061228d,
+	CELL_ADEC_ERROR_ATX_PACK_CE_UNDERFLOW = 0x8061228e,
+	CELL_ADEC_ERROR_ATX_SYNTAX_IDCT = 0x8061228f,
+	CELL_ADEC_ERROR_ATX_SYNTAX_GAINADJ = 0x80612290,
+	CELL_ADEC_ERROR_ATX_SYNTAX_IDSF = 0x80612291,
+	CELL_ADEC_ERROR_ATX_SYNTAX_SPECTRA = 0x80612292,
+	CELL_ADEC_ERROR_ATX_SYNTAX_IDWL = 0x80612293,
+	CELL_ADEC_ERROR_ATX_SYNTAX_GHWAVE = 0x80612294,
+	CELL_ADEC_ERROR_ATX_SYNTAX_SHEADER = 0x80612295,
+	CELL_ADEC_ERROR_ATX_SYNTAX_IDWL_A = 0x80612296,
+	CELL_ADEC_ERROR_ATX_SYNTAX_IDWL_B = 0x80612297,
+	CELL_ADEC_ERROR_ATX_SYNTAX_IDWL_C = 0x80612298,
+	CELL_ADEC_ERROR_ATX_SYNTAX_IDWL_D = 0x80612299,
+	CELL_ADEC_ERROR_ATX_SYNTAX_IDWL_E = 0x8061229a,
+	CELL_ADEC_ERROR_ATX_SYNTAX_IDSF_A = 0x8061229b,
+	CELL_ADEC_ERROR_ATX_SYNTAX_IDSF_B = 0x8061229c,
+	CELL_ADEC_ERROR_ATX_SYNTAX_IDSF_C = 0x8061229d,
+	CELL_ADEC_ERROR_ATX_SYNTAX_IDSF_D = 0x8061229e,
+	CELL_ADEC_ERROR_ATX_SYNTAX_IDCT_A = 0x8061229f,
+	CELL_ADEC_ERROR_ATX_SYNTAX_GC_NGC = 0x806122a0,
+	CELL_ADEC_ERROR_ATX_SYNTAX_GC_IDLEV_A = 0x806122a1,
+	CELL_ADEC_ERROR_ATX_SYNTAX_GC_IDLOC_A = 0x806122a2,
+	CELL_ADEC_ERROR_ATX_SYNTAX_GC_IDLEV_B = 0x806122a3,
+	CELL_ADEC_ERROR_ATX_SYNTAX_GC_IDLOC_B = 0x806122a4,
+	CELL_ADEC_ERROR_ATX_SYNTAX_SN_NWVS = 0x806122a5,
+	CELL_ADEC_ERROR_ATX_FATAL_HANDLE = 0x806122aa,
+	CELL_ADEC_ERROR_ATX_ASSERT_SAMPLING_FREQ = 0x806122ab,
+	CELL_ADEC_ERROR_ATX_ASSERT_CH_CONFIG_INDEX = 0x806122ac,
+	CELL_ADEC_ERROR_ATX_ASSERT_NBYTES = 0x806122ad,
+	CELL_ADEC_ERROR_ATX_ASSERT_BLOCK_NUM = 0x806122ae,
+	CELL_ADEC_ERROR_ATX_ASSERT_BLOCK_ID = 0x806122af,
+	CELL_ADEC_ERROR_ATX_ASSERT_CHANNELS = 0x806122b0,
+	CELL_ADEC_ERROR_ATX_UNINIT_BLOCK_SPECIFIED = 0x806122b1,
+	CELL_ADEC_ERROR_ATX_POSCFG_PRESENT = 0x806122b2,
+	CELL_ADEC_ERROR_ATX_BUFFER_OVERFLOW = 0x806122b3,
+	CELL_ADEC_ERROR_ATX_ILL_BLK_TYPE_ID = 0x806122b4,
+	CELL_ADEC_ERROR_ATX_UNPACK_CHANNEL_BLK_FAILED = 0x806122b5,
+	CELL_ADEC_ERROR_ATX_ILL_BLK_ID_USED_1 = 0x806122b6,
+	CELL_ADEC_ERROR_ATX_ILL_BLK_ID_USED_2 = 0x806122b7,
+	CELL_ADEC_ERROR_ATX_ILLEGAL_ENC_SETTING = 0x806122b8,
+	CELL_ADEC_ERROR_ATX_ILLEGAL_DEC_SETTING = 0x806122b9,
+	CELL_ADEC_ERROR_ATX_ASSERT_NSAMPLES = 0x806122ba,
+	CELL_ADEC_ERROR_ATX_ILL_SYNCWORD = 0x806122bb,
+	CELL_ADEC_ERROR_ATX_ILL_SAMPLING_FREQ = 0x806122bc,
+	CELL_ADEC_ERROR_ATX_ILL_CH_CONFIG_INDEX = 0x806122bd,
+	CELL_ADEC_ERROR_ATX_RAW_DATA_FRAME_SIZE_OVER = 0x806122be,
+	CELL_ADEC_ERROR_ATX_SYNTAX_ENHANCE_LENGTH_OVER = 0x806122bf,
+	CELL_ADEC_ERROR_ATX_SPU_INTERNAL_FAIL = 0x806122c8,
+};
+
+enum : u32
+{
+	CELL_ADEC_ATRACX_WORD_SZ_16BIT = 0x02,
+	CELL_ADEC_ATRACX_WORD_SZ_24BIT = 0x03,
+	CELL_ADEC_ATRACX_WORD_SZ_32BIT = 0x04,
+	CELL_ADEC_ATRACX_WORD_SZ_FLOAT = 0x84,
+};
+
+enum : u8
+{
+	CELL_ADEC_ATRACX_ATS_HDR_NOTINC = 0,
+	CELL_ADEC_ATRACX_ATS_HDR_INC = 1,
+};
+
+enum : u8
+{
+	ATRACX_DOWNMIX_OFF = 0,
+	ATRACX_DOWNMIX_ON = 1,
+};
+
+struct CellAdecParamAtracX
+{
+	be_t<u32> sampling_freq;
+	be_t<u32> ch_config_idx;
+	be_t<u32> nch_out;
+	be_t<u32> nbytes;
+	std::array<u8, 4> extra_config_data;
+	be_t<u32> bw_pcm;
+	u8 downmix_flag;
+	u8 au_includes_ats_hdr_flg;
+};
+
+struct CellAdecAtracXInfo
+{
+	be_t<u32> samplingFreq;
+	be_t<u32> channelConfigIndex;
+	be_t<u32> nbytes;
+};
+
+CHECK_SIZE(CellAdecAtracXInfo, 12);
+
+struct AtracXdecAtsHeader
+{
+	be_t<u16> sync_word; // 0x0fd0
+	be_t<u16> params;    // 3 bits: sample rate, 3 bits: channel config, 10 bits: (nbytes / 8) - 1
+	u8 extra_config_data[4];
+};
+
+CHECK_SIZE(AtracXdecAtsHeader, 8);
+
+enum class AtracXdecCmdType : u32
+{
+	invalid,
+	start_seq,
+	decode_au,
+	end_seq,
+	close,
+};
+
+struct AtracXdecCmd
+{
+	be_t<AtracXdecCmdType> type;
+	be_t<s32> pcm_handle;
+	vm::bcptr<u8> au_start_addr;
+	be_t<u32> au_size;
+	vm::bptr<void> pcm_start_addr; // Unused
+	be_t<u32> pcm_size;            // Unused
+	CellAdecParamAtracX atracx_param;
+
+	AtracXdecCmd() = default; // cellAdecOpen()
+
+	AtracXdecCmd(AtracXdecCmdType&& type) // cellAdecEndSeq(), cellAdecClose()
+		: type(type)
+	{
+	}
+
+	AtracXdecCmd(AtracXdecCmdType&& type, const CellAdecParamAtracX& atracx_param) // cellAdecStartSeq()
+		: type(type), atracx_param(atracx_param)
+	{
+	}
+
+	AtracXdecCmd(AtracXdecCmdType&& type, const s32& pcm_handle, const CellAdecAuInfo& au_info) // cellAdecDecodeAu()
+		: type(type), pcm_handle(pcm_handle), au_start_addr(au_info.startAddr), au_size(au_info.size)
+	{
+	}
+};
+
+CHECK_SIZE(AtracXdecCmd, 0x34);
+
+struct AtracXdecDecoder
+{
+	be_t<u32> sampling_freq;
+	be_t<u32> ch_config_idx;
+	be_t<u32> nch_in;
+	be_t<u32> nch_blocks;
+	be_t<u32> nbytes;
+	be_t<u32> nch_out;
+	be_t<u32> bw_pcm;
+	be_t<u32> nbytes_128_aligned;
+	be_t<u32> status;
+	be_t<u32> pcm_output_size;
+
+	const vm::bptr<u8> work_mem;
+
+	// HLE exclusive
+	b8 config_is_set = false; // For savestates
+	const AVCodec* codec;
+	AVCodecContext* ctx;
+	AVPacket* packet;
+	AVFrame* frame;
+
+	u8 spurs_stuff[84]; // 120 bytes on LLE, pointers to CellSpurs, CellSpursTaskset, etc.
+
+	be_t<u32> spurs_task_id; // CellSpursTaskId
+
+	AtracXdecDecoder(vm::ptr<u8> work_mem) : work_mem(work_mem) {}
+
+	void alloc_avcodec();
+	void free_avcodec();
+	void init_avcodec();
+
+	error_code set_config_info(u32 sampling_freq, u32 ch_config_idx, u32 nbytes);
+	error_code init_decode(u32 bw_pcm, u32 nch_out);
+	error_code parse_ats_header(vm::cptr<u8> au_start_addr);
+};
+
+CHECK_SIZE(AtracXdecDecoder, 0xa8);
+
+// HLE exclusive, for savestates
+enum class atracxdec_state : u8
+{
+	initial,
+	waiting_for_cmd,
+	checking_run_thread_1,
+	executing_cmd,
+	waiting_for_output,
+	checking_run_thread_2,
+	decoding
+};
+
+struct AtracXdecContext
+{
+	be_t<u64> thread_id; // sys_ppu_thread_t
+
+	be_t<u32> queue_mutex;     // sys_mutex_t
+	be_t<u32> queue_not_empty; // sys_cond_t
+	AdecCmdQueue<AtracXdecCmd> cmd_queue;
+
+	be_t<u32> output_mutex;    // sys_mutex_t
+	be_t<u32> output_consumed; // sys_cond_t
+	be_t<u32> output_locked = false;
+
+	be_t<u32> run_thread_mutex; // sys_mutex_t
+	be_t<u32> run_thread_cond;  // sys_cond_t
+	be_t<u32> run_thread = true;
+
+	const AdecCb<AdecNotifyAuDone> notify_au_done;
+	const AdecCb<AdecNotifyPcmOut> notify_pcm_out;
+	const AdecCb<AdecNotifyError> notify_error;
+	const AdecCb<AdecNotifySeqDone> notify_seq_done;
+
+	const vm::bptr<u8> work_mem;
+
+	// HLE exclusive
+	u64 cmd_counter = 0;         // For debugging
+	AtracXdecCmd cmd;            // For savestates; if savestate was created while processing a decode command, we need to save the current command
+	atracxdec_state savestate{}; // For savestates
+	b8 skip_next_frame;          // Needed to emulate behavior of LLE SPU program, it doesn't output the first frame after a sequence reset or error
+
+	u8 spurs_stuff[58]; // 120 bytes on LLE, pointers to CellSpurs, CellSpursTaskset, etc.
+
+	CellAdecParamAtracX atracx_param;
+
+	u8 reserved;
+	b8 first_decode;
+
+	AtracXdecDecoder decoder;
+
+	AtracXdecContext(vm::ptr<AdecNotifyAuDone> notifyAuDone, vm::ptr<void> notifyAuDoneArg, vm::ptr<AdecNotifyPcmOut> notifyPcmOut, vm::ptr<void> notifyPcmOutArg,
+		vm::ptr<AdecNotifyError> notifyError, vm::ptr<void> notifyErrorArg, vm::ptr<AdecNotifySeqDone> notifySeqDone, vm::ptr<void> notifySeqDoneArg, vm::bptr<u8> work_mem)
+		: notify_au_done{notifyAuDone, notifyAuDoneArg}, notify_pcm_out{notifyPcmOut, notifyPcmOutArg}, notify_error{notifyError, notifyErrorArg}, notify_seq_done{notifySeqDone, notifySeqDoneArg}, work_mem(work_mem), decoder(work_mem)
+	{
+	}
+
+	void exec(ppu_thread& ppu);
+
+	template <AtracXdecCmdType type>
+	error_code send_command(ppu_thread& ppu, auto&&... args);
+};
+
+static_assert(std::is_standard_layout_v<AtracXdecContext>);
+CHECK_SIZE_ALIGN(AtracXdecContext, 0x268, 8);
+
+constexpr u32 ATXDEC_SPURS_STRUCTS_SIZE = 0x1cf00; // CellSpurs, CellSpursTaskset, context, etc.
+constexpr u16 ATXDEC_SAMPLES_PER_FRAME = 0x800;
+constexpr u16 ATXDEC_MAX_FRAME_LENGTH = 0x2000;
+constexpr std::array<u8, 8> ATXDEC_NCH_BLOCKS_MAP = {0, 1, 1, 2, 3, 4, 5, 5};
+
+// Expected output channel order
+//  - for 1 to 7 channels: Front Left, Center, Front Right, Rear Left, Rear Right, Rear Center, LFE
+//  - for 8 channels:      Front Left, Front Right, Center, LFE, Rear Left, Rear Right, Side Left, Side Right
+// FFmpeg output
+//  - ver <= 5.1.2: Front Left, Front Right, Center, Rear Left, Rear Right, Rear Center, Side Left, Side Right, LFE
+//  - ver >= 5.1.3: Front Left, Front Right, Center, LFE, Rear Left, Rear Right, Rear Center, Side Left, Side Right
+constexpr u8 ATXDEC_AVCODEC_CH_MAP[7][8] =
+	{
+		{0},
+		{0, 1},
+		{0, 2, 1},
+		{0, 2, 1, 3},
+#if LIBAVCODEC_VERSION_INT < AV_VERSION_INT(59, 51, 101)
+		{0, 2, 1, 3, 4, 5},
+		{0, 2, 1, 3, 4, 5, 6},
+		{0, 1, 2, 4, 5, 6, 7, 3}
+#else
+		{0, 2, 1, 4, 5, 3},
+		{0, 2, 1, 4, 5, 6, 3},
+		{0, 1, 2, 3, 4, 5, 6, 7}
+#endif
+};

ps3fw/include/rpcsx/fw/ps3/cellAudio.h

@@ -0,0 +1,454 @@
+#pragma once
+
+#include "Emu/Audio/AudioBackend.h"
+#include "Emu/Audio/AudioDumper.h"
+#include "Emu/Audio/audio_resampler.h"
+#include "Emu/Memory/vm.h"
+#include "Emu/Memory/vm_ptr.h"
+#include "Emu/system_config_types.h"
+#include "util/Thread.h"
+#include "util/simple_ringbuf.h"
+
+struct lv2_event_queue;
+
+// Error codes
+enum CellAudioError : u32
+{
+	CELL_AUDIO_ERROR_ALREADY_INIT = 0x80310701,
+	CELL_AUDIO_ERROR_AUDIOSYSTEM = 0x80310702,
+	CELL_AUDIO_ERROR_NOT_INIT = 0x80310703,
+	CELL_AUDIO_ERROR_PARAM = 0x80310704,
+	CELL_AUDIO_ERROR_PORT_FULL = 0x80310705,
+	CELL_AUDIO_ERROR_PORT_ALREADY_RUN = 0x80310706,
+	CELL_AUDIO_ERROR_PORT_NOT_OPEN = 0x80310707,
+	CELL_AUDIO_ERROR_PORT_NOT_RUN = 0x80310708,
+	CELL_AUDIO_ERROR_TRANS_EVENT = 0x80310709,
+	CELL_AUDIO_ERROR_PORT_OPEN = 0x8031070a,
+	CELL_AUDIO_ERROR_SHAREDMEMORY = 0x8031070b,
+	CELL_AUDIO_ERROR_MUTEX = 0x8031070c,
+	CELL_AUDIO_ERROR_EVENT_QUEUE = 0x8031070d,
+	CELL_AUDIO_ERROR_AUDIOSYSTEM_NOT_FOUND = 0x8031070e,
+	CELL_AUDIO_ERROR_TAG_NOT_FOUND = 0x8031070f,
+};
+
+// constants
+enum
+{
+	CELL_AUDIO_BLOCK_8 = 8,
+	CELL_AUDIO_BLOCK_16 = 16,
+	CELL_AUDIO_BLOCK_32 = 32,
+	CELL_AUDIO_BLOCK_SAMPLES = 256,
+
+	CELL_AUDIO_CREATEEVENTFLAG_SPU = 0x00000001,
+
+	CELL_AUDIO_EVENT_MIX = 0,
+	CELL_AUDIO_EVENT_HEADPHONE = 1,
+
+	CELL_AUDIO_EVENTFLAG_BEFOREMIX = 0x80000000,
+	CELL_AUDIO_EVENTFLAG_DECIMATE_2 = 0x08000000,
+	CELL_AUDIO_EVENTFLAG_DECIMATE_4 = 0x10000000,
+	CELL_AUDIO_EVENTFLAG_HEADPHONE = 0x20000000,
+	CELL_AUDIO_EVENTFLAG_NOMIX = 0x40000000,
+
+	CELL_AUDIO_MAX_PORT = 4,
+	CELL_AUDIO_MAX_PORT_2 = 8,
+
+	CELL_AUDIO_MISC_ACCVOL_ALLDEVICE = 0x0000ffffUL,
+	CELL_AUDIO_PERSONAL_DEVICE_PRIMARY = 0x8000,
+
+	CELL_AUDIO_PORT_2CH = 2,
+	CELL_AUDIO_PORT_8CH = 8,
+
+	CELL_AUDIO_PORTATTR_BGM = 0x0000000000000010ULL,
+	CELL_AUDIO_PORTATTR_INITLEVEL = 0x0000000000001000ULL,
+	CELL_AUDIO_PORTATTR_OUT_NO_ROUTE = 0x0000000000100000ULL,
+	CELL_AUDIO_PORTATTR_OUT_PERSONAL_0 = 0x0000000001000000ULL,
+	CELL_AUDIO_PORTATTR_OUT_PERSONAL_1 = 0x0000000002000000ULL,
+	CELL_AUDIO_PORTATTR_OUT_PERSONAL_2 = 0x0000000004000000ULL,
+	CELL_AUDIO_PORTATTR_OUT_PERSONAL_3 = 0x0000000008000000ULL,
+	CELL_AUDIO_PORTATTR_OUT_SECONDARY = 0x0000000000000001ULL,
+	CELL_AUDIO_PORTATTR_OUT_STREAM1 = 0x0000000000000001ULL,
+
+	CELL_AUDIO_STATUS_CLOSE = 0x1010,
+	CELL_AUDIO_STATUS_READY = 1,
+	CELL_AUDIO_STATUS_RUN = 2,
+};
+
+enum class audio_backend_update : u32
+{
+	NONE,
+	PARAM,
+	ALL,
+};
+
+// libaudio datatypes
+struct CellAudioPortParam
+{
+	be_t<u64> nChannel{};
+	be_t<u64> nBlock{};
+	be_t<u64> attr{};
+	be_t<float> level{};
+};
+
+struct CellAudioPortConfig
+{
+	vm::bptr<u64> readIndexAddr{};
+	be_t<u32> status{};
+	be_t<u64> nChannel{};
+	be_t<u64> nBlock{};
+	be_t<u32> portSize{};
+	be_t<u32> portAddr{};
+};
+
+enum : u32
+{
+	AUDIO_PORT_COUNT = 8,
+	AUDIO_MAX_BLOCK_COUNT = 32,
+	AUDIO_MAX_CHANNELS_COUNT = 8,
+
+	AUDIO_PORT_OFFSET = AUDIO_BUFFER_SAMPLES * AUDIO_MAX_BLOCK_COUNT *
+	                    AUDIO_MAX_CHANNELS_COUNT * sizeof(f32),
+	EXTRA_AUDIO_BUFFERS = 8,
+	MAX_AUDIO_EVENT_QUEUES = 64,
+
+	AUDIO_BLOCK_SIZE_2CH = 2 * AUDIO_BUFFER_SAMPLES,
+	AUDIO_BLOCK_SIZE_8CH = 8 * AUDIO_BUFFER_SAMPLES,
+
+	PORT_BUFFER_TAG_COUNT = 6,
+
+	PORT_BUFFER_TAG_LAST_2CH = AUDIO_BLOCK_SIZE_2CH - 1,
+	PORT_BUFFER_TAG_DELTA_2CH =
+		PORT_BUFFER_TAG_LAST_2CH / (PORT_BUFFER_TAG_COUNT - 1),
+	PORT_BUFFER_TAG_FIRST_2CH =
+		PORT_BUFFER_TAG_LAST_2CH % (PORT_BUFFER_TAG_COUNT - 1),
+
+	PORT_BUFFER_TAG_LAST_8CH = AUDIO_BLOCK_SIZE_8CH - 1,
+	PORT_BUFFER_TAG_DELTA_8CH =
+		PORT_BUFFER_TAG_LAST_8CH / (PORT_BUFFER_TAG_COUNT - 1),
+	PORT_BUFFER_TAG_FIRST_8CH =
+		PORT_BUFFER_TAG_LAST_8CH % (PORT_BUFFER_TAG_COUNT - 1),
+};
+
+enum class audio_port_state : u32
+{
+	closed,
+	opened,
+	started,
+};
+
+struct audio_port
+{
+	atomic_t<audio_port_state> state = audio_port_state::closed;
+
+	u32 number = 0;
+	vm::ptr<char> addr{};
+	vm::ptr<u64> index{};
+
+	u32 num_channels = 0;
+	u32 num_blocks = 0;
+	u64 attr = 0;
+	u64 cur_pos = 0;
+	u64 global_counter = 0; // copy of global counter
+	u64 active_counter = 0;
+	u32 size = 0;
+	u64 timestamp = 0; // copy of global timestamp
+
+	struct level_set_t
+	{
+		float value = 0.0f;
+		float inc = 0.0f;
+	};
+
+	float level = 0.0f;
+	atomic_t<level_set_t> level_set{};
+
+	u32 block_size() const
+	{
+		return num_channels * AUDIO_BUFFER_SAMPLES;
+	}
+
+	u32 buf_size() const
+	{
+		return block_size() * sizeof(float);
+	}
+
+	u32 position(s32 offset = 0) const
+	{
+		s32 ofs = (offset % num_blocks) + num_blocks;
+		return (cur_pos + ofs) % num_blocks;
+	}
+
+	u32 buf_addr(s32 offset = 0) const
+	{
+		return addr.addr() + position(offset) * buf_size();
+	}
+
+	be_t<f32>* get_vm_ptr(s32 offset = 0) const
+	{
+		return vm::_ptr<f32>(buf_addr(offset));
+	}
+
+	// Tags
+	u32 prev_touched_tag_nr = 0;
+	f32 last_tag_value[PORT_BUFFER_TAG_COUNT] = {0};
+
+	void tag(s32 offset = 0);
+
+	audio_port() = default;
+
+	// Handle copy ctor of atomic var
+	audio_port(const audio_port& r)
+	{
+		std::memcpy(static_cast<void*>(this), &r, sizeof(r));
+	}
+
+	ENABLE_BITWISE_SERIALIZATION;
+};
+
+struct cell_audio_config
+{
+	struct raw_config
+	{
+		std::string audio_device{};
+		bool buffering_enabled = false;
+		s64 desired_buffer_duration = 0;
+		bool enable_time_stretching = false;
+		s64 time_stretching_threshold = 0;
+		bool convert_to_s16 = false;
+		bool dump_to_file = false;
+		audio_channel_layout channel_layout = audio_channel_layout::automatic;
+		audio_renderer renderer = audio_renderer::null;
+		audio_provider provider = audio_provider::none;
+	};
+
+	raw_config new_raw{};
+	raw_config raw{};
+
+	std::shared_ptr<AudioBackend> backend = nullptr;
+
+	AudioChannelCnt audio_downmix = AudioChannelCnt::SURROUND_7_1;
+	audio_channel_layout backend_channel_layout =
+		audio_channel_layout::surround_7_1;
+	u32 backend_ch_cnt = 8;
+	u32 audio_channels = 2;
+	u32 audio_sampling_rate = DEFAULT_AUDIO_SAMPLING_RATE;
+	u32 audio_block_period = 0;
+	u32 audio_sample_size = 0;
+	f64 audio_min_buffer_duration = 0.0;
+
+	u32 audio_buffer_length = 0;
+
+	/*
+	 * Buffering
+	 */
+
+	u64 desired_buffer_duration = 0;
+
+	// We need a non-blocking backend (implementing play/pause/flush) to be able
+	// to do buffering correctly We also need to be able to query the current
+	// playing state
+	bool buffering_enabled = false;
+
+	u64 minimum_block_period = 0; // the block period will not be dynamically
+	                              // lowered below this value (usecs)
+	u64 maximum_block_period = 0; // the block period will not be dynamically
+	                              // increased above this value (usecs)
+
+	u32 desired_full_buffers = 0;
+	u32 num_allocated_buffers = 0; // number of ringbuffer buffers
+
+	static constexpr f32 period_average_alpha =
+		0.02f; // alpha factor for the m_average_period rolling average
+
+	// when comparing the current period time with the desired period, if it is
+	// below this number of usecs we do not wait any longer(quantum dependent)
+#ifdef _WIN32
+	static constexpr s64 period_comparison_margin = 250;
+#else
+	static constexpr s64 period_comparison_margin = 5;
+#endif
+
+	u64 fully_untouched_timeout =
+		0; // timeout if the game has not touched any audio buffer yet
+	u64 partially_untouched_timeout =
+		0; // timeout if the game has not touched all audio buffers yet
+
+	/*
+	 * Time Stretching
+	 */
+
+	// We need to be able to set a dynamic frequency ratio to be able to do time
+	// stretching
+	bool time_stretching_enabled = false;
+
+	f32 time_stretching_threshold =
+		0.0f; // we only apply time stretching below this buffer fill rate
+	          // (adjusted for average period)
+	static constexpr f32 time_stretching_step =
+		0.1f; // will only reduce/increase the frequency ratio in steps of at
+	          // least this value
+
+	/*
+	 * Constructor
+	 */
+	cell_audio_config();
+
+	/*
+	 * Config changes
+	 */
+	void reset(bool backend_changed = true);
+};
+
+class audio_ringbuffer
+{
+private:
+	const std::shared_ptr<AudioBackend> backend;
+
+	const cell_audio_config& cfg;
+
+	const u32 buf_sz;
+
+	AudioDumper m_dump{};
+
+	std::unique_ptr<float[]> buffer[MAX_AUDIO_BUFFERS]{};
+
+	simple_ringbuf cb_ringbuf{};
+	audio_resampler resampler{};
+
+	atomic_t<bool> backend_active = false;
+	atomic_t<bool> backend_device_changed = false;
+	bool playing = false;
+
+	u64 update_timestamp = 0;
+	u64 play_timestamp = 0;
+
+	u64 last_remainder = 0;
+
+	f32 frequency_ratio = RESAMPLER_MAX_FREQ_VAL;
+
+	u32 cur_pos = 0;
+
+	bool get_backend_playing() const
+	{
+		return backend->IsPlaying();
+	}
+
+	void commit_data(f32* buf, u32 sample_cnt);
+	u32 backend_write_callback(u32 size, void* buf);
+	void backend_state_callback(AudioStateEvent event);
+
+public:
+	audio_ringbuffer(cell_audio_config& cfg);
+	~audio_ringbuffer();
+
+	void play();
+	void flush();
+	u64 update(bool emu_is_paused);
+	void enqueue(bool enqueue_silence = false, bool force = false);
+	void enqueue_silence(u32 buf_count = 1, bool force = false);
+	void process_resampled_data();
+	f32 set_frequency_ratio(f32 new_ratio);
+
+	float* get_buffer(u32 num) const;
+	static u64 get_timestamp();
+	float* get_current_buffer() const;
+
+	u64 get_enqueued_samples() const;
+	u64 get_enqueued_playtime() const;
+
+	bool is_playing() const
+	{
+		return playing;
+	}
+
+	f32 get_frequency_ratio() const
+	{
+		return frequency_ratio;
+	}
+
+	bool get_operational_status() const
+	{
+		return backend->Operational();
+	}
+
+	bool device_changed()
+	{
+		return backend_device_changed.test_and_reset() &&
+		       backend->DefaultDeviceChanged();
+	}
+
+	std::string_view get_backend_name() const
+	{
+		return backend->GetName();
+	}
+};
+
+class cell_audio_thread
+{
+private:
+	std::unique_ptr<audio_ringbuffer> ringbuffer{};
+
+	void reset_ports(s32 offset = 0);
+	void advance(u64 timestamp);
+	std::tuple<u32, u32, u32, u32> count_port_buffer_tags();
+	template <AudioChannelCnt channels, AudioChannelCnt downmix>
+	void mix(float* out_buffer, s32 offset = 0);
+	void finish_port_volume_stepping();
+
+	void update_config(bool backend_changed);
+	void reset_counters();
+
+public:
+	shared_mutex emu_cfg_upd_m{};
+	cell_audio_config cfg{};
+	atomic_t<audio_backend_update> m_update_configuration =
+		audio_backend_update::NONE;
+
+	shared_mutex mutex{};
+	atomic_t<u8> init = 0;
+
+	u32 key_count = 0;
+	u8 event_period = 0;
+	std::array<u64, MAX_AUDIO_EVENT_QUEUES> event_sources{};
+	std::array<u64, MAX_AUDIO_EVENT_QUEUES> event_data3{};
+
+	struct key_info
+	{
+		u8 start_period = 0;                // Starting event_period
+		u32 flags = 0;                      // iFlags
+		u64 source = 0;                     // Event source
+		u64 ack_timestamp = 0;              // timestamp of last call of cellAudioSendAck
+		shared_ptr<lv2_event_queue> port{}; // Underlying event port
+	};
+
+	std::vector<key_info> keys{};
+	std::array<audio_port, AUDIO_PORT_COUNT> ports{};
+
+	u64 m_last_period_end = 0;
+	u64 m_counter = 0;
+	u64 m_start_time = 0;
+	u64 m_dynamic_period = 0;
+	f32 m_average_playtime = 0.0f;
+	bool m_backend_failed = false;
+	bool m_audio_should_restart = false;
+
+	void operator()();
+
+	SAVESTATE_INIT_POS(9);
+
+	cell_audio_thread();
+	cell_audio_thread(utils::serial& ar);
+	void save(utils::serial& ar);
+
+	audio_port* open_port();
+
+	static constexpr auto thread_name = "cellAudio Thread"sv;
+};
+
+using cell_audio = named_thread<cell_audio_thread>;
+
+namespace audio
+{
+	cell_audio_config::raw_config get_raw_config();
+	extern void configure_audio(bool force_reset = false);
+} // namespace audio

ps3fw/include/rpcsx/fw/ps3/cellAudioIn.h

@@ -0,0 +1,91 @@
+#pragma once
+
+#include "util/types.hpp"
+
+// Error codes
+enum CellAudioInError : u32
+{
+	CELL_AUDIO_IN_ERROR_NOT_IMPLEMENTED = 0x8002b260,
+	CELL_AUDIO_IN_ERROR_ILLEGAL_CONFIGURATION = 0x8002b261,
+	CELL_AUDIO_IN_ERROR_ILLEGAL_PARAMETER = 0x8002b262,
+	CELL_AUDIO_IN_ERROR_PARAMETER_OUT_OF_RANGE = 0x8002b263,
+	CELL_AUDIO_IN_ERROR_DEVICE_NOT_FOUND = 0x8002b264,
+	CELL_AUDIO_IN_ERROR_UNSUPPORTED_AUDIO_IN = 0x8002b265,
+	CELL_AUDIO_IN_ERROR_UNSUPPORTED_SOUND_MODE = 0x8002b266,
+	CELL_AUDIO_IN_ERROR_CONDITION_BUSY = 0x8002b267,
+};
+
+enum CellAudioInDeviceMode
+{
+	CELL_AUDIO_IN_SINGLE_DEVICE_MODE = 0,
+	CELL_AUDIO_IN_MULTI_DEVICE_MODE = 1,
+	CELL_AUDIO_IN_MULTI_DEVICE_MODE_2 = 2,
+	CELL_AUDIO_IN_MULTI_DEVICE_MODE_10 = 10,
+};
+
+enum CellAudioInPortType
+{
+	CELL_AUDIO_IN_PORT_USB = 3,
+	CELL_AUDIO_IN_PORT_BLUETOOTH = 4,
+};
+
+enum CellAudioInDeviceState
+{
+	CELL_AUDIO_IN_DEVICE_STATE_UNAVAILABLE = 0,
+	CELL_AUDIO_IN_DEVICE_STATE_AVAILABLE = 1,
+};
+
+enum CellAudioInCodingType
+{
+	CELL_AUDIO_IN_CODING_TYPE_LPCM = 0,
+};
+
+enum CellAudioInChnum
+{
+	CELL_AUDIO_IN_CHNUM_NONE = 0,
+	CELL_AUDIO_IN_CHNUM_1 = 1,
+	CELL_AUDIO_IN_CHNUM_2 = 2,
+};
+
+enum CellAudioInFs
+{
+	CELL_AUDIO_IN_FS_UNDEFINED = 0x00,
+	CELL_AUDIO_IN_FS_8KHZ = 0x01,
+	CELL_AUDIO_IN_FS_12KHZ = 0x02,
+	CELL_AUDIO_IN_FS_16KHZ = 0x04,
+	CELL_AUDIO_IN_FS_24KHZ = 0x08,
+	CELL_AUDIO_IN_FS_32KHZ = 0x10,
+	CELL_AUDIO_IN_FS_48KHZ = 0x20,
+};
+
+struct CellAudioInSoundMode
+{
+	u8 type;
+	u8 channel;
+	be_t<u16> fs;
+	u8 reserved[4];
+};
+
+struct CellAudioInDeviceInfo
+{
+	u8 portType;
+	u8 availableModeCount;
+	u8 state;
+	u8 deviceNumber;
+	u8 reserved[12];
+	be_t<u64> deviceId;
+	be_t<u64> type;
+	char name[64];
+	CellAudioInSoundMode availableModes[16];
+};
+
+struct CellAudioInRegistrationOption
+{
+	be_t<u32> reserved;
+};
+
+struct CellAudioInDeviceConfiguration
+{
+	u8 volume;
+	u8 reserved[31];
+};

ps3fw/include/rpcsx/fw/ps3/cellAudioOut.h

@@ -0,0 +1,223 @@
+#pragma once
+
+#include "Emu/Audio/AudioBackend.h"
+#include "Emu/Memory/vm_ptr.h"
+
+// Error codes
+enum CellAudioOutError : u32
+{
+	CELL_AUDIO_OUT_ERROR_NOT_IMPLEMENTED = 0x8002b240,
+	CELL_AUDIO_OUT_ERROR_ILLEGAL_CONFIGURATION = 0x8002b241,
+	CELL_AUDIO_OUT_ERROR_ILLEGAL_PARAMETER = 0x8002b242,
+	CELL_AUDIO_OUT_ERROR_PARAMETER_OUT_OF_RANGE = 0x8002b243,
+	CELL_AUDIO_OUT_ERROR_DEVICE_NOT_FOUND = 0x8002b244,
+	CELL_AUDIO_OUT_ERROR_UNSUPPORTED_AUDIO_OUT = 0x8002b245,
+	CELL_AUDIO_OUT_ERROR_UNSUPPORTED_SOUND_MODE = 0x8002b246,
+	CELL_AUDIO_OUT_ERROR_CONDITION_BUSY = 0x8002b247,
+};
+
+enum CellAudioOut
+{
+	CELL_AUDIO_OUT_PRIMARY = 0,
+	CELL_AUDIO_OUT_SECONDARY = 1,
+};
+
+enum CellAudioOutDownMixer
+{
+	CELL_AUDIO_OUT_DOWNMIXER_NONE = 0,
+	CELL_AUDIO_OUT_DOWNMIXER_TYPE_A = 1,
+	CELL_AUDIO_OUT_DOWNMIXER_TYPE_B = 2,
+};
+
+enum CellAudioOutDeviceMode
+{
+	CELL_AUDIO_OUT_SINGLE_DEVICE_MODE = 0,
+	CELL_AUDIO_OUT_MULTI_DEVICE_MODE = 1,
+	CELL_AUDIO_OUT_MULTI_DEVICE_MODE_2 = 2,
+};
+
+enum CellAudioOutPortType
+{
+	CELL_AUDIO_OUT_PORT_HDMI = 0,
+	CELL_AUDIO_OUT_PORT_SPDIF = 1,
+	CELL_AUDIO_OUT_PORT_ANALOG = 2,
+	CELL_AUDIO_OUT_PORT_USB = 3,
+	CELL_AUDIO_OUT_PORT_BLUETOOTH = 4,
+	CELL_AUDIO_OUT_PORT_NETWORK = 5,
+};
+
+enum CellAudioOutDeviceState
+{
+	CELL_AUDIO_OUT_DEVICE_STATE_UNAVAILABLE = 0,
+	CELL_AUDIO_OUT_DEVICE_STATE_AVAILABLE = 1,
+};
+
+enum CellAudioOutOutputState
+{
+	CELL_AUDIO_OUT_OUTPUT_STATE_ENABLED = 0,
+	CELL_AUDIO_OUT_OUTPUT_STATE_DISABLED = 1,
+	CELL_AUDIO_OUT_OUTPUT_STATE_PREPARING = 2,
+};
+
+enum CellAudioOutCodingType
+{
+	CELL_AUDIO_OUT_CODING_TYPE_LPCM = 0,
+	CELL_AUDIO_OUT_CODING_TYPE_AC3 = 1,
+	CELL_AUDIO_OUT_CODING_TYPE_MPEG1 = 2,
+	CELL_AUDIO_OUT_CODING_TYPE_MP3 = 3,
+	CELL_AUDIO_OUT_CODING_TYPE_MPEG2 = 4,
+	CELL_AUDIO_OUT_CODING_TYPE_AAC = 5,
+	CELL_AUDIO_OUT_CODING_TYPE_DTS = 6,
+	CELL_AUDIO_OUT_CODING_TYPE_ATRAC = 7,
+	CELL_AUDIO_OUT_CODING_TYPE_DOLBY_TRUE_HD = 8, // Speculative name
+	CELL_AUDIO_OUT_CODING_TYPE_DOLBY_DIGITAL_PLUS = 9,
+	CELL_AUDIO_OUT_CODING_TYPE_DTS_HD_HIGHRES = 10, // Speculative name
+	CELL_AUDIO_OUT_CODING_TYPE_DTS_HD_MASTER = 11,  // Speculative name
+	CELL_AUDIO_OUT_CODING_TYPE_BITSTREAM = 0xff,
+};
+
+enum CellAudioOutChnum
+{
+	CELL_AUDIO_OUT_CHNUM_2 = 2,
+	CELL_AUDIO_OUT_CHNUM_4 = 4,
+	CELL_AUDIO_OUT_CHNUM_6 = 6,
+	CELL_AUDIO_OUT_CHNUM_8 = 8,
+};
+
+enum CellAudioOutFs
+{
+	CELL_AUDIO_OUT_FS_32KHZ = 0x01,
+	CELL_AUDIO_OUT_FS_44KHZ = 0x02,
+	CELL_AUDIO_OUT_FS_48KHZ = 0x04,
+	CELL_AUDIO_OUT_FS_88KHZ = 0x08,
+	CELL_AUDIO_OUT_FS_96KHZ = 0x10,
+	CELL_AUDIO_OUT_FS_176KHZ = 0x20,
+	CELL_AUDIO_OUT_FS_192KHZ = 0x40,
+};
+
+enum CellAudioOutSpeakerLayout
+{
+	CELL_AUDIO_OUT_SPEAKER_LAYOUT_DEFAULT = 0x00000000,
+	CELL_AUDIO_OUT_SPEAKER_LAYOUT_2CH = 0x00000001,
+	CELL_AUDIO_OUT_SPEAKER_LAYOUT_6CH_LREClr = 0x00010000,
+	CELL_AUDIO_OUT_SPEAKER_LAYOUT_8CH_LREClrxy = 0x40000000,
+};
+
+enum CellAudioOutEvent
+{
+	CELL_AUDIO_OUT_EVENT_DEVICE_CHANGED = 0,
+	CELL_AUDIO_OUT_EVENT_OUTPUT_DISABLED = 1,
+	CELL_AUDIO_OUT_EVENT_DEVICE_AUTHENTICATED = 2,
+	CELL_AUDIO_OUT_EVENT_OUTPUT_ENABLED = 3,
+};
+
+enum CellAudioOutCopyControl
+{
+	CELL_AUDIO_OUT_COPY_CONTROL_COPY_FREE = 0,
+	CELL_AUDIO_OUT_COPY_CONTROL_COPY_ONCE = 1,
+	CELL_AUDIO_OUT_COPY_CONTROL_COPY_NEVER = 2,
+};
+
+struct CellAudioOutConfiguration
+{
+	u8 channel;
+	u8 encoder;
+	u8 reserved[10];
+	be_t<u32> downMixer;
+};
+
+struct CellAudioOutSoundMode
+{
+	u8 type;
+	u8 channel;
+	u8 fs;
+	u8 reserved;
+	be_t<u32> layout;
+
+	ENABLE_BITWISE_SERIALIZATION;
+};
+
+struct CellAudioOutDeviceInfo
+{
+	u8 portType;
+	u8 availableModeCount;
+	u8 state;
+	u8 reserved[3];
+	be_t<u16> latency;
+	CellAudioOutSoundMode availableModes[16];
+};
+
+struct CellAudioOutState
+{
+	u8 state;
+	u8 encoder;
+	u8 reserved[6];
+	be_t<u32> downMixer;
+	CellAudioOutSoundMode soundMode;
+};
+
+struct CellAudioOutSoundMode2
+{
+	u8 type;
+	u8 channel;
+	be_t<u16> fs;
+	u8 reserved[4];
+};
+
+struct CellAudioOutDeviceInfo2
+{
+	u8 portType;
+	u8 availableModeCount;
+	u8 state;
+	u8 deviceNumber;
+	u8 reserved[12];
+	be_t<u64> deviceId;
+	be_t<u64> type;
+	char name[64];
+	CellAudioOutSoundMode2 availableModes2[16];
+};
+
+struct CellAudioOutOption
+{
+	be_t<u32> reserved;
+};
+
+struct CellAudioOutRegistrationOption
+{
+	be_t<u32> reserved;
+};
+
+struct CellAudioOutDeviceConfiguration
+{
+	u8 volume;
+	u8 reserved[31];
+};
+
+typedef s32(CellAudioOutCallback)(u32 slot, u32 audioOut, u32 deviceIndex, u32 event, vm::ptr<CellAudioOutDeviceInfo> info, vm::ptr<void> userData);
+
+// FXO Object
+
+struct audio_out_configuration
+{
+	shared_mutex mtx;
+
+	struct audio_out
+	{
+		u32 state = CELL_AUDIO_OUT_OUTPUT_STATE_ENABLED;
+		u32 channels = CELL_AUDIO_OUT_CHNUM_2;
+		u32 encoder = CELL_AUDIO_OUT_CODING_TYPE_LPCM;
+		u32 downmixer = CELL_AUDIO_OUT_DOWNMIXER_NONE;
+		u32 copy_control = CELL_AUDIO_OUT_COPY_CONTROL_COPY_FREE;
+		std::vector<CellAudioOutSoundMode> sound_modes;
+		CellAudioOutSoundMode sound_mode{};
+
+		std::pair<AudioChannelCnt, AudioChannelCnt> get_channel_count_and_downmixer() const;
+	};
+
+	std::array<audio_out, 2> out;
+
+	SAVESTATE_INIT_POS(8.9); // Is a dependency of cellAudio
+	audio_out_configuration();
+	audio_out_configuration(utils::serial& ar);
+	void save(utils::serial& ar);
+};

ps3fw/include/rpcsx/fw/ps3/cellBgdl.h

@@ -0,0 +1,36 @@
+#pragma once
+
+#include "Emu/Memory/vm_ptr.h"
+
+// Return Codes
+enum
+{
+	CELL_BGDL_UTIL_ERROR_BUSY = 0x8002ce01,
+	CELL_BGDL_UTIL_ERROR_INTERNAL = 0x8002ce02,
+	CELL_BGDL_UTIL_ERROR_PARAM = 0x8002ce03,
+	CELL_BGDL_UTIL_ERROR_ACCESS_ERROR = 0x8002ce04,
+	CELL_BGDL_UTIL_ERROR_INITIALIZE = 0x8002ce05,
+};
+
+enum CellBGDLState : s32
+{
+	CELL_BGDL_STATE_ERROR = 0,
+	CELL_BGDL_STATE_PAUSE,
+	CELL_BGDL_STATE_READY,
+	CELL_BGDL_STATE_RUN,
+	CELL_BGDL_STATE_COMPLETE,
+};
+
+enum CellBGDLMode : s32
+{
+	CELL_BGDL_MODE_AUTO = 0,
+	CELL_BGDL_MODE_ALWAYS_ALLOW,
+};
+
+struct CellBGDLInfo
+{
+	be_t<u64> received_size;
+	be_t<u64> content_size;
+	be_t<s32> state; // CellBGDLState
+	vm::bptr<void> reserved;
+};

ps3fw/include/rpcsx/fw/ps3/cellCamera.h

@@ -0,0 +1,490 @@
+#pragma once
+
+#include "Emu/Io/camera_handler_base.h"
+#include "Emu/Memory/vm_ptr.h"
+#include "util/Thread.h"
+#include "util/mutex.h"
+
+#include <map>
+
+// Error Codes
+enum CellCameraError : u32
+{
+	CELL_CAMERA_ERROR_ALREADY_INIT = 0x80140801,
+	CELL_CAMERA_ERROR_NOT_INIT = 0x80140803,
+	CELL_CAMERA_ERROR_PARAM = 0x80140804,
+	CELL_CAMERA_ERROR_ALREADY_OPEN = 0x80140805,
+	CELL_CAMERA_ERROR_NOT_OPEN = 0x80140806,
+	CELL_CAMERA_ERROR_DEVICE_NOT_FOUND = 0x80140807,
+	CELL_CAMERA_ERROR_DEVICE_DEACTIVATED = 0x80140808,
+	CELL_CAMERA_ERROR_NOT_STARTED = 0x80140809,
+	CELL_CAMERA_ERROR_FORMAT_UNKNOWN = 0x8014080a,
+	CELL_CAMERA_ERROR_RESOLUTION_UNKNOWN = 0x8014080b,
+	CELL_CAMERA_ERROR_BAD_FRAMERATE = 0x8014080c,
+	CELL_CAMERA_ERROR_TIMEOUT = 0x8014080d,
+	CELL_CAMERA_ERROR_BUSY = 0x8014080e,
+	CELL_CAMERA_ERROR_FATAL = 0x8014080f,
+	CELL_CAMERA_ERROR_MUTEX = 0x80140810,
+};
+
+// Event masks
+enum
+{
+	CELL_CAMERA_EFLAG_FRAME_UPDATE = 0x00000001,
+	CELL_CAMERA_EFLAG_OPEN = 0x00000002,
+	CELL_CAMERA_EFLAG_CLOSE = 0x00000004,
+	CELL_CAMERA_EFLAG_START = 0x00000008,
+	CELL_CAMERA_EFLAG_STOP = 0x00000010,
+	CELL_CAMERA_EFLAG_RESET = 0x00000020,
+};
+
+// Event types
+enum
+{
+	CELL_CAMERA_DETACH = 0,
+	CELL_CAMERA_ATTACH = 1,
+	CELL_CAMERA_FRAME_UPDATE = 2,
+	CELL_CAMERA_OPEN = 3,
+	CELL_CAMERA_CLOSE = 4,
+	CELL_CAMERA_START = 5,
+	CELL_CAMERA_STOP = 6,
+	CELL_CAMERA_RESET = 7
+};
+
+// Read mode
+enum
+{
+	CELL_CAMERA_READ_FUNCCALL = 0,
+	CELL_CAMERA_READ_DIRECT = 1,
+};
+
+// Colormatching
+enum
+{
+	CELL_CAMERA_CM_CP_UNSPECIFIED = 0,
+	CELL_CAMERA_CM_CP_BT709_sRGB = 1,
+	CELL_CAMERA_CM_CP_BT470_2M = 2,
+	CELL_CAMERA_CM_CP_BT470_2BG = 3,
+	CELL_CAMERA_CM_CP_SMPTE170M = 4,
+	CELL_CAMERA_CM_CP_SMPTE240M = 5,
+
+	CELL_CAMERA_CM_TC_UNSPECIFIED = 0,
+	CELL_CAMERA_CM_TC_BT709 = 1,
+	CELL_CAMERA_CM_TC_BT470_2M = 2,
+	CELL_CAMERA_CM_TC_BT470_2BG = 3,
+	CELL_CAMERA_CM_TC_SMPTE170M = 4,
+	CELL_CAMERA_CM_TC_SMPTE240M = 5,
+	CELL_CAMERA_CM_TC_LINEAR = 6,
+	CELL_CAMERA_CM_TC_sRGB = 7,
+
+	CELL_CAMERA_CM_MC_UNSPECIFIED = 0,
+	CELL_CAMERA_CM_MC_BT709 = 1,
+	CELL_CAMERA_CM_MC_FCC = 2,
+	CELL_CAMERA_CM_MC_BT470_2BG = 3,
+	CELL_CAMERA_CM_MC_SMPTE170M = 4,
+	CELL_CAMERA_CM_MC_SMPTE240M = 5,
+};
+
+// Power Line Frequency
+enum
+{
+	CELL_CAMERA_PLFREQ_DISABLED = 0,
+	CELL_CAMERA_PLFREQ_50Hz = 1,
+	CELL_CAMERA_PLFREQ_60Hz = 2,
+};
+
+// DEVICECAP
+enum
+{
+	CELL_CAMERA_CTC_SCANNING_MODE = (1 << 0),
+	CELL_CAMERA_CTC_AUTO_EXPOSURE_MODE = (1 << 1),
+	CELL_CAMERA_CTC_AUTO_EXPOSURE_PRIORITY = (1 << 2),
+	CELL_CAMERA_CTC_EXPOSURE_TIME_ABS = (1 << 3),
+	CELL_CAMERA_CTC_EXPOSURE_TIME_REL = (1 << 4),
+	CELL_CAMERA_CTC_FOCUS_ABS = (1 << 5),
+	CELL_CAMERA_CTC_FOCUS_REL = (1 << 6),
+	CELL_CAMERA_CTC_IRIS_ABS = (1 << 7),
+	CELL_CAMERA_CTC_IRIS_REL = (1 << 8),
+	CELL_CAMERA_CTC_ZOOM_ABS = (1 << 9),
+	CELL_CAMERA_CTC_ZOOM_REL = (1 << 10),
+	CELL_CAMERA_CTC_PANTILT_ABS = (1 << 11),
+	CELL_CAMERA_CTC_PANTILT_REL = (1 << 12),
+	CELL_CAMERA_CTC_ROLL_ABS = (1 << 13),
+	CELL_CAMERA_CTC_ROLL_REL = (1 << 14),
+	CELL_CAMERA_CTC_RESERVED_15 = (1 << 15),
+	CELL_CAMERA_CTC_RESERVED_16 = (1 << 16),
+	CELL_CAMERA_CTC_FOCUS_AUTO = (1 << 17),
+	CELL_CAMERA_CTC_PRIVACY = (1 << 18),
+
+	CELL_CAMERA_PUC_BRIGHTNESS = (1 << 0),
+	CELL_CAMERA_PUC_CONTRAST = (1 << 1),
+	CELL_CAMERA_PUC_HUE = (1 << 2),
+	CELL_CAMERA_PUC_SATURATION = (1 << 3),
+	CELL_CAMERA_PUC_SHARPNESS = (1 << 4),
+	CELL_CAMERA_PUC_GAMMA = (1 << 5),
+	CELL_CAMERA_PUC_WHITE_BALANCE_TEMPERATURE = (1 << 6),
+	CELL_CAMERA_PUC_WHITE_BALANCE_COMPONENT = (1 << 7),
+	CELL_CAMERA_PUC_BACKLIGHT_COMPENSATION = (1 << 8),
+	CELL_CAMERA_PUC_GAIN = (1 << 9),
+	CELL_CAMERA_PUC_POWER_LINE_FREQUENCY = (1 << 10),
+	CELL_CAMERA_PUC_HUE_AUTO = (1 << 11),
+	CELL_CAMERA_PUC_WHITE_BALANCE_TEMPERATURE_AUTO = (1 << 12),
+	CELL_CAMERA_PUC_WHITE_BALANCE_COMPONENT_AUTO = (1 << 13),
+	CELL_CAMERA_PUC_DIGITAL_MULTIPLIER = (1 << 14),
+	CELL_CAMERA_PUC_DIGITAL_MULTIPLIER_LIMIT = (1 << 15),
+	CELL_CAMERA_PUC_ANALOG_VIDEO_STANDARD = (1 << 16),
+	CELL_CAMERA_PUC_ANALOG_VIDEO_LOCK_STATUS = (1 << 17),
+};
+
+// UVCREQCODE Control Selector
+enum
+{
+	CELL_CAMERA_CS_SHIFT = 0,
+	CELL_CAMERA_CS_BITS = 0x000000ff,
+	CELL_CAMERA_CAP_SHIFT = 8,
+	CELL_CAMERA_CAP_BITS = 0x0000ff00,
+	CELL_CAMERA_NUM_SHIFT = 16,
+	CELL_CAMERA_NUM_BITS = 0x000f0000,
+	CELL_CAMERA_NUM_1 = 0x00010000,
+	CELL_CAMERA_NUM_2 = 0x00020000,
+	CELL_CAMERA_NUM_3 = 0x00030000,
+	CELL_CAMERA_NUM_4 = 0x00040000,
+	CELL_CAMERA_LEN_SHIFT = 20,
+	CELL_CAMERA_LEN_BITS = 0x00f00000,
+	CELL_CAMERA_LEN_1 = 0x00100000,
+	CELL_CAMERA_LEN_2 = 0x00200000,
+	CELL_CAMERA_LEN_4 = 0x00400000,
+	CELL_CAMERA_ID_SHIFT = 24,
+	CELL_CAMERA_ID_BITS = 0x0f000000,
+	CELL_CAMERA_ID_CT = 0x01000000,
+	CELL_CAMERA_ID_SU = 0x02000000,
+	CELL_CAMERA_ID_PU = 0x04000000,
+};
+
+// UVCREQCODE Camera Terminal Control
+enum
+{
+	CELL_CAMERA_UVC_SCANNING_MODE = 0x01110001,
+	CELL_CAMERA_UVC_AUTO_EXPOSURE_MODE = 0x01110102,
+	CELL_CAMERA_UVC_AUTO_EXPOSURE_PRIORITY = 0x01110203,
+	CELL_CAMERA_UVC_EXPOSURE_TIME_ABS = 0x01410304,
+	CELL_CAMERA_UVC_EXPOSURE_TIME_REL = 0x01110405,
+	CELL_CAMERA_UVC_FOCUS_ABS = 0x01210506,
+	CELL_CAMERA_UVC_FOCUS_REL = 0x01120607,
+	CELL_CAMERA_UVC_FOCUS_AUTO = 0x01111108,
+	CELL_CAMERA_UVC_IRIS_ABS = 0x01210709,
+	CELL_CAMERA_UVC_IRIS_REL = 0x0111080a,
+	CELL_CAMERA_UVC_ZOOM_ABS = 0x0121090b,
+	CELL_CAMERA_UVC_ZOOM_REL = 0x01130a0c,
+	CELL_CAMERA_UVC_PANTILT_ABS = 0x01420b0d,
+	CELL_CAMERA_UVC_PANTILT_REL = 0x01140c0e,
+	CELL_CAMERA_UVC_ROLL_ABS = 0x01210d0f,
+	CELL_CAMERA_UVC_ROLL_REL = 0x01120e10,
+	CELL_CAMERA_UVC_PRIVACY = 0x01111211,
+};
+
+// UVCREQCODE Selector Unit Control/Processing Unit Control
+enum
+{
+	CELL_CAMERA_UVC_INPUT_SELECT = 0x02110101,
+
+	CELL_CAMERA_UVC_BACKLIGHT_COMPENSATION = 0x04210801,
+	CELL_CAMERA_UVC_BRIGHTNESS = 0x04210002,
+	CELL_CAMERA_UVC_CONTRAST = 0x04210103,
+	CELL_CAMERA_UVC_GAIN = 0x04210904,
+	CELL_CAMERA_UVC_POWER_LINE_FREQUENCY = 0x04110a05,
+	CELL_CAMERA_UVC_HUE = 0x04210206,
+	CELL_CAMERA_UVC_HUE_AUTO = 0x04110b10,
+	CELL_CAMERA_UVC_SATURATION = 0x04210307,
+	CELL_CAMERA_UVC_SHARPNESS = 0x04210408,
+	CELL_CAMERA_UVC_GAMMA = 0x04210509,
+	CELL_CAMERA_UVC_WHITE_BALANCE_TEMPERATURE = 0x0421060a,
+	CELL_CAMERA_UVC_WHITE_BALANCE_TEMPERATURE_AUTO = 0x04110c0b,
+	CELL_CAMERA_UVC_WHITE_BALANCE_COMPONENT = 0x0422070c,
+	CELL_CAMERA_UVC_WHITE_BALANCE_COMPONENT_AUTO = 0x04110d0d,
+	CELL_CAMERA_UVC_DIGITAL_MULTIPLIER = 0x04210e0e,
+	CELL_CAMERA_UVC_DIGITAL_MULTIPLIER_LIMIT = 0x04210f0f,
+	CELL_CAMERA_UVC_ANALOG_VIDEO_STANDARD = 0x04111011,
+	CELL_CAMERA_UVC_ANALOG_VIDEO_LOCK_STATUS = 0x04111112,
+};
+
+// UVCREQCODE Request code bits
+enum
+{
+	CELL_CAMERA_RC_CUR = 0x81,
+	CELL_CAMERA_RC_MIN = 0x82,
+	CELL_CAMERA_RC_MAX = 0x83,
+	CELL_CAMERA_RC_RES = 0x84,
+	CELL_CAMERA_RC_LEN = 0x85,
+	CELL_CAMERA_RC_INFO = 0x86,
+	CELL_CAMERA_RC_DEF = 0x87,
+};
+
+// Camera types
+enum CellCameraType : s32
+{
+	CELL_CAMERA_TYPE_UNKNOWN,
+	CELL_CAMERA_EYETOY,
+	CELL_CAMERA_EYETOY2,
+	CELL_CAMERA_USBVIDEOCLASS,
+};
+
+// Image format
+enum CellCameraFormat : s32
+{
+	CELL_CAMERA_FORMAT_UNKNOWN,
+	CELL_CAMERA_JPG,
+	CELL_CAMERA_RAW8,
+	CELL_CAMERA_YUV422,
+	CELL_CAMERA_RAW10,
+	CELL_CAMERA_RGBA,
+	CELL_CAMERA_YUV420,
+	CELL_CAMERA_V_Y1_U_Y0,
+	CELL_CAMERA_Y0_U_Y1_V = CELL_CAMERA_YUV422,
+};
+
+// Image resolution
+enum CellCameraResolution : s32
+{
+	CELL_CAMERA_RESOLUTION_UNKNOWN,
+	CELL_CAMERA_VGA,
+	CELL_CAMERA_QVGA,
+	CELL_CAMERA_WGA,
+	CELL_CAMERA_SPECIFIED_WIDTH_HEIGHT,
+};
+
+// Camera attributes
+enum CellCameraAttribute : s32
+{
+	CELL_CAMERA_GAIN,
+	CELL_CAMERA_REDBLUEGAIN,
+	CELL_CAMERA_SATURATION,
+	CELL_CAMERA_EXPOSURE,
+	CELL_CAMERA_BRIGHTNESS,
+	CELL_CAMERA_AEC,
+	CELL_CAMERA_AGC,
+	CELL_CAMERA_AWB,
+	CELL_CAMERA_ABC,
+	CELL_CAMERA_LED,
+	CELL_CAMERA_AUDIOGAIN,
+	CELL_CAMERA_QS,
+	CELL_CAMERA_NONZEROCOEFFS,
+	CELL_CAMERA_YUVFLAG,
+	CELL_CAMERA_JPEGFLAG,
+	CELL_CAMERA_BACKLIGHTCOMP,
+	CELL_CAMERA_MIRRORFLAG,
+	CELL_CAMERA_MEASUREDQS,
+	CELL_CAMERA_422FLAG,
+	CELL_CAMERA_USBLOAD,
+	CELL_CAMERA_GAMMA,
+	CELL_CAMERA_GREENGAIN,
+	CELL_CAMERA_AGCLIMIT,
+	CELL_CAMERA_DENOISE,
+	CELL_CAMERA_FRAMERATEADJUST,
+	CELL_CAMERA_PIXELOUTLIERFILTER,
+	CELL_CAMERA_AGCLOW,
+	CELL_CAMERA_AGCHIGH,
+	CELL_CAMERA_DEVICELOCATION,
+
+	CELL_CAMERA_FORMATCAP = 100,
+	CELL_CAMERA_FORMATINDEX,
+	CELL_CAMERA_NUMFRAME,
+	CELL_CAMERA_FRAMEINDEX,
+	CELL_CAMERA_FRAMESIZE,
+	CELL_CAMERA_INTERVALTYPE,
+	CELL_CAMERA_INTERVALINDEX,
+	CELL_CAMERA_INTERVALVALUE,
+	CELL_CAMERA_COLORMATCHING,
+	CELL_CAMERA_PLFREQ,
+	CELL_CAMERA_DEVICEID,
+	CELL_CAMERA_DEVICECAP,
+	CELL_CAMERA_DEVICESPEED,
+	CELL_CAMERA_UVCREQCODE,
+	CELL_CAMERA_UVCREQDATA,
+	CELL_CAMERA_DEVICEID2,
+
+	CELL_CAMERA_READMODE = 300,
+	CELL_CAMERA_GAMEPID,
+	CELL_CAMERA_PBUFFER,
+	CELL_CAMERA_READFINISH,
+
+	CELL_CAMERA_ATTRIBUTE_UNKNOWN = 500,
+};
+
+// Request codes
+enum
+{
+	SET_CUR = 0x01,
+	GET_CUR = 0x81,
+	GET_MIN = 0x82,
+	GET_MAX = 0x83,
+	GET_RES = 0x84,
+	GET_LEN = 0x85,
+	GET_INFO = 0x86,
+	GET_DEF = 0x87,
+};
+
+enum // version
+{
+	CELL_CAMERA_INFO_VER_100 = 0x0100,
+	CELL_CAMERA_INFO_VER_101 = 0x0101,
+	CELL_CAMERA_INFO_VER_200 = 0x0200,
+	CELL_CAMERA_INFO_VER = CELL_CAMERA_INFO_VER_200,
+
+	CELL_CAMERA_READ_VER_100 = 0x0100,
+	CELL_CAMERA_READ_VER = CELL_CAMERA_READ_VER_100,
+};
+
+// Other
+enum
+{
+	CELL_CAMERA_MAX_CAMERAS = 1
+};
+
+struct CellCameraInfo
+{
+	// filled in by application as inputs for open
+	be_t<s32> format;
+	be_t<s32> resolution;
+	be_t<s32> framerate;
+
+	// filled in by open
+	vm::bptr<u8> buffer;
+	be_t<s32> bytesize;
+	be_t<s32> width;
+	be_t<s32> height;
+	be_t<s32> dev_num;
+	be_t<s32> guid;
+};
+
+struct CellCameraInfoEx
+{
+	be_t<CellCameraFormat> format; // CellCameraFormat
+	be_t<s32> resolution;          // CellCameraResolution
+	be_t<s32> framerate;
+
+	vm::bptr<u8> buffer;
+	be_t<s32> bytesize;
+	be_t<s32>
+		width;        // only used if resolution == CELL_CAMERA_SPECIFIED_WIDTH_HEIGHT
+	be_t<s32> height; // likewise
+	be_t<s32> dev_num;
+	be_t<s32> guid;
+
+	be_t<s32> info_ver;
+	be_t<u32> container;
+	be_t<s32> read_mode;
+	vm::bptr<u8> pbuf[2];
+
+	ENABLE_BITWISE_SERIALIZATION;
+};
+
+struct CellCameraReadEx
+{
+	be_t<s32> version;
+	be_t<u32> frame;
+	be_t<u32> bytesread;
+	be_t<u64> timestamp; // system_time_t (microseconds)
+	vm::bptr<u8> pbuf;
+};
+
+class camera_context
+{
+	struct notify_event_data
+	{
+		u64 source;
+		u64 flag;
+
+		ENABLE_BITWISE_SERIALIZATION;
+	};
+
+public:
+	void operator()();
+	void reset_state();
+	void send_attach_state(bool attached);
+	void set_attr(s32 attrib, u32 arg1, u32 arg2);
+
+	/**
+	 * \brief Sets up notify event queue supplied and immediately sends an ATTACH
+	 * event to it
+	 * \param key Event queue key to add
+	 * \param source Event source port
+	 * \param flag Event flag (CELL_CAMERA_EFLAG_*)
+	 */
+	void add_queue(u64 key, u64 source, u64 flag);
+
+	/**
+	 * \brief Unsets/removes event queue specified
+	 * \param key Event queue key to remove
+	 */
+	void remove_queue(u64 key);
+
+	std::map<u64, notify_event_data> notify_data_map;
+
+	shared_mutex mutex;
+	shared_mutex mutex_notify_data_map;
+	u64 start_timestamp_us = 0;
+
+	atomic_t<u8> read_mode{CELL_CAMERA_READ_FUNCCALL};
+	atomic_t<bool> is_streaming{false};
+	atomic_t<bool> is_attached{false};
+	atomic_t<bool> is_attached_dirty{false};
+	atomic_t<bool> is_open{false};
+
+	CellCameraInfoEx info{};
+	atomic_t<u32> pbuf_write_index = 0;
+	std::array<atomic_t<bool>, 2> pbuf_locked = {false, false};
+	u32 pbuf_next_index() const;
+
+	struct attr_t
+	{
+		u32 v1, v2;
+
+		ENABLE_BITWISE_SERIALIZATION;
+	};
+
+	attr_t attr[500]{};
+	atomic_t<bool> has_new_frame = false;
+	atomic_t<u32> frame_num = 0;
+	atomic_t<u64> frame_timestamp_us = 0;
+	atomic_t<u32> bytes_read = 0;
+
+	atomic_t<u8> init = 0;
+
+	SAVESTATE_INIT_POS(16);
+
+	camera_context() = default;
+	camera_context(utils::serial& ar);
+	void save(utils::serial& ar);
+
+	static constexpr auto thread_name = "Camera Thread"sv;
+
+	std::shared_ptr<camera_handler_base> handler;
+	bool open_camera();
+	bool start_camera();
+	bool get_camera_frame(u8* dst, u32& width, u32& height, u64& frame_number,
+		u64& bytes_read);
+	void stop_camera();
+	void close_camera();
+	bool on_handler_state(camera_handler_base::camera_handler_state state);
+};
+
+using camera_thread = named_thread<camera_context>;
+
+/// Shared data between cellGem and cellCamera
+struct gem_camera_shared
+{
+	gem_camera_shared() {}
+	gem_camera_shared(utils::serial& ar);
+
+	void save(utils::serial& ar);
+
+	SAVESTATE_INIT_POS(7);
+
+	atomic_t<u64> frame_timestamp_us{}; // latest read timestamp from cellCamera
+	                                    // (cellCameraRead(Ex))
+	atomic_t<s32> width{640};
+	atomic_t<s32> height{480};
+	atomic_t<s32> size{0};
+	atomic_t<CellCameraFormat> format{CELL_CAMERA_RAW8};
+};

ps3fw/include/rpcsx/fw/ps3/cellCelp8Enc.h

@@ -0,0 +1,95 @@
+#pragma once
+
+struct CellSpurs;
+
+// libCelp8Enc = 0x806140a1 - 0x806140bf
+
+// typedef void* CellCelp8EncHandle;
+
+// Return Codes
+enum CellCelp8EncError : u32
+{
+	CELL_CELP8ENC_ERROR_FAILED = 0x806140a1,
+	CELL_CELP8ENC_ERROR_SEQ = 0x806140a2,
+	CELL_CELP8ENC_ERROR_ARG = 0x806140a3,
+	CELL_CELP8ENC_ERROR_CORE_FAILED = 0x806140b1,
+	CELL_CELP8ENC_ERROR_CORE_SEQ = 0x806140b2,
+	CELL_CELP8ENC_ERROR_CORE_ARG = 0x806140b3,
+};
+
+// Definitions
+enum CELL_CELP8ENC_MPE_CONFIG
+{
+	CELL_CELP8ENC_MPE_CONFIG_0 = 0,
+	CELL_CELP8ENC_MPE_CONFIG_2 = 2,
+	CELL_CELP8ENC_MPE_CONFIG_6 = 6,
+	CELL_CELP8ENC_MPE_CONFIG_9 = 9,
+	CELL_CELP8ENC_MPE_CONFIG_12 = 12,
+	CELL_CELP8ENC_MPE_CONFIG_15 = 15,
+	CELL_CELP8ENC_MPE_CONFIG_18 = 18,
+	CELL_CELP8ENC_MPE_CONFIG_21 = 21,
+	CELL_CELP8ENC_MPE_CONFIG_24 = 24,
+	CELL_CELP8ENC_MPE_CONFIG_26 = 26,
+};
+
+enum CELL_CELP8ENC_SAMPEL_RATE
+{
+	CELL_CELP8ENC_FS_8kHz = 1,
+};
+
+enum CELL_CELP8ENC_EXCITATION_MODE
+{
+	CELL_CELP8ENC_EXCITATION_MODE_MPE = 0,
+};
+
+enum CELL_CELP8ENC_WORD_SZ
+{
+	CELL_CELP8ENC_WORD_SZ_FLOAT,
+};
+
+struct CellCelp8EncAttr
+{
+	be_t<u32> workMemSize;
+	be_t<u32> celpEncVerUpper;
+	be_t<u32> celpEncVerLower;
+};
+
+struct CellCelp8EncResource
+{
+	be_t<u32> totalMemSize;
+	vm::bptr<void> startAddr;
+	be_t<u32> ppuThreadPriority;
+	be_t<u32> spuThreadPriority;
+	be_t<u32 /*usz*/> ppuThreadStackSize;
+};
+
+struct CellCelp8EncParam
+{
+	be_t<u32> excitationMode;
+	be_t<u32> sampleRate;
+	be_t<u32> configuration;
+	be_t<u32> wordSize;
+	vm::bptr<u8> outBuff;
+	be_t<u32> outSize;
+};
+
+struct CellCelp8EncAuInfo
+{
+	vm::bptr<void> startAddr;
+	be_t<u32> size;
+};
+
+struct CellCelp8EncPcmInfo
+{
+	vm::bptr<void> startAddr;
+	be_t<u32> size;
+};
+
+struct CellCelp8EncResourceEx
+{
+	be_t<u32> totalMemSize;
+	vm::bptr<void> startAddr;
+	vm::bptr<CellSpurs> spurs;
+	u8 priority[8];
+	be_t<u32> maxContention;
+};

ps3fw/include/rpcsx/fw/ps3/cellCelpEnc.h

@@ -0,0 +1,90 @@
+#pragma once
+
+struct CellSpurs;
+
+// libCelpEnc = 0x80614001 - 0x806140ff
+
+// typedef void* CellCelpEncHandle;
+
+// Return Codes
+enum CellCelpEncError : u32
+{
+	CELL_CELPENC_ERROR_FAILED = 0x80614001,
+	CELL_CELPENC_ERROR_SEQ = 0x80614002,
+	CELL_CELPENC_ERROR_ARG = 0x80614003,
+	CELL_CELPENC_ERROR_CORE_FAILED = 0x80614081,
+	CELL_CELPENC_ERROR_CORE_SEQ = 0x80614082,
+	CELL_CELPENC_ERROR_CORE_ARG = 0x80614083,
+};
+
+// Definitions
+enum CELL_CELPENC_RPE_CONFIG
+{
+	CELL_CELPENC_RPE_CONFIG_0,
+	CELL_CELPENC_RPE_CONFIG_1,
+	CELL_CELPENC_RPE_CONFIG_2,
+	CELL_CELPENC_RPE_CONFIG_3,
+};
+
+enum CELL_CELPENC_SAMPEL_RATE
+{
+	CELL_CELPENC_FS_16kHz = 2,
+};
+
+enum CELL_CELPENC_EXCITATION_MODE
+{
+	CELL_CELPENC_EXCITATION_MODE_RPE = 1,
+};
+
+enum CELL_CELPENC_WORD_SZ
+{
+	CELL_CELPENC_WORD_SZ_INT16_LE,
+	CELL_CELPENC_WORD_SZ_FLOAT
+};
+
+struct CellCelpEncAttr
+{
+	be_t<u32> workMemSize;
+	be_t<u32> celpEncVerUpper;
+	be_t<u32> celpEncVerLower;
+};
+
+struct CellCelpEncResource
+{
+	be_t<u32> totalMemSize;
+	vm::bptr<void> startAddr;
+	be_t<u32> ppuThreadPriority;
+	be_t<u32> spuThreadPriority;
+	be_t<u32 /*usz*/> ppuThreadStackSize;
+};
+
+struct CellCelpEncParam
+{
+	be_t<u32> excitationMode;
+	be_t<u32> sampleRate;
+	be_t<u32> configuration;
+	be_t<u32> wordSize;
+	vm::bptr<u8> outBuff;
+	be_t<u32> outSize;
+};
+
+struct CellCelpEncAuInfo
+{
+	vm::bptr<void> startAddr;
+	be_t<u32> size;
+};
+
+struct CellCelpEncPcmInfo
+{
+	vm::bptr<void> startAddr;
+	be_t<u32> size;
+};
+
+struct CellCelpEncResourceEx
+{
+	be_t<u32> totalMemSize;
+	vm::bptr<void> startAddr;
+	vm::bptr<CellSpurs> spurs;
+	u8 priority[8];
+	be_t<u32> maxContention;
+};

ps3fw/include/rpcsx/fw/ps3/cellCrossController.h

@@ -0,0 +1,52 @@
+#pragma once
+
+enum CellCrossControllerError : u32
+{
+	CELL_CROSS_CONTROLLER_ERROR_CANCEL = 0x8002cd80,
+	CELL_CROSS_CONTROLLER_ERROR_NETWORK = 0x8002cd81,
+	CELL_CROSS_CONTROLLER_ERROR_OUT_OF_MEMORY = 0x8002cd90,
+	CELL_CROSS_CONTROLLER_ERROR_FATAL = 0x8002cd91,
+	CELL_CROSS_CONTROLLER_ERROR_INVALID_PKG_FILENAME = 0x8002cd92,
+	CELL_CROSS_CONTROLLER_ERROR_INVALID_SIG_FILENAME = 0x8002cd93,
+	CELL_CROSS_CONTROLLER_ERROR_INVALID_ICON_FILENAME = 0x8002cd94,
+	CELL_CROSS_CONTROLLER_ERROR_INVALID_VALUE = 0x8002cd95,
+	CELL_CROSS_CONTROLLER_ERROR_PKG_FILE_OPEN = 0x8002cd96,
+	CELL_CROSS_CONTROLLER_ERROR_SIG_FILE_OPEN = 0x8002cd97,
+	CELL_CROSS_CONTROLLER_ERROR_ICON_FILE_OPEN = 0x8002cd98,
+	CELL_CROSS_CONTROLLER_ERROR_INVALID_STATE = 0x8002cd99,
+	CELL_CROSS_CONTROLLER_ERROR_INVALID_PKG_FILE = 0x8002cd9a,
+	CELL_CROSS_CONTROLLER_ERROR_INTERNAL = 0x8002cda0,
+};
+
+enum
+{
+	CELL_CROSS_CONTROLLER_STATUS_INITIALIZED = 1,
+	CELL_CROSS_CONTROLLER_STATUS_FINALIZED = 2
+};
+
+enum
+{
+	CELL_CROSS_CONTROLLER_PKG_APP_VER_LEN = 6,   // e.g. 01.00
+	CELL_CROSS_CONTROLLER_PKG_TITLE_ID_LEN = 10, // e.g. NEKO12345
+	CELL_CROSS_CONTROLLER_PKG_TITLE_LEN = 52,    // e.g. Cat Simulator 5
+
+	// Undefined helper value
+	CELL_CROSS_CONTROLLER_PARAM_FILE_NAME_LEN = 255,
+};
+
+struct CellCrossControllerParam
+{
+	vm::bcptr<char> pPackageFileName;
+	vm::bcptr<char> pSignatureFileName;
+	vm::bcptr<char> pIconFileName;
+	vm::bptr<void> option;
+};
+
+struct CellCrossControllerPackageInfo
+{
+	vm::bcptr<char> pTitle;
+	vm::bcptr<char> pTitleId;
+	vm::bcptr<char> pAppVer;
+};
+
+using CellCrossControllerCallback = void(s32 status, s32 errorCode, vm::ptr<void> option, vm::ptr<void> userdata);

ps3fw/include/rpcsx/fw/ps3/cellDaisy.h

@@ -0,0 +1,82 @@
+#pragma once
+
+// libDaisy = 0x80410501 - 0x804105ff
+
+// Error codes
+enum CellDaisyError : u32
+{
+	CELL_DAISY_ERROR_NO_BEGIN = 0x80410501,
+	CELL_DAISY_ERROR_INVALID_PORT_ATTACH = 0x80410502,
+	CELL_DAISY_ERROR_NOT_IMPLEMENTED = 0x80410503,
+	CELL_DAISY_ERROR_AGAIN = 0x80410511,
+	CELL_DAISY_ERROR_INVAL = 0x80410512,
+	CELL_DAISY_ERROR_PERM = 0x80410509,
+	CELL_DAISY_ERROR_BUSY = 0x8041051A,
+	CELL_DAISY_ERROR_STAT = 0x8041050F,
+};
+
+// Return codes
+enum
+{
+	QUEUE_IS_BUSY = 2,
+	TERMINATED = 3,
+	GLUE_ACTIVE = 4,
+};
+
+// Assertations
+enum
+{
+	CELL_DAISY_MIN_QUEUE_SIZE = 1,
+	CELL_DAISY_MAX_LOCAL_QUEUE_SIZE = 32,
+	CELL_DAISY_MAX_ATO_QUEUE_SIZE = 32,
+	CELL_DAISY_MAX_SNR_QUEUE_SIZE = 12,
+	CELL_DAISY_MIN_ENTRY_SIZE = 16,
+	CELL_DAISY_MAX_ENTRY_SIZE = (16 * 1024),
+	CELL_DAISY_MAX_DMA_TAG = 31,
+
+	// CELL_DAISY_ENTRY_SIZE(x)
+	// CELL_DAISY_EA_ATOMIC(x)
+	// CELL_DAISY_EA_DMA(x)
+};
+
+// Definitions
+// The following are prefixed with DAISY_ to prevent name conflits
+enum
+{
+	// Queue IO
+	DAISY_OUTPUT,
+	DAISY_INPUT,
+
+	// Block Mode
+	DAISY_NOT_STALL = 0,
+	DAISY_STALL = 1,
+
+	// Queue Status
+	DAISY_PTR_UNAVAILABLE = 0x40000001,
+	DAISY_PTR_TERMINATED = 0x40000002,
+
+	// Buffer Mode
+	DAISY_COPY = 0,
+	DAISY_REFERENCE = 1,
+
+	// Constructor Mode
+	DAISY_NO_PARAMETER = 0,
+	DAISY_PARAMETER = 1,
+
+	// Glue Mode
+	DAISY_ONE_PORT = 1,
+	DAISY_TWO_PORT = 2,
+
+	// Queue Mode
+	DAISY_IN_ORDER,
+	DAISY_OUT_OF_ORDER,
+
+	// Buffer Type
+	DAISY_BUFFER_TYPE_REMOTE = 1,
+	DAISY_BUFFER_TYPE_LOCAL = 2,
+
+	// Queue Control Type
+	DAISY_QCTL_TYPE_ATOMIC = 1,
+	DAISY_QCTL_TYPE_LOCAL = 2,
+	DAISY_QCTL_TYPE_SIGNAL_NOTIFICATION = 3,
+};

ps3fw/include/rpcsx/fw/ps3/cellDmux.h

@@ -0,0 +1,328 @@
+#pragma once
+
+#include "Emu/Memory/vm_ptr.h"
+#include "cellPamf.h"
+
+// Error Codes
+enum CellDmuxError : u32
+{
+	CELL_DMUX_ERROR_ARG = 0x80610201,
+	CELL_DMUX_ERROR_SEQ = 0x80610202,
+	CELL_DMUX_ERROR_BUSY = 0x80610203,
+	CELL_DMUX_ERROR_EMPTY = 0x80610204,
+	CELL_DMUX_ERROR_FATAL = 0x80610205,
+};
+
+enum CellDmuxStreamType : s32
+{
+	CELL_DMUX_STREAM_TYPE_UNDEF = 0,
+	CELL_DMUX_STREAM_TYPE_PAMF = 1,
+	CELL_DMUX_STREAM_TYPE_TERMINATOR = 2,
+};
+
+enum CellDmuxMsgType : s32
+{
+	CELL_DMUX_MSG_TYPE_DEMUX_DONE = 0,
+	CELL_DMUX_MSG_TYPE_FATAL_ERR = 1,
+	CELL_DMUX_MSG_TYPE_PROG_END_CODE = 2,
+};
+
+enum CellDmuxEsMsgType : s32
+{
+	CELL_DMUX_ES_MSG_TYPE_AU_FOUND = 0,
+	CELL_DMUX_ES_MSG_TYPE_FLUSH_DONE = 1,
+};
+
+enum CellDmuxPamfM2vLevel : s32
+{
+	CELL_DMUX_PAMF_M2V_MP_LL = 0,
+	CELL_DMUX_PAMF_M2V_MP_ML,
+	CELL_DMUX_PAMF_M2V_MP_H14,
+	CELL_DMUX_PAMF_M2V_MP_HL,
+};
+
+enum CellDmuxPamfAvcLevel : s32
+{
+	CELL_DMUX_PAMF_AVC_LEVEL_2P1 = 21,
+	CELL_DMUX_PAMF_AVC_LEVEL_3P0 = 30,
+	CELL_DMUX_PAMF_AVC_LEVEL_3P1 = 31,
+	CELL_DMUX_PAMF_AVC_LEVEL_3P2 = 32,
+	CELL_DMUX_PAMF_AVC_LEVEL_4P1 = 41,
+	CELL_DMUX_PAMF_AVC_LEVEL_4P2 = 42,
+};
+
+struct CellDmuxPamfAuSpecificInfoM2v
+{
+	be_t<u32> reserved1;
+};
+
+struct CellDmuxPamfAuSpecificInfoAvc
+{
+	be_t<u32> reserved1;
+};
+
+struct CellDmuxPamfAuSpecificInfoLpcm
+{
+	u8 channelAssignmentInfo;
+	u8 samplingFreqInfo;
+	u8 bitsPerSample;
+};
+
+struct CellDmuxPamfAuSpecificInfoAc3
+{
+	be_t<u32> reserved1;
+};
+
+struct CellDmuxPamfAuSpecificInfoAtrac3plus
+{
+	be_t<u32> reserved1;
+};
+
+struct CellDmuxPamfAuSpecificInfoUserData
+{
+	be_t<u32> reserved1;
+};
+
+struct CellDmuxPamfEsSpecificInfoM2v
+{
+	be_t<u32> profileLevel;
+};
+
+struct CellDmuxPamfEsSpecificInfoAvc
+{
+	be_t<u32> level;
+};
+
+struct CellDmuxPamfEsSpecificInfoLpcm
+{
+	be_t<u32> samplingFreq;
+	be_t<u32> numOfChannels;
+	be_t<u32> bitsPerSample;
+};
+
+struct CellDmuxPamfEsSpecificInfoAc3
+{
+	be_t<u32> reserved1;
+};
+
+struct CellDmuxPamfEsSpecificInfoAtrac3plus
+{
+	be_t<u32> reserved1;
+};
+
+struct CellDmuxPamfEsSpecificInfoUserData
+{
+	be_t<u32> reserved1;
+};
+
+enum CellDmuxPamfSamplingFrequency : s32
+{
+	CELL_DMUX_PAMF_FS_48K = 48000,
+};
+
+enum CellDmuxPamfBitsPerSample : s32
+{
+	CELL_DMUX_PAMF_BITS_PER_SAMPLE_16 = 16,
+	CELL_DMUX_PAMF_BITS_PER_SAMPLE_24 = 24,
+};
+
+enum CellDmuxPamfLpcmChannelAssignmentInfo : s32
+{
+	CELL_DMUX_PAMF_LPCM_CH_M1 = 1,
+	CELL_DMUX_PAMF_LPCM_CH_LR = 3,
+	CELL_DMUX_PAMF_LPCM_CH_LRCLSRSLFE = 9,
+	CELL_DMUX_PAMF_LPCM_CH_LRCLSCS1CS2RSLFE = 11,
+};
+
+enum CellDmuxPamfLpcmFs : s32
+{
+	CELL_DMUX_PAMF_LPCM_FS_48K = 1,
+};
+
+enum CellDmuxPamfLpcmBitsPerSamples : s32
+{
+	CELL_DMUX_PAMF_LPCM_BITS_PER_SAMPLE_16 = 1,
+	CELL_DMUX_PAMF_LPCM_BITS_PER_SAMPLE_24 = 3,
+};
+
+struct CellDmuxMsg
+{
+	be_t<s32> msgType; // CellDmuxMsgType
+	be_t<u64> supplementalInfo;
+};
+
+struct CellDmuxEsMsg
+{
+	be_t<s32> msgType; // CellDmuxEsMsgType
+	be_t<u64> supplementalInfo;
+};
+
+struct CellDmuxType
+{
+	be_t<s32> streamType; // CellDmuxStreamType
+	be_t<u32> reserved[2];
+};
+
+struct CellDmuxPamfSpecificInfo
+{
+	be_t<u32> thisSize;
+	b8 programEndCodeCb;
+};
+
+struct CellDmuxType2
+{
+	be_t<s32> streamType; // CellDmuxStreamType
+	be_t<u32> streamSpecificInfo;
+};
+
+struct CellDmuxResource
+{
+	be_t<u32> memAddr;
+	be_t<u32> memSize;
+	be_t<u32> ppuThreadPriority;
+	be_t<u32> ppuThreadStackSize;
+	be_t<u32> spuThreadPriority;
+	be_t<u32> numOfSpus;
+};
+
+struct CellDmuxResourceEx
+{
+	be_t<u32> memAddr;
+	be_t<u32> memSize;
+	be_t<u32> ppuThreadPriority;
+	be_t<u32> ppuThreadStackSize;
+	be_t<u32> spurs_addr;
+	u8 priority[8];
+	be_t<u32> maxContention;
+};
+
+struct CellDmuxResourceSpurs
+{
+	vm::bptr<void> spurs; // CellSpurs*
+	be_t<u64, 1> priority;
+	be_t<u32> maxContention;
+};
+
+/*
+struct CellDmuxResource2Ex
+{
+    b8 isResourceEx; //true
+    CellDmuxResourceEx resourceEx;
+};
+
+struct CellDmuxResource2NoEx
+{
+    b8 isResourceEx; //false
+    CellDmuxResource resource;
+};
+*/
+
+struct CellDmuxResource2
+{
+	b8 isResourceEx;
+	be_t<u32> memAddr;
+	be_t<u32> memSize;
+	be_t<u32> ppuThreadPriority;
+	be_t<u32> ppuThreadStackSize;
+	be_t<u32> shit[4];
+};
+
+using CellDmuxCbMsg = u32(u32 demuxerHandle, vm::ptr<CellDmuxMsg> demuxerMsg, u32 cbArg);
+
+using CellDmuxCbEsMsg = u32(u32 demuxerHandle, u32 esHandle, vm::ptr<CellDmuxEsMsg> esMsg, u32 cbArg);
+
+// Used for internal callbacks as well
+template <typename F>
+struct DmuxCb
+{
+	vm::bptr<F> cbFunc;
+	be_t<u32> cbArg;
+};
+
+using CellDmuxCb = DmuxCb<CellDmuxCbMsg>;
+
+using CellDmuxEsCb = DmuxCb<CellDmuxCbEsMsg>;
+
+struct CellDmuxAttr
+{
+	be_t<u32> memSize;
+	be_t<u32> demuxerVerUpper;
+	be_t<u32> demuxerVerLower;
+};
+
+struct CellDmuxEsAttr
+{
+	be_t<u32> memSize;
+};
+
+struct CellDmuxEsResource
+{
+	be_t<u32> memAddr;
+	be_t<u32> memSize;
+};
+
+struct CellDmuxAuInfo
+{
+	be_t<u32> auAddr;
+	be_t<u32> auSize;
+	be_t<u32> auMaxSize;
+	be_t<u64> userData;
+	be_t<u32> ptsUpper;
+	be_t<u32> ptsLower;
+	be_t<u32> dtsUpper;
+	be_t<u32> dtsLower;
+};
+
+struct CellDmuxAuInfoEx
+{
+	be_t<u32> auAddr;
+	be_t<u32> auSize;
+	be_t<u32> reserved;
+	b8 isRap;
+	be_t<u64> userData;
+	CellCodecTimeStamp pts;
+	CellCodecTimeStamp dts;
+};
+
+struct CellDmuxPamfAttr;
+struct CellDmuxPamfEsAttr;
+
+using DmuxNotifyDemuxDone = error_code(vm::ptr<void>, u32, vm::ptr<void>);
+using DmuxNotifyFatalErr = error_code(vm::ptr<void>, u32, vm::ptr<void>);
+using DmuxNotifyProgEndCode = error_code(vm::ptr<void>, vm::ptr<void>);
+
+using DmuxEsNotifyAuFound = error_code(vm::ptr<void>, vm::cptr<void>, vm::ptr<void>);
+using DmuxEsNotifyFlushDone = error_code(vm::ptr<void>, vm::ptr<void>);
+
+using CellDmuxCoreOpQueryAttr = error_code(vm::cptr<void>, vm::ptr<CellDmuxPamfAttr>);
+using CellDmuxCoreOpOpen = error_code(vm::cptr<void>, vm::cptr<CellDmuxResource>, vm::cptr<CellDmuxResourceSpurs>, vm::cptr<DmuxCb<DmuxNotifyDemuxDone>>, vm::cptr<DmuxCb<DmuxNotifyProgEndCode>>, vm::cptr<DmuxCb<DmuxNotifyFatalErr>>, vm::pptr<void>);
+using CellDmuxCoreOpClose = error_code(vm::ptr<void>);
+using CellDmuxCoreOpResetStream = error_code(vm::ptr<void>);
+using CellDmuxCoreOpCreateThread = error_code(vm::ptr<void>);
+using CellDmuxCoreOpJoinThread = error_code(vm::ptr<void>);
+using CellDmuxCoreOpSetStream = error_code(vm::ptr<void>, vm::cptr<void>, u32, b8, u64);
+using CellDmuxCoreOpFreeMemory = error_code(vm::ptr<void>, vm::ptr<void>, u32);
+using CellDmuxCoreOpQueryEsAttr = error_code(vm::cptr<void>, vm::cptr<void>, vm::ptr<CellDmuxPamfEsAttr>);
+using CellDmuxCoreOpEnableEs = error_code(vm::ptr<void>, vm::cptr<void>, vm::cptr<CellDmuxEsResource>, vm::cptr<DmuxCb<DmuxEsNotifyAuFound>>, vm::cptr<DmuxCb<DmuxEsNotifyFlushDone>>, vm::cptr<void>, vm::pptr<void>);
+using CellDmuxCoreOpDisableEs = u32(vm::ptr<void>);
+using CellDmuxCoreOpFlushEs = u32(vm::ptr<void>);
+using CellDmuxCoreOpResetEs = u32(vm::ptr<void>);
+using CellDmuxCoreOpResetStreamAndWaitDone = u32(vm::ptr<void>);
+
+struct CellDmuxCoreOps
+{
+	vm::bptr<CellDmuxCoreOpQueryAttr> queryAttr;
+	vm::bptr<CellDmuxCoreOpOpen> open;
+	vm::bptr<CellDmuxCoreOpClose> close;
+	vm::bptr<CellDmuxCoreOpResetStream> resetStream;
+	vm::bptr<CellDmuxCoreOpCreateThread> createThread;
+	vm::bptr<CellDmuxCoreOpJoinThread> joinThread;
+	vm::bptr<CellDmuxCoreOpSetStream> setStream;
+	vm::bptr<CellDmuxCoreOpFreeMemory> freeMemory;
+	vm::bptr<CellDmuxCoreOpQueryEsAttr> queryEsAttr;
+	vm::bptr<CellDmuxCoreOpEnableEs> enableEs;
+	vm::bptr<CellDmuxCoreOpDisableEs> disableEs;
+	vm::bptr<CellDmuxCoreOpFlushEs> flushEs;
+	vm::bptr<CellDmuxCoreOpResetEs> resetEs;
+	vm::bptr<CellDmuxCoreOpResetStreamAndWaitDone> resetStreamAndWaitDone;
+};

ps3fw/include/rpcsx/fw/ps3/cellDmuxPamf.h

@@ -0,0 +1,15 @@
+#pragma once
+
+struct CellDmuxPamfAttr
+{
+	be_t<u32> maxEnabledEsNum;
+	be_t<u32> version;
+	be_t<u32> memSize;
+};
+
+struct CellDmuxPamfEsAttr
+{
+	be_t<u32> auQueueMaxSize;
+	be_t<u32> memSize;
+	be_t<u32> specificInfoSize;
+};

ps3fw/include/rpcsx/fw/ps3/cellFiber.h

@@ -0,0 +1,116 @@
+#pragma once
+
+#include "Emu/Memory/vm_ptr.h"
+
+// Return Codes
+enum CellFiberError : u32
+{
+	CELL_FIBER_ERROR_AGAIN = 0x80760001,        // Resource was temporarily unavailable
+	CELL_FIBER_ERROR_INVAL = 0x80760002,        // Value of the argument is invalid
+	CELL_FIBER_ERROR_NOMEM = 0x80760004,        // Insufficient memory
+	CELL_FIBER_ERROR_DEADLK = 0x80760008,       // Execution of the operation will cause a deadlock
+	CELL_FIBER_ERROR_PERM = 0x80760009,         // Executed operation is not permitted
+	CELL_FIBER_ERROR_BUSY = 0x8076000A,         // The operation target is busy
+	CELL_FIBER_ERROR_ABORT = 0x8076000C,        // The operation has been aborted
+	CELL_FIBER_ERROR_STAT = 0x8076000F,         // State of the operation target is invalid
+	CELL_FIBER_ERROR_ALIGN = 0x80760010,        // The alignment of the argument address is invalid
+	CELL_FIBER_ERROR_NULL_POINTER = 0x80760011, // Invalid NULL pointer is specified for the argument
+	CELL_FIBER_ERROR_NOSYSINIT = 0x80760020,    // cellFiberPpuInitialize() has not been called
+};
+
+//
+// CellFiberPpuScheduler
+//
+
+struct alignas(128) CellFiberPpuScheduler
+{
+	u8 skip[512];
+};
+
+CHECK_SIZE_ALIGN(CellFiberPpuScheduler, 512, 128);
+
+struct alignas(8) CellFiberPpuSchedulerAttribute
+{
+	u8 privateHeader[16];
+	b8 autoCheckFlags;
+	b8 debuggerSupport;
+	u8 padding[2];
+	be_t<u32> autoCheckFlagsIntervalUsec;
+	u8 skip[232];
+};
+
+CHECK_SIZE_ALIGN(CellFiberPpuSchedulerAttribute, 256, 8);
+
+//
+// CellFiberPpu
+//
+
+struct alignas(128) CellFiberPpu
+{
+	u8 skip[896];
+};
+
+CHECK_SIZE_ALIGN(CellFiberPpu, 896, 128);
+
+typedef s32(CellFiberPpuEntry)(u64 arg);
+typedef void(CellFiberPpuOnExitCallback)(u64 arg, s32 exitCode);
+
+struct alignas(8) CellFiberPpuAttribute
+{
+	u8 privateHeader[16];
+	char name[32];
+	vm::bptr<CellFiberPpuOnExitCallback> onExitCallback;
+	be_t<u32> __reserved0__;
+	be_t<u64> onExitCallbackArg;
+	be_t<u64> __reserved1__;
+	u8 skip[184];
+};
+
+CHECK_SIZE_ALIGN(CellFiberPpuAttribute, 256, 8);
+
+//
+// CellFiberPpuContext
+//
+
+struct alignas(16) CellFiberPpuContext
+{
+	u8 skip[640];
+};
+
+CHECK_SIZE_ALIGN(CellFiberPpuContext, 640, 16);
+
+typedef void(CellFiberPpuContextEntry)(u64 arg, vm::ptr<CellFiberPpuContext> fiberFrom);
+
+struct alignas(8) CellFiberPpuContextAttribute
+{
+	u8 privateHeader[16];
+	char name[32];
+	b8 debuggerSupport;
+	u8 skip[79];
+};
+
+CHECK_SIZE_ALIGN(CellFiberPpuContextAttribute, 128, 8);
+
+struct CellFiberPpuContextExecutionOption;
+
+typedef vm::ptr<CellFiberPpuContext>(CellFiberPpuSchedulerCallback)(u64 arg0, u64 arg1);
+
+//
+// CellFiberPpuUtilWorkerControl
+//
+
+struct alignas(128) CellFiberPpuUtilWorkerControl
+{
+	u8 skip[768];
+};
+
+CHECK_SIZE_ALIGN(CellFiberPpuUtilWorkerControl, 768, 128);
+
+struct alignas(8) CellFiberPpuUtilWorkerControlAttribute
+{
+	CellFiberPpuSchedulerAttribute scheduler;
+	be_t<u64> privateHeader[2];
+	u8 __reserved__[112];
+};
+
+CHECK_SIZE_ALIGN(CellFiberPpuUtilWorkerControlAttribute, 384, 8);

ps3fw/include/rpcsx/fw/ps3/cellFont.h

@@ -0,0 +1,345 @@
+#pragma once
+
+#include "Emu/Memory/vm_ptr.h"
+
+// Error codes
+enum CellFontError : u32
+{
+	CELL_FONT_ERROR_FATAL = 0x80540001,
+	CELL_FONT_ERROR_INVALID_PARAMETER = 0x80540002,
+	CELL_FONT_ERROR_UNINITIALIZED = 0x80540003,
+	CELL_FONT_ERROR_INITIALIZE_FAILED = 0x80540004,
+	CELL_FONT_ERROR_INVALID_CACHE_BUFFER = 0x80540005,
+	CELL_FONT_ERROR_ALREADY_INITIALIZED = 0x80540006,
+	CELL_FONT_ERROR_ALLOCATION_FAILED = 0x80540007,
+	CELL_FONT_ERROR_NO_SUPPORT_FONTSET = 0x80540008,
+	CELL_FONT_ERROR_OPEN_FAILED = 0x80540009,
+	CELL_FONT_ERROR_READ_FAILED = 0x8054000a,
+	CELL_FONT_ERROR_FONT_OPEN_FAILED = 0x8054000b,
+	CELL_FONT_ERROR_FONT_NOT_FOUND = 0x8054000c,
+	CELL_FONT_ERROR_FONT_OPEN_MAX = 0x8054000d,
+	CELL_FONT_ERROR_FONT_CLOSE_FAILED = 0x8054000e,
+	CELL_FONT_ERROR_ALREADY_OPENED = 0x8054000f,
+	CELL_FONT_ERROR_NO_SUPPORT_FUNCTION = 0x80540010,
+	CELL_FONT_ERROR_NO_SUPPORT_CODE = 0x80540011,
+	CELL_FONT_ERROR_NO_SUPPORT_GLYPH = 0x80540012,
+	CELL_FONT_ERROR_BUFFER_SIZE_NOT_ENOUGH = 0x80540016,
+	CELL_FONT_ERROR_RENDERER_ALREADY_BIND = 0x80540020,
+	CELL_FONT_ERROR_RENDERER_UNBIND = 0x80540021,
+	CELL_FONT_ERROR_RENDERER_INVALID = 0x80540022,
+	CELL_FONT_ERROR_RENDERER_ALLOCATION_FAILED = 0x80540023,
+	CELL_FONT_ERROR_ENOUGH_RENDERING_BUFFER = 0x80540024,
+	CELL_FONT_ERROR_NO_SUPPORT_SURFACE = 0x80540040,
+};
+
+// Font Set Types
+enum
+{
+	CELL_FONT_TYPE_RODIN_SANS_SERIF_LATIN = 0x00000000,
+	CELL_FONT_TYPE_RODIN_SANS_SERIF_LIGHT_LATIN = 0x00000001,
+	CELL_FONT_TYPE_RODIN_SANS_SERIF_BOLD_LATIN = 0x00000002,
+	CELL_FONT_TYPE_RODIN_SANS_SERIF_LATIN2 = 0x00000018,
+	CELL_FONT_TYPE_RODIN_SANS_SERIF_LIGHT_LATIN2 = 0x00000019,
+	CELL_FONT_TYPE_RODIN_SANS_SERIF_BOLD_LATIN2 = 0x0000001a,
+	CELL_FONT_TYPE_MATISSE_SERIF_LATIN = 0x00000020,
+	CELL_FONT_TYPE_NEWRODIN_GOTHIC_JAPANESE = 0x00000008,
+	CELL_FONT_TYPE_NEWRODIN_GOTHIC_LIGHT_JAPANESE = 0x00000009,
+	CELL_FONT_TYPE_NEWRODIN_GOTHIC_BOLD_JAPANESE = 0x0000000a,
+	CELL_FONT_TYPE_YD_GOTHIC_KOREAN = 0x0000000c,
+	CELL_FONT_TYPE_SEURAT_MARU_GOTHIC_LATIN = 0x00000040,
+	CELL_FONT_TYPE_SEURAT_MARU_GOTHIC_LATIN2 = 0x00000041,
+	CELL_FONT_TYPE_VAGR_SANS_SERIF_ROUND = 0x00000043,
+	CELL_FONT_TYPE_VAGR_SANS_SERIF_ROUND_LATIN2 = 0x00000044,
+	CELL_FONT_TYPE_SEURAT_MARU_GOTHIC_JAPANESE = 0x00000048,
+
+	CELL_FONT_TYPE_NEWRODIN_GOTHIC_JP_SET = 0x00000100,
+	CELL_FONT_TYPE_NEWRODIN_GOTHIC_LATIN_SET = 0x00000101,
+	CELL_FONT_TYPE_NEWRODIN_GOTHIC_RODIN_SET = 0x00000104,
+	CELL_FONT_TYPE_NEWRODIN_GOTHIC_RODIN2_SET = 0x00000204,
+	CELL_FONT_TYPE_NEWRODIN_GOTHIC_YG_RODIN2_SET = 0x00000201,
+	CELL_FONT_TYPE_NEWRODIN_GOTHIC_YG_DFHEI5_SET = 0x00000108,
+	CELL_FONT_TYPE_NEWRODIN_GOTHIC_YG_DFHEI5_RODIN_SET = 0x00000109,
+	CELL_FONT_TYPE_NEWRODIN_GOTHIC_YG_DFHEI5_RODIN2_SET = 0x00000209,
+	CELL_FONT_TYPE_DFHEI5_GOTHIC_YG_NEWRODIN_TCH_SET = 0x0000010a,
+	CELL_FONT_TYPE_DFHEI5_GOTHIC_YG_NEWRODIN_RODIN_TCH_SET = 0x0000010b,
+	CELL_FONT_TYPE_DFHEI5_GOTHIC_YG_NEWRODIN_RODIN2_TCH_SET = 0x0000020b,
+	CELL_FONT_TYPE_DFHEI5_GOTHIC_YG_NEWRODIN_SCH_SET = 0x0000010c,
+	CELL_FONT_TYPE_DFHEI5_GOTHIC_YG_NEWRODIN_RODIN_SCH_SET = 0x0000010d,
+	CELL_FONT_TYPE_DFHEI5_GOTHIC_YG_NEWRODIN_RODIN2_SCH_SET = 0x0000020d,
+
+	CELL_FONT_TYPE_SEURAT_MARU_GOTHIC_RSANS_SET = 0x00300104,
+	CELL_FONT_TYPE_SEURAT_CAPIE_MARU_GOTHIC_RSANS_SET = 0x00300105,
+	CELL_FONT_TYPE_SEURAT_CAPIE_MARU_GOTHIC_JP_SET = 0x00300107,
+	CELL_FONT_TYPE_SEURAT_MARU_GOTHIC_YG_DFHEI5_RSANS_SET = 0x00300109,
+	CELL_FONT_TYPE_SEURAT_CAPIE_MARU_GOTHIC_YG_DFHEI5_RSANS_SET = 0x0030010F,
+	CELL_FONT_TYPE_VAGR_SEURAT_CAPIE_MARU_GOTHIC_RSANS_SET = 0x00300124,
+	CELL_FONT_TYPE_VAGR_SEURAT_CAPIE_MARU_GOTHIC_YG_DFHEI5_RSANS_SET = 0x00300129,
+
+	CELL_FONT_TYPE_NEWRODIN_GOTHIC_YG_LIGHT_SET = 0x00040100,
+	CELL_FONT_TYPE_NEWRODIN_GOTHIC_YG_RODIN_LIGHT_SET = 0x00040101,
+	CELL_FONT_TYPE_NEWRODIN_GOTHIC_YG_RODIN2_LIGHT_SET = 0x00040201,
+	CELL_FONT_TYPE_NEWRODIN_GOTHIC_RODIN_LIGHT_SET = 0x00040104,
+	CELL_FONT_TYPE_NEWRODIN_GOTHIC_RODIN2_LIGHT_SET = 0x00040204,
+	CELL_FONT_TYPE_NEWRODIN_GOTHIC_YG_BOLD_SET = 0x00070100,
+	CELL_FONT_TYPE_NEWRODIN_GOTHIC_YG_RODIN_BOLD_SET = 0x00070101,
+	CELL_FONT_TYPE_NEWRODIN_GOTHIC_YG_RODIN2_BOLD_SET = 0x00070201,
+	CELL_FONT_TYPE_NEWRODIN_GOTHIC_RODIN_BOLD_SET = 0x00070104,
+	CELL_FONT_TYPE_NEWRODIN_GOTHIC_RODIN2_BOLD_SET = 0x00070204,
+
+	CELL_FONT_TYPE_SEURAT_MARU_GOTHIC_RSANS2_SET = 0x00300204,
+	CELL_FONT_TYPE_SEURAT_CAPIE_MARU_GOTHIC_RSANS2_SET = 0x00300205,
+	CELL_FONT_TYPE_SEURAT_MARU_GOTHIC_YG_DFHEI5_RSANS2_SET = 0x00300209,
+	CELL_FONT_TYPE_SEURAT_CAPIE_MARU_GOTHIC_YG_DFHEI5_RSANS2_SET = 0x0030020F,
+	CELL_FONT_TYPE_SEURAT_CAPIE_MARU_GOTHIC_YG_DFHEI5_VAGR2_SET = 0x00300229,
+	CELL_FONT_TYPE_SEURAT_CAPIE_MARU_GOTHIC_VAGR2_SET = 0x00300224,
+};
+
+enum
+{
+	CELL_FONT_LIBRARY_TYPE_NONE = 0
+};
+
+enum
+{
+	CELL_FONT_MAP_FONT = 0,
+	CELL_FONT_MAP_UNICODE = 1,
+};
+
+enum
+{
+	CELL_FONT_OPEN_MODE_DEFAULT = 0,
+	CELL_FONT_OPEN_MODE_IGNORE_VERTICAL_METRICS = 1,
+};
+
+enum
+{
+	CELL_FONT_GRAPHICS_DRAW_TYPE_MONO = 0,
+	CELL_FONT_GRAPHICS_DRAW_TYPE_COLOR = 1,
+	CELL_FONT_GRAPHICS_DRAW_TYPE_COLOR_REVERSE = 2,
+};
+
+// Custom enum to determine the origin of a CellFont object
+enum
+{
+	CELL_FONT_OPEN_FONTSET,
+	CELL_FONT_OPEN_FONT_FILE,
+	CELL_FONT_OPEN_FONT_INSTANCE,
+	CELL_FONT_OPEN_MEMORY,
+};
+
+constexpr f32 CELL_FONT_GLYPH_OUTLINE_CONTROL_DISTANCE_DEFAULT = 0.125f;
+
+using CellFontMallocCallback = vm::ptr<void>(vm::ptr<void> arg, u32 size);
+using CellFontFreeCallback = void(vm::ptr<void> arg, vm::ptr<void> ptr);
+using CellFontReallocCallback = vm::ptr<void>(vm::ptr<void> arg, vm::ptr<void> p, u32 reallocSize);
+using CellFontCallocCallback = vm::ptr<void>(vm::ptr<void> arg, u32 num, u32 size);
+
+struct CellFontMemoryInterface
+{
+	vm::bptr<void> arg;
+	vm::bptr<CellFontMallocCallback> malloc;
+	vm::bptr<CellFontFreeCallback> free;
+	vm::bptr<CellFontReallocCallback> realloc;
+	vm::bptr<CellFontCallocCallback> calloc;
+};
+
+struct CellFontEntry
+{
+	be_t<u32> lock;
+	be_t<u32> uniqueId;
+	vm::bcptr<void> fontLib;
+	vm::bptr<void> fontH;
+};
+
+struct CellFontConfig
+{
+	// FileCache
+	vm::bptr<u32> fc_buffer;
+	be_t<u32> fc_size;
+
+	be_t<u32> userFontEntryMax;
+	vm::bptr<CellFontEntry> userFontEntrys;
+
+	be_t<u32> flags;
+};
+
+struct CellFontLibrary
+{
+	be_t<u32> libraryType;
+	be_t<u32> libraryVersion;
+	vm::bptr<u32> SystemClosed;
+};
+
+struct CellFontType
+{
+	be_t<u32> type;
+	be_t<u32> map;
+};
+
+struct CellFontHorizontalLayout
+{
+	be_t<f32> baseLineY;
+	be_t<f32> lineHeight;
+	be_t<f32> effectHeight;
+};
+
+struct CellFontVerticalLayout
+{
+	be_t<f32> baseLineX;
+	be_t<f32> lineWidth;
+	be_t<f32> effectWidth;
+};
+
+struct CellFontVertexesGlyphSubHeader
+{
+	be_t<u32> size;
+	be_t<f32> SystemReserved[11];
+};
+
+struct CellFontVertexesGlyphData
+{
+	const be_t<u32> size;
+	vm::bptr<f32> SystemClosed;
+};
+
+struct CellFontVertexesGlyph
+{
+	vm::bptr<CellFontVertexesGlyphData> data;
+	vm::bptr<CellFontVertexesGlyphSubHeader> subHeader;
+};
+
+struct CellFontGlyphMetrics
+{
+	be_t<f32> width;
+	be_t<f32> height;
+
+	be_t<f32> h_bearingX;
+	be_t<f32> h_bearingY;
+	be_t<f32> h_advance;
+
+	be_t<f32> v_bearingX;
+	be_t<f32> v_bearingY;
+	be_t<f32> v_advance;
+};
+
+struct CellFontGlyphOutline
+{
+	be_t<s16> contoursCount;
+	be_t<s16> pointsCount;
+
+	struct Point
+	{
+		be_t<f32> x;
+		be_t<f32> y;
+	};
+	vm::bptr<Point> points;
+	vm::bptr<u8> pointTags;
+	vm::bptr<u16> contourIndexs;
+
+	be_t<u32> flags;
+
+	vm::bptr<void> generateEnv;
+};
+
+using CellFontGetOutlineVertexCallback = vm::ptr<void>(vm::ptr<void> arg, s32 contourN, s32 vertexNumber, s32 vertexAttr, f32 x, f32 y);
+
+struct CellFontGetOutlineVertexesIF
+{
+	vm::bptr<CellFontGetOutlineVertexCallback> callback;
+	vm::bptr<void> arg;
+};
+
+struct CellFontGlyphBoundingBox
+{
+	be_t<f32> min_x;
+	be_t<f32> min_y;
+	be_t<f32> max_x;
+	be_t<f32> max_y;
+};
+
+struct CellFontKerning
+{
+	be_t<f32> offsetX;
+	be_t<f32> offsetY;
+};
+
+struct CellFontGlyphStyle
+{
+	be_t<f32> scale_widthPixel;
+	be_t<f32> scale_heightPixel;
+	be_t<f32> effect_weight;
+	be_t<f32> effect_slant;
+};
+
+struct CellFontGlyph
+{
+	be_t<u16> CF_type;
+	be_t<u16> type;
+	be_t<u32> size;
+	CellFontGlyphMetrics Metrics;
+	CellFontGlyphOutline Outline;
+};
+
+struct CellFontRenderSurface
+{
+	vm::bptr<void> buffer;
+	be_t<s32> widthByte;
+	be_t<s32> pixelSizeByte;
+	be_t<s32> width;
+	be_t<s32> height;
+
+	// Scissor
+	be_t<u32> sc_x0;
+	be_t<u32> sc_y0;
+	be_t<u32> sc_x1;
+	be_t<u32> sc_y1;
+};
+
+struct CellFontImageTransInfo
+{
+	vm::bptr<u8> image;
+	be_t<u32> imageWidthByte;
+	be_t<u32> imageWidth;
+	be_t<u32> imageHeight;
+	vm::bptr<void> surface;
+	be_t<u32> surfWidthByte;
+};
+
+struct CellFont
+{
+	be_t<float> scale_x;
+	be_t<float> scale_y;
+	be_t<float> slant;
+	be_t<u32> renderer_addr;
+
+	be_t<u32> fontdata_addr;
+	be_t<u32> origin;
+	struct stbtt_fontinfo* stbfont;
+	// hack: don't place anything after pointer
+};
+
+struct CellFontRendererConfig
+{
+	// Buffering Policy
+	vm::bptr<void> buffer;
+	be_t<u32> initSize;
+	be_t<u32> maxSize;
+	be_t<u32> expandSize;
+	be_t<u32> resetSize;
+};
+
+struct CellFontRenderer
+{
+	vm::bptr<void> systemReserved[64];
+};
+
+struct CellFontGraphics
+{
+	be_t<u32> graphicsType;
+	vm::bptr<uint32_t> SystemClosed;
+};
+
+struct CellFontGraphicsDrawContext
+{
+	vm::bptr<void> SystemReserved[64];
+};

ps3fw/include/rpcsx/fw/ps3/cellFontFT.h

@@ -0,0 +1,13 @@
+#pragma once
+
+#include "cellFont.h"
+
+#include "Emu/Memory/vm_ptr.h"
+
+struct CellFontLibraryConfigFT
+{
+	vm::bptr<void> library;
+	CellFontMemoryInterface MemoryIF;
+};
+
+using CellFontRendererConfigFT = CellFontRendererConfig;

ps3fw/include/rpcsx/fw/ps3/cellFs.h

@@ -0,0 +1,42 @@
+#pragma once
+
+#include "Emu/Memory/vm_ptr.h"
+
+// CellFsRingBuffer.copy
+enum : s32
+{
+	CELL_FS_ST_COPY = 0,
+	CELL_FS_ST_COPYLESS = 1,
+};
+
+struct CellFsRingBuffer
+{
+	be_t<u64> ringbuf_size;
+	be_t<u64> block_size;
+	be_t<u64> transfer_rate;
+	be_t<s32> copy;
+};
+
+// cellFsStReadGetStatus status
+enum : u64
+{
+	CELL_FS_ST_INITIALIZED = 0x0001,
+	CELL_FS_ST_NOT_INITIALIZED = 0x0002,
+	CELL_FS_ST_STOP = 0x0100,
+	CELL_FS_ST_PROGRESS = 0x0200,
+};
+
+enum : s32
+{
+	CELL_FS_AIO_MAX_FS = 10,      // cellFsAioInit limit
+	CELL_FS_AIO_MAX_REQUEST = 32, // cellFsAioRead request limit per mount point
+};
+
+struct CellFsAio
+{
+	be_t<u32> fd;
+	be_t<u64> offset;
+	vm::bptrb<void> buf;
+	be_t<u64> size;
+	be_t<u64> user_data;
+};

ps3fw/include/rpcsx/fw/ps3/cellGame.h

@@ -0,0 +1,354 @@
+#pragma once
+
+#include "Emu/Cell/ErrorCodes.h"
+#include "Emu/Memory/vm_ptr.h"
+
+// Return Codes
+enum
+{
+	CELL_GAME_RET_OK = 0,
+	CELL_GAME_RET_CANCEL = 1,
+	CELL_GAME_RET_NONE = 2,
+};
+
+enum CellGameError : u32
+{
+	CELL_GAME_ERROR_NOTFOUND = 0x8002cb04,
+	CELL_GAME_ERROR_BROKEN = 0x8002cb05,
+	CELL_GAME_ERROR_INTERNAL = 0x8002cb06,
+	CELL_GAME_ERROR_PARAM = 0x8002cb07,
+	CELL_GAME_ERROR_NOAPP = 0x8002cb08,
+	CELL_GAME_ERROR_ACCESS_ERROR = 0x8002cb09,
+	CELL_GAME_ERROR_NOSPACE = 0x8002cb20,
+	CELL_GAME_ERROR_NOTSUPPORTED = 0x8002cb21,
+	CELL_GAME_ERROR_FAILURE = 0x8002cb22,
+	CELL_GAME_ERROR_BUSY = 0x8002cb23,
+	CELL_GAME_ERROR_IN_SHUTDOWN = 0x8002cb24,
+	CELL_GAME_ERROR_INVALID_ID = 0x8002cb25,
+	CELL_GAME_ERROR_EXIST = 0x8002cb26,
+	CELL_GAME_ERROR_NOTPATCH = 0x8002cb27,
+	CELL_GAME_ERROR_INVALID_THEME_FILE = 0x8002cb28,
+	CELL_GAME_ERROR_BOOTPATH = 0x8002cb50,
+};
+
+enum CellGameDataError : u32
+{
+	CELL_GAMEDATA_ERROR_CBRESULT = 0x8002b601,
+	CELL_GAMEDATA_ERROR_ACCESS_ERROR = 0x8002b602,
+	CELL_GAMEDATA_ERROR_INTERNAL = 0x8002b603,
+	CELL_GAMEDATA_ERROR_PARAM = 0x8002b604,
+	CELL_GAMEDATA_ERROR_NOSPACE = 0x8002b605,
+	CELL_GAMEDATA_ERROR_BROKEN = 0x8002b606,
+	CELL_GAMEDATA_ERROR_FAILURE = 0x8002b607,
+};
+
+enum CellDiscGameError : u32
+{
+	CELL_DISCGAME_ERROR_INTERNAL = 0x8002bd01,
+	CELL_DISCGAME_ERROR_NOT_DISCBOOT = 0x8002bd02,
+	CELL_DISCGAME_ERROR_PARAM = 0x8002bd03,
+};
+
+// Definitions
+enum
+{
+	CELL_GAME_PATH_MAX = 128,
+	CELL_GAME_DIRNAME_SIZE = 32,
+	CELL_GAME_HDDGAMEPATH_SIZE = 128,
+	CELL_GAME_THEMEFILENAME_SIZE = 48,
+
+	CELL_GAME_SYSP_LANGUAGE_NUM = 20,
+	CELL_GAME_SYSP_TITLE_SIZE = 128,
+	CELL_GAME_SYSP_TITLEID_SIZE = 10,
+	CELL_GAME_SYSP_VERSION_SIZE = 6,
+	CELL_GAME_SYSP_PS3_SYSTEM_VER_SIZE = 8,
+	CELL_GAME_SYSP_APP_VER_SIZE = 6,
+
+	CELL_GAME_GAMETYPE_SYS = 0,
+	CELL_GAME_GAMETYPE_DISC = 1,
+	CELL_GAME_GAMETYPE_HDD = 2,
+	CELL_GAME_GAMETYPE_GAMEDATA = 3,
+	CELL_GAME_GAMETYPE_HOME = 4,
+
+	CELL_GAME_SIZEKB_NOTCALC = -1,
+
+	CELL_GAME_THEMEINSTALL_BUFSIZE_MIN = 4096,
+
+	CELL_GAME_ATTRIBUTE_PATCH = 0x1,
+	CELL_GAME_ATTRIBUTE_APP_HOME = 0x2,
+	CELL_GAME_ATTRIBUTE_DEBUG = 0x4,
+	CELL_GAME_ATTRIBUTE_XMBBUY = 0x8,
+	CELL_GAME_ATTRIBUTE_COMMERCE2_BROWSER = 0x10,
+	CELL_GAME_ATTRIBUTE_INVITE_MESSAGE = 0x20,
+	CELL_GAME_ATTRIBUTE_CUSTOM_DATA_MESSAGE = 0x40,
+	CELL_GAME_ATTRIBUTE_WEB_BROWSER = 0x100,
+
+	CELL_GAME_THEME_OPTION_NONE = 0x0,
+	CELL_GAME_THEME_OPTION_APPLY = 0x1,
+
+	CELL_GAME_DISCTYPE_OTHER = 0,
+	CELL_GAME_DISCTYPE_PS3 = 1,
+	CELL_GAME_DISCTYPE_PS2 = 2,
+};
+
+// Parameter IDs of PARAM.SFO
+enum
+{
+	// Integers
+	CELL_GAME_PARAMID_PARENTAL_LEVEL = 102,
+	CELL_GAME_PARAMID_RESOLUTION = 103,
+	CELL_GAME_PARAMID_SOUND_FORMAT = 104,
+
+	// Strings
+	CELL_GAME_PARAMID_TITLE = 0,
+	CELL_GAME_PARAMID_TITLE_DEFAULT = 1,
+	CELL_GAME_PARAMID_TITLE_JAPANESE = 2,
+	CELL_GAME_PARAMID_TITLE_ENGLISH = 3,
+	CELL_GAME_PARAMID_TITLE_FRENCH = 4,
+	CELL_GAME_PARAMID_TITLE_SPANISH = 5,
+	CELL_GAME_PARAMID_TITLE_GERMAN = 6,
+	CELL_GAME_PARAMID_TITLE_ITALIAN = 7,
+	CELL_GAME_PARAMID_TITLE_DUTCH = 8,
+	CELL_GAME_PARAMID_TITLE_PORTUGUESE = 9,
+	CELL_GAME_PARAMID_TITLE_RUSSIAN = 10,
+	CELL_GAME_PARAMID_TITLE_KOREAN = 11,
+	CELL_GAME_PARAMID_TITLE_CHINESE_T = 12,
+	CELL_GAME_PARAMID_TITLE_CHINESE_S = 13,
+	CELL_GAME_PARAMID_TITLE_FINNISH = 14,
+	CELL_GAME_PARAMID_TITLE_SWEDISH = 15,
+	CELL_GAME_PARAMID_TITLE_DANISH = 16,
+	CELL_GAME_PARAMID_TITLE_NORWEGIAN = 17,
+	CELL_GAME_PARAMID_TITLE_POLISH = 18,
+	CELL_GAME_PARAMID_TITLE_PORTUGUESE_BRAZIL = 19, // FW 4.00
+	CELL_GAME_PARAMID_TITLE_ENGLISH_UK = 20,        // FW 4.00
+	CELL_GAME_PARAMID_TITLE_TURKISH = 21,           // FW 4.30
+	CELL_GAME_PARAMID_TITLE_ID = 100,
+	CELL_GAME_PARAMID_VERSION = 101,
+	CELL_GAME_PARAMID_PS3_SYSTEM_VER = 105,
+	CELL_GAME_PARAMID_APP_VER = 106,
+};
+
+// Error dialog types
+enum
+{
+	CELL_GAME_ERRDIALOG_BROKEN_GAMEDATA = 0,
+	CELL_GAME_ERRDIALOG_BROKEN_HDDGAME = 1,
+	CELL_GAME_ERRDIALOG_NOSPACE = 2,
+	CELL_GAME_ERRDIALOG_BROKEN_EXIT_GAMEDATA = 100,
+	CELL_GAME_ERRDIALOG_BROKEN_EXIT_HDDGAME = 101,
+	CELL_GAME_ERRDIALOG_NOSPACE_EXIT = 102,
+};
+
+enum // CellGameResolution
+{
+	CELL_GAME_RESOLUTION_480 = 0x01,
+	CELL_GAME_RESOLUTION_576 = 0x02,
+	CELL_GAME_RESOLUTION_720 = 0x04,
+	CELL_GAME_RESOLUTION_1080 = 0x08,
+	CELL_GAME_RESOLUTION_480SQ = 0x10,
+	CELL_GAME_RESOLUTION_576SQ = 0x20,
+};
+
+enum // CellGameSoundFormat
+{
+	CELL_GAME_SOUNDFORMAT_2LPCM = 0x01,
+	CELL_GAME_SOUNDFORMAT_51LPCM = 0x04,
+	CELL_GAME_SOUNDFORMAT_71LPCM = 0x10,
+	CELL_GAME_SOUNDFORMAT_51DDENC = 0x102,
+	CELL_GAME_SOUNDFORMAT_51DTSENC = 0x202,
+};
+
+struct CellGameContentSize
+{
+	be_t<s32> hddFreeSizeKB;
+	be_t<s32> sizeKB;
+	be_t<s32> sysSizeKB;
+};
+
+struct CellGameSetInitParams
+{
+	char title[CELL_GAME_SYSP_TITLE_SIZE];
+	char titleId[CELL_GAME_SYSP_TITLEID_SIZE];
+	char reserved0[2];
+	char version[CELL_GAME_SYSP_VERSION_SIZE];
+	char reserved1[66];
+};
+
+struct CellGameDataCBResult
+{
+	be_t<s32> result;
+	be_t<s32> errNeedSizeKB;
+	vm::bptr<char> invalidMsg;
+	vm::bptr<void> reserved;
+};
+
+enum // old consts
+{
+	CELL_GAMEDATA_CBRESULT_OK_CANCEL = 1,
+	CELL_GAMEDATA_CBRESULT_OK = 0,
+	CELL_GAMEDATA_CBRESULT_ERR_NOSPACE = -1,
+	CELL_GAMEDATA_CBRESULT_ERR_BROKEN = -3,
+	CELL_GAMEDATA_CBRESULT_ERR_NODATA = -4,
+	CELL_GAMEDATA_CBRESULT_ERR_INVALID = -5,
+
+	CELL_GAMEDATA_RET_OK = 0,
+	CELL_GAMEDATA_RET_CANCEL = 1,
+
+	CELL_GAMEDATA_ATTR_NORMAL = 0,
+	CELL_GAMEDATA_VERSION_CURRENT = 0,
+
+	CELL_GAMEDATA_INVALIDMSG_MAX = 256,
+	CELL_GAMEDATA_PATH_MAX = 1055,
+	CELL_GAMEDATA_DIRNAME_SIZE = 32,
+
+	CELL_GAMEDATA_SIZEKB_NOTCALC = -1,
+
+	CELL_GAMEDATA_SYSP_LANGUAGE_NUM = 20,
+	CELL_GAMEDATA_SYSP_TITLE_SIZE = 128,
+	CELL_GAMEDATA_SYSP_TITLEID_SIZE = 10,
+	CELL_GAMEDATA_SYSP_VERSION_SIZE = 6,
+
+	CELL_GAMEDATA_ISNEWDATA_NO = 0,
+	CELL_GAMEDATA_ISNEWDATA_YES = 1,
+
+	CELL_GAMEDATA_ERRDIALOG_NONE = 0,
+	CELL_GAMEDATA_ERRDIALOG_ALWAYS = 1,
+
+	CELL_DISCGAME_SYSP_TITLEID_SIZE = 10,
+};
+
+enum
+{
+	TITLEID_SFO_ENTRY_SIZE = 16, // This is the true length on PS3 (TODO: Fix in more places)
+};
+
+struct CellGameDataSystemFileParam
+{
+	char title[CELL_GAMEDATA_SYSP_TITLE_SIZE];
+	char titleLang[CELL_GAMEDATA_SYSP_LANGUAGE_NUM][CELL_GAMEDATA_SYSP_TITLE_SIZE];
+	char titleId[CELL_GAMEDATA_SYSP_TITLEID_SIZE];
+	char reserved0[2];
+	char dataVersion[CELL_GAMEDATA_SYSP_VERSION_SIZE];
+	char reserved1[2];
+	be_t<u32> parentalLevel;
+	be_t<u32> attribute;
+	be_t<u32> resolution;  // cellHddGameCheck member: GD doesn't have this value
+	be_t<u32> soundFormat; // cellHddGameCheck member: GD doesn't have this value
+	char reserved2[248];
+};
+
+struct CellDiscGameSystemFileParam
+{
+	char titleId[CELL_DISCGAME_SYSP_TITLEID_SIZE];
+	char reserved0[2];
+	be_t<u32> parentalLevel;
+	char reserved1[16];
+};
+
+struct CellGameDataStatGet
+{
+	be_t<s32> hddFreeSizeKB;
+	be_t<u32> isNewData;
+	char contentInfoPath[CELL_GAMEDATA_PATH_MAX];
+	char gameDataPath[CELL_GAMEDATA_PATH_MAX];
+	char reserved0[2];
+	be_t<s64> st_atime_;
+	be_t<s64> st_mtime_;
+	be_t<s64> st_ctime_;
+	CellGameDataSystemFileParam getParam;
+	be_t<s32> sizeKB;
+	be_t<s32> sysSizeKB;
+	char reserved1[68];
+};
+
+struct CellGameDataStatSet
+{
+	vm::bptr<CellGameDataSystemFileParam> setParam;
+	be_t<u32> reserved;
+};
+
+typedef void(CellGameDataStatCallback)(vm::ptr<CellGameDataCBResult> cbResult, vm::ptr<CellGameDataStatGet> get, vm::ptr<CellGameDataStatSet> set);
+
+// cellSysutil: cellHddGame
+
+enum CellHddGameError : u32
+{
+	CELL_HDDGAME_ERROR_CBRESULT = 0x8002ba01,
+	CELL_HDDGAME_ERROR_ACCESS_ERROR = 0x8002ba02,
+	CELL_HDDGAME_ERROR_INTERNAL = 0x8002ba03,
+	CELL_HDDGAME_ERROR_PARAM = 0x8002ba04,
+	CELL_HDDGAME_ERROR_NOSPACE = 0x8002ba05,
+	CELL_HDDGAME_ERROR_BROKEN = 0x8002ba06,
+	CELL_HDDGAME_ERROR_FAILURE = 0x8002ba07,
+};
+
+enum
+{
+	// Return Codes
+	CELL_HDDGAME_RET_OK = 0,
+	CELL_HDDGAME_RET_CANCEL = 1,
+
+	// Callback Result
+	CELL_HDDGAME_CBRESULT_OK_CANCEL = 1,
+	CELL_HDDGAME_CBRESULT_OK = 0,
+	CELL_HDDGAME_CBRESULT_ERR_NOSPACE = -1,
+	CELL_HDDGAME_CBRESULT_ERR_BROKEN = -3,
+	CELL_HDDGAME_CBRESULT_ERR_NODATA = -4,
+	CELL_HDDGAME_CBRESULT_ERR_INVALID = -5,
+
+	// Character Strings
+	CELL_HDDGAME_INVALIDMSG_MAX = 256,
+	CELL_HDDGAME_PATH_MAX = 1055,
+	CELL_HDDGAME_SYSP_TITLE_SIZE = 128,
+	CELL_HDDGAME_SYSP_TITLEID_SIZE = 10,
+	CELL_HDDGAME_SYSP_VERSION_SIZE = 6,
+	CELL_HDDGAME_SYSP_SYSTEMVER_SIZE = 8,
+
+	// HDD Directory exists
+	CELL_HDDGAME_ISNEWDATA_EXIST = 0,
+	CELL_HDDGAME_ISNEWDATA_NODIR = 1,
+
+	// Languages
+	CELL_HDDGAME_SYSP_LANGUAGE_NUM = 20,
+
+	// Stat Get
+	CELL_HDDGAME_SIZEKB_NOTCALC = -1,
+};
+
+using CellHddGameStatGet = CellGameDataStatGet;
+using CellHddGameStatSet = CellGameDataStatSet;
+using CellHddGameSystemFileParam = CellGameDataSystemFileParam;
+using CellHddGameCBResult = CellGameDataCBResult;
+
+typedef void(CellHddGameStatCallback)(vm::ptr<CellHddGameCBResult> cbResult, vm::ptr<CellHddGameStatGet> get, vm::ptr<CellHddGameStatSet> set);
+typedef s32(CellGameThemeInstallCallback)(u32 fileOffset, u32 readSize, vm::ptr<void> buf);
+typedef void(CellGameDiscEjectCallback)();
+typedef void(CellGameDiscInsertCallback)(u32 discType, vm::ptr<char> titleId);
+using CellDiscGameDiscEjectCallback = CellGameDiscEjectCallback;
+using CellDiscGameDiscInsertCallback = CellGameDiscInsertCallback;
+
+struct disc_change_manager
+{
+	disc_change_manager();
+	virtual ~disc_change_manager();
+
+	std::mutex mtx;
+	atomic_t<bool> is_inserting = false;
+	vm::ptr<CellGameDiscEjectCallback> eject_callback = vm::null;
+	vm::ptr<CellGameDiscInsertCallback> insert_callback = vm::null;
+
+	enum class eject_state
+	{
+		unknown,
+		inserted,
+		ejected,
+		busy
+	};
+	atomic_t<eject_state> state = eject_state::unknown;
+
+	error_code register_callbacks(vm::ptr<CellGameDiscEjectCallback> func_eject, vm::ptr<CellGameDiscInsertCallback> func_insert);
+	error_code unregister_callbacks();
+
+	void eject_disc();
+	void insert_disc(u32 disc_type, std::string title_id);
+};

ps3fw/include/rpcsx/fw/ps3/cellGcmSys.h

@@ -0,0 +1,44 @@
+#pragma once
+
+#include "Emu/RSX/GCM.h"
+#include "Emu/Memory/vm_ptr.h"
+
+enum CellGcmError : u32
+{
+	CELL_GCM_ERROR_FAILURE = 0x802100ff,
+	CELL_GCM_ERROR_NO_IO_PAGE_TABLE = 0x80210001,
+	CELL_GCM_ERROR_INVALID_ENUM = 0x80210002,
+	CELL_GCM_ERROR_INVALID_VALUE = 0x80210003,
+	CELL_GCM_ERROR_INVALID_ALIGNMENT = 0x80210004,
+	CELL_GCM_ERROR_ADDRESS_OVERWRAP = 0x80210005,
+};
+
+struct CellGcmOffsetTable
+{
+	vm::bptr<u16> ioAddress;
+	vm::bptr<u16> eaAddress;
+};
+
+struct gcm_config
+{
+	u32 zculls_addr;
+	vm::ptr<CellGcmDisplayInfo> gcm_buffers = vm::null;
+	u32 tiles_addr;
+	u32 ctxt_addr;
+
+	CellGcmConfig current_config;
+	CellGcmContextData current_context;
+	gcmInfo gcm_info;
+
+	CellGcmOffsetTable offsetTable{};
+	u16 IoMapTable[0xC00]{};
+	shared_mutex gcmio_mutex;
+
+	u64 system_mode = 0;
+	u32 local_size = 0;
+	u32 local_addr = 0;
+
+	atomic_t<u32> reserved_size = 0;
+};
+
+void InitOffsetTable();

ps3fw/include/rpcsx/fw/ps3/cellGem.h

@@ -0,0 +1,280 @@
+#pragma once
+
+#include "Emu/Memory/vm_ptr.h"
+
+static const float CELL_GEM_SPHERE_RADIUS_MM = 22.5f;
+
+// Error codes
+enum CellGemError : u32
+{
+	CELL_GEM_ERROR_RESOURCE_ALLOCATION_FAILED = 0x80121801,
+	CELL_GEM_ERROR_ALREADY_INITIALIZED = 0x80121802,
+	CELL_GEM_ERROR_UNINITIALIZED = 0x80121803,
+	CELL_GEM_ERROR_INVALID_PARAMETER = 0x80121804,
+	CELL_GEM_ERROR_INVALID_ALIGNMENT = 0x80121805,
+	CELL_GEM_ERROR_UPDATE_NOT_FINISHED = 0x80121806,
+	CELL_GEM_ERROR_UPDATE_NOT_STARTED = 0x80121807,
+	CELL_GEM_ERROR_CONVERT_NOT_FINISHED = 0x80121808,
+	CELL_GEM_ERROR_CONVERT_NOT_STARTED = 0x80121809,
+	CELL_GEM_ERROR_WRITE_NOT_FINISHED = 0x8012180A,
+	CELL_GEM_ERROR_NOT_A_HUE = 0x8012180B,
+};
+
+// Runtime statuses
+enum CellGemStatus : u32
+{
+	CELL_GEM_NOT_CONNECTED = 1,
+	CELL_GEM_SPHERE_NOT_CALIBRATED = 2,
+	CELL_GEM_SPHERE_CALIBRATING = 3,
+	CELL_GEM_COMPUTING_AVAILABLE_COLORS = 4,
+	CELL_GEM_HUE_NOT_SET = 5,
+	CELL_GEM_NO_VIDEO = 6,
+	CELL_GEM_TIME_OUT_OF_RANGE = 7,
+	CELL_GEM_NOT_CALIBRATED = 8,
+	CELL_GEM_NO_EXTERNAL_PORT_DEVICE = 9,
+};
+
+// CellGemInfo status flags.
+enum
+{
+	CELL_GEM_STATUS_DISCONNECTED = 0,
+	CELL_GEM_STATUS_READY = 1,
+};
+
+// CellGemPadData defines for bit assignment of digital buttons.
+enum
+{
+	CELL_GEM_CTRL_SELECT = 1 << 0,
+	CELL_GEM_CTRL_T = 1 << 1,
+	CELL_GEM_CTRL_MOVE = 1 << 2,
+	CELL_GEM_CTRL_START = 1 << 3,
+	CELL_GEM_CTRL_TRIANGLE = 1 << 4,
+	CELL_GEM_CTRL_CIRCLE = 1 << 5,
+	CELL_GEM_CTRL_CROSS = 1 << 6,
+	CELL_GEM_CTRL_SQUARE = 1 << 7,
+};
+
+// Bit assignments for CellGemExtPortData status member.
+enum
+{
+	CELL_GEM_EXT_CONNECTED = 1 << 0,
+	CELL_GEM_EXT_EXT0 = 1 << 1,
+	CELL_GEM_EXT_EXT1 = 1 << 2,
+};
+
+// Values used to describe characteristics of the extension connector.
+enum
+{
+	CELL_GEM_EXTERNAL_PORT_DEVICE_INFO_SIZE = 38,
+	CELL_GEM_EXTERNAL_PORT_OUTPUT_SIZE = 40,
+};
+
+// Limits for cellGemPrepareCamera max_exposure argument.
+enum
+{
+	CELL_GEM_MIN_CAMERA_EXPOSURE = 40,
+	CELL_GEM_MAX_CAMERA_EXPOSURE = 511,
+};
+
+// Flags for cellGemGetState.
+enum
+{
+	CELL_GEM_STATE_FLAG_CURRENT_TIME = 0,
+	CELL_GEM_STATE_FLAG_LATEST_IMAGE_TIME = 1,
+	CELL_GEM_STATE_FLAG_TIMESTAMP = 2,
+};
+
+// Flags for cellGemGetInertialState.
+enum
+{
+	CELL_GEM_INERTIAL_STATE_FLAG_LATEST = 0,
+	CELL_GEM_INERTIAL_STATE_FLAG_PREVIOUS = 1,
+	CELL_GEM_INERTIAL_STATE_FLAG_NEXT = 2,
+};
+
+// Special values for cellGemTrackHues.
+enum : u32
+{
+	CELL_GEM_DONT_TRACK_HUE = 2 << 24,
+	CELL_GEM_DONT_CARE_HUE = 4 << 24,
+	CELL_GEM_DONT_CHANGE_HUE = 8 << 24,
+};
+
+// Masks for cellGemGetStatusFlags.
+enum
+{
+	CELL_GEM_FLAG_CALIBRATION_OCCURRED = 1 << 0,
+	CELL_GEM_FLAG_CALIBRATION_SUCCEEDED = 1 << 1,
+	CELL_GEM_FLAG_CALIBRATION_FAILED_CANT_FIND_SPHERE = 1 << 2,
+	CELL_GEM_FLAG_CALIBRATION_FAILED_MOTION_DETECTED = 1 << 3,
+	CELL_GEM_FLAG_CALIBRATION_FAILED_BRIGHT_LIGHTING = 1 << 4,
+	CELL_GEM_FLAG_CALIBRATION_WARNING_MOTION_DETECTED = 1 << 5,
+	CELL_GEM_FLAG_CALIBRATION_WARNING_BRIGHT_LIGHTING = 1 << 6,
+	CELL_GEM_FLAG_LIGHTING_CHANGED = 1 << 7,
+	CELL_GEM_FLAG_WRONG_FIELD_OF_VIEW_SETTING = 1 << 8,
+	CELL_GEM_FLAG_CAMERA_PITCH_ANGLE_CHANGED = 1 << 9,
+	CELL_GEM_FLAG_VARIABLE_MAGNETIC_FIELD = 1 << 10,
+	CELL_GEM_FLAG_WEAK_MAGNETIC_FIELD = 1 << 11,
+	CELL_GEM_FLAG_VERY_COLORFUL_ENVIRONMENT = 1 << 12,
+	CELL_GEM_FLAG_CURRENT_HUE_CONFLICTS_WITH_ENVIRONMENT = 1 << 13,
+	CELL_GEM_ALL_FLAGS = 0xffffffffffffffffull
+};
+
+// Masks for CellGemState tracking_flags member
+enum
+{
+	CELL_GEM_TRACKING_FLAG_POSITION_TRACKED = 1 << 0,
+	CELL_GEM_TRACKING_FLAG_VISIBLE = 1 << 1,
+};
+
+// General constants
+enum
+{
+	CELL_GEM_LATENCY_OFFSET = -22000,
+	CELL_GEM_MAX_NUM = 4,
+	CELL_GEM_VERSION = 2,
+};
+
+// Video conversion flags
+enum
+{
+	CELL_GEM_AUTO_WHITE_BALANCE = 0x1,
+	CELL_GEM_GAMMA_BOOST = 0x2,
+	CELL_GEM_COMBINE_PREVIOUS_INPUT_FRAME = 0x4,
+	CELL_GEM_FILTER_OUTLIER_PIXELS = 0x8
+};
+
+// Video conversion output formats
+enum CellGemVideoConvertFormatEnum : s32
+{
+	CELL_GEM_NO_VIDEO_OUTPUT = 1,
+	CELL_GEM_RGBA_640x480 = 2,
+	CELL_GEM_YUV_640x480 = 3,
+	CELL_GEM_YUV422_640x480 = 4,
+	CELL_GEM_YUV411_640x480 = 5,
+	CELL_GEM_RGBA_320x240 = 6,
+	CELL_GEM_BAYER_RESTORED = 7,
+	CELL_GEM_BAYER_RESTORED_RGGB = 8,
+	CELL_GEM_BAYER_RESTORED_RASTERIZED = 9
+};
+
+// External device IDs (types)
+enum
+{
+	SHARP_SHOOTER_DEVICE_ID = 0x8081,
+	RACING_WHEEL_DEVICE_ID = 0x8101
+};
+
+struct CellGemAttribute
+{
+	be_t<u32> version;
+	be_t<u32> max_connect;
+	be_t<u32> memory_ptr;
+	be_t<u32> spurs_addr;
+	u8 spu_priorities[8];
+
+	ENABLE_BITWISE_SERIALIZATION;
+};
+
+struct CellGemCameraState
+{
+	be_t<s32> exposure;
+	be_t<f32> exposure_time;
+	be_t<f32> gain;
+	be_t<f32> pitch_angle;
+	be_t<f32> pitch_angle_estimate;
+
+	ENABLE_BITWISE_SERIALIZATION;
+};
+
+struct CellGemExtPortData
+{
+	be_t<u16> status;
+	be_t<u16> digital1;
+	be_t<u16> digital2;
+	be_t<u16> analog_right_x;
+	be_t<u16> analog_right_y;
+	be_t<u16> analog_left_x;
+	be_t<u16> analog_left_y;
+	u8 custom[5];
+};
+
+struct CellGemImageState
+{
+	be_t<u64> frame_timestamp; // time the frame was captured by libCamera. system_time_t (usecs)
+	be_t<u64> timestamp;       // time processing of the frame was finished. system_time_t (usecs)
+	be_t<f32> u;               // horizontal screen position in pixels
+	be_t<f32> v;               // vertical screen position in pixels
+	be_t<f32> r;               // size of sphere on screen in pixels
+	be_t<f32> projectionx;
+	be_t<f32> projectiony;
+	be_t<f32> distance; // Move sphere distance from camera (probably)
+	u8 visible;         // whether the sphere is visible in the current frame
+	u8 r_valid;         // whether `r` contains valid size
+};
+
+struct CellGemPadData
+{
+	be_t<u16> digitalbuttons;
+	be_t<u16> analog_T;
+};
+
+struct CellGemInertialState
+{
+	be_t<f32> accelerometer[4];      // accelerometer readings including accelerometer_bias (G units)
+	be_t<f32> gyro[4];               // gyro readings including gyro_bias (radians/s)
+	be_t<f32> accelerometer_bias[4]; // accelerometer bias (G units)
+	be_t<f32> gyro_bias[4];          // gyro bias (radians/s)
+	CellGemPadData pad;
+	CellGemExtPortData ext;
+	be_t<u64> timestamp; // system_time_t (microseconds)
+	be_t<s32> counter;
+	be_t<f32> temperature;
+};
+
+struct CellGemInfo
+{
+	be_t<u32> max_connect;
+	be_t<u32> now_connect;
+	be_t<u32> status[CELL_GEM_MAX_NUM];
+	be_t<u32> port[CELL_GEM_MAX_NUM];
+};
+
+// origin is the center of the camera
+// x increases to right (facing the camera)
+// y increases upwards
+// z increases towards user (away from the camera)
+struct CellGemState
+{
+	be_t<f32> pos[4];          // center of sphere (mm)
+	be_t<f32> vel[4];          // velocity of sphere (mm/s)
+	be_t<f32> accel[4];        // acceleration of sphere (mm/s²)
+	be_t<f32> quat[4];         // quaternion orientation (x,y,z,w) of controller relative to default (facing the camera with buttons up)
+	be_t<f32> angvel[4];       // angular velocity of controller (radians/s)
+	be_t<f32> angaccel[4];     // angular acceleration of controller (radians/s²)
+	be_t<f32> handle_pos[4];   // center of controller handle (mm)
+	be_t<f32> handle_vel[4];   // velocity of controller handle (mm/s)
+	be_t<f32> handle_accel[4]; // acceleration of controller handle (mm/s²)
+	CellGemPadData pad;
+	CellGemExtPortData ext;
+	be_t<u64> timestamp; // system_time_t (microseconds)
+	be_t<f32> temperature;
+	be_t<f32> camera_pitch_angle;
+	be_t<u32> tracking_flags;
+};
+
+struct CellGemVideoConvertAttribute
+{
+	be_t<s32> version;
+	be_t<CellGemVideoConvertFormatEnum> output_format;
+	be_t<s32> conversion_flags;
+	be_t<f32> gain;
+	be_t<f32> red_gain;
+	be_t<f32> green_gain;
+	be_t<f32> blue_gain;
+	vm::bptr<u8> buffer_memory;
+	vm::bptr<u8> video_data_out;
+	u8 alpha;
+
+	ENABLE_BITWISE_SERIALIZATION;
+};

ps3fw/include/rpcsx/fw/ps3/cellGifDec.h

@@ -0,0 +1,248 @@
+#pragma once
+
+#include "Emu/Memory/vm_ptr.h"
+
+// Return Codes
+enum CellGifDecError : u32
+{
+	CELL_GIFDEC_ERROR_OPEN_FILE = 0x80611300,
+	CELL_GIFDEC_ERROR_STREAM_FORMAT = 0x80611301,
+	CELL_GIFDEC_ERROR_SEQ = 0x80611302,
+	CELL_GIFDEC_ERROR_ARG = 0x80611303,
+	CELL_GIFDEC_ERROR_FATAL = 0x80611304,
+	CELL_GIFDEC_ERROR_SPU_UNSUPPORT = 0x80611305,
+	CELL_GIFDEC_ERROR_SPU_ERROR = 0x80611306,
+	CELL_GIFDEC_ERROR_CB_PARAM = 0x80611307,
+};
+
+enum CellGifDecStreamSrcSel : s32
+{
+	CELL_GIFDEC_FILE = 0,   // Input from a file
+	CELL_GIFDEC_BUFFER = 1, // Input from a buffer
+};
+
+enum CellGifDecSpuThreadEna : s32
+{
+	CELL_GIFDEC_SPU_THREAD_DISABLE = 0, // Do not use SPU threads
+	CELL_GIFDEC_SPU_THREAD_ENABLE = 1,  // Use SPU threads
+};
+
+enum CellGifDecRecordType : s32
+{
+	CELL_GIFDEC_RECORD_TYPE_IMAGE_DESC = 1, // Image data block
+	CELL_GIFDEC_RECORD_TYPE_EXTENSION = 2,  // Extension block
+	CELL_GIFDEC_RECORD_TYPE_TERMINATE = 3,  // Trailer block
+};
+
+enum CellGifDecColorSpace : s32
+{
+	CELL_GIFDEC_RGBA = 10, // RGBA
+	CELL_GIFDEC_ARGB = 20, // ARGB
+};
+
+enum CellGifDecCommand : s32
+{
+	CELL_GIFDEC_CONTINUE = 0, // Continue decoding
+	CELL_GIFDEC_STOP = 1,     // Force decoding to stop
+};
+
+enum CellGifDecDecodeStatus : s32
+{
+	CELL_GIFDEC_DEC_STATUS_FINISH = 0, // Decoding finished
+	CELL_GIFDEC_DEC_STATUS_STOP = 1,   // Decoding was stopped
+};
+
+enum CellGifDecBufferMode : s32
+{
+	CELL_GIFDEC_LINE_MODE = 1
+};
+
+enum CellGifDecSpuMode : s32
+{
+	CELL_GIFDEC_RECEIVE_EVENT = 0,
+	CELL_GIFDEC_TRYRECEIVE_EVENT = 1
+};
+
+enum CellGifDecInterlaceMode : s32
+{
+	CELL_GIFDEC_NO_INTERLACE = 0,
+	CELL_GIFDEC_INTERLACE = 1
+};
+
+// Callbacks for memory management
+using CellGifDecCbControlMalloc = vm::ptr<void>(u32 size, vm::ptr<void> cbCtrlMallocArg);
+using CellGifDecCbControlFree = s32(vm::ptr<void> ptr, vm::ptr<void> cbCtrlFreeArg);
+
+// Structs
+struct CellGifDecThreadInParam
+{
+	be_t<s32> spuThreadEnable; // CellGifDecSpuThreadEna
+	be_t<u32> ppuThreadPriority;
+	be_t<u32> spuThreadPriority;
+	vm::bptr<CellGifDecCbControlMalloc> cbCtrlMallocFunc;
+	vm::bptr<void> cbCtrlMallocArg;
+	vm::bptr<CellGifDecCbControlFree> cbCtrlFreeFunc;
+	vm::bptr<void> cbCtrlFreeArg;
+};
+
+struct CellGifDecThreadOutParam
+{
+	be_t<u32> gifCodecVersion;
+};
+
+struct CellGifDecExtThreadInParam
+{
+	vm::bptr<struct CellSpurs> spurs;
+	u8 priority[8];
+	be_t<u32> maxContention;
+};
+
+struct CellGifDecExtThreadOutParam
+{
+	be_t<u64> reserved;
+};
+
+struct CellGifDecSrc
+{
+	be_t<s32> srcSelect; // CellGifDecStreamSrcSel
+	vm::bcptr<char> fileName;
+	be_t<s64> fileOffset;
+	be_t<u32> fileSize;
+	vm::bptr<void> streamPtr;
+	be_t<u32> streamSize;
+	be_t<s32> spuThreadEnable; // CellGifDecSpuThreadEna
+};
+
+struct CellGifDecOpnInfo
+{
+	be_t<u32> initSpaceAllocated;
+};
+
+struct CellGifDecInfo
+{
+	be_t<u32> SWidth;
+	be_t<u32> SHeight;
+	be_t<u32> SGlobalColorTableFlag;
+	be_t<u32> SColorResolution;
+	be_t<u32> SSortFlag;
+	be_t<u32> SSizeOfGlobalColorTable;
+	be_t<u32> SBackGroundColor;
+	be_t<u32> SPixelAspectRatio;
+};
+
+struct CellGifDecInParam
+{
+	vm::bptr<volatile s32> commandPtr; // CellGifDecCommand
+	be_t<s32> colorSpace;              // CellGifDecColorSpace
+	u8 outputColorAlpha1;
+	u8 outputColorAlpha2;
+	u8 reserved[2];
+};
+
+struct CellGifDecOutParam
+{
+	be_t<u64> outputWidthByte;
+	be_t<u32> outputWidth;
+	be_t<u32> outputHeight;
+	be_t<u32> outputComponents;
+	be_t<u32> outputBitDepth;
+	be_t<s32> outputColorSpace; // CellGifDecColorSpace
+	be_t<u32> useMemorySpace;
+};
+
+struct CellGifDecExtension
+{
+	u8 label;
+	vm::bptr<u8> data;
+};
+
+struct CellGifDecDataOutInfo
+{
+	be_t<s32> recordType; // CellGifDecRecordType
+	CellGifDecExtension outExtension;
+	be_t<s32> status; // CellGifDecDecodeStatus
+};
+
+struct CellGifDecDataCtrlParam
+{
+	be_t<u64> outputBytesPerLine;
+};
+
+struct CellGifDecExtInfo
+{
+	vm::bptr<u64> reserved;
+};
+
+struct CellGifDecStrmInfo
+{
+	be_t<u32> decodedStrmSize;
+};
+
+struct CellGifDecStrmParam
+{
+	vm::bptr<void> strmPtr;
+	be_t<u32> strmSize;
+};
+
+using CellGifDecCbControlStream = s32(vm::ptr<CellGifDecStrmInfo> strmInfo, vm::ptr<CellGifDecStrmParam> strmParam, vm::ptr<void> cbCtrlStrmArg);
+
+struct CellGifDecCbCtrlStrm
+{
+	vm::bptr<CellGifDecCbControlStream> cbCtrlStrmFunc;
+	vm::bptr<void> cbCtrlStrmArg;
+};
+
+struct CellGifDecExtInParam
+{
+	be_t<s32> bufferMode; // CellGifDecBufferMode
+	be_t<u32> outputCounts;
+	be_t<s32> spuMode; // CellGifDecSpuMode
+};
+
+struct CellGifDecExtOutParam
+{
+	be_t<u64> outputWidthByte;
+	be_t<u32> outputHeight;
+};
+
+struct CellGifDecDispParam
+{
+	vm::bptr<void> nextOutputImage;
+};
+
+struct CellGifDecDispInfo
+{
+	be_t<u64> outputFrameWidthByte;
+	be_t<u32> outputFrameHeight;
+	be_t<u64> outputStartXByte;
+	be_t<u32> outputStartY;
+	be_t<u64> outputWidthByte;
+	be_t<u32> outputHeight;
+	be_t<u32> outputBitDepth;
+	be_t<u32> outputComponents;
+	be_t<u32> scanPassCount;
+	vm::bptr<void> outputImage;
+	be_t<s32> interlaceFlag; // CellGifDecInterlaceMode
+};
+
+using CellGifDecCbControlDisp = s32(vm::ptr<CellGifDecDispInfo> dispInfo, vm::ptr<CellGifDecDispParam> dispParam, vm::ptr<void> cbCtrlDispArg);
+
+struct CellGifDecCbCtrlDisp
+{
+	vm::bptr<CellGifDecCbControlDisp> cbCtrlDispFunc;
+	vm::bptr<void> cbCtrlDispArg;
+};
+
+// Custom structs
+struct GifDecoder
+{
+};
+
+struct GifStream
+{
+	u32 fd{};
+	u64 fileSize{};
+	CellGifDecInfo info{};
+	CellGifDecOutParam outParam{};
+	CellGifDecSrc src{};
+};

ps3fw/include/rpcsx/fw/ps3/cellHttpUtil.h

@@ -0,0 +1,74 @@
+#pragma once
+
+#include "Emu/Memory/vm_ptr.h"
+
+// libHttp_Util: 0x80711001 - 0x807110ff
+
+// Error Codes
+enum CellHttpUtilError : u32
+{
+	CELL_HTTP_UTIL_ERROR_NO_MEMORY = 0x80711001,
+	CELL_HTTP_UTIL_ERROR_NO_BUFFER = 0x80711002,
+	CELL_HTTP_UTIL_ERROR_NO_STRING = 0x80711003,
+	CELL_HTTP_UTIL_ERROR_INSUFFICIENT = 0x80711004,
+	CELL_HTTP_UTIL_ERROR_INVALID_URI = 0x80711005,
+	CELL_HTTP_UTIL_ERROR_INVALID_HEADER = 0x80711006,
+	CELL_HTTP_UTIL_ERROR_INVALID_REQUEST = 0x80711007,
+	CELL_HTTP_UTIL_ERROR_INVALID_RESPONSE = 0x80711008,
+	CELL_HTTP_UTIL_ERROR_INVALID_LENGTH = 0x80711009,
+	CELL_HTTP_UTIL_ERROR_INVALID_CHARACTER = 0x8071100a,
+};
+
+enum
+{
+	CELL_HTTP_UTIL_URI_FLAG_FULL_URI = 0x00000000,
+	CELL_HTTP_UTIL_URI_FLAG_NO_SCHEME = 0x00000001,
+	CELL_HTTP_UTIL_URI_FLAG_NO_CREDENTIALS = 0x00000002,
+	CELL_HTTP_UTIL_URI_FLAG_NO_PASSWORD = 0x00000004,
+	CELL_HTTP_UTIL_URI_FLAG_NO_PATH = 0x00000008
+};
+
+struct CellHttpUri
+{
+	vm::bcptr<char> scheme;
+	vm::bcptr<char> hostname;
+	vm::bcptr<char> username;
+	vm::bcptr<char> password;
+	vm::bcptr<char> path;
+	be_t<u32> port;
+	u8 reserved[4];
+};
+
+struct CellHttpUriPath
+{
+	vm::bcptr<char> path;
+	vm::bcptr<char> query;
+	vm::bcptr<char> fragment;
+};
+
+struct CellHttpRequestLine
+{
+	vm::bcptr<char> method;
+	vm::bcptr<char> path;
+	vm::bcptr<char> protocol;
+	be_t<u32> majorVersion;
+	be_t<u32> minorVersion;
+};
+
+struct CellHttpStatusLine
+{
+	vm::bcptr<char> protocol;
+	be_t<u32> majorVersion;
+	be_t<u32> minorVersion;
+	vm::bcptr<char> reasonPhrase;
+	be_t<s32> statusCode;
+	u8 reserved[4];
+};
+
+struct CellHttpHeader
+{
+	vm::bcptr<char> name;
+	vm::bcptr<char> value;
+};
+
+error_code cellHttpUtilCopyUri(vm::ptr<CellHttpUri> dest, vm::cptr<CellHttpUri> src, vm::ptr<void> pool, u32 poolSize, vm::ptr<u32> required);

ps3fw/include/rpcsx/fw/ps3/cellImeJp.h

@@ -0,0 +1,148 @@
+#pragma once
+
+#include "Emu/Memory/vm_ptr.h"
+
+typedef vm::ptr<void> CellImeJpHandle;
+
+// Return Codes
+enum CellImeJpError : u32
+{
+	CELL_IMEJP_ERROR_ERR = 0x8002bf01,
+	CELL_IMEJP_ERROR_CONTEXT = 0x8002bf11,
+	CELL_IMEJP_ERROR_ALREADY_OPEN = 0x8002bf21,
+	CELL_IMEJP_ERROR_DIC_OPEN = 0x8002bf31,
+	CELL_IMEJP_ERROR_PARAM = 0x8002bf41,
+	CELL_IMEJP_ERROR_IME_ALREADY_IN_USE = 0x8002bf51,
+	CELL_IMEJP_ERROR_OTHER = 0x8002bfff,
+};
+
+// Input state of the ImeJp
+enum
+{
+	CELL_IMEJP_BEFORE_INPUT = 0,
+	CELL_IMEJP_BEFORE_CONVERT = 1,
+	CELL_IMEJP_CONVERTING = 2,
+	CELL_IMEJP_CANDIDATE_EMPTY = 3,
+	CELL_IMEJP_POSTCONVERT_KANA = 4,
+	CELL_IMEJP_POSTCONVERT_HALF = 5,
+	CELL_IMEJP_POSTCONVERT_RAW = 6,
+	CELL_IMEJP_CANDIDATES = 7,
+	CELL_IMEJP_MOVE_CLAUSE_GAP = 8,
+};
+
+// cellImeJpEnterChar, returning values pointed in pOutputStatus.
+enum
+{
+	CELL_IMEJP_RET_NONE = 0,
+	CELL_IMEJP_RET_THROUGH = 1,
+	CELL_IMEJP_RET_CONFIRMED = 2,
+};
+
+enum
+{
+	CELL_IMEJP_ROMAN_INPUT = 0,
+	CELL_IMEJP_KANA_INPUT = 1,
+};
+
+enum
+{
+	CELL_IMEJP_DSPCHAR_HIRA = 1,
+	CELL_IMEJP_DSPCHAR_FKANA = 2,
+	CELL_IMEJP_DSPCHAR_RAW = 3,
+	CELL_IMEJP_DSPCHAR_HKANA = 4,
+	CELL_IMEJP_DSPCHAR_HRAW = 5,
+};
+
+enum
+{
+	CELL_IMEJP_FIXINMODE_OFF = 0,
+	CELL_IMEJP_FIXINMODE_HIRA = 1,
+	CELL_IMEJP_FIXINMODE_FKAN = 2,
+	CELL_IMEJP_FIXINMODE_RAW = 3,
+	CELL_IMEJP_FIXINMODE_HKAN = 4,
+	CELL_IMEJP_FIXINMODE_HRAW = 5,
+};
+
+enum
+{
+	CELL_IMEJP_EXTENSIONCH_NONE = 0x0000,
+	CELL_IMEJP_EXTENSIONCH_HANKANA = 0x0001,
+	CELL_IMEJP_EXTENSIONCH_UD09TO15 = 0x0004,
+	CELL_IMEJP_EXTENSIONCH_UD85TO94 = 0x0008,
+	CELL_IMEJP_EXTENSIONCH_OUTJIS = 0x0010,
+};
+
+enum
+{
+	CELL_IMEJP_POSTCONV_HIRA = 1,
+	CELL_IMEJP_POSTCONV_KANA = 2,
+	CELL_IMEJP_POSTCONV_HALF = 3,
+	CELL_IMEJP_POSTCONV_RAW = 4,
+};
+
+enum
+{
+	CELL_IMEJP_FOCUS_NEXT = 0,
+	CELL_IMEJP_FOCUS_BEFORE = 1,
+	CELL_IMEJP_FOCUS_TOP = 2,
+	CELL_IMEJP_FOCUS_END = 3,
+};
+
+enum
+{
+	CELL_IMEJP_DIC_PATH_MAXLENGTH = 256,
+
+	// Helper
+	CELL_IMEJP_STRING_MAXLENGTH = 128, // including terminator
+};
+
+struct CellImeJpAddDic
+{
+	char path[CELL_IMEJP_DIC_PATH_MAXLENGTH];
+};
+
+struct CellImeJpPredictItem
+{
+	u16 KanaYomi[31];
+	u16 Hyoki[61];
+};
+
+struct ime_jp_manager
+{
+	shared_mutex mutex;
+
+	atomic_t<bool> is_initialized{false};
+
+	u32 input_state = CELL_IMEJP_BEFORE_INPUT;
+	std::vector<std::string> dictionary_paths;
+	std::u16string confirmed_string; // Confirmed part of the string (first part of the entire string)
+	std::u16string converted_string; // Converted part of the unconfirmed input string
+	std::u16string input_string;     // Unconfirmed part of the string (second part of the entire string)
+	usz cursor = 0;                  // The cursor. Can move across the entire input string.
+	usz focus_begin = 0;             // Begin of the focus string
+	usz focus_length = 0;            // Length of the focus string
+	s16 fix_input_mode = CELL_IMEJP_FIXINMODE_OFF;
+	s16 input_char_type = CELL_IMEJP_DSPCHAR_HIRA;
+	s16 kana_input_mode = CELL_IMEJP_ROMAN_INPUT;
+	s16 allowed_extensions = CELL_IMEJP_EXTENSIONCH_UD09TO15 | CELL_IMEJP_EXTENSIONCH_UD85TO94 | CELL_IMEJP_EXTENSIONCH_OUTJIS;
+
+	ime_jp_manager();
+
+	bool addChar(u16 c);
+	bool addString(vm::cptr<u16> str);
+	bool backspaceWord();
+	bool deleteWord();
+	bool remove_character(bool forward);
+	void clear_input();
+	void move_cursor(s8 amount);                      // s8 because CELL_IMEJP_STRING_MAXLENGTH is 128
+	void move_focus(s8 amount);                       // s8 because CELL_IMEJP_STRING_MAXLENGTH is 128
+	void move_focus_end(s8 amount, bool wrap_around); // s8 because CELL_IMEJP_STRING_MAXLENGTH is 128
+
+	struct candidate
+	{
+		std::u16string text; // Actual text of the candidate
+		u16 offset = 0;      // The offset of the next character after the candidate replaced part of the current focus.
+	};
+	std::vector<candidate> get_candidate_list() const;
+	std::u16string get_focus_string() const;
+};

ps3fw/include/rpcsx/fw/ps3/cellJpgDec.h

@@ -0,0 +1,120 @@
+#pragma once
+
+// Return Codes
+enum CellJpgDecError : u32
+{
+	CELL_JPGDEC_ERROR_HEADER = 0x80611101,
+	CELL_JPGDEC_ERROR_STREAM_FORMAT = 0x80611102,
+	CELL_JPGDEC_ERROR_ARG = 0x80611103,
+	CELL_JPGDEC_ERROR_SEQ = 0x80611104,
+	CELL_JPGDEC_ERROR_BUSY = 0x80611105,
+	CELL_JPGDEC_ERROR_FATAL = 0x80611106,
+	CELL_JPGDEC_ERROR_OPEN_FILE = 0x80611107,
+	CELL_JPGDEC_ERROR_SPU_UNSUPPORT = 0x80611108,
+	CELL_JPGDEC_ERROR_CB_PARAM = 0x80611109,
+};
+
+enum CellJpgDecColorSpace
+{
+	CELL_JPG_UNKNOWN = 0,
+	CELL_JPG_GRAYSCALE = 1,
+	CELL_JPG_RGB = 2,
+	CELL_JPG_YCbCr = 3,
+	CELL_JPG_RGBA = 10,
+	CELL_JPG_UPSAMPLE_ONLY = 11,
+	CELL_JPG_ARGB = 20,
+	CELL_JPG_GRAYSCALE_TO_ALPHA_RGBA = 40,
+	CELL_JPG_GRAYSCALE_TO_ALPHA_ARGB = 41,
+};
+
+enum CellJpgDecStreamSrcSel
+{
+	CELL_JPGDEC_FILE = 0,
+	CELL_JPGDEC_BUFFER = 1,
+};
+
+enum CellJpgDecDecodeStatus
+{
+	CELL_JPGDEC_DEC_STATUS_FINISH = 0, // Decoding finished
+	CELL_JPGDEC_DEC_STATUS_STOP = 1,   // Decoding halted
+};
+
+enum CellJpgDecOutputMode
+{
+	CELL_JPGDEC_TOP_TO_BOTTOM = 0, // Top left to bottom right
+	CELL_JPGDEC_BOTTOM_TO_TOP = 1, // Bottom left to top right
+};
+
+struct CellJpgDecInfo
+{
+	be_t<u32> imageWidth;
+	be_t<u32> imageHeight;
+	be_t<u32> numComponents;
+	be_t<u32> colorSpace; // CellJpgDecColorSpace
+};
+
+struct CellJpgDecSrc
+{
+	be_t<u32> srcSelect; // CellJpgDecStreamSrcSel
+	vm::bcptr<char> fileName;
+	be_t<u64> fileOffset; // int64_t
+	be_t<u32> fileSize;
+	be_t<u32> streamPtr;
+	be_t<u32> streamSize;
+	be_t<u32> spuThreadEnable; // CellJpgDecSpuThreadEna
+};
+
+struct CellJpgDecInParam
+{
+	be_t<u32> commandPtr;
+	be_t<u32> downScale;
+	be_t<u32> method;           // CellJpgDecMethod
+	be_t<u32> outputMode;       // CellJpgDecOutputMode
+	be_t<u32> outputColorSpace; // CellJpgDecColorSpace
+	u8 outputColorAlpha;
+	u8 reserved[3];
+};
+
+struct CellJpgDecOutParam
+{
+	be_t<u64> outputWidthByte;
+	be_t<u32> outputWidth;
+	be_t<u32> outputHeight;
+	be_t<u32> outputComponents;
+	be_t<u32> outputMode;       // CellJpgDecOutputMode
+	be_t<u32> outputColorSpace; // CellJpgDecColorSpace
+	be_t<u32> downScale;
+	be_t<u32> useMemorySpace;
+};
+
+struct CellJpgDecOpnInfo
+{
+	be_t<u32> initSpaceAllocated;
+};
+
+struct CellJpgDecDataCtrlParam
+{
+	be_t<u64> outputBytesPerLine;
+};
+
+struct CellJpgDecDataOutInfo
+{
+	be_t<float> mean;
+	be_t<u32> outputLines;
+	be_t<u32> status;
+};
+
+// Custom structs
+struct CellJpgDecSubHandle
+{
+	static const u32 id_base = 1;
+	static const u32 id_step = 1;
+	static const u32 id_count = 1023;
+	SAVESTATE_INIT_POS(35);
+
+	u32 fd;
+	u64 fileSize;
+	CellJpgDecInfo info;
+	CellJpgDecOutParam outParam;
+	CellJpgDecSrc src;
+};

ps3fw/include/rpcsx/fw/ps3/cellJpgEnc.h

@@ -0,0 +1,42 @@
+#pragma once
+
+// Error Codes
+enum CellJpgEncError : u32
+{
+	CELL_JPGENC_ERROR_ARG = 0x80611191,
+	CELL_JPGENC_ERROR_SEQ = 0x80611192,
+	CELL_JPGENC_ERROR_BUSY = 0x80611193,
+	CELL_JPGENC_ERROR_EMPTY = 0x80611194,
+	CELL_JPGENC_ERROR_RESET = 0x80611195,
+	CELL_JPGENC_ERROR_FATAL = 0x80611196,
+
+	CELL_JPGENC_ERROR_STREAM_ABORT = 0x806111A1,
+	CELL_JPGENC_ERROR_STREAM_SKIP = 0x806111A2,
+	CELL_JPGENC_ERROR_STREAM_OVERFLOW = 0x806111A3,
+	CELL_JPGENC_ERROR_STREAM_FILE_OPEN = 0x806111A4,
+};
+
+// Definitions
+enum
+{
+	CELL_JPGENC_COLOR_SPACE_GRAYSCALE = 1,
+	CELL_JPGENC_COLOR_SPACE_RGB = 2,
+	CELL_JPGENC_COLOR_SPACE_YCbCr = 3,
+	CELL_JPGENC_COLOR_SPACE_RGBA = 10,
+	CELL_JPGENC_COLOR_SPACE_ARGB = 20,
+
+	CELL_JPGENC_SAMPLING_FMT_YCbCr444,
+	CELL_JPGENC_SAMPLING_FMT_YCbCr422,
+	CELL_JPGENC_SAMPLING_FMT_YCbCr420,
+	CELL_JPGENC_SAMPLING_FMT_YCbCr411,
+	CELL_JPGENC_SAMPLING_FMT_FULL,
+
+	CELL_JPGENC_DCT_METHOD_QUALITY = 0,
+	CELL_JPGENC_DCT_METHOD_FAST = 5,
+
+	CELL_JPGENC_COMPR_MODE_CONSTANT_QUALITY,
+	CELL_JPGENC_COMPR_MODE_STREAM_SIZE_LIMIT,
+
+	CELL_JPGENC_LOCATION_FILE,
+	CELL_JPGENC_LOCATION_BUFFER,
+};

ps3fw/include/rpcsx/fw/ps3/cellKb.h

@@ -0,0 +1,58 @@
+#pragma once
+
+#include "Emu/Io/Keyboard.h"
+
+enum CellKbError : u32
+{
+	CELL_KB_ERROR_FATAL = 0x80121001,
+	CELL_KB_ERROR_INVALID_PARAMETER = 0x80121002,
+	CELL_KB_ERROR_ALREADY_INITIALIZED = 0x80121003,
+	CELL_KB_ERROR_UNINITIALIZED = 0x80121004,
+	CELL_KB_ERROR_RESOURCE_ALLOCATION_FAILED = 0x80121005,
+	CELL_KB_ERROR_READ_FAILED = 0x80121006,
+	CELL_KB_ERROR_NO_DEVICE = 0x80121007,
+	CELL_KB_ERROR_SYS_SETTING_FAILED = 0x80121008,
+};
+
+enum CellKbLedMode
+{
+	CELL_KB_LED_MODE_MANUAL = 0,
+	CELL_KB_LED_MODE_AUTO1 = 1,
+	CELL_KB_LED_MODE_AUTO2 = 2,
+};
+
+enum
+{
+	CELL_KB_RAWDAT = 0x8000U,
+	CELL_KB_KEYPAD = 0x4000U,
+};
+
+enum
+{
+	CELL_KB_ARRANGEMENT_101 = CELL_KB_MAPPING_101,
+	CELL_KB_ARRANGEMENT_106 = CELL_KB_MAPPING_106,
+	CELL_KB_ARRANGEMENT_106_KANA = CELL_KB_MAPPING_106_KANA,
+};
+
+struct CellKbInfo
+{
+	be_t<u32> max_connect;
+	be_t<u32> now_connect;
+	be_t<u32> info;
+	u8 status[CELL_KB_MAX_KEYBOARDS];
+};
+
+struct CellKbData
+{
+	be_t<u32> led;
+	be_t<u32> mkey;
+	be_t<s32> len;
+	be_t<u16> keycode[CELL_KB_MAX_KEYCODES];
+};
+
+struct CellKbConfig
+{
+	be_t<u32> arrange;
+	be_t<u32> read_mode;
+	be_t<u32> code_type;
+};

ps3fw/include/rpcsx/fw/ps3/cellL10n.h

@@ -0,0 +1,97 @@
+#pragma once
+
+// L10nResult
+enum
+{
+	ConversionOK,
+	SRCIllegal,
+	DSTExhausted,
+	ConverterUnknown,
+};
+
+// detection result
+enum
+{
+	L10N_STR_UNKNOWN = (1 << 0),
+	L10N_STR_ASCII = (1 << 1),
+	L10N_STR_JIS = (1 << 2),
+	L10N_STR_EUCJP = (1 << 3),
+	L10N_STR_SJIS = (1 << 4),
+	L10N_STR_UTF8 = (1 << 5),
+	L10N_STR_ILLEGAL = (1 << 16),
+	L10N_STR_ERROR = (1 << 17),
+};
+
+// CodePages
+enum
+{
+	L10N_UTF8 = 0,
+	L10N_UTF16,
+	L10N_UTF32,
+	L10N_UCS2,
+	L10N_UCS4,
+	L10N_ISO_8859_1,
+	L10N_ISO_8859_2,
+	L10N_ISO_8859_3,
+	L10N_ISO_8859_4,
+	L10N_ISO_8859_5,
+	L10N_ISO_8859_6,
+	L10N_ISO_8859_7,
+	L10N_ISO_8859_8,
+	L10N_ISO_8859_9,
+	L10N_ISO_8859_10,
+	L10N_ISO_8859_11,
+	L10N_ISO_8859_13,
+	L10N_ISO_8859_14,
+	L10N_ISO_8859_15,
+	L10N_ISO_8859_16,
+	L10N_CODEPAGE_437,
+	L10N_CODEPAGE_850,
+	L10N_CODEPAGE_863,
+	L10N_CODEPAGE_866,
+	L10N_CODEPAGE_932,
+	L10N_SHIFT_JIS = L10N_CODEPAGE_932,
+	L10N_CODEPAGE_936,
+	L10N_GBK = L10N_CODEPAGE_936,
+	L10N_CODEPAGE_949,
+	L10N_UHC = L10N_CODEPAGE_949,
+	L10N_CODEPAGE_950,
+	L10N_BIG5 = L10N_CODEPAGE_950,
+	L10N_CODEPAGE_1251,
+	L10N_CODEPAGE_1252,
+	L10N_EUC_CN,
+	L10N_EUC_JP,
+	L10N_EUC_KR,
+	L10N_ISO_2022_JP,
+	L10N_JIS = L10N_ISO_2022_JP,
+	L10N_ARIB,
+	L10N_HZ,
+	L10N_GB18030,
+	L10N_RIS_506,
+	L10N_MUSIC_SHIFT_JIS = L10N_RIS_506,
+	// FW 3.10 and below
+	L10N_CODEPAGE_852,
+	L10N_CODEPAGE_1250,
+	L10N_CODEPAGE_737,
+	L10N_CODEPAGE_1253,
+	L10N_CODEPAGE_857,
+	L10N_CODEPAGE_1254,
+	L10N_CODEPAGE_775,
+	L10N_CODEPAGE_1257,
+	L10N_CODEPAGE_855,
+	L10N_CODEPAGE_858,
+	L10N_CODEPAGE_860,
+	L10N_CODEPAGE_861,
+	L10N_CODEPAGE_865,
+	L10N_CODEPAGE_869,
+	_L10N_CODE_
+};
+
+enum
+{
+	UTF16_SURROGATES_MASK1 = 0xf800,
+	UTF16_SURROGATES_MASK2 = 0xfc00,
+	UTF16_SURROGATES = 0xd800,
+	UTF16_HIGH_SURROGATES = 0xd800,
+	UTF16_LOW_SURROGATES = 0xdc00,
+};

ps3fw/include/rpcsx/fw/ps3/cellMic.h

@@ -0,0 +1,438 @@
+#pragma once
+
+#include "3rdparty/OpenAL/openal-soft/include/AL/alc.h"
+#include "util/Thread.h"
+#include "util/mutex.h"
+
+// Error Codes
+enum CellMicInError : u32
+{
+	CELL_MICIN_ERROR_ALREADY_INIT = 0x80140101,
+	CELL_MICIN_ERROR_DEVICE = 0x80140102,
+	CELL_MICIN_ERROR_NOT_INIT = 0x80140103,
+	CELL_MICIN_ERROR_PARAM = 0x80140104,
+	CELL_MICIN_ERROR_PORT_FULL = 0x80140105,
+	CELL_MICIN_ERROR_ALREADY_OPEN = 0x80140106,
+	CELL_MICIN_ERROR_NOT_OPEN = 0x80140107,
+	CELL_MICIN_ERROR_NOT_RUN = 0x80140108,
+	CELL_MICIN_ERROR_TRANS_EVENT = 0x80140109,
+	CELL_MICIN_ERROR_OPEN = 0x8014010a,
+	CELL_MICIN_ERROR_SHAREDMEMORY = 0x8014010b,
+	CELL_MICIN_ERROR_MUTEX = 0x8014010c,
+	CELL_MICIN_ERROR_EVENT_QUEUE = 0x8014010d,
+	CELL_MICIN_ERROR_DEVICE_NOT_FOUND = 0x8014010e,
+	CELL_MICIN_ERROR_FATAL = 0x8014010f,
+	CELL_MICIN_ERROR_DEVICE_NOT_SUPPORT = 0x80140110,
+	// CELL_MICIN_ERROR_SYSTEM             = CELL_MICIN_ERROR_DEVICE,
+	// CELL_MICIN_ERROR_SYSTEM_NOT_FOUND   = CELL_MICIN_ERROR_DEVICE_NOT_FOUND,
+	// CELL_MICIN_ERROR_SYSTEM_NOT_SUPPORT = CELL_MICIN_ERROR_DEVICE_NOT_SUPPORT
+};
+
+enum CellMicInErrorDsp : u32
+{
+	CELL_MICIN_ERROR_DSP = 0x80140200,
+	CELL_MICIN_ERROR_DSP_ASSERT = 0x80140201,
+	CELL_MICIN_ERROR_DSP_PATH = 0x80140202,
+	CELL_MICIN_ERROR_DSP_FILE = 0x80140203,
+	CELL_MICIN_ERROR_DSP_PARAM = 0x80140204,
+	CELL_MICIN_ERROR_DSP_MEMALLOC = 0x80140205,
+	CELL_MICIN_ERROR_DSP_POINTER = 0x80140206,
+	CELL_MICIN_ERROR_DSP_FUNC = 0x80140207,
+	CELL_MICIN_ERROR_DSP_MEM = 0x80140208,
+	CELL_MICIN_ERROR_DSP_ALIGN16 = 0x80140209,
+	CELL_MICIN_ERROR_DSP_ALIGN128 = 0x8014020a,
+	CELL_MICIN_ERROR_DSP_EAALIGN128 = 0x8014020b,
+	CELL_MICIN_ERROR_DSP_LIB_HANDLER = 0x80140216,
+	CELL_MICIN_ERROR_DSP_LIB_INPARAM = 0x80140217,
+	CELL_MICIN_ERROR_DSP_LIB_NOSPU = 0x80140218,
+	CELL_MICIN_ERROR_DSP_LIB_SAMPRATE = 0x80140219,
+};
+
+enum CellMicSignalState : u32
+{
+	CELLMIC_SIGSTATE_LOCTALK = 0,
+	CELLMIC_SIGSTATE_FARTALK = 1,
+	CELLMIC_SIGSTATE_NSR = 3,
+	CELLMIC_SIGSTATE_AGC = 4,
+	CELLMIC_SIGSTATE_MICENG = 5,
+	CELLMIC_SIGSTATE_SPKENG = 6,
+};
+
+enum CellMicCommand
+{
+	CELLMIC_INIT = 0,
+	CELLMIC_END,
+	CELLMIC_ATTACH,
+	CELLMIC_DETACH,
+	CELLMIC_SWITCH,
+	CELLMIC_DATA,
+	CELLMIC_OPEN,
+	CELLMIC_CLOSE,
+	CELLMIC_START,
+	CELLMIC_STOP,
+	CELLMIC_QUERY,
+	CELLMIC_CONFIG,
+	CELLMIC_CALLBACK,
+	CELLMIC_RESET,
+	CELLMIC_STATUS,
+	CELLMIC_IPC,
+	CELLMIC_CALLBACK2,
+	CELLMIC_WEAK,
+	CELLMIC_INIT2,
+};
+
+enum CellMicDeviceAttr : u32
+{
+	CELLMIC_DEVATTR_LED = 9,
+	CELLMIC_DEVATTR_GAIN = 10,
+	CELLMIC_DEVATTR_VOLUME = 201,
+	CELLMIC_DEVATTR_AGC = 202,
+	CELLMIC_DEVATTR_CHANVOL = 301,
+	CELLMIC_DEVATTR_DSPTYPE = 302,
+};
+
+enum CellMicSignalAttr : u32
+{
+	CELLMIC_SIGATTR_BKNGAIN = 0,
+	CELLMIC_SIGATTR_REVERB = 9,
+	CELLMIC_SIGATTR_AGCLEVEL = 26,
+	CELLMIC_SIGATTR_VOLUME = 301,
+	CELLMIC_SIGATTR_PITCHSHIFT = 331
+};
+
+enum CellMicSignalType : u8
+{
+	CELLMIC_SIGTYPE_NULL = 0,
+	CELLMIC_SIGTYPE_DSP = 1,
+	CELLMIC_SIGTYPE_AUX = 2,
+	CELLMIC_SIGTYPE_RAW = 4,
+};
+
+enum CellMicType : s32
+{
+	CELLMIC_TYPE_UNDEF = -1,
+	CELLMIC_TYPE_UNKNOWN = 0,
+	CELLMIC_TYPE_EYETOY1 = 1,
+	CELLMIC_TYPE_EYETOY2 = 2,
+	CELLMIC_TYPE_USBAUDIO = 3,
+	CELLMIC_TYPE_BLUETOOTH = 4,
+	CELLMIC_TYPE_A2DP = 5,
+};
+
+enum
+{
+	CELL_MAX_MICS = 8,
+	MAX_MICS_PERMISSABLE = 4,
+
+	NullDeviceID = -1,
+
+	CELL_MIC_STARTFLAG_LATENCY_4 = 0x00000001,
+	CELL_MIC_STARTFLAG_LATENCY_2 = 0x00000002,
+	CELL_MIC_STARTFLAG_LATENCY_1 = 0x00000003,
+};
+
+enum : u64
+{
+	SYSMICIN_KEYBASE = 0x8000CA7211071000ULL,
+	EQUEUE_KEY_MICIN_ACCESSPOINT = 0x8000CA7211072abcULL,
+	LIBMIC_KEYBASE = 0x8000000000000100ULL,
+};
+
+struct CellMicInputFormatI
+{
+	u8 channelNum;
+	u8 subframeSize;
+	u8 bitResolution;
+	u8 dataType;
+	be_t<u32> sampleRate;
+};
+
+struct CellMicInputStream
+{
+	be_t<u32> uiBufferBottom;
+	be_t<u32> uiBufferSize;
+	be_t<u32> uiBuffer;
+};
+
+struct CellMicInputDefinition
+{
+	be_t<u32> uiDevId;
+	CellMicInputStream data;
+	CellMicInputFormatI aux_format;
+	CellMicInputFormatI raw_format;
+	CellMicInputFormatI sig_format;
+};
+
+struct CellMicStatus
+{
+	be_t<s32> raw_samprate;
+	be_t<s32> dsp_samprate;
+	be_t<s32> dsp_volume;
+	be_t<s32> isStart;
+	be_t<s32> isOpen;
+	be_t<s32> local_voice;
+	be_t<s32> remote_voice;
+	be_t<f32> mic_energy;
+	be_t<f32> spk_energy;
+};
+
+// --- End of cell definitions ---
+
+template <usz Size>
+class simple_ringbuf
+{
+public:
+	simple_ringbuf()
+	{
+		m_container.resize(Size);
+	}
+
+	bool has_data() const
+	{
+		return m_used != 0;
+	}
+
+	u32 read_bytes(u8* buf, const u32 size)
+	{
+		const u32 to_read = size > m_used ? m_used : size;
+		if (!to_read)
+			return 0;
+
+		ensure(buf);
+
+		u8* data = m_container.data();
+		const u32 new_tail = m_tail + to_read;
+
+		if (new_tail >= Size)
+		{
+			const u32 first_chunk_size = Size - m_tail;
+			std::memcpy(buf, data + m_tail, first_chunk_size);
+			std::memcpy(buf + first_chunk_size, data, to_read - first_chunk_size);
+			m_tail = (new_tail - Size);
+		}
+		else
+		{
+			std::memcpy(buf, data + m_tail, to_read);
+			m_tail = new_tail;
+		}
+
+		m_used -= to_read;
+
+		return to_read;
+	}
+
+	void write_bytes(const u8* buf, const u32 size)
+	{
+		if (size == 0)
+		{
+			return;
+		}
+
+		ensure(size <= Size);
+
+		const u32 over_size = m_used + size;
+
+		if (over_size > Size)
+		{
+			m_tail += (over_size - Size);
+			if (m_tail > Size)
+				m_tail -= Size;
+
+			m_used = Size;
+		}
+		else
+		{
+			m_used = over_size;
+		}
+
+		u8* data = m_container.data();
+		const u32 new_head = m_head + size;
+
+		if (new_head >= Size)
+		{
+			const u32 first_chunk_size = Size - m_head;
+			std::memcpy(data + m_head, buf, first_chunk_size);
+			std::memcpy(data, buf + first_chunk_size, size - first_chunk_size);
+			m_head = (new_head - Size);
+		}
+		else
+		{
+			std::memcpy(data + m_head, buf, size);
+			m_head = new_head;
+		}
+	}
+
+protected:
+	std::vector<u8> m_container;
+	u32 m_head = 0, m_tail = 0, m_used = 0;
+};
+
+class microphone_device
+{
+public:
+	microphone_device(microphone_handler type = microphone_handler::null);
+
+	void add_device(const std::string& name);
+
+	void set_registered(bool registered)
+	{
+		mic_registered = registered;
+	};
+
+	error_code open_microphone(const u8 type, const u32 dsp_r, const u32 raw_r,
+		const u8 channels = 2);
+	error_code close_microphone();
+
+	error_code start_microphone();
+	error_code stop_microphone();
+
+	std::string get_device_name() const
+	{
+		return devices.empty() ? "" : devices.front().name;
+	}
+
+	void update_audio();
+	bool has_data() const;
+
+	f32 calculate_energy_level();
+
+	bool is_registered() const
+	{
+		return mic_registered;
+	}
+	bool is_opened() const
+	{
+		return mic_opened;
+	}
+	bool is_started() const
+	{
+		return mic_started;
+	}
+	u8 get_signal_types() const
+	{
+		return signal_types;
+	}
+	constexpr u8 get_bit_resolution() const
+	{
+		return bit_resolution;
+	}
+	u32 get_raw_samplingrate() const
+	{
+		return raw_samplingrate;
+	}
+	u8 get_num_channels() const
+	{
+		return num_channels;
+	}
+	u8 get_datatype() const
+	{
+		switch (device_type)
+		{
+		case microphone_handler::real_singstar:
+		case microphone_handler::singstar:
+			return 0; // LE
+		default:
+			return 1; // BE
+		}
+	}
+
+	u32 read_raw(u8* buf, u32 size)
+	{
+		return rbuf_raw.read_bytes(buf, size);
+	}
+	u32 read_dsp(u8* buf, u32 size)
+	{
+		return rbuf_dsp.read_bytes(buf, size);
+	}
+
+	// Microphone attributes
+	u32 attr_gain = 3;                            // 0 to 5.   Default is 3.
+	u32 attr_volume = 145;                        // 0 to 241. Default is 145.
+	u32 attr_agc = 0;                             // 0 to 241. Default is 0.
+	std::array<u32, 2> attr_chanvol = {100, 100}; // 0 to 100. Default is ?.
+	u32 attr_led = 0;
+	u32 attr_dsptype = 0;
+
+private:
+	template <u32 bytesize>
+	static inline void variable_byteswap(const void* src, void* dst);
+	inline u32 convert_16_bit_pcm_to_float(const std::vector<u8>& buffer,
+		u32 num_bytes);
+
+	u32 capture_audio();
+
+	void get_data(const u32 num_samples);
+	void get_raw(const u32 num_samples);
+	void get_dsp(const u32 num_samples);
+
+	microphone_handler device_type = microphone_handler::null;
+
+	bool mic_registered = false;
+	bool mic_opened = false;
+	bool mic_started = false;
+
+	struct mic_device
+	{
+		std::string name;
+		ALCdevice* device = nullptr;
+		std::vector<u8> buf;
+	};
+
+	std::vector<mic_device> devices;
+	std::vector<u8> temp_buf;
+	std::vector<u8> float_buf;
+
+	// Sampling information provided at opening of mic
+	u32 raw_samplingrate = 48000;
+	u32 dsp_samplingrate = 48000;
+	u32 aux_samplingrate = 48000;
+	u8 num_channels = 2;
+
+	u8 signal_types = CELLMIC_SIGTYPE_NULL;
+
+	u32 sample_size = 0; // Determined at opening for internal use
+
+	static constexpr u8 bit_resolution = 16;
+	static constexpr usz inbuf_size = 400000; // Default value unknown
+	static constexpr usz float_buf_size =
+		inbuf_size * (sizeof(f32) / sizeof(s16));
+
+	simple_ringbuf<inbuf_size> rbuf_raw;
+	simple_ringbuf<float_buf_size> rbuf_dsp;
+	simple_ringbuf<inbuf_size> rbuf_aux;
+};
+
+class mic_context
+{
+public:
+	void operator()();
+	void load_config_and_init();
+	void wake_up();
+
+	// Returns index of registered device
+	u32 register_device(const std::string& name);
+	void unregister_device(u32 dev_num);
+	bool check_device(u32 dev_num);
+
+	u64 event_queue_key = 0;
+	u64 event_queue_source = 0;
+
+	std::array<microphone_device, CELL_MAX_MICS> mic_list{};
+
+	shared_mutex mutex;
+	atomic_t<u8> init = 0;
+
+	static constexpr auto thread_name = "Microphone Thread"sv;
+
+protected:
+	atomic_t<u32> wakey = 0;
+
+	//	u32 signalStateLocalTalk = 9; // value is in range 0-10. 10 indicates
+	// talking, 0 indicating none. 	u32 signalStateFarTalk = 0; // value is in range
+	// 0-10. 10 indicates talking from far away, 0 indicating none. 	f32
+	// signalStateNoiseSupression; // value is in decibels 	f32
+	// signalStateGainControl; 	f32 signalStateMicSignalLevel; // value is in
+	// decibels 	f32 signalStateSpeakerSignalLevel; // value is in decibels
+};
+
+using mic_thread = named_thread<mic_context>;

ps3fw/include/rpcsx/fw/ps3/cellMouse.h

@@ -0,0 +1,70 @@
+#pragma once
+
+enum CellMouseError : u32
+{
+	CELL_MOUSE_ERROR_FATAL = 0x80121201,
+	CELL_MOUSE_ERROR_INVALID_PARAMETER = 0x80121202,
+	CELL_MOUSE_ERROR_ALREADY_INITIALIZED = 0x80121203,
+	CELL_MOUSE_ERROR_UNINITIALIZED = 0x80121204,
+	CELL_MOUSE_ERROR_RESOURCE_ALLOCATION_FAILED = 0x80121205,
+	CELL_MOUSE_ERROR_DATA_READ_FAILED = 0x80121206,
+	CELL_MOUSE_ERROR_NO_DEVICE = 0x80121207,
+	CELL_MOUSE_ERROR_SYS_SETTING_FAILED = 0x80121208,
+};
+
+enum
+{
+	CELL_MOUSE_MAX_DATA_LIST_NUM = 8,
+	CELL_MOUSE_MAX_CODES = 64,
+	CELL_MAX_MICE = 127,
+};
+
+struct CellMouseInfo
+{
+	be_t<u32> max_connect;
+	be_t<u32> now_connect;
+	be_t<u32> info;
+	be_t<u16> vendor_id[CELL_MAX_MICE];
+	be_t<u16> product_id[CELL_MAX_MICE];
+	u8 status[CELL_MAX_MICE];
+};
+
+struct CellMouseInfoTablet
+{
+	be_t<u32> is_supported;
+	be_t<u32> mode;
+};
+
+struct CellMouseData
+{
+	u8 update;
+	u8 buttons;
+	s8 x_axis;
+	s8 y_axis;
+	s8 wheel;
+	s8 tilt;
+};
+
+struct CellMouseTabletData
+{
+	be_t<s32> len;
+	u8 data[CELL_MOUSE_MAX_CODES];
+};
+
+struct CellMouseDataList
+{
+	be_t<u32> list_num;
+	CellMouseData list[CELL_MOUSE_MAX_DATA_LIST_NUM];
+};
+
+struct CellMouseTabletDataList
+{
+	be_t<u32> list_num;
+	CellMouseTabletData list[CELL_MOUSE_MAX_DATA_LIST_NUM];
+};
+
+struct CellMouseRawData
+{
+	be_t<s32> len;
+	u8 data[CELL_MOUSE_MAX_CODES];
+};

ps3fw/include/rpcsx/fw/ps3/cellMsgDialog.h

@@ -0,0 +1,148 @@
+#pragma once
+
+#include "Emu/Cell/ErrorCodes.h"
+#include "Emu/Memory/vm_ptr.h"
+#include "util/BitField.h"
+#include "util/atomic.hpp"
+#include "util/types.hpp"
+
+#include <functional>
+#include <string>
+
+enum
+{
+	CELL_MSGDIALOG_PROGRESSBAR_STRING_SIZE = 64,
+	CELL_MSGDIALOG_STRING_SIZE = 512,
+};
+
+enum CellMsgDialogError : u32
+{
+	CELL_MSGDIALOG_ERROR_PARAM = 0x8002b301,
+	CELL_MSGDIALOG_ERROR_DIALOG_NOT_OPENED = 0x8002b302,
+};
+
+enum : u32
+{
+	CELL_MSGDIALOG_TYPE_SE_TYPE_ERROR = 0 << 0,
+	CELL_MSGDIALOG_TYPE_SE_TYPE_NORMAL = 1 << 0,
+
+	CELL_MSGDIALOG_TYPE_SE_MUTE_OFF = 0 << 1,
+	CELL_MSGDIALOG_TYPE_SE_MUTE_ON = 1 << 1,
+
+	CELL_MSGDIALOG_TYPE_BG_VISIBLE = 0 << 2,
+	CELL_MSGDIALOG_TYPE_BG_INVISIBLE = 1 << 2,
+
+	CELL_MSGDIALOG_TYPE_BUTTON_TYPE_NONE = 0 << 4,
+	CELL_MSGDIALOG_TYPE_BUTTON_TYPE_YESNO = 1 << 4,
+	CELL_MSGDIALOG_TYPE_BUTTON_TYPE_OK = 2 << 4,
+
+	CELL_MSGDIALOG_TYPE_DISABLE_CANCEL_OFF = 0 << 7,
+	CELL_MSGDIALOG_TYPE_DISABLE_CANCEL_ON = 1 << 7,
+
+	CELL_MSGDIALOG_TYPE_DEFAULT_CURSOR_NONE = 0 << 8,
+	CELL_MSGDIALOG_TYPE_DEFAULT_CURSOR_YES = 0 << 8,
+	CELL_MSGDIALOG_TYPE_DEFAULT_CURSOR_NO = 1 << 8,
+	CELL_MSGDIALOG_TYPE_DEFAULT_CURSOR_OK = 0 << 8,
+
+	CELL_MSGDIALOG_TYPE_PROGRESSBAR_NONE = 0 << 12,
+	CELL_MSGDIALOG_TYPE_PROGRESSBAR_SINGLE = 1 << 12,
+	CELL_MSGDIALOG_TYPE_PROGRESSBAR_DOUBLE = 2 << 12,
+};
+
+// MsgDialog Button Type
+enum : s32
+{
+	CELL_MSGDIALOG_BUTTON_NONE = -1,
+	CELL_MSGDIALOG_BUTTON_INVALID = 0,
+	CELL_MSGDIALOG_BUTTON_OK = 1,
+	CELL_MSGDIALOG_BUTTON_YES = 1,
+	CELL_MSGDIALOG_BUTTON_NO = 2,
+	CELL_MSGDIALOG_BUTTON_ESCAPE = 3,
+};
+
+enum CellMsgDialogProgressBarIndex
+{
+	CELL_MSGDIALOG_PROGRESSBAR_INDEX_SINGLE =
+		0, // the only bar in a single bar dialog
+	CELL_MSGDIALOG_PROGRESSBAR_INDEX_DOUBLE_UPPER =
+		0, // the upper bar in a double bar dialog
+	CELL_MSGDIALOG_PROGRESSBAR_INDEX_DOUBLE_LOWER =
+		1, // the lower bar in a double bar dialog
+};
+
+using CellMsgDialogCallback = void(s32 buttonType, vm::ptr<void> userData);
+
+union MsgDialogType
+{
+	u32 value;
+
+	bf_t<u32, 0, 1> se_normal;
+	bf_t<u32, 1, 1> se_mute_on;
+	bf_t<u32, 2, 1> bg_invisible;
+	bf_t<u32, 4, 3> button_type;
+	bf_t<u32, 7, 1> disable_cancel;
+	bf_t<u32, 8, 2> default_cursor;
+	bf_t<u32, 12, 2> progress_bar_count;
+};
+
+enum class MsgDialogState
+{
+	Open,
+	Abort,
+	Close,
+};
+
+enum class msg_dialog_source
+{
+	_cellMsgDialog,
+	_cellSaveData,
+	_cellGame,
+	_cellCrossController,
+	_sceNp,
+	_sceNpTrophy,
+	sys_progress,
+	shader_loading,
+};
+
+void close_msg_dialog();
+error_code open_msg_dialog(bool is_blocking, u32 type, vm::cptr<char> msgString,
+	msg_dialog_source source,
+	vm::ptr<CellMsgDialogCallback> callback = vm::null,
+	vm::ptr<void> userData = vm::null,
+	vm::ptr<void> extParam = vm::null,
+	s32* return_code = nullptr);
+error_code open_exit_dialog(const std::string& message, bool is_exit_requested,
+	msg_dialog_source source);
+
+class MsgDialogBase
+{
+protected:
+	// the progressbar that will be represented in the taskbar. Use -1 to combine
+	// the progress.
+	s32 taskbar_index = 0;
+
+public:
+	atomic_t<MsgDialogState> state{MsgDialogState::Close};
+
+	MsgDialogType type{};
+	msg_dialog_source source = msg_dialog_source::_cellMsgDialog;
+
+	std::function<void(s32 status)> on_close = nullptr;
+
+	virtual ~MsgDialogBase();
+	virtual void Create(const std::string& msg,
+		const std::string& title = "") = 0;
+	virtual void Close(bool success) = 0;
+	virtual void SetMsg(const std::string& msg) = 0;
+	virtual void ProgressBarSetMsg(u32 progressBarIndex,
+		const std::string& msg) = 0;
+	virtual void ProgressBarReset(u32 progressBarIndex) = 0;
+	virtual void ProgressBarInc(u32 progressBarIndex, u32 delta) = 0;
+	virtual void ProgressBarSetValue(u32 progressBarIndex, u32 value) = 0;
+	virtual void ProgressBarSetLimit(u32 index, u32 limit) = 0;
+
+	void ProgressBarSetTaskbarIndex(s32 index)
+	{
+		taskbar_index = index;
+	}
+};

ps3fw/include/rpcsx/fw/ps3/cellMusic.h

@@ -0,0 +1,179 @@
+#pragma once
+
+#include "Emu/Memory/vm_ptr.h"
+#include "Emu/Cell/ErrorCodes.h"
+#include "cellSearch.h"
+
+// Error Codes
+enum CellMusicError : u32
+{
+	CELL_MUSIC_CANCELED = 1,
+	CELL_MUSIC_PLAYBACK_FINISHED = 0x8002c101,
+	CELL_MUSIC_ERROR_PARAM = 0x8002c102,
+	CELL_MUSIC_ERROR_BUSY = 0x8002c103,
+	CELL_MUSIC_ERROR_NO_ACTIVE_CONTENT = 0x8002c104,
+	CELL_MUSIC_ERROR_NO_MATCH_FOUND = 0x8002c105,
+	CELL_MUSIC_ERROR_INVALID_CONTEXT = 0x8002c106,
+	CELL_MUSIC_ERROR_PLAYBACK_FAILURE = 0x8002c107,
+	CELL_MUSIC_ERROR_NO_MORE_CONTENT = 0x8002c108,
+	CELL_MUSIC_DIALOG_OPEN = 0x8002c109,
+	CELL_MUSIC_DIALOG_CLOSE = 0x8002c10a,
+	CELL_MUSIC_ERROR_GENERIC = 0x8002c1ff,
+};
+
+enum CellMusic2Error : u32
+{
+	CELL_MUSIC2_CANCELED = 1,
+	CELL_MUSIC2_PLAYBACK_FINISHED = 0x8002c101,
+	CELL_MUSIC2_ERROR_PARAM = 0x8002c102,
+	CELL_MUSIC2_ERROR_BUSY = 0x8002c103,
+	CELL_MUSIC2_ERROR_NO_ACTIVE_CONTENT = 0x8002c104,
+	CELL_MUSIC2_ERROR_NO_MATCH_FOUND = 0x8002c105,
+	CELL_MUSIC2_ERROR_INVALID_CONTEXT = 0x8002c106,
+	CELL_MUSIC2_ERROR_PLAYBACK_FAILURE = 0x8002c107,
+	CELL_MUSIC2_ERROR_NO_MORE_CONTENT = 0x8002c108,
+	CELL_MUSIC2_DIALOG_OPEN = 0x8002c109,
+	CELL_MUSIC2_DIALOG_CLOSE = 0x8002c10a,
+	CELL_MUSIC2_ERROR_GENERIC = 0x8002c1ff,
+};
+
+enum
+{
+	CELL_SYSUTIL_MUSIC_INITIALIZING_FINISHED = 1,
+	CELL_SYSUTIL_MUSIC_SHUTDOWN_FINISHED = 4, // Was 3 in 1.03, changed to 4 in 1.1
+	CELL_SYSUTIL_MUSIC_LOADING_FINISHED = 5,
+	CELL_SYSUTIL_MUSIC_UNLOADING_FINISHED = 7,
+	CELL_SYSUTIL_MUSIC_RELEASED = 9,
+	CELL_SYSUTIL_MUSIC_GRABBED = 11,
+};
+
+enum
+{
+	CELL_SYSUTIL_MUSIC2_INITIALIZING_FINISHED = CELL_SYSUTIL_MUSIC_INITIALIZING_FINISHED,
+	CELL_SYSUTIL_MUSIC2_SHUTDOWN_FINISHED = CELL_SYSUTIL_MUSIC_SHUTDOWN_FINISHED,
+	CELL_SYSUTIL_MUSIC2_LOADING_FINISHED = CELL_SYSUTIL_MUSIC_LOADING_FINISHED,
+	CELL_SYSUTIL_MUSIC2_UNLOADING_FINISHED = CELL_SYSUTIL_MUSIC_UNLOADING_FINISHED,
+	CELL_SYSUTIL_MUSIC2_RELEASED = CELL_SYSUTIL_MUSIC_RELEASED,
+	CELL_SYSUTIL_MUSIC2_GRABBED = CELL_SYSUTIL_MUSIC_GRABBED,
+};
+
+enum
+{
+	CELL_MUSIC_EVENT_STATUS_NOTIFICATION = 0,
+	CELL_MUSIC_EVENT_INITIALIZE_RESULT = 1,
+	CELL_MUSIC_EVENT_FINALIZE_RESULT = 2,
+	CELL_MUSIC_EVENT_SELECT_CONTENTS_RESULT = 3,
+	CELL_MUSIC_EVENT_SET_PLAYBACK_COMMAND_RESULT = 4,
+	CELL_MUSIC_EVENT_SET_VOLUME_RESULT = 5,
+	CELL_MUSIC_EVENT_SET_SELECTION_CONTEXT_RESULT = 6,
+	CELL_MUSIC_EVENT_UI_NOTIFICATION = 7,
+};
+
+enum
+{
+	CELL_MUSIC2_EVENT_STATUS_NOTIFICATION = CELL_MUSIC_EVENT_STATUS_NOTIFICATION,
+	CELL_MUSIC2_EVENT_INITIALIZE_RESULT = CELL_MUSIC_EVENT_INITIALIZE_RESULT,
+	CELL_MUSIC2_EVENT_FINALIZE_RESULT = CELL_MUSIC_EVENT_FINALIZE_RESULT,
+	CELL_MUSIC2_EVENT_SELECT_CONTENTS_RESULT = CELL_MUSIC_EVENT_SELECT_CONTENTS_RESULT,
+	CELL_MUSIC2_EVENT_SET_PLAYBACK_COMMAND_RESULT = CELL_MUSIC_EVENT_SET_PLAYBACK_COMMAND_RESULT,
+	CELL_MUSIC2_EVENT_SET_VOLUME_RESULT = CELL_MUSIC_EVENT_SET_VOLUME_RESULT,
+	CELL_MUSIC2_EVENT_SET_SELECTION_CONTEXT_RESULT = CELL_MUSIC_EVENT_SET_SELECTION_CONTEXT_RESULT,
+	CELL_MUSIC2_EVENT_UI_NOTIFICATION = CELL_MUSIC_EVENT_UI_NOTIFICATION,
+};
+
+enum
+{
+	CELL_MUSIC_PB_CMD_STOP = 0,
+	CELL_MUSIC_PB_CMD_PLAY = 1,
+	CELL_MUSIC_PB_CMD_PAUSE = 2,
+	CELL_MUSIC_PB_CMD_NEXT = 3,
+	CELL_MUSIC_PB_CMD_PREV = 4,
+	CELL_MUSIC_PB_CMD_FASTFORWARD = 5,
+	CELL_MUSIC_PB_CMD_FASTREVERSE = 6,
+};
+
+enum
+{
+	CELL_MUSIC2_PB_CMD_STOP = CELL_MUSIC_PB_CMD_STOP,
+	CELL_MUSIC2_PB_CMD_PLAY = CELL_MUSIC_PB_CMD_PLAY,
+	CELL_MUSIC2_PB_CMD_PAUSE = CELL_MUSIC_PB_CMD_PAUSE,
+	CELL_MUSIC2_PB_CMD_NEXT = CELL_MUSIC_PB_CMD_NEXT,
+	CELL_MUSIC2_PB_CMD_PREV = CELL_MUSIC_PB_CMD_PREV,
+	CELL_MUSIC2_PB_CMD_FASTFORWARD = CELL_MUSIC_PB_CMD_FASTFORWARD,
+	CELL_MUSIC2_PB_CMD_FASTREVERSE = CELL_MUSIC_PB_CMD_FASTREVERSE,
+};
+
+enum
+{
+	CELL_MUSIC_PB_STATUS_STOP = 0,
+	CELL_MUSIC_PB_STATUS_PLAY = 1,
+	CELL_MUSIC_PB_STATUS_PAUSE = 2,
+	CELL_MUSIC_PB_STATUS_FASTFORWARD = 3,
+	CELL_MUSIC_PB_STATUS_FASTREVERSE = 4,
+};
+
+enum
+{
+	CELL_MUSIC2_PB_STATUS_STOP = CELL_MUSIC_PB_STATUS_STOP,
+	CELL_MUSIC2_PB_STATUS_PLAY = CELL_MUSIC_PB_STATUS_PLAY,
+	CELL_MUSIC2_PB_STATUS_PAUSE = CELL_MUSIC_PB_STATUS_PAUSE,
+	CELL_MUSIC2_PB_STATUS_FASTFORWARD = CELL_MUSIC_PB_STATUS_FASTFORWARD,
+	CELL_MUSIC2_PB_STATUS_FASTREVERSE = CELL_MUSIC_PB_STATUS_FASTREVERSE,
+};
+
+enum
+{
+	CELL_MUSIC_PLAYBACK_MEMORY_CONTAINER_SIZE = 11 * 1024 * 1024,
+	CELL_MUSIC_PLAYER_MODE_NORMAL = 0,
+	CELL_MUSIC2_PLAYER_MODE_NORMAL = CELL_MUSIC_PLAYER_MODE_NORMAL,
+	CELL_MUSIC_SELECTION_CONTEXT_SIZE = 2048,
+};
+
+using CellMusicCallback = void(u32 event, vm::ptr<void> param, vm::ptr<void> userData);
+using CellMusic2Callback = void(u32 event, vm::ptr<void> param, vm::ptr<void> userData);
+
+struct CellMusicSelectionContext
+{
+	// TODO: find out what fw does with it
+	// Let's just hijack it with our own data.
+	char data[CELL_MUSIC_SELECTION_CONTEXT_SIZE];
+};
+
+struct music_selection_context
+{
+	bool valid = false;
+	char magic[4] = "SUS";
+	std::string hash;
+	CellSearchContentType content_type = CELL_SEARCH_CONTENTTYPE_MUSIC;
+	CellSearchRepeatMode repeat_mode = CELL_SEARCH_REPEATMODE_NONE;
+	CellSearchContextOption context_option = CELL_SEARCH_CONTEXTOPTION_NONE;
+	u32 first_track{0};
+	u32 current_track{0};
+	std::vector<std::string> playlist;
+
+	static constexpr u32 max_depth = 2; // root + 1 folder + file
+	static constexpr const char* target_file_type = "Music Playlist";
+	static constexpr const char* target_version = "1.0";
+	static std::string get_next_hash();
+	static std::string context_to_hex(const CellMusicSelectionContext& context);
+
+	bool set(const CellMusicSelectionContext& in);
+	CellMusicSelectionContext get() const;
+
+	std::string to_string() const;
+	std::string get_yaml_path() const;
+
+	void set_playlist(const std::string& path);
+	void create_playlist(const std::string& new_hash);
+	bool load_playlist();
+	void set_track(std::string_view track);
+	u32 step_track(bool next);
+
+	operator bool() const
+	{
+		return atomic_storage<bool>::load(valid);
+	}
+
+	// Helper
+	error_code find_content_id(vm::ptr<CellSearchContentId> contents_id);
+};

ps3fw/include/rpcsx/fw/ps3/cellMusicDecode.h

@@ -0,0 +1,69 @@
+#pragma once
+
+// Return Codes (CELL_MUSIC_DECODE2 codes are omitted if they are identical)
+enum CellMusicDecodeError : u32
+{
+	CELL_MUSIC_DECODE_CANCELED = 1,
+	CELL_MUSIC_DECODE_DECODE_FINISHED = 0x8002C101,
+	CELL_MUSIC_DECODE_ERROR_PARAM = 0x8002C102,
+	CELL_MUSIC_DECODE_ERROR_BUSY = 0x8002C103,
+	CELL_MUSIC_DECODE_ERROR_NO_ACTIVE_CONTENT = 0x8002C104,
+	CELL_MUSIC_DECODE_ERROR_NO_MATCH_FOUND = 0x8002C105,
+	CELL_MUSIC_DECODE_ERROR_INVALID_CONTEXT = 0x8002C106,
+	CELL_MUSIC_DECODE_ERROR_DECODE_FAILURE = 0x8002C107,
+	CELL_MUSIC_DECODE_ERROR_NO_MORE_CONTENT = 0x8002C108,
+	CELL_MUSIC_DECODE_DIALOG_OPEN = 0x8002C109,
+	CELL_MUSIC_DECODE_DIALOG_CLOSE = 0x8002C10A,
+	CELL_MUSIC_DECODE_ERROR_NO_LPCM_DATA = 0x8002C10B,
+	CELL_MUSIC_DECODE_NEXT_CONTENTS_READY = 0x8002C10C,
+	CELL_MUSIC_DECODE_ERROR_GENERIC = 0x8002C1FF,
+};
+
+// Constants (CELL_MUSIC_DECODE2 codes are omitted if they are identical)
+enum
+{
+	CELL_MUSIC_DECODE_EVENT_STATUS_NOTIFICATION = 0,
+	CELL_MUSIC_DECODE_EVENT_INITIALIZE_RESULT = 1,
+	CELL_MUSIC_DECODE_EVENT_FINALIZE_RESULT = 2,
+	CELL_MUSIC_DECODE_EVENT_SELECT_CONTENTS_RESULT = 3,
+	CELL_MUSIC_DECODE_EVENT_SET_DECODE_COMMAND_RESULT = 4,
+	CELL_MUSIC_DECODE_EVENT_SET_SELECTION_CONTEXT_RESULT = 5,
+	CELL_MUSIC_DECODE_EVENT_UI_NOTIFICATION = 6,
+	CELL_MUSIC_DECODE_EVENT_NEXT_CONTENTS_READY_RESULT = 7,
+
+	CELL_MUSIC_DECODE_MODE_NORMAL = 0,
+
+	CELL_MUSIC_DECODE_CMD_STOP = 0,
+	CELL_MUSIC_DECODE_CMD_START = 1,
+	CELL_MUSIC_DECODE_CMD_NEXT = 2,
+	CELL_MUSIC_DECODE_CMD_PREV = 3,
+
+	CELL_MUSIC_DECODE_STATUS_DORMANT = 0,
+	CELL_MUSIC_DECODE_STATUS_DECODING = 1,
+
+	CELL_MUSIC_DECODE_POSITION_NONE = 0,
+	CELL_MUSIC_DECODE_POSITION_START = 1,
+	CELL_MUSIC_DECODE_POSITION_MID = 2,
+	CELL_MUSIC_DECODE_POSITION_END = 3,
+	CELL_MUSIC_DECODE_POSITION_END_LIST_END = 4,
+
+	CELL_MUSIC_DECODE2_MODE_NORMAL = 0,
+
+	CELL_MUSIC_DECODE2_SPEED_MAX = 0,
+	CELL_MUSIC_DECODE2_SPEED_2 = 2,
+
+	CELL_SYSUTIL_MUSIC_DECODE2_INITIALIZING_FINISHED = 1,
+	CELL_SYSUTIL_MUSIC_DECODE2_SHUTDOWN_FINISHED = 4, // 3(SDK103) -> 4(SDK110)
+	CELL_SYSUTIL_MUSIC_DECODE2_LOADING_FINISHED = 5,
+	CELL_SYSUTIL_MUSIC_DECODE2_UNLOADING_FINISHED = 7,
+	CELL_SYSUTIL_MUSIC_DECODE2_RELEASED = 9,
+	CELL_SYSUTIL_MUSIC_DECODE2_GRABBED = 11,
+
+	CELL_MUSIC_DECODE2_MIN_BUFFER_SIZE = 448 * 1024,
+	CELL_MUSIC_DECODE2_MANAGEMENT_SIZE = 64 * 1024,
+	CELL_MUSIC_DECODE2_PAGESIZE_64K = 64 * 1024,
+	CELL_MUSIC_DECODE2_PAGESIZE_1M = 1 * 1024 * 1024,
+};
+
+using CellMusicDecodeCallback = void(u32, vm::ptr<void> param, vm::ptr<void> userData);
+using CellMusicDecode2Callback = void(u32, vm::ptr<void> param, vm::ptr<void> userData);

ps3fw/include/rpcsx/fw/ps3/cellNetCtl.h

@@ -0,0 +1,335 @@
+#pragma once
+
+#include "Emu/Memory/vm_ptr.h"
+
+// Error Codes
+enum CellNetCtlError : u32
+{
+	CELL_NET_CTL_ERROR_NOT_INITIALIZED = 0x80130101,
+	CELL_NET_CTL_ERROR_NOT_TERMINATED = 0x80130102,
+	CELL_NET_CTL_ERROR_HANDLER_MAX = 0x80130103,
+	CELL_NET_CTL_ERROR_ID_NOT_FOUND = 0x80130104,
+	CELL_NET_CTL_ERROR_INVALID_ID = 0x80130105,
+	CELL_NET_CTL_ERROR_INVALID_CODE = 0x80130106,
+	CELL_NET_CTL_ERROR_INVALID_ADDR = 0x80130107,
+	CELL_NET_CTL_ERROR_NOT_CONNECTED = 0x80130108,
+	CELL_NET_CTL_ERROR_NOT_AVAIL = 0x80130109,
+	CELL_NET_CTL_ERROR_INVALID_TYPE = 0x8013010a,
+	CELL_NET_CTL_ERROR_INVALID_SIZE = 0x8013010b,
+	CELL_NET_CTL_ERROR_NET_DISABLED = 0x80130181,
+	CELL_NET_CTL_ERROR_NET_NOT_CONNECTED = 0x80130182,
+	CELL_NET_CTL_ERROR_NP_NO_ACCOUNT = 0x80130183,
+	CELL_NET_CTL_ERROR_NP_RESERVED1 = 0x80130184,
+	CELL_NET_CTL_ERROR_NP_RESERVED2 = 0x80130185,
+	CELL_NET_CTL_ERROR_NET_CABLE_NOT_CONNECTED = 0x80130186,
+	CELL_NET_CTL_ERROR_DIALOG_CANCELED = 0x80130190,
+	CELL_NET_CTL_ERROR_DIALOG_ABORTED = 0x80130191,
+
+	CELL_NET_CTL_ERROR_WLAN_DEAUTHED = 0x80130137,
+	CELL_NET_CTL_ERROR_WLAN_KEYINFO_EXCHNAGE_TIMEOUT = 0x8013013d,
+	CELL_NET_CTL_ERROR_WLAN_ASSOC_FAILED = 0x8013013e,
+	CELL_NET_CTL_ERROR_WLAN_AP_DISAPPEARED = 0x8013013f,
+	CELL_NET_CTL_ERROR_PPPOE_SESSION_INIT = 0x80130409,
+	CELL_NET_CTL_ERROR_PPPOE_SESSION_NO_PADO = 0x8013040a,
+	CELL_NET_CTL_ERROR_PPPOE_SESSION_NO_PADS = 0x8013040b,
+	CELL_NET_CTL_ERROR_PPPOE_SESSION_GET_PADT = 0x8013040d,
+	CELL_NET_CTL_ERROR_PPPOE_SESSION_SERVICE_NAME = 0x8013040f,
+	CELL_NET_CTL_ERROR_PPPOE_SESSION_AC_SYSTEM = 0x80130410,
+	CELL_NET_CTL_ERROR_PPPOE_SESSION_GENERIC = 0x80130411,
+	CELL_NET_CTL_ERROR_PPPOE_STATUS_AUTH = 0x80130412,
+	CELL_NET_CTL_ERROR_PPPOE_STATUS_NETWORK = 0x80130413,
+	CELL_NET_CTL_ERROR_PPPOE_STATUS_TERMINATE = 0x80130414,
+	CELL_NET_CTL_ERROR_DHCP_LEASE_TIME = 0x80130504,
+
+	CELL_GAMEUPDATE_ERROR_NOT_INITIALIZED = 0x8002cc01,
+	CELL_GAMEUPDATE_ERROR_ALREADY_INITIALIZED = 0x8002cc02,
+	CELL_GAMEUPDATE_ERROR_INVALID_ADDR = 0x8002cc03,
+	CELL_GAMEUPDATE_ERROR_INVALID_SIZE = 0x8002cc04,
+	CELL_GAMEUPDATE_ERROR_INVALID_MEMORY_CONTAINER = 0x8002cc05,
+	CELL_GAMEUPDATE_ERROR_INSUFFICIENT_MEMORY_CONTAINER = 0x8002cc06,
+	CELL_GAMEUPDATE_ERROR_BUSY = 0x8002cc07,
+	CELL_GAMEUPDATE_ERROR_NOT_START = 0x8002cc08,
+	CELL_GAMEUPDATE_ERROR_LOAD_FAILED = 0x8002cc09,
+};
+
+// Network connection states
+enum CellNetCtlState : s32
+{
+	CELL_NET_CTL_STATE_Disconnected = 0,
+	CELL_NET_CTL_STATE_Connecting = 1,
+	CELL_NET_CTL_STATE_IPObtaining = 2,
+	CELL_NET_CTL_STATE_IPObtained = 3,
+};
+
+// Transition connection states
+enum
+{
+	CELL_NET_CTL_EVENT_CONNECT_REQ = 0,
+	CELL_NET_CTL_EVENT_ESTABLISH = 1,
+	CELL_NET_CTL_EVENT_GET_IP = 2,
+	CELL_NET_CTL_EVENT_DISCONNECT_REQ = 3,
+	CELL_NET_CTL_EVENT_ERROR = 4,
+	CELL_NET_CTL_EVENT_LINK_DISCONNECTED = 5,
+	CELL_NET_CTL_EVENT_AUTO_RETRY = 6,
+};
+
+// Network connection devices
+enum
+{
+	CELL_NET_CTL_DEVICE_WIRED = 0,
+	CELL_NET_CTL_DEVICE_WIRELESS = 1,
+};
+
+// Cable connection types
+enum
+{
+	CELL_NET_CTL_LINK_TYPE_AUTO = 0,
+	CELL_NET_CTL_LINK_TYPE_10BASE_HALF = 1,
+	CELL_NET_CTL_LINK_TYPE_10BASE_FULL = 2,
+	CELL_NET_CTL_LINK_TYPE_100BASE_HALF = 3,
+	CELL_NET_CTL_LINK_TYPE_100BASE_FULL = 4,
+	CELL_NET_CTL_LINK_TYPE_1000BASE_HALF = 5,
+	CELL_NET_CTL_LINK_TYPE_1000BASE_FULL = 6,
+};
+
+// Link connection states
+enum
+{
+	CELL_NET_CTL_LINK_DISCONNECTED = 0,
+	CELL_NET_CTL_LINK_CONNECTED = 1,
+};
+
+// Wireless connection security measures
+enum
+{
+	CELL_NET_CTL_WLAN_SECURITY_NOAUTH = 0,
+	CELL_NET_CTL_WLAN_SECURITY_WEP = 1,
+	CELL_NET_CTL_WLAN_SECURITY_WPAPSK_TKIP = 2,
+	CELL_NET_CTL_WLAN_SECURITY_WPAPSK_AES = 3,
+	CELL_NET_CTL_WLAN_SECURITY_UNSUPPORTED = 4,
+	CELL_NET_CTL_WLAN_SECURITY_WPA2PSK_TKIP = 5,
+	CELL_NET_CTL_WLAN_SECURITY_WPA2PSK_AES = 6,
+	CELL_NET_CTL_WLAN_SECURITY_WPAPSK_WPA2PSK = 7,
+};
+
+// 802.1X settings
+enum
+{
+	CELL_NET_CTL_8021X_NONE = 0,
+	CELL_NET_CTL_8021X_EAP_MD5 = 1,
+};
+
+// IP settings
+enum
+{
+	CELL_NET_CTL_IP_DHCP = 0,
+	CELL_NET_CTL_IP_STATIC = 1,
+	CELL_NET_CTL_IP_PPPOE = 2,
+};
+
+// HTTP proxy settings
+enum
+{
+	CELL_NET_CTL_HTTP_PROXY_OFF = 0,
+	CELL_NET_CTL_HTTP_PROXY_ON = 1,
+};
+
+// UPnP settings
+enum
+{
+	CELL_NET_CTL_UPNP_ON = 0,
+	CELL_NET_CTL_UPNP_OFF = 1,
+};
+
+// Codes for information
+enum
+{
+	CELL_NET_CTL_INFO_DEVICE = 1,
+	CELL_NET_CTL_INFO_ETHER_ADDR = 2,
+	CELL_NET_CTL_INFO_MTU = 3,
+	CELL_NET_CTL_INFO_LINK = 4,
+	CELL_NET_CTL_INFO_LINK_TYPE = 5,
+	CELL_NET_CTL_INFO_BSSID = 6,
+	CELL_NET_CTL_INFO_SSID = 7,
+	CELL_NET_CTL_INFO_WLAN_SECURITY = 8,
+	CELL_NET_CTL_INFO_8021X_TYPE = 9,
+	CELL_NET_CTL_INFO_8021X_AUTH_NAME = 10,
+	CELL_NET_CTL_INFO_RSSI = 11,
+	CELL_NET_CTL_INFO_CHANNEL = 12,
+	CELL_NET_CTL_INFO_IP_CONFIG = 13,
+	CELL_NET_CTL_INFO_DHCP_HOSTNAME = 14,
+	CELL_NET_CTL_INFO_PPPOE_AUTH_NAME = 15,
+	CELL_NET_CTL_INFO_IP_ADDRESS = 16,
+	CELL_NET_CTL_INFO_NETMASK = 17,
+	CELL_NET_CTL_INFO_DEFAULT_ROUTE = 18,
+	CELL_NET_CTL_INFO_PRIMARY_DNS = 19,
+	CELL_NET_CTL_INFO_SECONDARY_DNS = 20,
+	CELL_NET_CTL_INFO_HTTP_PROXY_CONFIG = 21,
+	CELL_NET_CTL_INFO_HTTP_PROXY_SERVER = 22,
+	CELL_NET_CTL_INFO_HTTP_PROXY_PORT = 23,
+	CELL_NET_CTL_INFO_UPNP_CONFIG = 24,
+	CELL_NET_CTL_INFO_RESERVED1 = 25,
+	CELL_NET_CTL_INFO_RESERVED2 = 26,
+};
+
+// Network start dialogs
+enum
+{
+	CELL_NET_CTL_NETSTART_TYPE_NET = 0,
+	CELL_NET_CTL_NETSTART_TYPE_NP = 1,
+	CELL_NET_CTL_NETSTART_TYPE_MAX = 2,
+};
+
+// Network start dialog statuses
+enum
+{
+	CELL_SYSUTIL_NET_CTL_NETSTART_LOADED = 0x0801,
+	CELL_SYSUTIL_NET_CTL_NETSTART_FINISHED = 0x0802,
+	CELL_SYSUTIL_NET_CTL_NETSTART_UNLOADED = 0x0803,
+};
+
+// UPnP NAT statuses
+enum
+{
+	CELL_NET_CTL_NATINFO_UPNP_UNCHECKED = 0,
+	CELL_NET_CTL_NATINFO_UPNP_NO = 1,
+	CELL_NET_CTL_NATINFO_UPNP_USED = 2,
+};
+
+// STUN NAT statuses
+enum
+{
+	CELL_NET_CTL_NATINFO_STUN_UNCHECKED = 0,
+	CELL_NET_CTL_NATINFO_STUN_FAILED = 1,
+	CELL_NET_CTL_NATINFO_STUN_OK = 2,
+};
+
+// NAT types
+enum
+{
+	CELL_NET_CTL_NATINFO_NAT_TYPE_1 = 1,
+	CELL_NET_CTL_NATINFO_NAT_TYPE_2 = 2,
+	CELL_NET_CTL_NATINFO_NAT_TYPE_3 = 3,
+};
+
+enum
+{
+	CELL_NET_CTL_ETHER_ADDR_LEN = 6,
+	CELL_NET_CTL_BSSID_LEN = 6,
+	CELL_NET_CTL_SSID_LEN = 32,
+	CELL_NET_CTL_WLAN_SECURITY_KEY_LEN = (64 + 1),
+	CELL_NET_CTL_AUTH_NAME_LEN = (127 + 1),
+	CELL_NET_CTL_AUTH_KEY_LEN = (127 + 1),
+	CELL_NET_CTL_DHCP_HOSTNAME_LEN = (254 + 1),
+	CELL_NET_CTL_HOSTNAME_LEN = (255 + 1),
+	CELL_NET_CTL_IPV4_ADDR_STR_LEN = 16,
+};
+
+struct CellNetCtlEtherAddr
+{
+	u8 data[CELL_NET_CTL_ETHER_ADDR_LEN];
+	u8 padding[2];
+};
+
+struct CellNetCtlSSID
+{
+	u8 data[CELL_NET_CTL_SSID_LEN];
+	u8 term;
+	u8 padding[3];
+};
+
+union CellNetCtlInfo
+{
+	be_t<u32> device;
+	CellNetCtlEtherAddr ether_addr;
+	be_t<u32> mtu;
+	be_t<u32> link;
+	be_t<u32> link_type;
+	CellNetCtlEtherAddr bssid;
+	CellNetCtlSSID ssid;
+	be_t<u32> wlan_security;
+	be_t<u32> auth_8021x_type;
+	char auth_8021x_auth_name[CELL_NET_CTL_AUTH_NAME_LEN];
+	u8 rssi;
+	u8 channel;
+	be_t<u32> ip_config;
+	char dhcp_hostname[CELL_NET_CTL_HOSTNAME_LEN];
+	char pppoe_auth_name[CELL_NET_CTL_AUTH_NAME_LEN];
+	char ip_address[CELL_NET_CTL_IPV4_ADDR_STR_LEN];
+	char netmask[CELL_NET_CTL_IPV4_ADDR_STR_LEN];
+	char default_route[CELL_NET_CTL_IPV4_ADDR_STR_LEN];
+	char primary_dns[CELL_NET_CTL_IPV4_ADDR_STR_LEN];
+	char secondary_dns[CELL_NET_CTL_IPV4_ADDR_STR_LEN];
+	be_t<u32> http_proxy_config;
+	char http_proxy_server[CELL_NET_CTL_HOSTNAME_LEN];
+	be_t<u16> http_proxy_port;
+	be_t<u32> upnp_config;
+};
+
+struct CellNetCtlNetStartDialogParam
+{
+	be_t<u32> size;
+	be_t<s32> type;
+	be_t<u32> cid; // Unused
+};
+
+struct CellNetCtlNetStartDialogResult
+{
+	be_t<u32> size;
+	be_t<s32> result;
+};
+
+struct CellNetCtlNatInfo
+{
+	be_t<u32> size;
+	be_t<s32> upnp_status;
+	be_t<s32> stun_status;
+	be_t<s32> nat_type;
+	be_t<u32> mapped_addr;
+};
+
+typedef void(cellNetCtlHandler)(s32 prev_state, s32 new_state, s32 event, s32 error_code, vm::ptr<u32> arg);
+
+inline const char* InfoCodeToName(s32 code)
+{
+	switch (code)
+	{
+	case CELL_NET_CTL_INFO_DEVICE: return "INFO_DEVICE";
+	case CELL_NET_CTL_INFO_ETHER_ADDR: return "INFO_ETHER_ADDR";
+	case CELL_NET_CTL_INFO_MTU: return "INFO_MTU";
+	case CELL_NET_CTL_INFO_LINK: return "INFO_LINK";
+	case CELL_NET_CTL_INFO_LINK_TYPE: return "INFO_LINK_TYPE";
+	case CELL_NET_CTL_INFO_BSSID: return "INFO_BSSID";
+	case CELL_NET_CTL_INFO_SSID: return "INFO_SSID";
+	case CELL_NET_CTL_INFO_WLAN_SECURITY: return "INFO_WLAN_SECURITY";
+	case CELL_NET_CTL_INFO_8021X_TYPE: return "INFO_8021X_TYPE";
+	case CELL_NET_CTL_INFO_8021X_AUTH_NAME: return "INFO_8021X_AUTH_NAME";
+	case CELL_NET_CTL_INFO_RSSI: return "INFO_RSSI";
+	case CELL_NET_CTL_INFO_CHANNEL: return "INFO_CHANNEL";
+	case CELL_NET_CTL_INFO_IP_CONFIG: return "INFO_IP_CONFIG";
+	case CELL_NET_CTL_INFO_DHCP_HOSTNAME: return "INFO_DHCP_HOSTNAME";
+	case CELL_NET_CTL_INFO_PPPOE_AUTH_NAME: return "INFO_PPPOE_AUTH_NAME";
+	case CELL_NET_CTL_INFO_IP_ADDRESS: return "INFO_IP_ADDRESS";
+	case CELL_NET_CTL_INFO_NETMASK: return "INFO_NETMASK";
+	case CELL_NET_CTL_INFO_DEFAULT_ROUTE: return "INFO_DEFAULT_ROUTE";
+	case CELL_NET_CTL_INFO_PRIMARY_DNS: return "INFO_PRIMARY_DNS";
+	case CELL_NET_CTL_INFO_SECONDARY_DNS: return "INFO_SECONDARY_DNS";
+	case CELL_NET_CTL_INFO_HTTP_PROXY_CONFIG: return "INFO_HTTP_PROXY_CONFIG";
+	case CELL_NET_CTL_INFO_HTTP_PROXY_SERVER: return "INFO_HTTP_PROXY_SERVER";
+	case CELL_NET_CTL_INFO_HTTP_PROXY_PORT: return "INFO_HTTP_PROXY_PORT";
+	case CELL_NET_CTL_INFO_UPNP_CONFIG: return "INFO_UPNP_CONFIG";
+	default: return "???";
+	}
+}
+
+enum
+{
+	CELL_GAMEUPDATE_RESULT_STATUS_NO_UPDATE = 0,
+	CELL_GAMEUPDATE_RESULT_STATUS_UPDATE_FOUND = 1,
+	CELL_GAMEUPDATE_RESULT_STATUS_MAINTENANCE = 2,
+	CELL_GAMEUPDATE_RESULT_STATUS_ERROR = 3,
+	CELL_GAMEUPDATE_RESULT_STATUS_CANCELLED = 4,
+	CELL_GAMEUPDATE_RESULT_STATUS_FINISHED = 5,
+	CELL_GAMEUPDATE_RESULT_STATUS_ABORTED = 6,
+	CELL_GAMEUPDATE_RESULT_STATUS_SYSTEM_UPDATE_NEEDED = 7
+};

ps3fw/include/rpcsx/fw/ps3/cellOskDialog.h

@@ -0,0 +1,410 @@
+#pragma once
+
+#include "Emu/Memory/vm_ptr.h"
+#include "util/atomic.hpp"
+#include "util/init_mutex.hpp"
+#include "util/mutex.h"
+#include "util/types.hpp"
+#include <functional>
+#include <string>
+
+// error codes
+enum CellOskDialogError : u32
+{
+	CELL_OSKDIALOG_ERROR_IME_ALREADY_IN_USE = 0x8002b501,
+	CELL_OSKDIALOG_ERROR_GET_SIZE_ERROR = 0x8002b502,
+	CELL_OSKDIALOG_ERROR_UNKNOWN = 0x8002b503,
+	CELL_OSKDIALOG_ERROR_PARAM = 0x8002b504,
+};
+
+// OSK status for the callback
+enum
+{
+	CELL_SYSUTIL_OSKDIALOG_LOADED = 0x0502,
+	CELL_SYSUTIL_OSKDIALOG_FINISHED = 0x0503,
+	CELL_SYSUTIL_OSKDIALOG_UNLOADED = 0x0504,
+	CELL_SYSUTIL_OSKDIALOG_INPUT_ENTERED = 0x0505,
+	CELL_SYSUTIL_OSKDIALOG_INPUT_CANCELED = 0x0506,
+	CELL_SYSUTIL_OSKDIALOG_INPUT_DEVICE_CHANGED = 0x0507,
+	CELL_SYSUTIL_OSKDIALOG_DISPLAY_CHANGED = 0x0508,
+};
+
+enum CellOskDialogInputFieldResult
+{
+	CELL_OSKDIALOG_INPUT_FIELD_RESULT_OK = 0,
+	CELL_OSKDIALOG_INPUT_FIELD_RESULT_CANCELED = 1,
+	CELL_OSKDIALOG_INPUT_FIELD_RESULT_ABORT = 2,
+	CELL_OSKDIALOG_INPUT_FIELD_RESULT_NO_INPUT_TEXT = 3,
+};
+
+enum CellOskDialogInitialKeyLayout
+{
+	CELL_OSKDIALOG_INITIAL_PANEL_LAYOUT_SYSTEM = 0,
+	CELL_OSKDIALOG_INITIAL_PANEL_LAYOUT_10KEY = 1,
+	CELL_OSKDIALOG_INITIAL_PANEL_LAYOUT_FULLKEY = 2,
+};
+
+enum CellOskDialogInputDevice
+{
+	CELL_OSKDIALOG_INPUT_DEVICE_PAD = 0,
+	CELL_OSKDIALOG_INPUT_DEVICE_KEYBOARD = 1,
+};
+
+enum CellOskDialogContinuousMode
+{
+	CELL_OSKDIALOG_CONTINUOUS_MODE_NONE = 0,
+	CELL_OSKDIALOG_CONTINUOUS_MODE_REMAIN_OPEN = 1,
+	CELL_OSKDIALOG_CONTINUOUS_MODE_HIDE = 2,
+	CELL_OSKDIALOG_CONTINUOUS_MODE_SHOW = 3,
+};
+
+enum CellOskDialogDisplayStatus
+{
+	CELL_OSKDIALOG_DISPLAY_STATUS_HIDE = 0,
+	CELL_OSKDIALOG_DISPLAY_STATUS_SHOW = 1,
+};
+
+enum CellOskDialogFilterCallbackReturnValue
+{
+	CELL_OSKDIALOG_NOT_CHANGE = 0,
+	CELL_OSKDIALOG_CHANGE_WORD = 1,
+};
+
+enum CellOskDialogActionValue
+{
+	CELL_OSKDIALOG_CHANGE_NO_EVENT = 0,
+	CELL_OSKDIALOG_CHANGE_EVENT_CANCEL = 1,
+	CELL_OSKDIALOG_CHANGE_WORDS_INPUT = 3,
+	CELL_OSKDIALOG_CHANGE_WORDS_INSERT = 4,
+	CELL_OSKDIALOG_CHANGE_WORDS_REPLACE_ALL = 6,
+};
+
+enum CellOskDialogFinishReason
+{
+	CELL_OSKDIALOG_CLOSE_CONFIRM = 0,
+	CELL_OSKDIALOG_CLOSE_CANCEL = 1,
+};
+
+enum CellOskDialogFinishReasonFake // Helper. Must be negative values.
+{
+	FAKE_CELL_OSKDIALOG_CLOSE_ABORT = -1,
+	FAKE_CELL_OSKDIALOG_CLOSE_TERMINATE = -2,
+};
+
+enum CellOskDialogType
+{
+	CELL_OSKDIALOG_TYPE_SINGLELINE_OSK = 0,
+	CELL_OSKDIALOG_TYPE_MULTILINE_OSK = 1,
+	CELL_OSKDIALOG_TYPE_FULL_KEYBOARD_SINGLELINE_OSK = 2,
+	CELL_OSKDIALOG_TYPE_FULL_KEYBOARD_MULTILINE_OSK = 3,
+	CELL_OSKDIALOG_TYPE_SEPARATE_SINGLELINE_TEXT_WINDOW = 4,
+	CELL_OSKDIALOG_TYPE_SEPARATE_MULTILINE_TEXT_WINDOW = 5,
+	CELL_OSKDIALOG_TYPE_SEPARATE_INPUT_PANEL_WINDOW = 6,
+	CELL_OSKDIALOG_TYPE_SEPARATE_FULL_KEYBOARD_INPUT_PANEL_WINDOW = 7,
+	CELL_OSKDIALOG_TYPE_SEPARATE_CANDIDATE_WINDOW = 8,
+};
+
+enum
+{
+	CELL_OSKDIALOG_STRING_SIZE = 512, // Theroretical maximum for osk input, games
+	                                  // can specify a lower limit
+};
+
+enum
+{
+	CELL_OSKDIALOG_PANELMODE_DEFAULT = 0x00000000,
+	CELL_OSKDIALOG_PANELMODE_GERMAN = 0x00000001,
+	CELL_OSKDIALOG_PANELMODE_ENGLISH = 0x00000002,
+	CELL_OSKDIALOG_PANELMODE_SPANISH = 0x00000004,
+	CELL_OSKDIALOG_PANELMODE_FRENCH = 0x00000008,
+	CELL_OSKDIALOG_PANELMODE_ITALIAN = 0x00000010,
+	CELL_OSKDIALOG_PANELMODE_DUTCH = 0x00000020,
+	CELL_OSKDIALOG_PANELMODE_PORTUGUESE = 0x00000040,
+	CELL_OSKDIALOG_PANELMODE_RUSSIAN = 0x00000080,
+	CELL_OSKDIALOG_PANELMODE_JAPANESE = 0x00000100,
+	CELL_OSKDIALOG_PANELMODE_DEFAULT_NO_JAPANESE = 0x00000200,
+	CELL_OSKDIALOG_PANELMODE_POLISH = 0x00000400,
+	CELL_OSKDIALOG_PANELMODE_KOREAN = 0x00001000,
+	CELL_OSKDIALOG_PANELMODE_TURKEY = 0x00002000,
+	CELL_OSKDIALOG_PANELMODE_TRADITIONAL_CHINESE = 0x00004000,
+	CELL_OSKDIALOG_PANELMODE_SIMPLIFIED_CHINESE = 0x00008000,
+	CELL_OSKDIALOG_PANELMODE_PORTUGUESE_BRAZIL = 0x00010000,
+	CELL_OSKDIALOG_PANELMODE_DANISH = 0x00020000,
+	CELL_OSKDIALOG_PANELMODE_SWEDISH = 0x00040000,
+	CELL_OSKDIALOG_PANELMODE_NORWEGIAN = 0x00080000,
+	CELL_OSKDIALOG_PANELMODE_FINNISH = 0x00100000,
+	CELL_OSKDIALOG_PANELMODE_JAPANESE_HIRAGANA = 0x00200000,
+	CELL_OSKDIALOG_PANELMODE_JAPANESE_KATAKANA = 0x00400000,
+	CELL_OSKDIALOG_PANELMODE_ALPHABET_FULL_WIDTH = 0x00800000,
+	CELL_OSKDIALOG_PANELMODE_ALPHABET = 0x01000000,
+	CELL_OSKDIALOG_PANELMODE_LATIN = 0x02000000,
+	CELL_OSKDIALOG_PANELMODE_NUMERAL_FULL_WIDTH = 0x04000000,
+	CELL_OSKDIALOG_PANELMODE_NUMERAL = 0x08000000,
+	CELL_OSKDIALOG_PANELMODE_URL = 0x10000000,
+	CELL_OSKDIALOG_PANELMODE_PASSWORD = 0x20000000
+};
+
+enum
+{
+	CELL_OSKDIALOG_LAYOUTMODE_X_ALIGN_LEFT = 0x00000200,
+	CELL_OSKDIALOG_LAYOUTMODE_X_ALIGN_CENTER = 0x00000400,
+	CELL_OSKDIALOG_LAYOUTMODE_X_ALIGN_RIGHT = 0x00000800,
+	CELL_OSKDIALOG_LAYOUTMODE_Y_ALIGN_TOP = 0x00001000,
+	CELL_OSKDIALOG_LAYOUTMODE_Y_ALIGN_CENTER = 0x00002000,
+	CELL_OSKDIALOG_LAYOUTMODE_Y_ALIGN_BOTTOM = 0x00004000
+};
+
+enum
+{
+	CELL_OSKDIALOG_NO_SPACE = 0x00000001,
+	CELL_OSKDIALOG_NO_RETURN = 0x00000002,
+	CELL_OSKDIALOG_NO_INPUT_ANALOG = 0x00000008,
+	CELL_OSKDIALOG_NO_STARTUP_EFFECT = 0x00001000,
+};
+
+enum
+{
+	CELL_OSKDIALOG_10KEY_PANEL = 0x00000001,
+	CELL_OSKDIALOG_FULLKEY_PANEL = 0x00000002
+};
+
+enum
+{
+	CELL_OSKDIALOG_DEVICE_MASK_PAD = 0x000000ff
+};
+
+enum
+{
+	CELL_OSKDIALOG_EVENT_HOOK_TYPE_FUNCTION_KEY = 0x00000001,
+	CELL_OSKDIALOG_EVENT_HOOK_TYPE_ASCII_KEY = 0x00000002,
+	CELL_OSKDIALOG_EVENT_HOOK_TYPE_ONLY_MODIFIER = 0x00000004
+};
+
+static const f32 CELL_OSKDIALOG_SCALE_MIN = 0.80f;
+static const f32 CELL_OSKDIALOG_SCALE_MAX = 1.05f;
+
+struct CellOskDialogInputFieldInfo
+{
+	vm::bptr<u16> message;
+	vm::bptr<u16> init_text;
+	be_t<u32> limit_length;
+};
+
+struct CellOskDialogPoint
+{
+	be_t<f32> x;
+	be_t<f32> y;
+};
+
+struct CellOskDialogParam
+{
+	be_t<u32> allowOskPanelFlg;
+	be_t<u32> firstViewPanel;
+	CellOskDialogPoint controlPoint;
+	be_t<s32> prohibitFlgs;
+};
+
+// Actual input data
+struct CellOskDialogCallbackReturnParam
+{
+	be_t<s32> result; // CellOskDialogInputFieldResult
+	be_t<s32> numCharsResultString;
+	vm::bptr<u16> pResultString;
+};
+
+struct CellOskDialogLayoutInfo
+{
+	be_t<s32> layoutMode;
+	CellOskDialogPoint position;
+};
+
+struct CellOskDialogSeparateWindowOption
+{
+	be_t<u32> continuousMode; // CellOskDialogContinuousMode
+	be_t<s32> deviceMask;
+	be_t<s32> inputFieldWindowWidth;
+	be_t<f32> inputFieldBackgroundTrans;
+	vm::bptr<CellOskDialogLayoutInfo> inputFieldLayoutInfo;
+	vm::bptr<CellOskDialogLayoutInfo> inputPanelLayoutInfo;
+	vm::bptr<void> reserved;
+};
+
+struct CellOskDialogKeyMessage
+{
+	be_t<u32> led;
+	be_t<u32> mkey;
+	be_t<u16> keycode;
+};
+
+struct CellOskDialogImeDictionaryInfo
+{
+	be_t<u32> targetLanguage;
+	vm::bcptr<char> dictionaryPath;
+};
+
+using cellOskDialogConfirmWordFilterCallback = int(vm::ptr<u16> pConfirmString,
+	s32 wordLength);
+using cellOskDialogHardwareKeyboardEventHookCallback =
+	class b8(vm::ptr<CellOskDialogKeyMessage> keyMessage, vm::ptr<u32> action,
+		vm::ptr<void> pActionInfo);
+using cellOskDialogForceFinishCallback = class b8();
+
+struct osk_window_layout
+{
+	u32 layout_mode = CELL_OSKDIALOG_LAYOUTMODE_X_ALIGN_LEFT |
+	                  CELL_OSKDIALOG_LAYOUTMODE_Y_ALIGN_TOP;
+	u32 x_align = CELL_OSKDIALOG_LAYOUTMODE_X_ALIGN_LEFT;
+	u32 y_align = CELL_OSKDIALOG_LAYOUTMODE_Y_ALIGN_TOP;
+	f32 x_offset = 0.0f;
+	f32 y_offset = 0.0f;
+
+	std::string to_string() const
+	{
+		return fmt::format("{ layout_mode=0x%x, x_align=0x%x, y_align=0x%x, "
+						   "x_offset=%.2f, y_offset=%.2f }",
+			layout_mode, x_align, y_align, x_offset, y_offset);
+	}
+};
+
+enum class OskDialogState
+{
+	Unloaded,
+	Open,
+	Abort,
+	Closed
+};
+
+class OskDialogBase
+{
+public:
+	struct color
+	{
+		f32 r = 1.0f;
+		f32 g = 1.0f;
+		f32 b = 1.0f;
+		f32 a = 1.0f;
+	};
+
+	struct osk_params
+	{
+		std::string title;
+		std::u16string message;
+		char16_t* init_text = nullptr;
+		u32 charlimit = 0;
+		u32 prohibit_flags = 0;
+		u32 panel_flag = 0;
+		u32 support_language = 0;
+		u32 first_view_panel = 0;
+		osk_window_layout layout{};
+		osk_window_layout input_layout{}; // Only used with separate windows
+		osk_window_layout panel_layout{}; // Only used with separate windows
+		u32 input_field_window_width = 0; // Only used with separate windows
+		f32 input_field_background_transparency =
+			1.0f; // Only used with separate windows
+		f32 initial_scale = 1.0f;
+		color base_color{};
+		bool dimmer_enabled = false;
+		bool use_separate_windows = false;
+		bool intercept_input = false;
+	};
+
+	virtual void Create(const osk_params& params) = 0;
+	virtual void Clear(bool clear_all_data) = 0;
+	virtual void Insert(const std::u16string& text) = 0;
+	virtual void SetText(const std::u16string& text) = 0;
+
+	// Closes the dialog.
+	// Set status to CELL_OSKDIALOG_CLOSE_CONFIRM or CELL_OSKDIALOG_CLOSE_CANCEL
+	// for user input. Set status to -1 if closed by the game or system. Set
+	// status to -2 if terminated by the system.
+	virtual void Close(s32 status) = 0;
+	virtual ~OskDialogBase() {};
+
+	std::function<void(s32 status)> on_osk_close;
+	std::function<void(CellOskDialogKeyMessage key_message)>
+		on_osk_key_input_entered;
+
+	atomic_t<OskDialogState> state{OskDialogState::Unloaded};
+	atomic_t<CellOskDialogContinuousMode> continuous_mode{
+		CELL_OSKDIALOG_CONTINUOUS_MODE_NONE};
+	atomic_t<CellOskDialogInputDevice> input_device{
+		CELL_OSKDIALOG_INPUT_DEVICE_PAD}; // The current input device.
+	atomic_t<bool> pad_input_enabled{
+		true}; // Determines if the OSK consumes the device's input.
+	atomic_t<bool> mouse_input_enabled{
+		true}; // Determines if the OSK consumes the device's input.
+	atomic_t<bool> keyboard_input_enabled{
+		true}; // Determines if the OSK consumes the device's input.
+	atomic_t<bool> ignore_device_events{
+		false}; // Determines if the OSK ignores device events.
+
+	atomic_t<CellOskDialogInputFieldResult> osk_input_result{
+		CellOskDialogInputFieldResult::CELL_OSKDIALOG_INPUT_FIELD_RESULT_OK};
+	std::array<char16_t, CELL_OSKDIALOG_STRING_SIZE> osk_text{};
+};
+
+struct osk_info
+{
+	std::shared_ptr<OskDialogBase> dlg;
+
+	std::array<char16_t, CELL_OSKDIALOG_STRING_SIZE>
+		valid_text{}; // The string that's going to be served to the game.
+	shared_mutex text_mtx;
+
+	atomic_t<bool> use_separate_windows = false;
+
+	atomic_t<bool> lock_ext_input_device = false;
+	atomic_t<u32> device_mask =
+		0; // OSK ignores input from the specified devices. 0 means all devices
+	       // can influence the OSK
+	atomic_t<u32> input_field_window_width = 0;
+	atomic_t<f32> input_field_background_transparency = 1.0f;
+	osk_window_layout input_field_layout_info{};
+	osk_window_layout input_panel_layout_info{};
+	atomic_t<u32> key_layout_options = CELL_OSKDIALOG_10KEY_PANEL;
+	atomic_t<CellOskDialogInitialKeyLayout> initial_key_layout =
+		CELL_OSKDIALOG_INITIAL_PANEL_LAYOUT_SYSTEM; // TODO: use
+	atomic_t<CellOskDialogInputDevice> initial_input_device =
+		CELL_OSKDIALOG_INPUT_DEVICE_PAD; // OSK at first only receives input from
+	                                     // the initial device
+
+	atomic_t<bool> clipboard_enabled = false; // For copy and paste
+	atomic_t<bool> half_byte_kana_enabled = false;
+	atomic_t<u32> supported_languages =
+		0; // Used to enable non-default languages in the OSK
+
+	atomic_t<bool> dimmer_enabled = true;
+	atomic_t<OskDialogBase::color> base_color =
+		OskDialogBase::color{0.2f, 0.2f, 0.2f, 1.0f};
+
+	atomic_t<bool> pointer_enabled = false;
+	atomic_t<f32> pointer_x = 0.0f;
+	atomic_t<f32> pointer_y = 0.0f;
+	atomic_t<f32> initial_scale = 1.0f;
+
+	osk_window_layout layout = {};
+
+	atomic_t<CellOskDialogContinuousMode> osk_continuous_mode =
+		CELL_OSKDIALOG_CONTINUOUS_MODE_NONE;
+	atomic_t<u32> last_dialog_state =
+		CELL_SYSUTIL_OSKDIALOG_UNLOADED; // Used for continuous seperate window
+	                                     // dialog
+
+	atomic_t<vm::ptr<cellOskDialogConfirmWordFilterCallback>>
+		osk_confirm_callback{};
+	atomic_t<vm::ptr<cellOskDialogForceFinishCallback>>
+		osk_force_finish_callback{};
+	atomic_t<vm::ptr<cellOskDialogHardwareKeyboardEventHookCallback>>
+		osk_hardware_keyboard_event_hook_callback{};
+	atomic_t<u16> hook_event_mode{0};
+
+	stx::init_mutex init;
+
+	void reset();
+
+	// Align horizontally
+	static u32 get_aligned_x(u32 layout_mode);
+
+	// Align vertically
+	static u32 get_aligned_y(u32 layout_mode);
+};

ps3fw/include/rpcsx/fw/ps3/cellPad.h

@@ -0,0 +1,145 @@
+#pragma once
+
+#include "Emu/Io/pad_types.h"
+
+#include <array>
+#include "util/types.hpp"
+
+enum CellPadError : u32
+{
+	CELL_PAD_ERROR_FATAL = 0x80121101,
+	CELL_PAD_ERROR_INVALID_PARAMETER = 0x80121102,
+	CELL_PAD_ERROR_ALREADY_INITIALIZED = 0x80121103,
+	CELL_PAD_ERROR_UNINITIALIZED = 0x80121104,
+	CELL_PAD_ERROR_RESOURCE_ALLOCATION_FAILED = 0x80121105,
+	CELL_PAD_ERROR_DATA_READ_FAILED = 0x80121106,
+	CELL_PAD_ERROR_NO_DEVICE = 0x80121107,
+	CELL_PAD_ERROR_UNSUPPORTED_GAMEPAD = 0x80121108,
+	CELL_PAD_ERROR_TOO_MANY_DEVICES = 0x80121109,
+	CELL_PAD_ERROR_EBUSY = 0x8012110a,
+};
+
+enum CellPadFilterError : u32
+{
+	CELL_PADFILTER_ERROR_INVALID_PARAMETER = 0x80121401,
+};
+
+// Length returned in CellPadData struct
+enum
+{
+	CELL_PAD_LEN_NO_CHANGE = 0,
+	CELL_PAD_LEN_CHANGE_DEFAULT = 8,
+	CELL_PAD_LEN_CHANGE_PRESS_ON = 20,
+	CELL_PAD_LEN_CHANGE_SENSOR_ON = 24,
+};
+
+enum
+{
+	CELL_PADFILTER_IIR_CUTOFF_2ND_LPF_BT_050 = 0, // 50% Nyquist frequency
+	CELL_PADFILTER_IIR_CUTOFF_2ND_LPF_BT_020 = 1, // 20% Nyquist frequency
+	CELL_PADFILTER_IIR_CUTOFF_2ND_LPF_BT_010 = 2, // 10% Nyquist frequency
+};
+
+struct pad_data_internal
+{
+	u16 vendor_id;
+	u16 product_id;
+	u32 port_status;
+	u32 device_capability;
+	u32 device_type;
+	u32 pclass_type;
+	u32 pclass_profile;
+
+	ENABLE_BITWISE_SERIALIZATION;
+};
+
+struct CellPadInfo
+{
+	be_t<u32> max_connect;
+	be_t<u32> now_connect;
+	be_t<u32> system_info;
+	be_t<u16> vendor_id[CELL_MAX_PADS];
+	be_t<u16> product_id[CELL_MAX_PADS];
+	u8 status[CELL_MAX_PADS];
+};
+
+struct CellPadInfo2
+{
+	be_t<u32> max_connect;
+	be_t<u32> now_connect;
+	be_t<u32> system_info;
+	be_t<u32> port_status[CELL_PAD_MAX_PORT_NUM];
+	be_t<u32> port_setting[CELL_PAD_MAX_PORT_NUM];
+	be_t<u32> device_capability[CELL_PAD_MAX_PORT_NUM];
+	be_t<u32> device_type[CELL_PAD_MAX_PORT_NUM];
+};
+
+struct CellPadPeriphInfo
+{
+	be_t<u32> max_connect;
+	be_t<u32> now_connect;
+	be_t<u32> system_info;
+	be_t<u32> port_status[CELL_PAD_MAX_PORT_NUM];
+	be_t<u32> port_setting[CELL_PAD_MAX_PORT_NUM];
+	be_t<u32> device_capability[CELL_PAD_MAX_PORT_NUM];
+	be_t<u32> device_type[CELL_PAD_MAX_PORT_NUM];
+	be_t<u32> pclass_type[CELL_PAD_MAX_PORT_NUM];
+	be_t<u32> pclass_profile[CELL_PAD_MAX_PORT_NUM];
+};
+
+struct CellPadPeriphData
+{
+	be_t<u32> pclass_type;
+	be_t<u32> pclass_profile;
+	CellPadData cellpad_data;
+};
+
+struct CellPadCapabilityInfo
+{
+	be_t<u32> info[CELL_PAD_MAX_CAPABILITY_INFO];
+};
+
+struct CellPadActParam
+{
+	u8 motor[CELL_PAD_ACTUATOR_MAX];
+	u8 reserved[6];
+};
+
+struct CellPadFilterIIRSos
+{
+	be_t<s32> u[3];
+	be_t<s32> a1;
+	be_t<s32> a2;
+	be_t<s32> b0;
+	be_t<s32> b1;
+	be_t<s32> b2;
+};
+
+struct pad_info
+{
+	atomic_t<u32> max_connect = 0;
+	std::array<u32, CELL_PAD_MAX_PORT_NUM> port_setting{0};
+	std::array<pad_data_internal, CELL_PAD_MAX_PORT_NUM> reported_info{};
+
+	SAVESTATE_INIT_POS(11);
+
+	pad_info() = default;
+	pad_info(utils::serial& ar);
+	void save(utils::serial& ar);
+
+	u32 get_max_connect() const
+	{
+		return std::min<u32>(max_connect, CELL_PAD_MAX_PORT_NUM);
+	}
+
+	// Unreliable way the firmware uses to optimize away pad calls for disconnected pads
+	// This result relies on data updates from config events on a dedicated thread to receive them
+	bool is_reportedly_connected(u32 port_no) const
+	{
+		return port_no < get_max_connect() && !!(reported_info[port_no].port_status & CELL_PAD_STATUS_CONNECTED);
+	}
+};
+
+error_code cellPadGetData(u32 port_no, vm::ptr<CellPadData> data);
+error_code cellPadInit(ppu_thread& ppu, u32 max_connect);
+error_code cellPadSetPortSetting(u32 port_no, u32 port_setting);

ps3fw/include/rpcsx/fw/ps3/cellPamf.h

@@ -0,0 +1,939 @@
+#pragma once
+
+#include "Emu/Cell/ErrorCodes.h"
+#include "Emu/Memory/vm_ptr.h"
+
+#include <mutex>
+#include <condition_variable>
+
+// Error Codes
+enum CellPamfError : u32
+{
+	CELL_PAMF_ERROR_STREAM_NOT_FOUND = 0x80610501,
+	CELL_PAMF_ERROR_INVALID_PAMF = 0x80610502,
+	CELL_PAMF_ERROR_INVALID_ARG = 0x80610503,
+	CELL_PAMF_ERROR_UNKNOWN_TYPE = 0x80610504,
+	CELL_PAMF_ERROR_UNSUPPORTED_VERSION = 0x80610505,
+	CELL_PAMF_ERROR_UNKNOWN_STREAM = 0x80610506,
+	CELL_PAMF_ERROR_EP_NOT_FOUND = 0x80610507,
+	CELL_PAMF_ERROR_NOT_AVAILABLE = 0x80610508,
+};
+
+// PamfReaderInitialize Attribute Flags
+enum
+{
+	CELL_PAMF_ATTRIBUTE_VERIFY_ON = 1,
+	CELL_PAMF_ATTRIBUTE_MINIMUM_HEADER = 2,
+};
+
+enum CellPamfStreamType
+{
+	CELL_PAMF_STREAM_TYPE_AVC = 0,
+	CELL_PAMF_STREAM_TYPE_M2V = 1,
+	CELL_PAMF_STREAM_TYPE_ATRAC3PLUS = 2,
+	CELL_PAMF_STREAM_TYPE_PAMF_LPCM = 3,
+	CELL_PAMF_STREAM_TYPE_AC3 = 4,
+	CELL_PAMF_STREAM_TYPE_USER_DATA = 5,
+	CELL_PAMF_STREAM_TYPE_PSMF_AVC = 6,
+	CELL_PAMF_STREAM_TYPE_PSMF_ATRAC3PLUS = 7,
+	CELL_PAMF_STREAM_TYPE_PSMF_LPCM = 8,
+	CELL_PAMF_STREAM_TYPE_PSMF_USER_DATA = 9,
+	CELL_PAMF_STREAM_TYPE_VIDEO = 20,
+	CELL_PAMF_STREAM_TYPE_AUDIO = 21,
+	CELL_PAMF_STREAM_TYPE_UNK = 22,
+};
+
+enum PamfStreamCodingType : u8
+{
+	PAMF_STREAM_CODING_TYPE_M2V = 0x02,
+	PAMF_STREAM_CODING_TYPE_AVC = 0x1b,
+	PAMF_STREAM_CODING_TYPE_PAMF_LPCM = 0x80,
+	PAMF_STREAM_CODING_TYPE_AC3 = 0x81,
+	PAMF_STREAM_CODING_TYPE_ATRAC3PLUS = 0xdc,
+	PAMF_STREAM_CODING_TYPE_USER_DATA = 0xdd,
+	PAMF_STREAM_CODING_TYPE_PSMF = 0xff,
+};
+
+enum
+{
+	CELL_PAMF_FS_48kHz = 1,
+};
+
+enum
+{
+	CELL_PAMF_BIT_LENGTH_16 = 1,
+	CELL_PAMF_BIT_LENGTH_24 = 3,
+};
+
+enum
+{
+	CELL_PAMF_AVC_PROFILE_MAIN = 77,
+	CELL_PAMF_AVC_PROFILE_HIGH = 100,
+};
+
+enum
+{
+	CELL_PAMF_AVC_LEVEL_2P1 = 21,
+	CELL_PAMF_AVC_LEVEL_3P0 = 30,
+	CELL_PAMF_AVC_LEVEL_3P1 = 31,
+	CELL_PAMF_AVC_LEVEL_3P2 = 32,
+	CELL_PAMF_AVC_LEVEL_4P1 = 41,
+	CELL_PAMF_AVC_LEVEL_4P2 = 42,
+};
+
+enum
+{
+	CELL_PAMF_AVC_FRC_24000DIV1001 = 0,
+	CELL_PAMF_AVC_FRC_24 = 1,
+	CELL_PAMF_AVC_FRC_25 = 2,
+	CELL_PAMF_AVC_FRC_30000DIV1001 = 3,
+	CELL_PAMF_AVC_FRC_30 = 4,
+	CELL_PAMF_AVC_FRC_50 = 5,
+	CELL_PAMF_AVC_FRC_60000DIV1001 = 6,
+};
+
+enum
+{
+	CELL_PAMF_M2V_MP_ML = 1,
+	CELL_PAMF_M2V_MP_H14 = 2,
+	CELL_PAMF_M2V_MP_HL = 3,
+	CELL_PAMF_M2V_UNKNOWN = 255,
+};
+
+enum
+{
+	CELL_PAMF_M2V_FRC_24000DIV1001 = 1,
+	CELL_PAMF_M2V_FRC_24 = 2,
+	CELL_PAMF_M2V_FRC_25 = 3,
+	CELL_PAMF_M2V_FRC_30000DIV1001 = 4,
+	CELL_PAMF_M2V_FRC_30 = 5,
+	CELL_PAMF_M2V_FRC_50 = 6,
+	CELL_PAMF_M2V_FRC_60000DIV1001 = 7,
+};
+
+enum
+{
+	CELL_PAMF_ASPECT_RATIO_1_1 = 1,
+	CELL_PAMF_ASPECT_RATIO_12_11 = 2,
+	CELL_PAMF_ASPECT_RATIO_10_11 = 3,
+	CELL_PAMF_ASPECT_RATIO_16_11 = 4,
+	CELL_PAMF_ASPECT_RATIO_40_33 = 5,
+	CELL_PAMF_ASPECT_RATIO_4_3 = 14,
+};
+
+enum
+{
+	CELL_PAMF_COLOUR_PRIMARIES_ITR_R_BT_709 = 1,
+	CELL_PAMF_COLOUR_PRIMARIES_UNSPECIFIED = 2,
+	CELL_PAMF_COLOUR_PRIMARIES_ITU_R_BT_470_SYS_M = 4,
+	CELL_PAMF_COLOUR_PRIMARIES_ITU_R_BT_470_SYS_BG = 5,
+	CELL_PAMF_COLOUR_PRIMARIES_SMPTE_170_M = 6,
+	CELL_PAMF_COLOUR_PRIMARIES_SMPTE_240_M = 7,
+	CELL_PAMF_COLOUR_PRIMARIES_GENERIC_FILM = 8,
+};
+
+enum
+{
+	CELL_PAMF_TRANSFER_CHARACTERISTICS_ITU_R_BT_709 = 1,
+	CELL_PAMF_TRANSFER_CHARACTERISTICS_UNSPECIFIED = 2,
+	CELL_PAMF_TRANSFER_CHARACTERISTICS_ITU_R_BT_470_SYS_M = 4,
+	CELL_PAMF_TRANSFER_CHARACTERISTICS_ITU_R_BT_470_SYS_BG = 5,
+	CELL_PAMF_TRANSFER_CHARACTERISTICS_SMPTE_170_M = 6,
+	CELL_PAMF_TRANSFER_CHARACTERISTICS_SMPTE_240_M = 7,
+	CELL_PAMF_TRANSFER_CHARACTERISTICS_LINEAR = 8,
+	CELL_PAMF_TRANSFER_CHARACTERISTICS_LOG_100_1 = 9,
+	CELL_PAMF_TRANSFER_CHARACTERISTICS_LOG_316_1 = 10,
+};
+
+enum
+{
+	CELL_PAMF_MATRIX_GBR = 0,
+	CELL_PAMF_MATRIX_ITU_R_BT_709 = 1,
+	CELL_PAMF_MATRIX_UNSPECIFIED = 2,
+	CELL_PAMF_MATRIX_FCC = 4,
+	CELL_PAMF_MATRIX_ITU_R_BT_470_SYS_BG = 5,
+	CELL_PAMF_MATRIX_SMPTE_170_M = 6,
+	CELL_PAMF_MATRIX_SMPTE_240_M = 7,
+	CELL_PAMF_MATRIX_YCGCO = 8,
+};
+
+// Timestamp information (time in increments of 90 kHz)
+struct CellCodecTimeStamp
+{
+	be_t<u32> upper;
+	be_t<u32> lower;
+};
+
+constexpr u32 CODEC_TS_INVALID = umax;
+
+// Entry point information
+struct CellPamfEp
+{
+	be_t<u32> indexN;
+	be_t<u32> nThRefPictureOffset;
+	CellCodecTimeStamp pts;
+	be_t<u64> rpnOffset;
+};
+
+struct CellPamfEpUnk // Speculative name, only used in two undocumented functions
+{
+	CellPamfEp ep;
+	be_t<u64> nextRpnOffset;
+};
+
+CHECK_SIZE(CellPamfEpUnk, 0x20);
+
+// Entry point iterator
+struct CellPamfEpIterator
+{
+	b8 isPamf;
+	be_t<u32> index;
+	be_t<u32> num;
+	vm::bcptr<void> pCur;
+};
+
+struct CellCodecEsFilterId
+{
+	be_t<u32> filterIdMajor;
+	be_t<u32> filterIdMinor;
+	be_t<u32> supplementalInfo1;
+	be_t<u32> supplementalInfo2;
+};
+
+// AVC (MPEG4 AVC Video) Specific Information
+struct CellPamfAvcInfo
+{
+	u8 profileIdc;
+	u8 levelIdc;
+	u8 frameMbsOnlyFlag;
+	u8 videoSignalInfoFlag;
+	u8 frameRateInfo;
+	u8 aspectRatioIdc;
+	be_t<u16> sarWidth;
+	be_t<u16> sarHeight;
+	be_t<u16> horizontalSize;
+	be_t<u16> verticalSize;
+	be_t<u16> frameCropLeftOffset;
+	be_t<u16> frameCropRightOffset;
+	be_t<u16> frameCropTopOffset;
+	be_t<u16> frameCropBottomOffset;
+	u8 videoFormat;
+	u8 videoFullRangeFlag;
+	u8 colourPrimaries;
+	u8 transferCharacteristics;
+	u8 matrixCoefficients;
+	u8 entropyCodingModeFlag;
+	u8 deblockingFilterFlag;
+	u8 minNumSlicePerPictureIdc;
+	u8 nfwIdc;
+	u8 maxMeanBitrate;
+};
+
+CHECK_SIZE(CellPamfAvcInfo, 0x20);
+
+// M2V (MPEG2 Video) Specific Information
+struct CellPamfM2vInfo
+{
+	u8 profileAndLevelIndication;
+	u8 progressiveSequence;
+	u8 videoSignalInfoFlag;
+	u8 frameRateInfo;
+	u8 aspectRatioIdc;
+	be_t<u16> sarWidth;
+	be_t<u16> sarHeight;
+	be_t<u16> horizontalSize;
+	be_t<u16> verticalSize;
+	be_t<u16> horizontalSizeValue;
+	be_t<u16> verticalSizeValue;
+	u8 videoFormat;
+	u8 videoFullRangeFlag;
+	u8 colourPrimaries;
+	u8 transferCharacteristics;
+	u8 matrixCoefficients;
+};
+
+CHECK_SIZE(CellPamfM2vInfo, 0x18);
+
+// ATRAC3+ Audio Specific Information
+struct CellPamfAtrac3plusInfo
+{
+	be_t<u32> samplingFrequency;
+	u8 numberOfChannels;
+};
+
+CHECK_SIZE(CellPamfAtrac3plusInfo, 8);
+
+// AC3 Audio Specific Information
+struct CellPamfAc3Info
+{
+	be_t<u32> samplingFrequency;
+	u8 numberOfChannels;
+};
+
+CHECK_SIZE(CellPamfAc3Info, 8);
+
+// LPCM Audio Specific Information
+struct CellPamfLpcmInfo
+{
+	be_t<u32> samplingFrequency;
+	u8 numberOfChannels;
+	be_t<u16> bitsPerSample;
+};
+
+CHECK_SIZE(CellPamfLpcmInfo, 8);
+
+// PAMF file structs, everything here is not aligned (LLE uses exclusively u8 pointers)
+
+struct PamfStreamHeader
+{
+	u8 stream_coding_type;
+
+	u8 reserved[3];
+
+	u8 stream_id;
+	u8 private_stream_id; // for streams multiplexed as private data streams (stream_id == 0xbd)
+
+	be_t<u16, 1> p_std_buffer; // 2 bits: unused ??? "00", 1 bit: P_STD_buffer_scale, 13 bits: P_STD_buffer_size
+
+	be_t<u32, 1> ep_offset; // offset of EP section in header
+	be_t<u32, 1> ep_num;    // count of EPs
+
+	union
+	{
+		u8 data[32]; // specific info
+
+		// AVC specific information
+		struct
+		{
+			u8 profileIdc;
+			u8 levelIdc;
+			u8 x2; // contains frameMbsOnlyFlag, videoSignalInfoFlag, frameRateInfo
+			u8 aspectRatioIdc;
+			be_t<u16, 1> sarWidth;
+			be_t<u16, 1> sarHeight;
+			u8 reserved1;
+			u8 horizontalSize; // divided by 16
+			u8 reserved2;
+			u8 verticalSize; // divided by 16
+			be_t<u16, 1> frameCropLeftOffset;
+			be_t<u16, 1> frameCropRightOffset;
+			be_t<u16, 1> frameCropTopOffset;
+			be_t<u16, 1> frameCropBottomOffset;
+			u8 x14; // contains videoFormat and videoFullRangeFlag
+			u8 colourPrimaries;
+			u8 transferCharacteristics;
+			u8 matrixCoefficients;
+			u8 x18; // contains entropyCodingModeFlag, deblockingFilterFlag, minNumSlicePerPictureIdc, nfwIdc
+			u8 maxMeanBitrate;
+		} AVC;
+
+		// M2V specific information
+		struct
+		{
+			s8 x0; // contains profileAndLevelIndication
+			u8 x1; // not used
+			u8 x2; // contains progressiveSequence, videoSignalInfoFlag, frameRateInfo
+			u8 aspectRatioIdc;
+			be_t<u16, 1> sarWidth;
+			be_t<u16, 1> sarHeight;
+			u8 reserved1;
+			u8 horizontalSize; // in units of 16 pixels
+			u8 reserved2;
+			u8 verticalSize; // in units of 16 pixels
+			be_t<u16, 1> horizontalSizeValue;
+			be_t<u16, 1> verticalSizeValue;
+			be_t<u32, 1> x10; // not used
+			u8 x14;           // contains videoFormat and videoFullRangeFlag
+			u8 colourPrimaries;
+			u8 transferCharacteristics;
+			u8 matrixCoefficients;
+		} M2V;
+
+		// Audio specific information
+		struct
+		{
+			be_t<u16, 1> unknown; // 0
+			u8 channels;          // number of channels (1, 2, 6, 8)
+			u8 freq;              // 1 (always 48000)
+			u8 bps;               // LPCM only
+		} audio;
+	};
+};
+
+CHECK_SIZE_ALIGN(PamfStreamHeader, 48, 1);
+
+struct PamfGroup
+{
+	be_t<u32, 1> size; // doesn't include this field
+
+	u8 reserved;
+
+	u8 stream_num; // same value as in PamfSequenceInfo
+	PamfStreamHeader streams;
+};
+
+CHECK_SIZE_ALIGN(PamfGroup, 6 + sizeof(PamfStreamHeader), 1);
+
+struct PamfGroupingPeriod
+{
+	be_t<u32, 1> size; // doesn't include this field
+
+	be_t<u16, 1> start_pts_high; // always 0, greatest valid pts is UINT32_MAX
+	be_t<u32, 1> start_pts_low;  // same value as in PamfSequenceInfo, since there is only one PamfGroupingPeriod
+	be_t<u16, 1> end_pts_high;   // unused due to bug
+	be_t<u32, 1> end_pts_low;    // same value as in PamfSequenceInfo, since there is only one PamfGroupingPeriod
+
+	u8 reserved;
+
+	u8 group_num; // always 1
+	PamfGroup groups;
+};
+
+CHECK_SIZE_ALIGN(PamfGroupingPeriod, 0x12 + sizeof(PamfGroup), 1);
+
+struct PamfSequenceInfo
+{
+	be_t<u32, 1> size; // doesn't include this field
+
+	be_t<u16, 1> reserved1;
+
+	be_t<u16, 1> start_pts_high; // always 0, greatest valid pts is UINT32_MAX
+	be_t<u32, 1> start_pts_low;  // Presentation Time Stamp (start)
+	be_t<u16, 1> end_pts_high;   // always 0, greatest valid pts is UINT32_MAX
+	be_t<u32, 1> end_pts_low;    // Presentation Time Stamp (end)
+
+	be_t<u32, 1> mux_rate_bound;  // multiplex bitrate in units of 50 bytes per second
+	be_t<u32, 1> std_delay_bound; // buffer delay in units of 1/90000 seconds
+
+	be_t<u32, 1> total_stream_num; // across all groups; since there is always only one group, this is equal stream_count in PamfGroup
+
+	u8 reserved2;
+
+	u8 grouping_period_num; // always 1
+	PamfGroupingPeriod grouping_periods;
+};
+
+CHECK_SIZE_ALIGN(PamfSequenceInfo, 0x20 + sizeof(PamfGroupingPeriod), 1);
+
+struct PamfHeader
+{
+	be_t<u32, 1> magic;       // "PAMF"
+	be_t<u32, 1> version;     // "0040" or "0041"
+	be_t<u32, 1> header_size; // in units of 2048 bytes
+	be_t<u32, 1> data_size;   // in units of 2048 bytes
+
+	be_t<u32, 1> psmf_marks_offset; // always 0
+	be_t<u32, 1> psmf_marks_size;   // always 0
+	be_t<u32, 1> unk_offset;        // always 0
+	be_t<u32, 1> unk_size;          // always 0
+
+	u8 reserved[0x30];
+
+	PamfSequenceInfo seq_info;
+};
+
+CHECK_SIZE_ALIGN(PamfHeader, 0x50 + sizeof(PamfSequenceInfo), 1);
+
+struct PamfEpHeader
+{
+	be_t<u16, 1> value0;   // 2 bits: indexN, 1 bit: unused, 13 bits: nThRefPictureOffset in units of 2048 bytes
+	be_t<u16, 1> pts_high; // always 0, greatest valid pts is UINT32_MAX
+	be_t<u32, 1> pts_low;
+	be_t<u32, 1> rpnOffset; // in units of 2048 bytes
+};
+
+CHECK_SIZE_ALIGN(PamfEpHeader, 12, 1);
+
+// PSMF specific
+
+struct PsmfStreamHeader
+{
+	u8 stream_id;
+	u8 private_stream_id; // for streams multiplexed as private data streams (stream_id == 0xbd)
+
+	be_t<u16, 1> p_std_buffer; // 2 bits: unused ??? "00", 1 bit: P_STD_buffer_scale, 13 bits: P_STD_buffer_size
+
+	be_t<u32, 1> ep_offset; // offset of EP section in header
+	be_t<u32, 1> ep_num;    // count of EPs
+
+	union
+	{
+		// Video specific information
+		struct
+		{
+			u8 horizontalSize; // in units of 16 pixels
+			u8 verticalSize;   // in units of 16 pixels
+		} video;
+
+		// Audio specific information
+		struct
+		{
+			be_t<u16, 1> unknown;    // 0
+			u8 channelConfiguration; // 1 = mono, 2 = stereo
+			u8 samplingFrequency;    // 2 = 44.1kHz
+		} audio;
+	};
+};
+
+CHECK_SIZE_ALIGN(PsmfStreamHeader, 0x10, 1);
+
+struct PsmfGroup
+{
+	be_t<u32, 1> size; // doesn't include this field
+
+	u8 reserved;
+
+	u8 stream_num; // same value as in PsmfSequenceInfo
+	PsmfStreamHeader streams;
+};
+
+CHECK_SIZE_ALIGN(PsmfGroup, 6 + sizeof(PsmfStreamHeader), 1);
+
+struct PsmfGroupingPeriod
+{
+	be_t<u32, 1> size; // doesn't include this field
+
+	be_t<u16, 1> start_pts_high; // always 0, greatest valid pts is UINT32_MAX
+	be_t<u32, 1> start_pts_low;  // same value as in PsmfSequenceInfo, since there is only one PsmfGroupingPeriod
+	be_t<u16, 1> end_pts_high;   // unused due to bug
+	be_t<u32, 1> end_pts_low;    // same value as in PsmfSequenceInfo, since there is only one PsmfGroupingPeriod
+
+	u8 reserved;
+
+	u8 group_num; // always 1
+	PsmfGroup groups;
+};
+
+CHECK_SIZE_ALIGN(PsmfGroupingPeriod, 0x12 + sizeof(PsmfGroup), 1);
+
+struct PsmfSequenceInfo
+{
+	be_t<u32, 1> size; // doesn't include this field
+
+	be_t<u16, 1> start_pts_high; // always 0, greatest valid pts is UINT32_MAX
+	be_t<u32, 1> start_pts_low;  // Presentation Time Stamp (start)
+	be_t<u16, 1> end_pts_high;   // always 0, greatest valid pts is UINT32_MAX
+	be_t<u32, 1> end_pts_low;    // Presentation Time Stamp (end)
+
+	be_t<u32, 1> mux_rate_bound;  // multiplex bitrate in units of 50 bytes per second
+	be_t<u32, 1> std_delay_bound; // buffer delay in units of 1/90000 seconds
+
+	u8 total_stream_num; // across all groups; since there is always only one group, this is equal stream_count in PsmfGroup
+
+	u8 grouping_period_num; // always 1
+	PsmfGroupingPeriod grouping_periods;
+};
+
+CHECK_SIZE_ALIGN(PsmfSequenceInfo, 0x1a + sizeof(PsmfGroupingPeriod), 1);
+
+struct PsmfHeader
+{
+	be_t<u32, 1> magic;       // "PSMF"
+	be_t<u32, 1> version;     // "0012", "0013", "0014" or "0015"
+	be_t<u32, 1> header_size; // not scaled, unlike PAMF
+	be_t<u32, 1> data_size;   // not scaled, unlike PAMF
+
+	be_t<u32, 1> psmf_marks_offset;
+	be_t<u32, 1> psmf_marks_size;
+	be_t<u32, 1> unk[2];
+
+	u8 reserved[0x30];
+
+	PsmfSequenceInfo seq_info;
+};
+
+CHECK_SIZE_ALIGN(PsmfHeader, 0x50 + sizeof(PsmfSequenceInfo), 1);
+
+struct PsmfEpHeader
+{
+	be_t<u16, 1> value0; // 2 bits: indexN, 2 bits: unused, 11 bits: nThRefPictureOffset in units of 1024 bytes, 1 bit: pts_high
+	be_t<u32, 1> pts_low;
+	be_t<u32, 1> rpnOffset; // in units of 2048 bytes
+};
+
+CHECK_SIZE_ALIGN(PsmfEpHeader, 10, 1);
+
+struct CellPamfReader
+{
+	be_t<u64> headerSize;
+	be_t<u64> dataSize;
+	be_t<u32> attribute;
+	be_t<u16> isPsmf;
+	be_t<u16> version;
+	be_t<u32> currentGroupingPeriodIndex;
+	be_t<u32> currentGroupIndex;
+	be_t<u32> currentStreamIndex;
+
+	union
+	{
+		struct
+		{
+			vm::bcptr<PamfHeader> header;
+			vm::bcptr<PamfSequenceInfo> sequenceInfo;
+			vm::bcptr<PamfGroupingPeriod> currentGroupingPeriod;
+			vm::bcptr<PamfGroup> currentGroup;
+			vm::bcptr<PamfStreamHeader> currentStream;
+		} pamf;
+
+		struct
+		{
+			vm::bcptr<PsmfHeader> header;
+			vm::bcptr<PsmfSequenceInfo> sequenceInfo;
+			vm::bcptr<PsmfGroupingPeriod> currentGroupingPeriod;
+			vm::bcptr<PsmfGroup> currentGroup;
+			vm::bcptr<PsmfStreamHeader> currentStream;
+		} psmf;
+	};
+
+	u32 reserved[18];
+};
+
+CHECK_SIZE(CellPamfReader, 128);
+
+error_code cellPamfReaderInitialize(vm::ptr<CellPamfReader> pSelf, vm::cptr<PamfHeader> pAddr, u64 fileSize, u32 attribute);
+
+extern const std::function<bool()> SQUEUE_ALWAYS_EXIT;
+extern const std::function<bool()> SQUEUE_NEVER_EXIT;
+
+bool squeue_test_exit();
+
+// TODO: eliminate this boolshit
+template <typename T, u32 sq_size = 256>
+class squeue_t
+{
+	struct squeue_sync_var_t
+	{
+		struct
+		{
+			u32 position : 31;
+			u32 pop_lock : 1;
+		};
+		struct
+		{
+			u32 count : 31;
+			u32 push_lock : 1;
+		};
+	};
+
+	atomic_t<squeue_sync_var_t> m_sync;
+
+	mutable std::mutex m_rcv_mutex;
+	mutable std::mutex m_wcv_mutex;
+	mutable std::condition_variable m_rcv;
+	mutable std::condition_variable m_wcv;
+
+	T m_data[sq_size];
+
+	enum squeue_sync_var_result : u32
+	{
+		SQSVR_OK = 0,
+		SQSVR_LOCKED = 1,
+		SQSVR_FAILED = 2,
+	};
+
+public:
+	squeue_t()
+		: m_sync(squeue_sync_var_t{})
+	{
+	}
+
+	static u32 get_max_size()
+	{
+		return sq_size;
+	}
+
+	bool is_full() const
+	{
+		return m_sync.load().count == sq_size;
+	}
+
+	bool push(const T& data, const std::function<bool()>& test_exit)
+	{
+		u32 pos = 0;
+
+		while (u32 res = m_sync.atomic_op([&pos](squeue_sync_var_t& sync) -> u32
+				   {
+					   ensure(sync.count <= sq_size);
+					   ensure(sync.position < sq_size);
+
+					   if (sync.push_lock)
+					   {
+						   return SQSVR_LOCKED;
+					   }
+					   if (sync.count == sq_size)
+					   {
+						   return SQSVR_FAILED;
+					   }
+
+					   sync.push_lock = 1;
+					   pos = sync.position + sync.count;
+					   return SQSVR_OK;
+				   }))
+		{
+			if (res == SQSVR_FAILED && (test_exit() || squeue_test_exit()))
+			{
+				return false;
+			}
+
+			std::unique_lock<std::mutex> wcv_lock(m_wcv_mutex);
+			m_wcv.wait_for(wcv_lock, std::chrono::milliseconds(1));
+		}
+
+		m_data[pos >= sq_size ? pos - sq_size : pos] = data;
+
+		m_sync.atomic_op([](squeue_sync_var_t& sync)
+			{
+				ensure(sync.count <= sq_size);
+				ensure(sync.position < sq_size);
+				ensure(!!sync.push_lock);
+				sync.push_lock = 0;
+				sync.count++;
+			});
+
+		m_rcv.notify_one();
+		m_wcv.notify_one();
+		return true;
+	}
+
+	bool push(const T& data, const volatile bool* do_exit)
+	{
+		return push(data, [do_exit]()
+			{
+				return do_exit && *do_exit;
+			});
+	}
+
+	bool push(const T& data)
+	{
+		return push(data, SQUEUE_NEVER_EXIT);
+	}
+
+	bool try_push(const T& data)
+	{
+		return push(data, SQUEUE_ALWAYS_EXIT);
+	}
+
+	bool pop(T& data, const std::function<bool()>& test_exit)
+	{
+		u32 pos = 0;
+
+		while (u32 res = m_sync.atomic_op([&pos](squeue_sync_var_t& sync) -> u32
+				   {
+					   ensure(sync.count <= sq_size);
+					   ensure(sync.position < sq_size);
+
+					   if (!sync.count)
+					   {
+						   return SQSVR_FAILED;
+					   }
+					   if (sync.pop_lock)
+					   {
+						   return SQSVR_LOCKED;
+					   }
+
+					   sync.pop_lock = 1;
+					   pos = sync.position;
+					   return SQSVR_OK;
+				   }))
+		{
+			if (res == SQSVR_FAILED && (test_exit() || squeue_test_exit()))
+			{
+				return false;
+			}
+
+			std::unique_lock<std::mutex> rcv_lock(m_rcv_mutex);
+			m_rcv.wait_for(rcv_lock, std::chrono::milliseconds(1));
+		}
+
+		data = m_data[pos];
+
+		m_sync.atomic_op([](squeue_sync_var_t& sync)
+			{
+				ensure(sync.count <= sq_size);
+				ensure(sync.position < sq_size);
+				ensure(!!sync.pop_lock);
+				sync.pop_lock = 0;
+				sync.position++;
+				sync.count--;
+				if (sync.position == sq_size)
+				{
+					sync.position = 0;
+				}
+			});
+
+		m_rcv.notify_one();
+		m_wcv.notify_one();
+		return true;
+	}
+
+	bool pop(T& data, const volatile bool* do_exit)
+	{
+		return pop(data, [do_exit]()
+			{
+				return do_exit && *do_exit;
+			});
+	}
+
+	bool pop(T& data)
+	{
+		return pop(data, SQUEUE_NEVER_EXIT);
+	}
+
+	bool try_pop(T& data)
+	{
+		return pop(data, SQUEUE_ALWAYS_EXIT);
+	}
+
+	bool peek(T& data, u32 start_pos, const std::function<bool()>& test_exit)
+	{
+		ensure(start_pos < sq_size);
+		u32 pos = 0;
+
+		while (u32 res = m_sync.atomic_op([&pos, start_pos](squeue_sync_var_t& sync) -> u32
+				   {
+					   ensure(sync.count <= sq_size);
+					   ensure(sync.position < sq_size);
+
+					   if (sync.count <= start_pos)
+					   {
+						   return SQSVR_FAILED;
+					   }
+					   if (sync.pop_lock)
+					   {
+						   return SQSVR_LOCKED;
+					   }
+
+					   sync.pop_lock = 1;
+					   pos = sync.position + start_pos;
+					   return SQSVR_OK;
+				   }))
+		{
+			if (res == SQSVR_FAILED && (test_exit() || squeue_test_exit()))
+			{
+				return false;
+			}
+
+			std::unique_lock<std::mutex> rcv_lock(m_rcv_mutex);
+			m_rcv.wait_for(rcv_lock, std::chrono::milliseconds(1));
+		}
+
+		data = m_data[pos >= sq_size ? pos - sq_size : pos];
+
+		m_sync.atomic_op([](squeue_sync_var_t& sync)
+			{
+				ensure(sync.count <= sq_size);
+				ensure(sync.position < sq_size);
+				ensure(!!sync.pop_lock);
+				sync.pop_lock = 0;
+			});
+
+		m_rcv.notify_one();
+		return true;
+	}
+
+	bool peek(T& data, u32 start_pos, const volatile bool* do_exit)
+	{
+		return peek(data, start_pos, [do_exit]()
+			{
+				return do_exit && *do_exit;
+			});
+	}
+
+	bool peek(T& data, u32 start_pos = 0)
+	{
+		return peek(data, start_pos, SQUEUE_NEVER_EXIT);
+	}
+
+	bool try_peek(T& data, u32 start_pos = 0)
+	{
+		return peek(data, start_pos, SQUEUE_ALWAYS_EXIT);
+	}
+
+	class squeue_data_t
+	{
+		T* const m_data;
+		const u32 m_pos;
+		const u32 m_count;
+
+		squeue_data_t(T* data, u32 pos, u32 count)
+			: m_data(data), m_pos(pos), m_count(count)
+		{
+		}
+
+	public:
+		T& operator[](u32 index)
+		{
+			ensure(index < m_count);
+			index += m_pos;
+			index = index < sq_size ? index : index - sq_size;
+			return m_data[index];
+		}
+	};
+
+	void process(void (*proc)(squeue_data_t data))
+	{
+		u32 pos, count;
+
+		while (m_sync.atomic_op([&pos, &count](squeue_sync_var_t& sync) -> u32
+			{
+				ensure(sync.count <= sq_size);
+				ensure(sync.position < sq_size);
+
+				if (sync.pop_lock || sync.push_lock)
+				{
+					return SQSVR_LOCKED;
+				}
+
+				pos = sync.position;
+				count = sync.count;
+				sync.pop_lock = 1;
+				sync.push_lock = 1;
+				return SQSVR_OK;
+			}))
+		{
+			std::unique_lock<std::mutex> rcv_lock(m_rcv_mutex);
+			m_rcv.wait_for(rcv_lock, std::chrono::milliseconds(1));
+		}
+
+		proc(squeue_data_t(m_data, pos, count));
+
+		m_sync.atomic_op([](squeue_sync_var_t& sync)
+			{
+				ensure(sync.count <= sq_size);
+				ensure(sync.position < sq_size);
+				ensure(!!sync.pop_lock);
+				ensure(!!sync.push_lock);
+				sync.pop_lock = 0;
+				sync.push_lock = 0;
+			});
+
+		m_wcv.notify_one();
+		m_rcv.notify_one();
+	}
+
+	void clear()
+	{
+		while (m_sync.atomic_op([](squeue_sync_var_t& sync) -> u32
+			{
+				ensure(sync.count <= sq_size);
+				ensure(sync.position < sq_size);
+
+				if (sync.pop_lock || sync.push_lock)
+				{
+					return SQSVR_LOCKED;
+				}
+
+				sync.pop_lock = 1;
+				sync.push_lock = 1;
+				return SQSVR_OK;
+			}))
+		{
+			std::unique_lock<std::mutex> rcv_lock(m_rcv_mutex);
+			m_rcv.wait_for(rcv_lock, std::chrono::milliseconds(1));
+		}
+
+		m_sync.exchange({});
+		m_wcv.notify_one();
+		m_rcv.notify_one();
+	}
+};

ps3fw/include/rpcsx/fw/ps3/cellPng.h

@@ -0,0 +1,176 @@
+#pragma once
+
+#include "Emu/Memory/vm_ptr.h"
+
+enum CellPngTxtType : s32
+{
+	CELL_PNG_TEXT = 0,
+	CELL_PNG_ZTXT = 1,
+	CELL_PNG_ITXT = 2,
+};
+
+enum CellPngUnknownLocation : s32
+{
+	CELL_PNG_BEFORE_PLTE = 1,
+	CELL_PNG_BEFORE_IDAT = 2,
+	CELL_PNG_AFTER_IDAT = 8,
+};
+
+struct CellPngPLTEentry
+{
+	u8 red;
+	u8 green;
+	u8 blue;
+};
+
+struct CellPngPaletteEntries
+{
+	be_t<u16> red;
+	be_t<u16> green;
+	be_t<u16> blue;
+	be_t<u16> alpha;
+	be_t<u16> frequency;
+};
+
+struct CellPngSPLTentry
+{
+	vm::bptr<char> paletteName;
+	u8 sampleDepth;
+	vm::bptr<CellPngPaletteEntries> paletteEntries;
+	be_t<u32> paletteEntriesNumber;
+};
+
+struct CellPngTextInfo
+{
+	be_t<s32> txtType; // CellPngTxtType
+	vm::bptr<char> keyword;
+	vm::bptr<char> text;
+	be_t<u32> textLength;
+	vm::bptr<char> languageTag;
+	vm::bptr<char> translatedKeyword;
+};
+
+struct CellPngPLTE
+{
+	be_t<u32> paletteEntriesNumber;
+	vm::bptr<CellPngPLTEentry> paletteEntries;
+};
+
+struct CellPngGAMA
+{
+	be_t<double> gamma;
+};
+
+struct CellPngSRGB
+{
+	be_t<u32> renderingIntent;
+};
+
+struct CellPngICCP
+{
+	vm::bptr<char> profileName;
+	vm::bptr<char> profile;
+	be_t<u32> profileLength;
+};
+
+struct CellPngSBIT
+{
+	be_t<u32> red;
+	be_t<u32> green;
+	be_t<u32> blue;
+	be_t<u32> gray;
+	be_t<u32> alpha;
+};
+
+struct CellPngTRNS
+{
+	vm::bptr<char> alphaForPaletteIndex;
+	be_t<u32> alphaForPaletteIndexNumber;
+	be_t<u16> red;
+	be_t<u16> green;
+	be_t<u16> blue;
+	be_t<u16> gray;
+};
+
+struct CellPngHIST
+{
+	vm::bptr<u16> histgramEntries;
+	be_t<u32> histgramEntriesNumber;
+};
+
+struct CellPngTIME
+{
+	be_t<u16> year;
+	u8 month;
+	u8 day;
+	u8 hour;
+	u8 minute;
+	u8 second;
+};
+
+struct CellPngBKGD
+{
+	u8 paletteIndex;
+	be_t<u32> red;
+	be_t<u32> green;
+	be_t<u32> blue;
+	be_t<u32> gray;
+};
+
+struct CellPngSPLT
+{
+	vm::bptr<CellPngSPLTentry> sPLTentries;
+	be_t<u32> sPLTentriesNumber;
+};
+
+struct CellPngOFFS
+{
+	be_t<s32> xPosition;
+	be_t<s32> yPosition;
+	be_t<u32> unitSpecifier;
+};
+
+struct CellPngPHYS
+{
+	be_t<u32> xAxis;
+	be_t<u32> yAxis;
+	be_t<u32> unitSpecifier;
+};
+
+struct CellPngSCAL
+{
+	be_t<u32> unitSpecifier;
+	be_t<double> pixelWidth;
+	be_t<double> pixelHeight;
+};
+
+struct CellPngCHRM
+{
+	be_t<double> whitePointX;
+	be_t<double> whitePointY;
+	be_t<double> redX;
+	be_t<double> redY;
+	be_t<double> greenX;
+	be_t<double> greenY;
+	be_t<double> blueX;
+	be_t<double> blueY;
+};
+
+struct CellPngPCAL
+{
+	vm::bptr<char> calibrationName;
+	be_t<s32> x0;
+	be_t<s32> x1;
+	be_t<u32> equationType;
+	be_t<u32> numberOfParameters;
+	vm::bptr<char> unitName;
+	vm::bpptr<char> parameter;
+};
+
+struct CellPngUnknownChunk
+{
+	char chunkType[5];
+	vm::bptr<char> chunkData;
+	be_t<u32> length;
+	be_t<s32> location; // CellPngUnknownLocation
+};

ps3fw/include/rpcsx/fw/ps3/cellPngDec.h

@@ -0,0 +1,349 @@
+#pragma once
+
+#include "Emu/Memory/vm_ptr.h"
+
+#include "png.h"
+
+enum : u32
+{
+	PNGDEC_CODEC_VERSION = 0x00420000,
+};
+
+// Return Codes
+enum CellPngDecError
+{
+	CELL_PNGDEC_ERROR_HEADER = 0x80611201,
+	CELL_PNGDEC_ERROR_STREAM_FORMAT = 0x80611202,
+	CELL_PNGDEC_ERROR_ARG = 0x80611203,
+	CELL_PNGDEC_ERROR_SEQ = 0x80611204,
+	CELL_PNGDEC_ERROR_BUSY = 0x80611205,
+	CELL_PNGDEC_ERROR_FATAL = 0x80611206,
+	CELL_PNGDEC_ERROR_OPEN_FILE = 0x80611207,
+	CELL_PNGDEC_ERROR_SPU_UNSUPPORT = 0x80611208,
+	CELL_PNGDEC_ERROR_SPU_ERROR = 0x80611209,
+	CELL_PNGDEC_ERROR_CB_PARAM = 0x8061120a,
+};
+
+// Consts
+enum CellPngDecColorSpace : s32
+{
+	CELL_PNGDEC_GRAYSCALE = 1,
+	CELL_PNGDEC_RGB = 2,
+	CELL_PNGDEC_PALETTE = 4,
+	CELL_PNGDEC_GRAYSCALE_ALPHA = 9,
+	CELL_PNGDEC_RGBA = 10,
+	CELL_PNGDEC_ARGB = 20,
+};
+
+enum CellPngDecSpuThreadEna : s32
+{
+	CELL_PNGDEC_SPU_THREAD_DISABLE = 0,
+	CELL_PNGDEC_SPU_THREAD_ENABLE = 1,
+};
+
+enum CellPngDecStreamSrcSel : s32
+{
+	CELL_PNGDEC_FILE = 0,
+	CELL_PNGDEC_BUFFER = 1,
+};
+
+enum CellPngDecInterlaceMode : s32
+{
+	CELL_PNGDEC_NO_INTERLACE = 0,
+	CELL_PNGDEC_ADAM7_INTERLACE = 1,
+};
+
+enum CellPngDecOutputMode : s32
+{
+	CELL_PNGDEC_TOP_TO_BOTTOM = 0,
+	CELL_PNGDEC_BOTTOM_TO_TOP = 1,
+};
+
+enum CellPngDecPackFlag : s32
+{
+	CELL_PNGDEC_1BYTE_PER_NPIXEL = 0,
+	CELL_PNGDEC_1BYTE_PER_1PIXEL = 1,
+};
+
+enum CellPngDecAlphaSelect : s32
+{
+	CELL_PNGDEC_STREAM_ALPHA = 0,
+	CELL_PNGDEC_FIX_ALPHA = 1,
+};
+
+enum CellPngDecCommand : s32
+{
+	CELL_PNGDEC_CONTINUE = 0,
+	CELL_PNGDEC_STOP = 1,
+};
+
+enum CellPngDecDecodeStatus : s32
+{
+	CELL_PNGDEC_DEC_STATUS_FINISH = 0,
+	CELL_PNGDEC_DEC_STATUS_STOP = 1,
+};
+
+enum CellPngDecBufferMode : s32
+{
+	CELL_PNGDEC_LINE_MODE = 1,
+};
+
+enum CellPngDecSpuMode : s32
+{
+	CELL_PNGDEC_RECEIVE_EVENT = 0,
+	CELL_PNGDEC_TRYRECEIVE_EVENT = 1,
+};
+
+// Callbacks for memory management
+using CellPngDecCbControlMalloc = vm::ptr<void>(u32 size, vm::ptr<void> cbCtrlMallocArg);
+using CellPngDecCbControlFree = s32(vm::ptr<void> ptr, vm::ptr<void> cbCtrlFreeArg);
+
+// Structs
+struct CellPngDecThreadInParam
+{
+	be_t<s32> spuThreadEnable; // CellPngDecSpuThreadEna
+	be_t<u32> ppuThreadPriority;
+	be_t<u32> spuThreadPriority;
+	vm::bptr<CellPngDecCbControlMalloc> cbCtrlMallocFunc;
+	vm::bptr<void> cbCtrlMallocArg;
+	vm::bptr<CellPngDecCbControlFree> cbCtrlFreeFunc;
+	vm::bptr<void> cbCtrlFreeArg;
+};
+
+struct CellPngDecExtThreadInParam
+{
+	vm::bptr<struct CellSpurs> spurs;
+	u8 priority[8];
+	be_t<u32> maxContention;
+};
+
+struct CellPngDecThreadOutParam
+{
+	be_t<u32> pngCodecVersion;
+};
+
+struct CellPngDecExtThreadOutParam
+{
+	be_t<u32> reserved;
+};
+
+struct CellPngDecSrc
+{
+	be_t<s32> srcSelect; // CellPngDecStreamSrcSel
+	vm::bcptr<char> fileName;
+	be_t<s64> fileOffset;
+	be_t<u32> fileSize;
+	vm::bptr<void> streamPtr;
+	be_t<u32> streamSize;
+	be_t<s32> spuThreadEnable; // CellGifDecSpuThreadEna
+};
+
+struct CellPngDecOpnInfo
+{
+	be_t<u32> initSpaceAllocated;
+};
+
+struct CellPngDecInfo
+{
+	be_t<u32> imageWidth;
+	be_t<u32> imageHeight;
+	be_t<u32> numComponents;
+	be_t<s32> colorSpace; // CellPngDecColorSpace
+	be_t<u32> bitDepth;
+	be_t<s32> interlaceMethod; // CellPngDecInterlaceMode
+	be_t<u32> chunkInformation;
+};
+
+struct CellPngDecInParam
+{
+	vm::bptr<volatile s32> commandPtr; // CellPngDecCommand
+	be_t<s32> outputMode;              // CellPngDecOutputMode
+	be_t<s32> outputColorSpace;        // CellPngDecColorSpace
+	be_t<u32> outputBitDepth;
+	be_t<s32> outputPackFlag;    // CellPngDecPackFlag
+	be_t<s32> outputAlphaSelect; // CellPngDecAlphaSelect
+	be_t<u32> outputColorAlpha;
+};
+
+struct CellPngDecOutParam
+{
+	be_t<u64> outputWidthByte;
+	be_t<u32> outputWidth;
+	be_t<u32> outputHeight;
+	be_t<u32> outputComponents;
+	be_t<u32> outputBitDepth;
+	be_t<s32> outputMode;       // CellPngDecOutputMode
+	be_t<s32> outputColorSpace; // CellPngDecOutputMode
+	be_t<u32> useMemorySpace;
+};
+
+struct CellPngDecDataCtrlParam
+{
+	be_t<u64> outputBytesPerLine;
+};
+
+struct CellPngDecDataOutInfo
+{
+	be_t<u32> chunkInformation;
+	be_t<u32> numText;
+	be_t<u32> numUnknownChunk;
+	be_t<s32> status; // CellPngDecDecodeStatus
+};
+
+// Structs for decoding partial streams
+struct CellPngDecStrmInfo
+{
+	be_t<u32> decodedStrmSize;
+};
+
+struct CellPngDecStrmParam
+{
+	vm::bptr<void> strmPtr;
+	be_t<u32> strmSize;
+};
+
+struct CellPngDecDispInfo
+{
+	be_t<u64> outputFrameWidthByte;
+	be_t<u32> outputFrameHeight;
+	be_t<u64> outputStartXByte;
+	be_t<u32> outputStartY;
+	be_t<u64> outputWidthByte;
+	be_t<u32> outputHeight;
+	be_t<u32> outputBitDepth;
+	be_t<u32> outputComponents;
+	be_t<u32> nextOutputStartY;
+	be_t<u32> scanPassCount;
+	vm::bptr<void> outputImage;
+};
+
+struct CellPngDecDispParam
+{
+	vm::bptr<void> nextOutputImage;
+};
+
+struct CellPngDecOpnParam
+{
+	be_t<u32> selectChunk;
+};
+
+struct CellPngDecExtInfo
+{
+	be_t<u64> reserved;
+};
+
+struct CellPngDecExtInParam
+{
+	be_t<s32> bufferMode; // CellPngDecBufferMode
+	be_t<u32> outputCounts;
+	be_t<s32> spuMode; // CellPngDecSpuMode
+};
+
+struct CellPngDecExtOutParam
+{
+	be_t<u64> outputWidthByte;
+	be_t<u32> outputHeight;
+};
+
+// Callbacks for decoding partial streams
+using CellPngDecCbControlStream = s32(vm::ptr<CellPngDecStrmInfo> strmInfo, vm::ptr<CellPngDecStrmParam> strmParam, vm::ptr<void> cbCtrlStrmArg);
+using CellPngDecCbControlDisp = s32(vm::ptr<CellPngDecDispInfo> dispInfo, vm::ptr<CellPngDecDispParam> dispParam, vm::ptr<void> cbCtrlDispArg);
+
+struct CellPngDecCbCtrlStrm
+{
+	vm::bptr<CellPngDecCbControlStream> cbCtrlStrmFunc;
+	vm::bptr<void> cbCtrlStrmArg;
+};
+
+struct CellPngDecCbCtrlDisp
+{
+	vm::bptr<CellPngDecCbControlDisp> cbCtrlDispFunc;
+	vm::bptr<void> cbCtrlDispArg;
+};
+
+// Custom structs
+struct PngHandle
+{
+	vm::ptr<CellPngDecCbControlMalloc> malloc_;
+	vm::ptr<void> malloc_arg;
+	vm::ptr<CellPngDecCbControlFree> free_;
+	vm::ptr<void> free_arg;
+};
+
+// For reading from a buffer using libpng
+struct PngBuffer
+{
+	// The cursor location and data pointer for reading from a buffer
+	usz cursor;
+	usz length;
+	vm::bptr<void> data;
+
+	// The file descriptor, and whether we need to read from a file descriptor
+	bool file;
+	u32 fd;
+};
+
+struct PngStream
+{
+	// PNG decoding structures
+	CellPngDecInfo info;
+	CellPngDecOutParam out_param;
+	CellPngDecSrc source;
+
+	// Partial decoding
+	CellPngDecCbCtrlStrm cbCtrlStream;
+	CellPngDecCbCtrlDisp cbCtrlDisp;
+	vm::ptr<CellPngDecDispInfo> cbDispInfo;
+	vm::ptr<CellPngDecDispParam> cbDispParam;
+	ppu_thread* ppuContext;
+
+	u32 outputCounts = 0;
+	u32 nextRow = 0;
+	bool endOfFile = false;
+
+	// Pixel packing value
+	be_t<s32> packing;
+	u32 passes;
+
+	// PNG custom read function structure, for decoding from a buffer
+	vm::ptr<PngBuffer> buffer;
+
+	// libpng structures for reading and decoding the PNG file
+	png_structp png_ptr;
+	png_infop info_ptr;
+};
+
+// Converts libpng colour type to cellPngDec colour type
+static s32 getPngDecColourType(u8 type)
+{
+	switch (type)
+	{
+	case PNG_COLOR_TYPE_RGB: return CELL_PNGDEC_RGB;
+	case PNG_COLOR_TYPE_RGBA: return CELL_PNGDEC_RGBA; // We can't diffrentiate between ARGB and RGBA. Doesn't seem to be exactly important.
+	case PNG_COLOR_TYPE_PALETTE: return CELL_PNGDEC_PALETTE;
+	case PNG_COLOR_TYPE_GRAY: return CELL_PNGDEC_GRAYSCALE;
+	case PNG_COLOR_TYPE_GRAY_ALPHA: return CELL_PNGDEC_GRAYSCALE_ALPHA;
+	default: fmt::throw_exception("Unknown colour type: %d", type);
+	}
+}
+
+static bool cellPngColorSpaceHasAlpha(u32 colorspace)
+{
+	switch (colorspace)
+	{
+	case CELL_PNGDEC_RGBA:
+	case CELL_PNGDEC_ARGB:
+	case CELL_PNGDEC_GRAYSCALE_ALPHA:
+		return true;
+	default:
+		return false;
+	}
+}
+
+// Custom exception for libPng errors
+
+class LibPngCustomException : public std::runtime_error
+{
+public:
+	LibPngCustomException(char const* const message) : runtime_error(message) {}
+};

ps3fw/include/rpcsx/fw/ps3/cellPngEnc.h

@@ -0,0 +1,174 @@
+#pragma once
+
+// Error Codes
+enum CellPngEncError
+{
+	CELL_PNGENC_ERROR_ARG = 0x80611291,
+	CELL_PNGENC_ERROR_SEQ = 0x80611292,
+	CELL_PNGENC_ERROR_BUSY = 0x80611293,
+	CELL_PNGENC_ERROR_EMPTY = 0x80611294,
+	CELL_PNGENC_ERROR_RESET = 0x80611295,
+	CELL_PNGENC_ERROR_FATAL = 0x80611296,
+	CELL_PNGENC_ERROR_STREAM_ABORT = 0x806112A1,
+	CELL_PNGENC_ERROR_STREAM_SKIP = 0x806112A2,
+	CELL_PNGENC_ERROR_STREAM_OVERFLOW = 0x806112A3,
+	CELL_PNGENC_ERROR_STREAM_FILE_OPEN = 0x806112A4,
+};
+
+enum CellPngEncColorSpace
+{
+	CELL_PNGENC_COLOR_SPACE_GRAYSCALE = 1,
+	CELL_PNGENC_COLOR_SPACE_RGB = 2,
+	CELL_PNGENC_COLOR_SPACE_PALETTE = 4,
+	CELL_PNGENC_COLOR_SPACE_GRAYSCALE_ALPHA = 9,
+	CELL_PNGENC_COLOR_SPACE_RGBA = 10,
+	CELL_PNGENC_COLOR_SPACE_ARGB = 20
+};
+
+enum CellPngEncCompressionLevel
+{
+	CELL_PNGENC_COMPR_LEVEL_0,
+	CELL_PNGENC_COMPR_LEVEL_1,
+	CELL_PNGENC_COMPR_LEVEL_2,
+	CELL_PNGENC_COMPR_LEVEL_3,
+	CELL_PNGENC_COMPR_LEVEL_4,
+	CELL_PNGENC_COMPR_LEVEL_5,
+	CELL_PNGENC_COMPR_LEVEL_6,
+	CELL_PNGENC_COMPR_LEVEL_7,
+	CELL_PNGENC_COMPR_LEVEL_8,
+	CELL_PNGENC_COMPR_LEVEL_9
+};
+
+enum CellPngEncFilterType
+{
+	CELL_PNGENC_FILTER_TYPE_NONE = 0x08,
+	CELL_PNGENC_FILTER_TYPE_SUB = 0x10,
+	CELL_PNGENC_FILTER_TYPE_UP = 0x20,
+	CELL_PNGENC_FILTER_TYPE_AVG = 0x40,
+	CELL_PNGENC_FILTER_TYPE_PAETH = 0x80,
+	CELL_PNGENC_FILTER_TYPE_ALL = 0xF8
+};
+
+enum CellPngEncChunkType
+{
+	CELL_PNGENC_CHUNK_TYPE_PLTE,
+	CELL_PNGENC_CHUNK_TYPE_TRNS,
+	CELL_PNGENC_CHUNK_TYPE_CHRM,
+	CELL_PNGENC_CHUNK_TYPE_GAMA,
+	CELL_PNGENC_CHUNK_TYPE_ICCP,
+	CELL_PNGENC_CHUNK_TYPE_SBIT,
+	CELL_PNGENC_CHUNK_TYPE_SRGB,
+	CELL_PNGENC_CHUNK_TYPE_TEXT,
+	CELL_PNGENC_CHUNK_TYPE_BKGD,
+	CELL_PNGENC_CHUNK_TYPE_HIST,
+	CELL_PNGENC_CHUNK_TYPE_PHYS,
+	CELL_PNGENC_CHUNK_TYPE_SPLT,
+	CELL_PNGENC_CHUNK_TYPE_TIME,
+	CELL_PNGENC_CHUNK_TYPE_OFFS,
+	CELL_PNGENC_CHUNK_TYPE_PCAL,
+	CELL_PNGENC_CHUNK_TYPE_SCAL,
+	CELL_PNGENC_CHUNK_TYPE_UNKNOWN
+};
+
+enum CellPngEncLocation
+{
+	CELL_PNGENC_LOCATION_FILE,
+	CELL_PNGENC_LOCATION_BUFFER
+};
+
+// typedef void *CellPngEncHandle;
+
+struct CellPngEncExParam // Size 8
+{
+	be_t<s32> index;
+	vm::bptr<s32> value;
+};
+
+struct CellPngEncConfig // Size 28
+{
+	be_t<u32> maxWidth;
+	be_t<u32> maxHeight;
+	be_t<u32> maxBitDepth;
+	b8 enableSpu;
+	u8 padding[3];
+	be_t<u32> addMemSize;
+	vm::bptr<CellPngEncExParam> exParamList;
+	be_t<u32> exParamNum;
+};
+
+struct CellPngEncAttr // Size 16
+{
+	be_t<u32> memSize; // usz
+	u8 cmdQueueDepth;
+	u8 padding[3];
+	be_t<u32> versionUpper;
+	be_t<u32> versionLower;
+};
+
+struct CellPngEncResource // Size 16
+{
+	vm::bptr<void> memAddr;
+	be_t<u32> memSize; // usz
+	be_t<s32> ppuThreadPriority;
+	be_t<s32> spuThreadPriority;
+};
+
+struct CellPngEncResourceEx // Size 24
+{
+	vm::bptr<void> memAddr;
+	be_t<u32> memSize; // usz
+	be_t<s32> ppuThreadPriority;
+	vm::bptr<void> spurs; // CellSpurs
+	u8 priority[8];
+};
+
+struct CellPngEncPicture // Size 40
+{
+	be_t<u32> width;
+	be_t<u32> height;
+	be_t<u32> pitchWidth;
+	be_t<u32> colorSpace; // CellPngEncColorSpace
+	be_t<u32> bitDepth;
+	b8 packedPixel;
+	u8 padding[3]; // TODO: is this correct?
+	vm::bptr<void> pictureAddr;
+	be_t<u64> userData;
+};
+
+struct CellPngEncAncillaryChunk // Size 8
+{
+	be_t<u32> chunkType; // CellPngEncChunkType
+	vm::bptr<void> chunkData;
+};
+
+struct CellPngEncEncodeParam // Size 24
+{
+	b8 enableSpu;
+	u8 padding[3];
+	be_t<u32> encodeColorSpace; // CellPngEncColorSpace
+	be_t<u32> compressionLevel; // CellPngEncCompressionLevel
+	be_t<u32> filterType;
+	vm::bptr<CellPngEncAncillaryChunk> ancillaryChunkList;
+	be_t<u32> ancillaryChunkNum;
+};
+
+struct CellPngEncOutputParam // Size 16
+{
+	be_t<u32> location; // CellPngEncLocation
+	vm::bcptr<char> streamFileName;
+	vm::bptr<void> streamAddr;
+	be_t<u32> limitSize; // usz
+};
+
+struct CellPngEncStreamInfo // Size 40
+{
+	be_t<s32> state;
+	be_t<u32> location; // CellPngEncLocation
+	vm::bcptr<char> streamFileName;
+	vm::bptr<void> streamAddr;
+	be_t<u32> limitSize;  // usz
+	be_t<u32> streamSize; // usz
+	be_t<u32> processedLine;
+	be_t<u64> userData;
+	// TODO: where are the missing 4 bytes?
+};

ps3fw/include/rpcsx/fw/ps3/cellRec.h

@@ -0,0 +1,244 @@
+#pragma once
+
+enum CellRecError : u32
+{
+	CELL_REC_ERROR_OUT_OF_MEMORY = 0x8002c501,
+	CELL_REC_ERROR_FATAL = 0x8002c502,
+	CELL_REC_ERROR_INVALID_VALUE = 0x8002c503,
+	CELL_REC_ERROR_FILE_OPEN = 0x8002c504,
+	CELL_REC_ERROR_FILE_WRITE = 0x8002c505,
+	CELL_REC_ERROR_INVALID_STATE = 0x8002c506,
+	CELL_REC_ERROR_FILE_NO_DATA = 0x8002c507
+};
+
+enum
+{
+	CELL_REC_STATUS_UNLOAD = 0,
+	CELL_REC_STATUS_OPEN = 1,
+	CELL_REC_STATUS_START = 2,
+	CELL_REC_STATUS_STOP = 3,
+	CELL_REC_STATUS_CLOSE = 4,
+	CELL_REC_STATUS_ERR = 10
+};
+
+enum
+{
+	CELL_REC_MIN_MEMORY_CONTAINER_SIZE = 0,
+	CELL_REC_MAX_MEMORY_CONTAINER_SIZE = 16 * 1024 * 1024, // 9 * 1024 * 1024 if SDK < 0x300000
+
+	CELL_REC_MAX_PATH_LEN = 1023,
+};
+
+enum
+{
+	CELL_REC_PARAM_PPU_THREAD_PRIORITY_DEFAULT = 400,
+	CELL_REC_PARAM_SPU_THREAD_PRIORITY_DEFAULT = 60,
+
+	CELL_REC_PARAM_CAPTURE_PRIORITY_HIGHEST = 0,
+	CELL_REC_PARAM_CAPTURE_PRIORITY_EXCEPT_NOTIFICATION = 1,
+	CELL_REC_PARAM_CAPTURE_PRIORITY_GAME_SCREEN = 2,
+
+	CELL_REC_PARAM_USE_SYSTEM_SPU_DISABLE = 0,
+	CELL_REC_PARAM_USE_SYSTEM_SPU_ENABLE = 1,
+
+	CELL_REC_PARAM_XMB_BGM_DISABLE = 0,
+	CELL_REC_PARAM_XMB_BGM_ENABLE = 1,
+
+	CELL_REC_PARAM_MPEG4_FAST_ENCODE_DISABLE = 0,
+	CELL_REC_PARAM_MPEG4_FAST_ENCODE_ENABLE = 1,
+
+	CELL_REC_PARAM_VIDEO_INPUT_DISABLE = 0,
+	CELL_REC_PARAM_VIDEO_INPUT_ARGB_4_3 = 1,
+	CELL_REC_PARAM_VIDEO_INPUT_ARGB_16_9 = 2,
+	CELL_REC_PARAM_VIDEO_INPUT_RGBA_4_3 = 3,
+	CELL_REC_PARAM_VIDEO_INPUT_RGBA_16_9 = 4,
+	CELL_REC_PARAM_VIDEO_INPUT_YUV420PLANAR_16_9 = 5,
+
+	CELL_REC_PARAM_AUDIO_INPUT_DISABLE = 0,
+	CELL_REC_PARAM_AUDIO_INPUT_ENABLE = 1,
+
+	CELL_REC_PARAM_AUDIO_INPUT_MIX_VOL_MIN = 0,
+	CELL_REC_PARAM_AUDIO_INPUT_MIX_VOL_MAX = 100,
+
+	CELL_REC_PARAM_REDUCE_MEMSIZE_DISABLE = 0,
+	CELL_REC_PARAM_REDUCE_MEMSIZE_ENABLE = 1,
+
+	// SMALL  = 320x240 (4:3) or 368x208 (16:9)
+	// MIDDLE = 368x272 (4:3) or 480x272 (16:9)
+	// LARGE  = 480x368 (4:3) or 640x368 (16:9)
+	// HD720  = 1280x720 (16:9)
+
+	// PS3 playable format; all
+	// PSP playable format: MPEG4 + SMALL, AVC + SMALL, AVC + MIDDLE
+
+	CELL_REC_PARAM_VIDEO_FMT_MPEG4_SMALL_512K_30FPS = 0x0000,
+	CELL_REC_PARAM_VIDEO_FMT_MPEG4_SMALL_768K_30FPS = 0x0010,
+	CELL_REC_PARAM_VIDEO_FMT_MPEG4_MIDDLE_512K_30FPS = 0x0100,
+	CELL_REC_PARAM_VIDEO_FMT_MPEG4_MIDDLE_768K_30FPS = 0x0110,
+	CELL_REC_PARAM_VIDEO_FMT_MPEG4_LARGE_512K_30FPS = 0x0200,
+	CELL_REC_PARAM_VIDEO_FMT_MPEG4_LARGE_768K_30FPS = 0x0210,
+	CELL_REC_PARAM_VIDEO_FMT_MPEG4_LARGE_1024K_30FPS = 0x0220,
+	CELL_REC_PARAM_VIDEO_FMT_MPEG4_LARGE_1536K_30FPS = 0x0230,
+	CELL_REC_PARAM_VIDEO_FMT_MPEG4_LARGE_2048K_30FPS = 0x0240,
+
+	CELL_REC_PARAM_VIDEO_FMT_AVC_MP_SMALL_512K_30FPS = 0x1000,
+	CELL_REC_PARAM_VIDEO_FMT_AVC_MP_SMALL_768K_30FPS = 0x1010,
+	CELL_REC_PARAM_VIDEO_FMT_AVC_MP_MIDDLE_512K_30FPS = 0x1100,
+	CELL_REC_PARAM_VIDEO_FMT_AVC_MP_MIDDLE_768K_30FPS = 0x1110,
+	CELL_REC_PARAM_VIDEO_FMT_AVC_MP_MIDDLE_1024K_30FPS = 0x1120,
+	CELL_REC_PARAM_VIDEO_FMT_AVC_MP_MIDDLE_1536K_30FPS = 0x1130,
+
+	CELL_REC_PARAM_VIDEO_FMT_AVC_BL_SMALL_512K_30FPS = 0x2000,
+	CELL_REC_PARAM_VIDEO_FMT_AVC_BL_SMALL_768K_30FPS = 0x2010,
+	CELL_REC_PARAM_VIDEO_FMT_AVC_BL_MIDDLE_512K_30FPS = 0x2100,
+	CELL_REC_PARAM_VIDEO_FMT_AVC_BL_MIDDLE_768K_30FPS = 0x2110,
+	CELL_REC_PARAM_VIDEO_FMT_AVC_BL_MIDDLE_1024K_30FPS = 0x2120,
+	CELL_REC_PARAM_VIDEO_FMT_AVC_BL_MIDDLE_1536K_30FPS = 0x2130,
+
+	CELL_REC_PARAM_VIDEO_FMT_MJPEG_SMALL_5000K_30FPS = 0x3060,
+	CELL_REC_PARAM_VIDEO_FMT_MJPEG_MIDDLE_5000K_30FPS = 0x3160,
+	CELL_REC_PARAM_VIDEO_FMT_MJPEG_LARGE_11000K_30FPS = 0x3270,
+	CELL_REC_PARAM_VIDEO_FMT_MJPEG_HD720_11000K_30FPS = 0x3670,
+	CELL_REC_PARAM_VIDEO_FMT_MJPEG_HD720_20000K_30FPS = 0x3680,
+	CELL_REC_PARAM_VIDEO_FMT_MJPEG_HD720_25000K_30FPS = 0x3690,
+
+	CELL_REC_PARAM_VIDEO_FMT_M4HD_SMALL_768K_30FPS = 0x4010,
+	CELL_REC_PARAM_VIDEO_FMT_M4HD_MIDDLE_768K_30FPS = 0x4110,
+	CELL_REC_PARAM_VIDEO_FMT_M4HD_LARGE_1536K_30FPS = 0x4230,
+	CELL_REC_PARAM_VIDEO_FMT_M4HD_LARGE_2048K_30FPS = 0x4240,
+	CELL_REC_PARAM_VIDEO_FMT_M4HD_HD720_2048K_30FPS = 0x4640,
+	CELL_REC_PARAM_VIDEO_FMT_M4HD_HD720_5000K_30FPS = 0x4660,
+	CELL_REC_PARAM_VIDEO_FMT_M4HD_HD720_11000K_30FPS = 0x4670,
+
+	CELL_REC_PARAM_AUDIO_FMT_AAC_96K = 0x0000,
+	CELL_REC_PARAM_AUDIO_FMT_AAC_128K = 0x0001,
+	CELL_REC_PARAM_AUDIO_FMT_AAC_64K = 0x0002,
+
+	CELL_REC_PARAM_AUDIO_FMT_ULAW_384K = 0x1007,
+	CELL_REC_PARAM_AUDIO_FMT_ULAW_768K = 0x1008,
+
+	CELL_REC_PARAM_AUDIO_FMT_PCM_384K = 0x2007,
+	CELL_REC_PARAM_AUDIO_FMT_PCM_768K = 0x2008,
+	CELL_REC_PARAM_AUDIO_FMT_PCM_1536K = 0x2009,
+
+	CELL_REC_PARAM_VIDEO_FMT_YOUTUBE = 0x0310,
+	CELL_REC_PARAM_VIDEO_FMT_YOUTUBE_LARGE = CELL_REC_PARAM_VIDEO_FMT_MPEG4_LARGE_2048K_30FPS,
+	CELL_REC_PARAM_VIDEO_FMT_YOUTUBE_HD720 = CELL_REC_PARAM_VIDEO_FMT_M4HD_HD720_5000K_30FPS,
+	CELL_REC_PARAM_AUDIO_FMT_YOUTUBE = CELL_REC_PARAM_AUDIO_FMT_AAC_64K,
+
+	CELL_REC_PARAM_VIDEO_FMT_YOUTUBE_MJPEG = CELL_REC_PARAM_VIDEO_FMT_MJPEG_HD720_11000K_30FPS,
+	CELL_REC_PARAM_AUDIO_FMT_YOUTUBE_MJPEG = CELL_REC_PARAM_AUDIO_FMT_PCM_768K,
+
+	CELL_REC_AUDIO_BLOCK_SAMPLES = 256,
+};
+
+enum
+{
+	CELL_REC_INFO_VIDEO_INPUT_ADDR = 0,
+	CELL_REC_INFO_VIDEO_INPUT_WIDTH = 1,
+	CELL_REC_INFO_VIDEO_INPUT_PITCH = 2,
+	CELL_REC_INFO_VIDEO_INPUT_HEIGHT = 3,
+	CELL_REC_INFO_AUDIO_INPUT_ADDR = 4,
+	CELL_REC_INFO_MOVIE_TIME_MSEC = 5,
+	CELL_REC_INFO_SPURS_SYSTEMWORKLOAD_ID = 6,
+};
+
+enum
+{
+	CELL_REC_SETINFO_MOVIE_START_TIME_MSEC = 100,
+	CELL_REC_SETINFO_MOVIE_END_TIME_MSEC = 101,
+	CELL_REC_SETINFO_MOVIE_META = 200,
+	CELL_REC_SETINFO_SCENE_META = 201,
+
+	CELL_REC_MOVIE_META_GAME_TITLE_LEN = 128,
+	CELL_REC_MOVIE_META_MOVIE_TITLE_LEN = 128,
+	CELL_REC_MOVIE_META_DESCRIPTION_LEN = 384,
+	CELL_REC_MOVIE_META_USERDATA_LEN = 64,
+
+	CELL_REC_SCENE_META_TYPE_CHAPTER = 0,
+	CELL_REC_SCENE_META_TYPE_CLIP_HIGHLIGHT = 1,
+	CELL_REC_SCENE_META_TYPE_CLIP_USER = 2,
+
+	CELL_REC_SCENE_META_TITLE_LEN = 128,
+	CELL_REC_SCENE_META_TAG_NUM = 6,
+	CELL_REC_SCENE_META_TAG_LEN = 64,
+};
+
+enum
+{
+	CELL_REC_OPTION_PPU_THREAD_PRIORITY = 1,
+	CELL_REC_OPTION_SPU_THREAD_PRIORITY = 2,
+	CELL_REC_OPTION_CAPTURE_PRIORITY = 3,
+	CELL_REC_OPTION_USE_SYSTEM_SPU = 4,
+	CELL_REC_OPTION_FIT_TO_YOUTUBE = 5,
+	CELL_REC_OPTION_XMB_BGM = 6,
+	CELL_REC_OPTION_RING_SEC = 7,
+	CELL_REC_OPTION_MPEG4_FAST_ENCODE = 8,
+	CELL_REC_OPTION_VIDEO_INPUT = 9,
+	CELL_REC_OPTION_AUDIO_INPUT = 10,
+	CELL_REC_OPTION_AUDIO_INPUT_MIX_VOL = 11,
+	CELL_REC_OPTION_REDUCE_MEMSIZE = 12,
+	CELL_REC_OPTION_SHOW_XMB = 13,
+	CELL_REC_OPTION_METADATA_FILENAME = 14,
+	CELL_REC_OPTION_SPURS = 15,
+};
+
+struct CellRecSpursParam
+{
+	vm::bptr<struct CellSpurs> pSpurs;
+	be_t<s32> spu_usage_rate;
+	u8 priority[8];
+};
+
+struct CellRecOption
+{
+	be_t<s32> option;
+	union
+	{
+		be_t<s32> ppu_thread_priority;           // CELL_REC_OPTION_PPU_THREAD_PRIORITY
+		be_t<s32> spu_thread_priority;           // CELL_REC_OPTION_SPU_THREAD_PRIORITY
+		be_t<s32> capture_priority;              // CELL_REC_OPTION_CAPTURE_PRIORITY
+		be_t<s32> use_system_spu;                // CELL_REC_OPTION_USE_SYSTEM_SPU
+		be_t<s32> fit_to_youtube;                // CELL_REC_OPTION_FIT_TO_YOUTUBE
+		be_t<s32> xmb_bgm;                       // CELL_REC_OPTION_XMB_BGM
+		be_t<s32> mpeg4_fast_encode;             // CELL_REC_OPTION_MPEG4_FAST_ENCODE
+		be_t<u32> ring_sec;                      // CELL_REC_OPTION_RING_SEC
+		be_t<s32> video_input;                   // CELL_REC_OPTION_VIDEO_INPUT
+		be_t<s32> audio_input;                   // CELL_REC_OPTION_AUDIO_INPUT
+		be_t<s32> audio_input_mix_vol;           // CELL_REC_OPTION_AUDIO_INPUT_MIX_VOL
+		be_t<s32> reduce_memsize;                // CELL_REC_OPTION_REDUCE_MEMSIZE
+		be_t<s32> show_xmb;                      // CELL_REC_OPTION_SHOW_XMB
+		vm::bptr<char> metadata_filename;        // CELL_REC_OPTION_METADATA_FILENAME
+		vm::bptr<CellRecSpursParam> pSpursParam; // CELL_REC_OPTION_SPURS
+		be_t<u64> dummy;                         // -
+	} value;
+};
+
+struct CellRecParam
+{
+	be_t<s32> videoFmt;
+	be_t<s32> audioFmt;
+	be_t<s32> numOfOpt;
+	vm::bptr<CellRecOption> pOpt;
+};
+
+struct CellRecMovieMetadata
+{
+	vm::bptr<char> gameTitle;
+	vm::bptr<char> movieTitle;
+	vm::bptr<char> description;
+	vm::bptr<char> userdata;
+};
+
+struct CellRecSceneMetadata
+{
+	be_t<u32> type;
+	be_t<u64> startTime;
+	be_t<u64> endTime;
+	u8 unk[4]; // NOTE: there seems to be undocumented padding
+	vm::bptr<char> title;
+	be_t<u32> tagNum;
+	vm::bpptr<char> tag;
+};
+
+using CellRecCallback = void(s32 recStatus, s32 recError, vm::ptr<void> userdata);

ps3fw/include/rpcsx/fw/ps3/cellRemotePlay.h

@@ -0,0 +1,23 @@
+#pragma once
+
+enum CellRemotePlayError : u32
+{
+	CELL_REMOTEPLAY_ERROR_INTERNAL = 0x80029830
+};
+
+enum
+{
+	CELL_REMOTEPLAY_STATUS_LOADING = 0x00000000,
+	CELL_REMOTEPLAY_STATUS_WAIT = 0x00000001,
+	CELL_REMOTEPLAY_STATUS_RUNNING = 0x00000002,
+	CELL_REMOTEPLAY_STATUS_UNLOADING = 0x00000003,
+	CELL_REMOTEPLAY_STATUS_FATALERROR = 0x00000004,
+	CELL_REMOTEPLAY_STATUS_PREMOEND = 0x00000005,
+};
+
+enum
+{
+	CELL_REMOTEPLAY_M4V_MEMORY_CONTAINER_SIZE = 8 * 1024 * 1024,
+	CELL_REMOTEPLAY_AVC_MEMORY_CONTAINER_SIZE = 10 * 1024 * 1024,
+	CELL_REMOTEPLAY_480P_MEMORY_CONTAINER_SIZE = 10 * 1024 * 1024,
+};

ps3fw/include/rpcsx/fw/ps3/cellResc.h

@@ -0,0 +1,124 @@
+#pragma once
+
+enum CellRescError : u32
+{
+	CELL_RESC_ERROR_NOT_INITIALIZED = 0x80210301,
+	CELL_RESC_ERROR_REINITIALIZED = 0x80210302,
+	CELL_RESC_ERROR_BAD_ALIGNMENT = 0x80210303,
+	CELL_RESC_ERROR_BAD_ARGUMENT = 0x80210304,
+	CELL_RESC_ERROR_LESS_MEMORY = 0x80210305,
+	CELL_RESC_ERROR_GCM_FLIP_QUE_FULL = 0x80210306,
+	CELL_RESC_ERROR_BAD_COMBINATION = 0x80210307,
+	CELL_RESC_ERROR_x308 = 0x80210308, // TODO: find proper name
+};
+
+enum
+{
+	COLOR_BUFFER_ALIGNMENT = 128,
+	VERTEX_BUFFER_ALIGNMENT = 4,
+	FRAGMENT_SHADER_ALIGNMENT = 64,
+	VERTEX_NUMBER_NORMAL = 4,
+
+	SRC_BUFFER_NUM = 8,
+	MAX_DST_BUFFER_NUM = 6,
+	RESC_PARAM_NUM
+};
+
+enum CellRescBufferMode
+{
+	CELL_RESC_720x480 = 0x1,
+	CELL_RESC_720x576 = 0x2,
+	CELL_RESC_1280x720 = 0x4,
+	CELL_RESC_1920x1080 = 0x8,
+};
+
+enum CellRescPalTemporalMode
+{
+	CELL_RESC_PAL_50 = 0,
+	CELL_RESC_PAL_60_DROP = 1,
+	CELL_RESC_PAL_60_INTERPOLATE = 2,
+	CELL_RESC_PAL_60_INTERPOLATE_30_DROP = 3,
+	CELL_RESC_PAL_60_INTERPOLATE_DROP_FLEXIBLE = 4,
+	CELL_RESC_PAL_60_FOR_HSYNC = 5,
+};
+
+enum CellRescRatioConvertMode
+{
+	CELL_RESC_FULLSCREEN = 0,
+	CELL_RESC_LETTERBOX = 1,
+	CELL_RESC_PANSCAN = 2,
+};
+
+enum CellRescFlipMode
+{
+	CELL_RESC_DISPLAY_VSYNC = 0,
+	CELL_RESC_DISPLAY_HSYNC = 1,
+};
+
+enum CellRescDstFormat
+{
+	CELL_RESC_SURFACE_A8R8G8B8 = 8,        // == CELL_GCM_SURFACE_A8R8G8B8
+	CELL_RESC_SURFACE_F_W16Z16Y16X16 = 11, // == CELL_GCM_SURFACE_F_W16Z16Y16X16
+};
+
+enum CellRescResourcePolicy
+{
+	CELL_RESC_CONSTANT_VRAM = 0x0,
+	CELL_RESC_MINIMUM_VRAM = 0x1,
+	CELL_RESC_CONSTANT_GPU_LOAD = 0x0,
+	CELL_RESC_MINIMUM_GPU_LOAD = 0x2,
+};
+
+enum CellRescConvolutionFilterMode
+{
+	CELL_RESC_NORMAL_BILINEAR = 0,
+	CELL_RESC_INTERLACE_FILTER = 1,
+	CELL_RESC_3X3_GAUSSIAN = 2,
+	CELL_RESC_2X3_QUINCUNX = 3,
+	CELL_RESC_2X3_QUINCUNX_ALT = 4,
+};
+
+struct CellRescDsts
+{
+	be_t<u32> format;
+	be_t<u32> pitch;
+	be_t<u32> heightAlign;
+};
+
+struct CellRescInitConfig
+{
+	be_t<u32> size; // usz
+	be_t<u32> resourcePolicy;
+	be_t<u32> supportModes;
+	be_t<u32> ratioMode;
+	be_t<u32> palTemporalMode;
+	be_t<u32> interlaceMode;
+	be_t<u32> flipMode;
+};
+
+struct CellRescSrc
+{
+	be_t<u32> format;
+	be_t<u32> pitch;
+	be_t<u16> width;
+	be_t<u16> height;
+	be_t<u32> offset;
+};
+
+struct cell_resc_manager
+{
+	atomic_t<bool> is_initialized = false;
+
+	u32 buffer_mode{};
+
+	struct
+	{
+		u32 size{};
+		u32 resource_policy{};
+		u32 support_modes{};
+		u32 ratio_mode{};
+		u32 pal_temporal_mode{};
+		u32 interlace_mode{};
+		u32 flip_mode{};
+	} config;
+};

ps3fw/include/rpcsx/fw/ps3/cellRtc.h

@@ -0,0 +1,71 @@
+#pragma once
+
+#include "Emu/Memory/vm_ptr.h"
+#include "Emu/Cell/ErrorCodes.h"
+
+// Return Codes
+enum CellRtcError
+{
+	CELL_RTC_ERROR_NOT_INITIALIZED = 0x80010601,
+	CELL_RTC_ERROR_INVALID_POINTER = 0x80010602,
+	CELL_RTC_ERROR_INVALID_VALUE = 0x80010603,
+	CELL_RTC_ERROR_INVALID_ARG = 0x80010604,
+	CELL_RTC_ERROR_NOT_SUPPORTED = 0x80010605,
+	CELL_RTC_ERROR_NO_CLOCK = 0x80010606,
+	CELL_RTC_ERROR_BAD_PARSE = 0x80010607,
+	CELL_RTC_ERROR_INVALID_YEAR = 0x80010621,
+	CELL_RTC_ERROR_INVALID_MONTH = 0x80010622,
+	CELL_RTC_ERROR_INVALID_DAY = 0x80010623,
+	CELL_RTC_ERROR_INVALID_HOUR = 0x80010624,
+	CELL_RTC_ERROR_INVALID_MINUTE = 0x80010625,
+	CELL_RTC_ERROR_INVALID_SECOND = 0x80010626,
+	CELL_RTC_ERROR_INVALID_MICROSECOND = 0x80010627,
+};
+
+struct CellRtcTick
+{
+	be_t<u64> tick;
+};
+
+struct CellRtcDateTime
+{
+	be_t<u16> year;        // 1 to 9999
+	be_t<u16> month;       // 1 to 12
+	be_t<u16> day;         // 1 to 31
+	be_t<u16> hour;        // 0 to 23
+	be_t<u16> minute;      // 0 to 59
+	be_t<u16> second;      // 0 to 59
+	be_t<u32> microsecond; // 0 to 999999
+};
+
+constexpr u64 RTC_MAGIC_OFFSET = 62135596800000000ull;    // 1970-01-01 00:00:00.000000
+constexpr u64 RTC_FILETIME_OFFSET = 50491123200000000ull; // 1601-01-01 00:00:00.000000
+constexpr u64 RTC_SYSTEM_TIME_MIN = 63082281600000000ull; // 2000-01-01 00:00:00.000000
+constexpr u64 RTC_SYSTEM_TIME_MAX = 66238041599999999ull; // 2099-12-31 23:59:59.999999
+
+constexpr u32 DAYS_IN_400_YEARS = 365 * 400 + 97;
+constexpr u16 DAYS_IN_100_YEARS = 365 * 100 + 24;
+constexpr u16 DAYS_IN_4_YEARS = 365 * 4 + 1;
+
+constexpr std::array<u8, 12> DAYS_IN_MONTH = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
+constexpr std::array<u8, 12> DAYS_IN_MONTH_LEAP = {31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
+
+constexpr std::array<u16, 13> MONTH_OFFSET = {0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, umax};
+constexpr std::array<u16, 13> MONTH_OFFSET_LEAP = {0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335, umax};
+
+constexpr std::array<std::string_view, 7> WEEKDAY_NAMES = {"sunday", "monday", "tuesday", "wednesday", "thursday", "friday", "saturday"};
+constexpr std::array<std::string_view, 12> MONTH_NAMES = {"january", "february", "march", "april", "may", "june", "july", "august", "september", "october", "november", "december"};
+constexpr std::array<std::string_view, 70> TIME_ZONE_NAMES = {"gmt", "est", "edt", "cst", "cdt", "mst", "mdt", "pst", "pdt", "nzdt", "nzst", "idle", "nzt", "aesst", "acsst", "cadt", "sadt", "aest", "east", "gst", "ligt", "acst", "sast", "cast", "awsst", "jst", "kst", "wdt", "mt", "awst", "cct", "wadt", "wst", "jt", "wast", "it", "bt", "eetdst", "eet", "cetdst", "fwt", "ist", "mest", "metdst", "sst", "bst", "cet", "dnt", "fst", "met", "mewt", "mez", "nor", "set", "swt", "wetdst", "wet", "wat", "ndt", "adt", "nft", "nst", "ast", "ydt", "hdt", "yst", "ahst", "cat", "nt", "idlw"};
+constexpr std::array<s8, 70> TIME_ZONE_VALUES = {0, -10, -8, -12, -10, -14, -12, -16, -14, 26, 24, 24, 24, 22, 21, 21, 21, 20, 20, 20, 20, 19, 19, 19, 18, 18, 18, 18, 17, 16, 16, 16, 16, 15, 14, 7, 6, 6, 4, 4, 4, 4, 4, 4, 4, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, -2, -3, -6, -5, -5, -8, -16, -18, -18, -20, -20, -22, -24}; // In units of 30 minutes
+
+error_code cellRtcTickAddMinutes(ppu_thread& ppu, vm::ptr<CellRtcTick> pTick0, vm::cptr<CellRtcTick> pTick1, s64 lAdd);
+
+error_code cellRtcSetTick(ppu_thread& ppu, vm::ptr<CellRtcDateTime> pTime, vm::cptr<CellRtcTick> pTick);
+constexpr u32 cellRtcGetTickResolution();
+error_code cellRtcCheckValid(vm::cptr<CellRtcDateTime> pTime);
+s32 cellRtcGetDayOfWeek(s32 year, s32 month, s32 day);
+error_code cellRtcGetTick(ppu_thread& ppu, vm::cptr<CellRtcDateTime> pTime, vm::ptr<CellRtcTick> pTick);
+error_code cellRtcGetCurrentTick(ppu_thread& ppu, vm::ptr<CellRtcTick> pTick);
+
+CellRtcDateTime tick_to_date_time(u64 tick);
+u64 date_time_to_tick(CellRtcDateTime date_time);

ps3fw/include/rpcsx/fw/ps3/cellRudp.h

@@ -0,0 +1,92 @@
+#pragma once
+
+#include "Emu/Memory/vm_ptr.h"
+
+// Return Codes
+constexpr auto CELL_RUDP_SUCCESS = CELL_OK;
+
+enum CellRudpError : u32
+{
+	CELL_RUDP_ERROR_NOT_INITIALIZED = 0x80770001,
+	CELL_RUDP_ERROR_ALREADY_INITIALIZED = 0x80770002,
+	CELL_RUDP_ERROR_INVALID_CONTEXT_ID = 0x80770003,
+	CELL_RUDP_ERROR_INVALID_ARGUMENT = 0x80770004,
+	CELL_RUDP_ERROR_INVALID_OPTION = 0x80770005,
+	CELL_RUDP_ERROR_INVALID_MUXMODE = 0x80770006,
+	CELL_RUDP_ERROR_MEMORY = 0x80770007,
+	CELL_RUDP_ERROR_INTERNAL = 0x80770008,
+	CELL_RUDP_ERROR_CONN_RESET = 0x80770009,
+	CELL_RUDP_ERROR_CONN_REFUSED = 0x8077000a,
+	CELL_RUDP_ERROR_CONN_TIMEOUT = 0x8077000b,
+	CELL_RUDP_ERROR_CONN_VERSION_MISMATCH = 0x8077000c,
+	CELL_RUDP_ERROR_CONN_TRANSPORT_TYPE_MISMATCH = 0x8077000d,
+	CELL_RUDP_ERROR_QUALITY_LEVEL_MISMATCH = 0x8077000e,
+	CELL_RUDP_ERROR_THREAD = 0x8077000f,
+	CELL_RUDP_ERROR_THREAD_IN_USE = 0x80770010,
+	CELL_RUDP_ERROR_NOT_ACCEPTABLE = 0x80770011,
+	CELL_RUDP_ERROR_MSG_TOO_LARGE = 0x80770012,
+	CELL_RUDP_ERROR_NOT_BOUND = 0x80770013,
+	CELL_RUDP_ERROR_CANCELLED = 0x80770014,
+	CELL_RUDP_ERROR_INVALID_VPORT = 0x80770015,
+	CELL_RUDP_ERROR_WOULDBLOCK = 0x80770016,
+	CELL_RUDP_ERROR_VPORT_IN_USE = 0x80770017,
+	CELL_RUDP_ERROR_VPORT_EXHAUSTED = 0x80770018,
+	CELL_RUDP_ERROR_INVALID_SOCKET = 0x80770019,
+	CELL_RUDP_ERROR_BUFFER_TOO_SMALL = 0x8077001a,
+	CELL_RUDP_ERROR_MSG_MALFORMED = 0x8077001b,
+	CELL_RUDP_ERROR_ADDR_IN_USE = 0x8077001c,
+	CELL_RUDP_ERROR_ALREADY_BOUND = 0x8077001d,
+	CELL_RUDP_ERROR_ALREADY_EXISTS = 0x8077001e,
+	CELL_RUDP_ERROR_INVALID_POLL_ID = 0x8077001f,
+	CELL_RUDP_ERROR_TOO_MANY_CONTEXTS = 0x80770020,
+	CELL_RUDP_ERROR_IN_PROGRESS = 0x80770021,
+	CELL_RUDP_ERROR_NO_EVENT_HANDLER = 0x80770022,
+	CELL_RUDP_ERROR_PAYLOAD_TOO_LARGE = 0x80770023,
+	CELL_RUDP_ERROR_END_OF_DATA = 0x80770024,
+	CELL_RUDP_ERROR_ALREADY_ESTABLISHED = 0x80770025,
+	CELL_RUDP_ERROR_KEEP_ALIVE_FAILURE = 0x80770026,
+};
+
+// Context options
+enum
+{
+	CELL_RUDP_OPTION_MAX_PAYLOAD = 1,
+	CELL_RUDP_OPTION_SNDBUF = 2,
+	CELL_RUDP_OPTION_RCVBUF = 3,
+	CELL_RUDP_OPTION_NODELAY = 4,
+	CELL_RUDP_OPTION_DELIVERY_CRITICAL = 5,
+	CELL_RUDP_OPTION_ORDER_CRITICAL = 6,
+	CELL_RUDP_OPTION_NONBLOCK = 7,
+	CELL_RUDP_OPTION_STREAM = 8,
+	CELL_RUDP_OPTION_CONNECTION_TIMEOUT = 9,
+	CELL_RUDP_OPTION_CLOSE_WAIT_TIMEOUT = 10,
+	CELL_RUDP_OPTION_AGGREGATION_TIMEOUT = 11,
+	CELL_RUDP_OPTION_LAST_ERROR = 14,
+	CELL_RUDP_OPTION_READ_TIMEOUT = 15,
+	CELL_RUDP_OPTION_WRITE_TIMEOUT = 16,
+	CELL_RUDP_OPTION_FLUSH_TIMEOUT = 17,
+	CELL_RUDP_OPTION_KEEP_ALIVE_INTERVAL = 18,
+	CELL_RUDP_OPTION_KEEP_ALIVE_TIMEOUT = 19,
+};
+
+// Polling event flags
+enum
+{
+	CELL_RUDP_POLL_EV_READ = 0x0001,
+	CELL_RUDP_POLL_EV_WRITE = 0x0002,
+	CELL_RUDP_POLL_EV_FLUSH = 0x0004,
+	CELL_RUDP_POLL_EV_ERROR = 0x0008,
+};
+
+struct sys_net_sockaddr;
+
+using CellRudpEventHandler = s32(s32 event_id, s32 soc, vm::cptr<u8> data, u32 datalen, vm::cptr<sys_net_sockaddr> addr, u32 addrlen, vm::ptr<void> arg);
+
+using CellRudpAllocatorFuncAlloc = vm::ptr<void>(u32 size);
+using CellRudpAllocatorFuncFree = void(vm::ptr<void> ptr);
+
+struct CellRudpAllocator
+{
+	vm::bptr<CellRudpAllocatorFuncAlloc> app_malloc;
+	vm::bptr<CellRudpAllocatorFuncFree> app_free;
+};

ps3fw/include/rpcsx/fw/ps3/cellSaveData.h

@@ -0,0 +1,363 @@
+#pragma once
+
+#include "util/types.hpp"
+#include "Emu/Memory/vm_ptr.h"
+#include <string>
+#include <vector>
+
+// Return codes
+enum CellSaveDataError : u32
+{
+	CELL_SAVEDATA_ERROR_CBRESULT = 0x8002b401,
+	CELL_SAVEDATA_ERROR_ACCESS_ERROR = 0x8002b402,
+	CELL_SAVEDATA_ERROR_INTERNAL = 0x8002b403,
+	CELL_SAVEDATA_ERROR_PARAM = 0x8002b404,
+	CELL_SAVEDATA_ERROR_NOSPACE = 0x8002b405,
+	CELL_SAVEDATA_ERROR_BROKEN = 0x8002b406,
+	CELL_SAVEDATA_ERROR_FAILURE = 0x8002b407,
+	CELL_SAVEDATA_ERROR_BUSY = 0x8002b408,
+	CELL_SAVEDATA_ERROR_NOUSER = 0x8002b409,
+	CELL_SAVEDATA_ERROR_SIZEOVER = 0x8002b40a,
+	CELL_SAVEDATA_ERROR_NODATA = 0x8002b40b,
+	CELL_SAVEDATA_ERROR_NOTSUPPORTED = 0x8002b40c,
+};
+
+// Callback return codes
+enum
+{
+	CELL_SAVEDATA_CBRESULT_OK_LAST_NOCONFIRM = 2,
+	CELL_SAVEDATA_CBRESULT_OK_LAST = 1,
+	CELL_SAVEDATA_CBRESULT_OK_NEXT = 0,
+	CELL_SAVEDATA_CBRESULT_ERR_NOSPACE = -1,
+	CELL_SAVEDATA_CBRESULT_ERR_FAILURE = -2,
+	CELL_SAVEDATA_CBRESULT_ERR_BROKEN = -3,
+	CELL_SAVEDATA_CBRESULT_ERR_NODATA = -4,
+	CELL_SAVEDATA_CBRESULT_ERR_INVALID = -5,
+};
+
+// Bind stat return codes
+enum
+{
+	CELL_SAVEDATA_BINDSTAT_OK = 0,
+	CELL_SAVEDATA_BINDSTAT_ERR_CONSOLE = 1 << 0,
+	CELL_SAVEDATA_BINDSTAT_ERR_DISC = 1 << 1,
+	CELL_SAVEDATA_BINDSTAT_ERR_PROGRAM = 1 << 2,
+	CELL_SAVEDATA_BINDSTAT_ERR_NOACCOUNTI = 1 << 3,
+	CELL_SAVEDATA_BINDSTAT_ERR_NOUSER = 1 << 3,
+	CELL_SAVEDATA_BINDSTAT_ERR_ACCOUNTID = 1 << 4,
+	CELL_SAVEDATA_BINDSTAT_ERR_OTHERS = 1 << 4,
+	CELL_SAVEDATA_BINDSTAT_ERR_NOUSERID = 1 << 5,
+	CELL_SAVEDATA_BINDSTAT_ERR_USERID = 1 << 6,
+	CELL_SAVEDATA_BINDSTAT_ERR_NOOWNER = 1 << 8,
+	CELL_SAVEDATA_BINDSTAT_ERR_OWNER = 1 << 9,
+	CELL_SAVEDATA_BINDSTAT_ERR_LOCALOWNER = 1 << 10,
+};
+
+// Constants
+enum
+{
+	// CellSaveDataParamSize
+	CELL_SAVEDATA_DIRNAME_SIZE = 32,
+	CELL_SAVEDATA_FILENAME_SIZE = 13,
+	CELL_SAVEDATA_SECUREFILEID_SIZE = 16,
+	CELL_SAVEDATA_PREFIX_SIZE = 256,
+	CELL_SAVEDATA_LISTITEM_MAX = 2048,
+	CELL_SAVEDATA_SECUREFILE_MAX = 113,
+	CELL_SAVEDATA_DIRLIST_MAX = 2048,
+	CELL_SAVEDATA_INVALIDMSG_MAX = 256,
+	CELL_SAVEDATA_INDICATORMSG_MAX = 64,
+
+	// CellSaveDataSystemParamSize
+	CELL_SAVEDATA_SYSP_TITLE_SIZE = 128,
+	CELL_SAVEDATA_SYSP_SUBTITLE_SIZE = 128,
+	CELL_SAVEDATA_SYSP_DETAIL_SIZE = 1024,
+	CELL_SAVEDATA_SYSP_LPARAM_SIZE = 8,
+
+	// CellSaveDataSortType
+	CELL_SAVEDATA_SORTTYPE_MODIFIEDTIME = 0,
+	CELL_SAVEDATA_SORTTYPE_SUBTITLE = 1,
+
+	// CellSaveDataSortOrder
+	CELL_SAVEDATA_SORTORDER_DESCENT = 0,
+	CELL_SAVEDATA_SORTORDER_ASCENT = 1,
+
+	// CellSaveDataIsNewData
+	CELL_SAVEDATA_ISNEWDATA_NO = 0,
+	CELL_SAVEDATA_ISNEWDATA_YES = 1,
+
+	// CellSaveDataFocusPosition
+	CELL_SAVEDATA_FOCUSPOS_DIRNAME = 0,
+	CELL_SAVEDATA_FOCUSPOS_LISTHEAD = 1,
+	CELL_SAVEDATA_FOCUSPOS_LISTTAIL = 2,
+	CELL_SAVEDATA_FOCUSPOS_LATEST = 3,
+	CELL_SAVEDATA_FOCUSPOS_OLDEST = 4,
+	CELL_SAVEDATA_FOCUSPOS_NEWDATA = 5,
+
+	// CellSaveDataFileOperation
+	CELL_SAVEDATA_FILEOP_READ = 0,
+	CELL_SAVEDATA_FILEOP_WRITE = 1,
+	CELL_SAVEDATA_FILEOP_DELETE = 2,
+	CELL_SAVEDATA_FILEOP_WRITE_NOTRUNC = 3,
+
+	// CellSaveDataFileType
+	CELL_SAVEDATA_FILETYPE_SECUREFILE = 0,
+	CELL_SAVEDATA_FILETYPE_NORMALFILE = 1,
+	CELL_SAVEDATA_FILETYPE_CONTENT_ICON0 = 2,
+	CELL_SAVEDATA_FILETYPE_CONTENT_ICON1 = 3,
+	CELL_SAVEDATA_FILETYPE_CONTENT_PIC1 = 4,
+	CELL_SAVEDATA_FILETYPE_CONTENT_SND0 = 5,
+
+	// CellSaveDataSystemFileParam attribute
+	CELL_SAVEDATA_ATTR_NORMAL = 0,
+	CELL_SAVEDATA_ATTR_NODUPLICATE = 1,
+
+	// reCreateMode
+	CELL_SAVEDATA_RECREATE_NO = 0,
+	CELL_SAVEDATA_RECREATE_NO_NOBROKEN = 1,
+	CELL_SAVEDATA_RECREATE_YES = 2,
+	CELL_SAVEDATA_RECREATE_YES_RESET_OWNER = 3,
+	CELL_SAVEDATA_RECREATE_MASK = 0xfffeffff,
+
+	// Version
+	CELL_SAVEDATA_VERSION_OLD = 0,
+	CELL_SAVEDATA_VERSION_420 = 1,
+
+	// Error Dialog
+	CELL_SAVEDATA_ERRDIALOG_NONE = 0,
+	CELL_SAVEDATA_ERRDIALOG_ALWAYS = 1,
+	CELL_SAVEDATA_ERRDIALOG_NOREPEAT = 2,
+
+	// Options for funcFixed dialog
+	CELL_SAVEDATA_OPTION_NONE = 0,
+	CELL_SAVEDATA_OPTION_NOCONFIRM = 1,
+
+	// CellSaveDataAutoIndicatorDispPosition
+	CELL_SAVEDATA_INDICATORPOS_LOWER_RIGHT = 0,
+	CELL_SAVEDATA_INDICATORPOS_LOWER_LEFT = 1,
+	CELL_SAVEDATA_INDICATORPOS_UPPER_RIGHT = 2,
+	CELL_SAVEDATA_INDICATORPOS_UPPER_LEFT = 3,
+	CELL_SAVEDATA_INDICATORPOS_CENTER = 4,
+
+	// CellSaveDataAutoIndicatorDispMsgAlign
+	CELL_SAVEDATA_INDICATORPOS_MSGALIGN_LEFT = 0 << 4,
+	CELL_SAVEDATA_INDICATORPOS_MSGALIGN_RIGHT = 1 << 4,
+	CELL_SAVEDATA_INDICATORPOS_MSGALIGN_CENTER = 2 << 4,
+
+	// CellSaveDataAutoIndicatorDispMode
+	CELL_SAVEDATA_INDICATORMODE_FIXED = 0,
+	CELL_SAVEDATA_INDICATORMODE_BLINK = 1,
+	CELL_SAVEDATA_INDICATORMODE_BLINK_FAST = 2,
+	CELL_SAVEDATA_INDICATORMODE_BLINK_SLOW = 3,
+
+	// Trophy ownership
+	CELL_SAVEDATA_DISABLE_TROPHY_OWNERSHIP_CHECK = 1 << 16,
+};
+
+// CellSaveDataListNewData::iconPosition
+enum : u32
+{
+	CELL_SAVEDATA_ICONPOS_HEAD = 0,
+	CELL_SAVEDATA_ICONPOS_TAIL = 1,
+};
+
+// Datatypes
+struct CellSaveDataSetList
+{
+	be_t<u32> sortType;
+	be_t<u32> sortOrder;
+	vm::bptr<char> dirNamePrefix;
+	vm::bptr<void> reserved;
+};
+
+struct CellSaveDataSetBuf
+{
+	be_t<u32> dirListMax;
+	be_t<u32> fileListMax;
+	be_t<u32> reserved[6];
+	be_t<u32> bufSize;
+	vm::bptr<void> buf;
+};
+
+struct CellSaveDataNewDataIcon
+{
+	vm::bptr<char> title;
+	be_t<u32> iconBufSize;
+	vm::bptr<void> iconBuf;
+	vm::bptr<void> reserved;
+};
+
+struct CellSaveDataListNewData
+{
+	be_t<u32> iconPosition;
+	vm::bptr<char> dirName;
+	vm::bptr<CellSaveDataNewDataIcon> icon;
+	vm::bptr<void> reserved;
+};
+
+struct CellSaveDataDirList
+{
+	char dirName[CELL_SAVEDATA_DIRNAME_SIZE];
+	char listParam[CELL_SAVEDATA_SYSP_LPARAM_SIZE];
+	char reserved[8];
+};
+
+struct CellSaveDataListGet
+{
+	be_t<u32> dirNum;
+	be_t<u32> dirListNum;
+	vm::bptr<CellSaveDataDirList> dirList;
+	char reserved[64];
+};
+
+struct CellSaveDataListSet
+{
+	be_t<u32> focusPosition;
+	vm::bptr<char> focusDirName;
+	be_t<u32> fixedListNum;
+	vm::bptr<CellSaveDataDirList> fixedList;
+	vm::bptr<CellSaveDataListNewData> newData;
+	vm::bptr<void> reserved;
+};
+
+struct CellSaveDataFixedSet
+{
+	vm::bptr<char> dirName;
+	vm::bptr<CellSaveDataNewDataIcon> newIcon;
+	be_t<u32> option;
+};
+
+struct CellSaveDataSystemFileParam
+{
+	char title[CELL_SAVEDATA_SYSP_TITLE_SIZE];
+	char subTitle[CELL_SAVEDATA_SYSP_SUBTITLE_SIZE];
+	char detail[CELL_SAVEDATA_SYSP_DETAIL_SIZE];
+	be_t<u32> attribute;
+	be_t<u32> parental_level; // char reserved2[4] in firmware 3.70 or higher
+	char listParam[CELL_SAVEDATA_SYSP_LPARAM_SIZE];
+	char reserved[256];
+};
+
+struct CellSaveDataDirStat
+{
+	be_t<s64> atime;
+	be_t<s64> mtime;
+	be_t<s64> ctime;
+	char dirName[CELL_SAVEDATA_DIRNAME_SIZE];
+};
+
+struct CellSaveDataFileStat
+{
+	be_t<u32> fileType;
+	char reserved1[4];
+	be_t<u64> size;
+	be_t<s64> atime;
+	be_t<s64> mtime;
+	be_t<s64> ctime;
+	char fileName[CELL_SAVEDATA_FILENAME_SIZE];
+	char reserved2[3];
+};
+
+struct CellSaveDataStatGet
+{
+	be_t<s32> hddFreeSizeKB;
+	be_t<u32> isNewData;
+	CellSaveDataDirStat dir;
+	CellSaveDataSystemFileParam getParam;
+	be_t<u32> bind;
+	be_t<s32> sizeKB;
+	be_t<s32> sysSizeKB;
+	be_t<u32> fileNum;
+	be_t<u32> fileListNum;
+	vm::bptr<CellSaveDataFileStat> fileList;
+	char reserved[64];
+};
+
+struct CellSaveDataAutoIndicator
+{
+	be_t<u32> dispPosition;
+	be_t<u32> dispMode;
+	vm::bptr<char> dispMsg;
+	be_t<u32> picBufSize;
+	vm::bptr<void> picBuf;
+	vm::bptr<void> reserved;
+};
+
+struct CellSaveDataStatSet
+{
+	vm::bptr<CellSaveDataSystemFileParam> setParam;
+	be_t<u32> reCreateMode;
+	vm::bptr<CellSaveDataAutoIndicator> indicator;
+};
+
+struct CellSaveDataFileGet
+{
+	be_t<u32> excSize;
+	char reserved[64];
+};
+
+struct CellSaveDataFileSet
+{
+	be_t<u32> fileOperation;
+	vm::bptr<void> reserved;
+	be_t<u32> fileType;
+	be_t<u128, 1> secureFileId;
+	vm::bptr<char> fileName;
+	be_t<u32> fileOffset;
+	be_t<u32> fileSize;
+	be_t<u32> fileBufSize;
+	vm::bptr<void> fileBuf;
+};
+
+struct CellSaveDataCBResult
+{
+	be_t<s32> result;
+	be_t<u32> progressBarInc;
+	be_t<s32> errNeedSizeKB;
+	vm::bptr<char> invalidMsg;
+	vm::bptr<void> userdata;
+};
+
+struct CellSaveDataDoneGet
+{
+	be_t<s32> excResult;
+	char dirName[CELL_SAVEDATA_DIRNAME_SIZE];
+	be_t<s32> sizeKB;
+	be_t<s32> hddFreeSizeKB;
+	char reserved[64];
+};
+
+// Callback Functions
+using CellSaveDataFixedCallback = void(vm::ptr<CellSaveDataCBResult> cbResult, vm::ptr<CellSaveDataListGet> get, vm::ptr<CellSaveDataFixedSet> set);
+using CellSaveDataListCallback = void(vm::ptr<CellSaveDataCBResult> cbResult, vm::ptr<CellSaveDataListGet> get, vm::ptr<CellSaveDataListSet> set);
+using CellSaveDataStatCallback = void(vm::ptr<CellSaveDataCBResult> cbResult, vm::ptr<CellSaveDataStatGet> get, vm::ptr<CellSaveDataStatSet> set);
+using CellSaveDataFileCallback = void(vm::ptr<CellSaveDataCBResult> cbResult, vm::ptr<CellSaveDataFileGet> get, vm::ptr<CellSaveDataFileSet> set);
+using CellSaveDataDoneCallback = void(vm::ptr<CellSaveDataCBResult> cbResult, vm::ptr<CellSaveDataDoneGet> get);
+
+// Auxiliary Structs
+struct SaveDataEntry
+{
+	std::string escaped;
+
+	std::string dirName;
+	std::string listParam;
+	std::string title;
+	std::string subtitle;
+	std::string details;
+	u64 size{0};
+	s64 atime{0};
+	s64 mtime{0};
+	s64 ctime{0};
+	std::vector<uchar> iconBuf;
+	bool isNew{false};
+
+	std::string date() const;
+	std::string data_size() const;
+};
+
+class SaveDialogBase
+{
+public:
+	virtual ~SaveDialogBase();
+
+	virtual s32 ShowSaveDataList(const std::string& base_dir, std::vector<SaveDataEntry>& save_entries, s32 focused, u32 op, vm::ptr<CellSaveDataListSet> listSet, bool enable_overlay) = 0;
+};

ps3fw/include/rpcsx/fw/ps3/cellScreenshot.h

@@ -0,0 +1,53 @@
+#pragma once
+
+#include "Emu/Memory/vm_ptr.h"
+
+// Return Codes
+enum CellScreenShotError : u32
+{
+	CELL_SCREENSHOT_ERROR_INTERNAL = 0x8002d101,
+	CELL_SCREENSHOT_ERROR_PARAM = 0x8002d102,
+	CELL_SCREENSHOT_ERROR_DECODE = 0x8002d103,
+	CELL_SCREENSHOT_ERROR_NOSPACE = 0x8002d104,
+	CELL_SCREENSHOT_ERROR_UNSUPPORTED_COLOR_FORMAT = 0x8002d105,
+};
+
+enum CellScreenShotParamSize
+{
+	CELL_SCREENSHOT_PHOTO_TITLE_MAX_LENGTH = 64,
+	CELL_SCREENSHOT_GAME_TITLE_MAX_LENGTH = 64,
+	CELL_SCREENSHOT_GAME_COMMENT_MAX_SIZE = 1024,
+};
+
+struct CellScreenShotSetParam
+{
+	vm::bcptr<char> photo_title;
+	vm::bcptr<char> game_title;
+	vm::bcptr<char> game_comment;
+	vm::bptr<void> reserved;
+};
+
+struct screenshot_info
+{
+	bool is_enabled{false};
+
+	std::string photo_title;
+	std::string game_title;
+	std::string game_comment;
+
+	s32 overlay_offset_x{0};
+	s32 overlay_offset_y{0};
+	std::string overlay_dir_name;
+	std::string overlay_file_name;
+
+	std::string get_overlay_path() const;
+	std::string get_photo_title() const;
+	std::string get_game_title() const;
+	std::string get_game_comment() const;
+	std::string get_screenshot_path(const std::string& date_path) const;
+};
+
+struct screenshot_manager : public screenshot_info
+{
+	shared_mutex mutex;
+};

ps3fw/include/rpcsx/fw/ps3/cellSearch.h

@@ -0,0 +1,360 @@
+#pragma once
+
+#include "Emu/Memory/vm_ptr.h"
+
+// Error Codes
+enum CellSearchError : u32
+{
+	CELL_SEARCH_CANCELED = 1,
+	CELL_SEARCH_ERROR_PARAM = 0x8002C801,
+	CELL_SEARCH_ERROR_BUSY = 0x8002C802,
+	CELL_SEARCH_ERROR_NO_MEMORY = 0x8002C803,
+	CELL_SEARCH_ERROR_UNKNOWN_MODE = 0x8002C804,
+	CELL_SEARCH_ERROR_ALREADY_INITIALIZED = 0x8002C805,
+	CELL_SEARCH_ERROR_NOT_INITIALIZED = 0x8002C806,
+	CELL_SEARCH_ERROR_FINALIZING = 0x8002C807,
+	CELL_SEARCH_ERROR_NOT_SUPPORTED_SEARCH = 0x8002C808,
+	CELL_SEARCH_ERROR_CONTENT_OBSOLETE = 0x8002C809,
+	CELL_SEARCH_ERROR_CONTENT_NOT_FOUND = 0x8002C80A,
+	CELL_SEARCH_ERROR_NOT_LIST = 0x8002C80B,
+	CELL_SEARCH_ERROR_OUT_OF_RANGE = 0x8002C80C,
+	CELL_SEARCH_ERROR_INVALID_SEARCHID = 0x8002C80D,
+	CELL_SEARCH_ERROR_ALREADY_GOT_RESULT = 0x8002C80E,
+	CELL_SEARCH_ERROR_NOT_SUPPORTED_CONTEXT = 0x8002C80F,
+	CELL_SEARCH_ERROR_INVALID_CONTENTTYPE = 0x8002C810,
+	CELL_SEARCH_ERROR_DRM = 0x8002C811,
+	CELL_SEARCH_ERROR_TAG = 0x8002C812,
+	CELL_SEARCH_ERROR_GENERIC = 0x8002C8FF,
+};
+
+// Constants
+enum
+{
+	CELL_SEARCH_CONTENT_ID_SIZE = 16,
+	CELL_SEARCH_TITLE_LEN_MAX = 384,
+	CELL_SEARCH_TAG_NUM_MAX = 6,
+	CELL_SEARCH_TAG_LEN_MAX = 63,
+	CELL_SEARCH_PATH_LEN_MAX = 63,
+	CELL_SEARCH_MTOPTION_LEN_MAX = 63,
+	CELL_SEARCH_DEVELOPERDATA_LEN_MAX = 64,
+	CELL_SEARCH_GAMECOMMENT_SIZE_MAX = 1024,
+	CELL_SEARCH_CONTENT_BUFFER_SIZE_MAX = 2048,
+};
+
+// Sort keys
+enum CellSearchSortKey : s32
+{
+	CELL_SEARCH_SORTKEY_NONE = 0,
+	CELL_SEARCH_SORTKEY_DEFAULT = 1,
+	CELL_SEARCH_SORTKEY_TITLE = 2,
+	CELL_SEARCH_SORTKEY_ALBUMTITLE = 3,
+	CELL_SEARCH_SORTKEY_GENRENAME = 4,
+	CELL_SEARCH_SORTKEY_ARTISTNAME = 5,
+	CELL_SEARCH_SORTKEY_IMPORTEDDATE = 6,
+	CELL_SEARCH_SORTKEY_TRACKNUMBER = 7,
+	CELL_SEARCH_SORTKEY_TAKENDATE = 8,
+	CELL_SEARCH_SORTKEY_USERDEFINED = 9,
+	CELL_SEARCH_SORTKEY_MODIFIEDDATE = 10,
+};
+
+// Sort order
+enum CellSearchSortOrder : s32
+{
+	CELL_SEARCH_SORTORDER_NONE = 0,
+	CELL_SEARCH_SORTORDER_ASCENDING = 1,
+	CELL_SEARCH_SORTORDER_DESCENDING = 2,
+};
+
+// Content types
+enum CellSearchContentType : s32
+{
+	CELL_SEARCH_CONTENTTYPE_NONE = 0,
+	CELL_SEARCH_CONTENTTYPE_MUSIC = 1,
+	CELL_SEARCH_CONTENTTYPE_MUSICLIST = 2,
+	CELL_SEARCH_CONTENTTYPE_PHOTO = 3,
+	CELL_SEARCH_CONTENTTYPE_PHOTOLIST = 4,
+	CELL_SEARCH_CONTENTTYPE_VIDEO = 5,
+	CELL_SEARCH_CONTENTTYPE_VIDEOLIST = 6,
+	CELL_SEARCH_CONTENTTYPE_SCENE = 7,
+};
+
+// Codecs
+enum CellSearchCodec : s32
+{
+	CELL_SEARCH_CODEC_UNKNOWN = 0,
+	CELL_SEARCH_CODEC_MPEG2 = 1,
+	CELL_SEARCH_CODEC_MPEG4 = 2,
+	CELL_SEARCH_CODEC_AVC = 3,
+	CELL_SEARCH_CODEC_MPEG1 = 4,
+	CELL_SEARCH_CODEC_AT3 = 5,
+	CELL_SEARCH_CODEC_AT3P = 6,
+	CELL_SEARCH_CODEC_ATALL = 7,
+	CELL_SEARCH_CODEC_MP3 = 8,
+	CELL_SEARCH_CODEC_AAC = 9,
+	CELL_SEARCH_CODEC_LPCM = 10,
+	CELL_SEARCH_CODEC_WAV = 11,
+	CELL_SEARCH_CODEC_WMA = 12,
+	CELL_SEARCH_CODEC_JPEG = 13,
+	CELL_SEARCH_CODEC_PNG = 14,
+	CELL_SEARCH_CODEC_TIFF = 15,
+	CELL_SEARCH_CODEC_BMP = 16,
+	CELL_SEARCH_CODEC_GIF = 17,
+	CELL_SEARCH_CODEC_MPEG2_TS = 18,
+	CELL_SEARCH_CODEC_DSD = 19,
+	CELL_SEARCH_CODEC_AC3 = 20,
+	CELL_SEARCH_CODEC_MPEG1_LAYER1 = 21,
+	CELL_SEARCH_CODEC_MPEG1_LAYER2 = 22,
+	CELL_SEARCH_CODEC_MPEG1_LAYER3 = 23,
+	CELL_SEARCH_CODEC_MPEG2_LAYER1 = 24,
+	CELL_SEARCH_CODEC_MPEG2_LAYER2 = 25,
+	CELL_SEARCH_CODEC_MPEG2_LAYER3 = 26,
+	CELL_SEARCH_CODEC_MOTIONJPEG = 27,
+	CELL_SEARCH_CODEC_MPO = 28,
+};
+
+// Scene types
+enum CellSearchSceneType : s32
+{
+	CELL_SEARCH_SCENETYPE_NONE = 0,
+	CELL_SEARCH_SCENETYPE_CHAPTER = 1,
+	CELL_SEARCH_SCENETYPE_CLIP_HIGHLIGHT = 2,
+	CELL_SEARCH_SCENETYPE_CLIP_USER = 3,
+};
+
+// List types
+enum CellSearchListType : s32
+{
+	CELL_SEARCH_LISTTYPE_NONE = 0,
+	CELL_SEARCH_LISTTYPE_MUSIC_ALBUM = 1,
+	CELL_SEARCH_LISTTYPE_MUSIC_GENRE = 2,
+	CELL_SEARCH_LISTTYPE_MUSIC_ARTIST = 3,
+	CELL_SEARCH_LISTTYPE_PHOTO_YEAR = 4,
+	CELL_SEARCH_LISTTYPE_PHOTO_MONTH = 5,
+	CELL_SEARCH_LISTTYPE_PHOTO_ALBUM = 6,
+	CELL_SEARCH_LISTTYPE_PHOTO_PLAYLIST = 7,
+	CELL_SEARCH_LISTTYPE_VIDEO_ALBUM = 8,
+	CELL_SEARCH_LISTTYPE_MUSIC_PLAYLIST = 9,
+};
+
+// Content status
+enum CellSearchContentStatus : s32
+{
+	CELL_SEARCH_CONTENTSTATUS_NONE,
+	CELL_SEARCH_CONTENTSTATUS_AVAILABLE,
+	CELL_SEARCH_CONTENTSTATUS_NOT_SUPPORTED,
+	CELL_SEARCH_CONTENTSTATUS_BROKEN,
+};
+
+// Search orientation
+enum CellSearchOrientation : s32
+{
+	CELL_SEARCH_ORIENTATION_UNKNOWN = 0,
+	CELL_SEARCH_ORIENTATION_TOP_LEFT,
+	CELL_SEARCH_ORIENTATION_TOP_RIGHT,
+	CELL_SEARCH_ORIENTATION_BOTTOM_RIGHT,
+	CELL_SEARCH_ORIENTATION_BOTTOM_LEFT,
+};
+
+// Search modes
+enum CellSearchMode : s32
+{
+	CELL_SEARCH_MODE_NORMAL = 0,
+};
+
+// Search events
+enum CellSearchEvent : s32
+{
+	CELL_SEARCH_EVENT_NOTIFICATION = 0,
+	CELL_SEARCH_EVENT_INITIALIZE_RESULT,
+	CELL_SEARCH_EVENT_FINALIZE_RESULT,
+	CELL_SEARCH_EVENT_LISTSEARCH_RESULT,
+	CELL_SEARCH_EVENT_CONTENTSEARCH_INLIST_RESULT,
+	CELL_SEARCH_EVENT_CONTENTSEARCH_RESULT,
+	CELL_SEARCH_EVENT_SCENESEARCH_INVIDEO_RESULT,
+	CELL_SEARCH_EVENT_SCENESEARCH_RESULT,
+};
+
+enum CellSearchListSearchType : s32
+{
+	CELL_SEARCH_LISTSEARCHTYPE_NONE = 0,
+	CELL_SEARCH_LISTSEARCHTYPE_MUSIC_ALBUM,
+	CELL_SEARCH_LISTSEARCHTYPE_MUSIC_GENRE,
+	CELL_SEARCH_LISTSEARCHTYPE_MUSIC_ARTIST,
+	CELL_SEARCH_LISTSEARCHTYPE_PHOTO_YEAR,
+	CELL_SEARCH_LISTSEARCHTYPE_PHOTO_MONTH,
+	CELL_SEARCH_LISTSEARCHTYPE_PHOTO_ALBUM,
+	CELL_SEARCH_LISTSEARCHTYPE_PHOTO_PLAYLIST,
+	CELL_SEARCH_LISTSEARCHTYPE_VIDEO_ALBUM,
+	CELL_SEARCH_LISTSEARCHTYPE_MUSIC_PLAYLIST,
+};
+
+enum CellSearchContentSearchType : s32
+{
+	CELL_SEARCH_CONTENTSEARCHTYPE_NONE = 0,
+	CELL_SEARCH_CONTENTSEARCHTYPE_MUSIC_ALL,
+	CELL_SEARCH_CONTENTSEARCHTYPE_PHOTO_ALL,
+	CELL_SEARCH_CONTENTSEARCHTYPE_VIDEO_ALL,
+};
+
+enum CellSearchSceneSearchType : s32
+{
+	CELL_SEARCH_SCENESEARCHTYPE_NONE = 0,
+	CELL_SEARCH_SCENESEARCHTYPE_CHAPTER,
+	CELL_SEARCH_SCENESEARCHTYPE_CLIP_HIGHLIGHT,
+	CELL_SEARCH_SCENESEARCHTYPE_CLIP_USER,
+	CELL_SEARCH_SCENESEARCHTYPE_CLIP,
+	CELL_SEARCH_SCENESEARCHTYPE_ALL,
+};
+
+enum CellSearchRepeatMode : s32
+{
+	CELL_SEARCH_REPEATMODE_NONE = 0,
+	CELL_SEARCH_REPEATMODE_REPEAT1,
+	CELL_SEARCH_REPEATMODE_ALL,
+	CELL_SEARCH_REPEATMODE_NOREPEAT1,
+};
+
+enum CellSearchContextOption : s32
+{
+	CELL_SEARCH_CONTEXTOPTION_NONE = 0,
+	CELL_SEARCH_CONTEXTOPTION_SHUFFLE,
+};
+
+enum CellSearchSharableType : s32
+{
+	CELL_SEARCH_SHARABLETYPE_PROHIBITED = 0,
+	CELL_SEARCH_SHARABLETYPE_PERMITTED,
+};
+
+using CellSearchId = s32;
+using CellSearchSystemCallback = void(CellSearchEvent event, s32 result, vm::cptr<void> param, vm::ptr<void> userData);
+
+struct CellSearchContentId
+{
+	char data[CELL_SEARCH_CONTENT_ID_SIZE];
+};
+
+struct CellSearchResultParam
+{
+	be_t<CellSearchId> searchId;
+	be_t<u32> resultNum;
+};
+
+struct CellSearchMusicListInfo
+{
+	be_t<s32> listType; // CellSearchListType
+	be_t<u32> numOfItems;
+	be_t<s64> duration;
+	char title[CELL_SEARCH_TITLE_LEN_MAX + 1];
+	char reserved[3];
+	char artistName[CELL_SEARCH_TITLE_LEN_MAX + 1];
+	char reserved2[3];
+};
+
+struct CellSearchPhotoListInfo
+{
+	be_t<s32> listType; // CellSearchListType
+	be_t<u32> numOfItems;
+	char title[CELL_SEARCH_TITLE_LEN_MAX + 1];
+	char reserved[3];
+};
+
+struct CellSearchVideoListInfo
+{
+	be_t<s32> listType; // CellSearchListType
+	be_t<u32> numOfItems;
+	be_t<s64> duration;
+	char title[CELL_SEARCH_TITLE_LEN_MAX + 1];
+	char reserved[3];
+};
+
+struct CellSearchMusicInfo
+{
+	be_t<s64> duration;
+	be_t<s64> size;
+	be_t<s64> importedDate;
+	be_t<s64> lastPlayedDate;
+	be_t<s32> releasedYear;
+	be_t<s32> trackNumber;
+	be_t<s32> bitrate;
+	be_t<s32> samplingRate;
+	be_t<s32> quantizationBitrate;
+	be_t<s32> playCount;
+	be_t<s32> drmEncrypted;
+	be_t<s32> codec;  // CellSearchCodec
+	be_t<s32> status; // CellSearchContentStatus
+	char diskNumber[8];
+	char title[CELL_SEARCH_TITLE_LEN_MAX + 1];
+	char reserved[3];
+	char albumTitle[CELL_SEARCH_TITLE_LEN_MAX + 1];
+	char reserved2[3];
+	char artistName[CELL_SEARCH_TITLE_LEN_MAX + 1];
+	char reserved3[3];
+	char genreName[CELL_SEARCH_TITLE_LEN_MAX + 1];
+	char reserved4[3];
+};
+
+struct CellSearchPhotoInfo
+{
+	be_t<s64> size;
+	be_t<s64> importedDate;
+	be_t<s64> takenDate;
+	be_t<s32> width;
+	be_t<s32> height;
+	be_t<s32> orientation; // CellSearchOrientation
+	be_t<s32> codec;       // CellSearchCodec
+	be_t<s32> status;      // CellSearchContentStatus
+	char title[CELL_SEARCH_TITLE_LEN_MAX + 1];
+	char reserved[3];
+	char albumTitle[CELL_SEARCH_TITLE_LEN_MAX + 1];
+	char reserved2[3];
+};
+
+struct CellSearchVideoInfo
+{
+	be_t<s64> duration;
+	be_t<s64> size;
+	be_t<s64> importedDate;
+	be_t<s64> takenDate;
+	be_t<s32> videoBitrate;
+	be_t<s32> audioBitrate;
+	be_t<s32> playCount;
+	be_t<s32> drmEncrypted;
+	be_t<s32> videoCodec; // CellSearchCodec
+	be_t<s32> audioCodec; // CellSearchCodec
+	be_t<s32> status;     // CellSearchContentStatus
+	char title[CELL_SEARCH_TITLE_LEN_MAX + 1];
+	char reserved[3];
+	char albumTitle[CELL_SEARCH_TITLE_LEN_MAX + 1];
+	char reserved2[3];
+};
+
+struct CellSearchVideoSceneInfo
+{
+	be_t<s32> sceneType; // CellSearchSceneType
+	be_t<s64> startTime_ms;
+	be_t<s64> endTime_ms;
+	CellSearchContentId videoId;
+	char title[CELL_SEARCH_TITLE_LEN_MAX + 1];
+	char reserved[3];
+	char tags[CELL_SEARCH_TAG_NUM_MAX][CELL_SEARCH_TAG_LEN_MAX];
+};
+
+struct CellSearchContentInfoPath
+{
+	char contentPath[CELL_SEARCH_PATH_LEN_MAX + 1];
+	char thumbnailPath[CELL_SEARCH_PATH_LEN_MAX + 1];
+};
+
+struct CellSearchContentInfoPathMovieThumb
+{
+	char movieThumbnailPath[CELL_SEARCH_PATH_LEN_MAX + 1];
+	char movieThumbnailOption[CELL_SEARCH_MTOPTION_LEN_MAX + 1];
+};
+
+struct CellSearchTimeInfo
+{
+	be_t<s64> takenDate;
+	be_t<s64> importedDate;
+	be_t<s64> modifiedDate;
+};

ps3fw/include/rpcsx/fw/ps3/cellSpudll.h

@@ -0,0 +1,26 @@
+#pragma once
+
+#include "Emu/Memory/vm_ptr.h"
+
+enum CellSpudllError : u32
+{
+	CELL_SPUDLL_ERROR_INVAL = 0x80410602,
+	CELL_SPUDLL_ERROR_STAT = 0x8041060f,
+	CELL_SPUDLL_ERROR_ALIGN = 0x80410610,
+	CELL_SPUDLL_ERROR_NULL_POINTER = 0x80410611,
+	CELL_SPUDLL_ERROR_SRCH = 0x80410605,
+	CELL_SPUDLL_ERROR_UNDEF = 0x80410612,
+	CELL_SPUDLL_ERROR_FATAL = 0x80410613,
+};
+
+struct CellSpudllHandleConfig
+{
+	be_t<u32> mode;
+	be_t<u32> dmaTag;
+	be_t<u32> numMaxReferred;
+	be_t<u32> numMaxDepend;
+	vm::bptr<void> unresolvedSymbolValueForFunc;
+	vm::bptr<void> unresolvedSymbolValueForObject;
+	vm::bptr<void> unresolvedSymbolValueForOther;
+	be_t<u32> __reserved__[9];
+};

ps3fw/include/rpcsx/fw/ps3/cellSpursJq.h

@@ -0,0 +1 @@
+#pragma once

ps3fw/include/rpcsx/fw/ps3/cellSsl.h

@@ -0,0 +1,195 @@
+#pragma once
+
+enum CellSslError : u32
+{
+	CELL_SSL_ERROR_NOT_INITIALIZED = 0x80740001,
+	CELL_SSL_ERROR_ALREADY_INITIALIZED = 0x80740002,
+	CELL_SSL_ERROR_INITIALIZATION_FAILED = 0x80740003,
+	CELL_SSL_ERROR_NO_BUFFER = 0x80740004,
+	CELL_SSL_ERROR_INVALID_CERTIFICATE = 0x80740005,
+	CELL_SSL_ERROR_UNRETRIEVABLE = 0x80740006,
+	CELL_SSL_ERROR_INVALID_FORMAT = 0x80740007,
+	CELL_SSL_ERROR_NOT_FOUND = 0x80740008,
+	CELL_SSL_ERROR_INVALID_TIME = 0x80740031,
+	CELL_SSL_ERROR_INAVLID_NEGATIVE_TIME = 0x80740032,
+	CELL_SSL_ERROR_INCORRECT_TIME = 0x80740033,
+	CELL_SSL_ERROR_UNDEFINED_TIME_TYPE = 0x80740034,
+	CELL_SSL_ERROR_NO_MEMORY = 0x80740035,
+	CELL_SSL_ERROR_NO_STRING = 0x80740036,
+	CELL_SSL_ERROR_UNKNOWN_LOAD_CERT = 0x80740037
+};
+
+// Certificate load flags
+enum : u64
+{
+	CELL_SSL_LOAD_CERT_SCE01 = 0x0000000000000001ULL,
+	CELL_SSL_LOAD_CERT_SCE02 = 0x0000000000000002ULL,
+	CELL_SSL_LOAD_CERT_SCE03 = 0x0000000000000004ULL,
+	CELL_SSL_LOAD_CERT_SCE04 = 0x0000000000000008ULL,
+	CELL_SSL_LOAD_CERT_SCE05 = 0x0000000000000010ULL,
+	CELL_SSL_LOAD_CERT_BALTIMORE_CT = 0x0000000000000020ULL,
+	CELL_SSL_LOAD_CERT_CLASS1_PCA_G2_V2 = 0x0000000000000040ULL,
+	CELL_SSL_LOAD_CERT_CLASS1_PCA_G3_V2 = 0x0000000000000080ULL,
+	CELL_SSL_LOAD_CERT_CLASS1_PCA_SS_V4 = 0x0000000000000100ULL,
+	CELL_SSL_LOAD_CERT_CLASS2_PCA_G2_V2 = 0x0000000000000200ULL,
+	CELL_SSL_LOAD_CERT_CLASS2_PCA_G3_V2 = 0x0000000000000400ULL,
+	CELL_SSL_LOAD_CERT_CLASS2_PCA_SS_V4 = 0x0000000000000800ULL,
+	CELL_SSL_LOAD_CERT_CLASS3_PCA_G2_V2 = 0x0000000000001000ULL,
+	CELL_SSL_LOAD_CERT_CLASS3_PCA_G3_V2 = 0x0000000000002000ULL,
+	CELL_SSL_LOAD_CERT_CLASS3_PCA_SS_V4 = 0x0000000000004000ULL,
+	CELL_SSL_LOAD_CERT_CLASS4_PCA_G2_V2 = 0x0000000000008000ULL,
+	CELL_SSL_LOAD_CERT_CLASS4_PCA_G3_V2 = 0x0000000000010000ULL,
+	CELL_SSL_LOAD_CERT_ENTRUST_NET_SS_CA = 0x0000000000020000ULL,
+	CELL_SSL_LOAD_CERT_EQUIFAX_SEC_CA = 0x0000000000040000ULL,
+	CELL_SSL_LOAD_CERT_EQUIFAX_SEC_EBUS1 = 0x0000000000080000ULL,
+	CELL_SSL_LOAD_CERT_GEOTRUST_GCA = 0x0000000000100000ULL,
+	CELL_SSL_LOAD_CERT_GLOBALSIGN_RCA = 0x0000000000200000ULL,
+	CELL_SSL_LOAD_CERT_GTE_CT_G_RCA = 0x0000000000400000ULL,
+	CELL_SSL_LOAD_CERT_GTE_CT_ROOT = 0x0000000000800000ULL,
+	CELL_SSL_LOAD_CERT_RSA1024_V1 = 0x0000000001000000ULL,
+	CELL_SSL_LOAD_CERT_RSA2048_V3 = 0x0000000002000000ULL,
+	CELL_SSL_LOAD_CERT_RSA_SECURE_SERVER = 0x0000000004000000ULL,
+	CELL_SSL_LOAD_CERT_THAWTE_PREM_SCA = 0x0000000008000000ULL,
+	CELL_SSL_LOAD_CERT_THAWTE_SCA = 0x0000000010000000ULL,
+	CELL_SSL_LOAD_CERT_VALICERT_CLASS2 = 0x0000000020000000ULL,
+	CELL_SSL_LOAD_CERT_VERISIGN_TSA_CA = 0x0000000040000000ULL,
+	CELL_SSL_LOAD_CERT_AAA_CERT_SERVICES = 0x0000000080000000ULL,
+	CELL_SSL_LOAD_CERT_ADDTRUST_EXT_CA = 0x0000000100000000ULL,
+	CELL_SSL_LOAD_CERT_UTN_USERFIRST_HW = 0x0000000200000000ULL,
+	CELL_SSL_LOAD_CERT_EQUIFAX_SEC_G_EBUS1 = 0x0000000400000000ULL,
+	CELL_SSL_LOAD_CERT_CLASS3_PCA_G5 = 0x0000000800000000ULL,
+	CELL_SSL_LOAD_CERT_DIGICERT_HA_EV_RCA = 0x0000001000000000ULL,
+	CELL_SSL_LOAD_CERT_DIGICERT_A_ID_RCA = 0x0000002000000000ULL,
+	CELL_SSL_LOAD_CERT_DIGICERT_GLOBAL_RCA = 0x0000004000000000ULL,
+	CELL_SSL_LOAD_CERT_CT_G_ROOT = 0x0000008000000000ULL,
+	CELL_SSL_LOAD_CERT_ENTRUST_CA2048 = 0x0000010000000000ULL,
+	CELL_SSL_LOAD_CERT_ENTRUST_RCA = 0x0000020000000000ULL,
+	CELL_SSL_LOAD_CERT_GLOBALSIGN_RCA_R2 = 0x0000040000000000ULL,
+	CELL_SSL_LOAD_CERT_GODADDY_CLASS2_CA = 0x0000080000000000ULL,
+	CELL_SSL_LOAD_CERT_STARFIELD_CLASS2_CA = 0x0000100000000000ULL,
+	CELL_SSL_LOAD_CERT_STARFIELD_S_RC = 0x0000200000000000ULL,
+	CELL_SSL_LOAD_CERT_THATE_PRIMARY_RCA = 0x0000400000000000ULL,
+	CELL_SSL_LOAD_CERT_VALICERT_CLASS1_VA = 0x0000800000000000ULL,
+	CELL_SSL_LOAD_CERT_SECOM_RCA1 = 0x0001000000000000ULL,
+	CELL_SSL_LOAD_CERT_SECURE_TRUST_CA = 0x0002000000000000ULL,
+	CELL_SSL_LOAD_CERT_ENTRUST_RCA_G2 = 0x0004000000000000ULL,
+	CELL_SSL_LOAD_CERT_VERISIGN_U_RCA = 0x0008000000000000ULL,
+	CELL_SSL_LOAD_CERT_GODADDY_C2_CA_G2 = 0x0010000000000000ULL,
+	CELL_SSL_LOAD_CERT_STARFIELD_C2_CA_G2 = 0x0020000000000000ULL,
+	CELL_SSL_LOAD_CERT_STARFIELD_S_RC_G2 = 0x0040000000000000ULL,
+	CELL_SSL_LOAD_CERT_STARTCOM_CA = 0x0080000000000000ULL,
+	CELL_SSL_LOAD_CERT_STARTCOM_CA_G2 = 0x0100000000000000ULL,
+	CELL_SSL_LOAD_CERT_SECOM_RCA2 = 0x0200000000000000ULL,
+
+	// Composite Flags
+
+	CELL_SSL_LOAD_CERT_SCE =
+		(CELL_SSL_LOAD_CERT_SCE01 |
+			CELL_SSL_LOAD_CERT_SCE02 |
+			CELL_SSL_LOAD_CERT_SCE03 |
+			CELL_SSL_LOAD_CERT_SCE04 |
+			CELL_SSL_LOAD_CERT_SCE05),
+	CELL_SSL_LOAD_CERT_SHA256 =
+		(CELL_SSL_LOAD_CERT_GLOBALSIGN_RCA_R2 |
+			CELL_SSL_LOAD_CERT_ENTRUST_RCA_G2 |
+			CELL_SSL_LOAD_CERT_VERISIGN_U_RCA |
+			CELL_SSL_LOAD_CERT_GODADDY_C2_CA_G2 |
+			CELL_SSL_LOAD_CERT_STARFIELD_C2_CA_G2 |
+			CELL_SSL_LOAD_CERT_STARFIELD_S_RC_G2 |
+			CELL_SSL_LOAD_CERT_STARTCOM_CA |
+			CELL_SSL_LOAD_CERT_STARTCOM_CA_G2 |
+			CELL_SSL_LOAD_CERT_SECOM_RCA2),
+	CELL_SSL_LOAD_CERT_NORMAL =
+		(CELL_SSL_LOAD_CERT_BALTIMORE_CT |
+			CELL_SSL_LOAD_CERT_CLASS3_PCA_G2_V2 |
+			CELL_SSL_LOAD_CERT_CLASS3_PCA_G3_V2 |
+			CELL_SSL_LOAD_CERT_CLASS3_PCA_SS_V4 |
+			CELL_SSL_LOAD_CERT_ENTRUST_NET_SS_CA |
+			CELL_SSL_LOAD_CERT_EQUIFAX_SEC_CA |
+			CELL_SSL_LOAD_CERT_EQUIFAX_SEC_EBUS1 |
+			CELL_SSL_LOAD_CERT_GEOTRUST_GCA |
+			CELL_SSL_LOAD_CERT_GLOBALSIGN_RCA |
+			CELL_SSL_LOAD_CERT_GTE_CT_G_RCA |
+			CELL_SSL_LOAD_CERT_RSA1024_V1 |
+			CELL_SSL_LOAD_CERT_RSA2048_V3 |
+			CELL_SSL_LOAD_CERT_THAWTE_PREM_SCA |
+			CELL_SSL_LOAD_CERT_THAWTE_SCA |
+			CELL_SSL_LOAD_CERT_VALICERT_CLASS2 |
+			CELL_SSL_LOAD_CERT_AAA_CERT_SERVICES |
+			CELL_SSL_LOAD_CERT_ADDTRUST_EXT_CA |
+			CELL_SSL_LOAD_CERT_UTN_USERFIRST_HW |
+			CELL_SSL_LOAD_CERT_EQUIFAX_SEC_G_EBUS1 |
+			CELL_SSL_LOAD_CERT_CLASS3_PCA_G5 |
+			CELL_SSL_LOAD_CERT_DIGICERT_HA_EV_RCA |
+			CELL_SSL_LOAD_CERT_DIGICERT_A_ID_RCA |
+			CELL_SSL_LOAD_CERT_DIGICERT_GLOBAL_RCA |
+			CELL_SSL_LOAD_CERT_CT_G_ROOT |
+			CELL_SSL_LOAD_CERT_ENTRUST_CA2048 |
+			CELL_SSL_LOAD_CERT_ENTRUST_RCA |
+			CELL_SSL_LOAD_CERT_GODADDY_CLASS2_CA |
+			CELL_SSL_LOAD_CERT_STARFIELD_CLASS2_CA |
+			CELL_SSL_LOAD_CERT_STARFIELD_S_RC |
+			CELL_SSL_LOAD_CERT_THATE_PRIMARY_RCA |
+			CELL_SSL_LOAD_CERT_VALICERT_CLASS1_VA |
+			CELL_SSL_LOAD_CERT_SECOM_RCA1 |
+			CELL_SSL_LOAD_CERT_SECURE_TRUST_CA |
+			CELL_SSL_LOAD_CERT_SHA256),
+	CELL_SSL_LOAD_CERT_ALL =
+		(CELL_SSL_LOAD_CERT_SCE |
+			CELL_SSL_LOAD_CERT_NORMAL),
+	CELL_SSL_LOAD_CERT_OBSOLETE =
+		(CELL_SSL_LOAD_CERT_RSA_SECURE_SERVER |
+			CELL_SSL_LOAD_CERT_VERISIGN_TSA_CA |
+			CELL_SSL_LOAD_CERT_GTE_CT_ROOT),
+	CELL_SSL_LOAD_CERT_NOT_FOR_SERVER =
+		(CELL_SSL_LOAD_CERT_CLASS1_PCA_G2_V2 |
+			CELL_SSL_LOAD_CERT_CLASS1_PCA_G3_V2 |
+			CELL_SSL_LOAD_CERT_CLASS1_PCA_SS_V4 |
+			CELL_SSL_LOAD_CERT_CLASS2_PCA_G2_V2 |
+			CELL_SSL_LOAD_CERT_CLASS2_PCA_G3_V2 |
+			CELL_SSL_LOAD_CERT_CLASS2_PCA_SS_V4 |
+			CELL_SSL_LOAD_CERT_CLASS4_PCA_G2_V2 |
+			CELL_SSL_LOAD_CERT_CLASS4_PCA_G3_V2),
+};
+
+enum // Cipher
+{
+	CELL_SSL_CIPHER_UNKNOWN = -1,
+	CELL_SSL_CIPHER_RSA_WITH_3DES_EDE_CBC_SHA = 0,
+	CELL_SSL_CIPHER_RSA_WITH_RC4_128_SHA = 1,
+	CELL_SSL_CIPHER_RSA_WITH_RC4_128_MD5 = 2,
+	CELL_SSL_CIPHER_RSA_WITH_DES_CBC_SHA = 3,
+	CELL_SSL_CIPHER_RSA_EXPORT1024_WITH_DES_CBC_SHA = 4,
+	CELL_SSL_CIPHER_RSA_EXPORT1024_WITH_RC4_56_SHA = 5,
+	CELL_SSL_CIPHER_RSA_EXPORT_WITH_DES40_CBC_SHA = 6,
+	CELL_SSL_CIPHER_RSA_EXPORT_WITH_RC2_CBC_40_MD5 = 7,
+	CELL_SSL_CIPHER_RSA_EXPORT_WITH_RC4_40_MD5 = 8
+};
+
+enum // Version
+{
+	CELL_SSL_VERSION_UNKNOWN = -1,
+	CELL_SSL_VERSION_TLS1 = 0,
+	CELL_SSL_VERSION_SSL3 = 1
+};
+
+enum // Other Constants
+{
+	CELL_SSL_MD5_FINGERPRINT_MAX_SIZE = 20
+};
+
+enum SpecialCerts
+{
+	BaltimoreCert = 6,
+	Class3G2V2Cert = 13,
+	ClassSSV4Cert = 15,
+	EntrustNetCert = 18,
+	GTECyberTrustGlobalCert = 23
+};
+
+struct ssl_manager
+{
+	atomic_t<bool> is_init{false};
+};
+
+b8 _cellSslIsInitd();

ps3fw/include/rpcsx/fw/ps3/cellStorage.h

@@ -0,0 +1,37 @@
+#pragma once
+
+enum CellStorageError : u32
+{
+	CELL_STORAGEDATA_ERROR_BUSY = 0x8002be01,
+	CELL_STORAGEDATA_ERROR_INTERNAL = 0x8002be02,
+	CELL_STORAGEDATA_ERROR_PARAM = 0x8002be03,
+	CELL_STORAGEDATA_ERROR_ACCESS_ERROR = 0x8002be04,
+	CELL_STORAGEDATA_ERROR_FAILURE = 0x8002be05
+};
+
+enum CellStorageDataVersion
+{
+	CELL_STORAGEDATA_VERSION_CURRENT = 0,
+	CELL_STORAGEDATA_VERSION_DST_FILENAME = 1,
+};
+
+enum CellStorageDataParamSize
+{
+	CELL_STORAGEDATA_HDD_PATH_MAX = 1055,
+	CELL_STORAGEDATA_MEDIA_PATH_MAX = 1024,
+	CELL_STORAGEDATA_FILENAME_MAX = 64,
+	CELL_STORAGEDATA_FILESIZE_MAX = 1024 * 1024 * 1024,
+	CELL_STORAGEDATA_TITLE_MAX = 256
+};
+
+inline const char* CELL_STORAGEDATA_IMPORT_FILENAME = "IMPORT.BIN";
+inline const char* CELL_STORAGEDATA_EXPORT_FILENAME = "EXPORT.BIN";
+
+struct CellStorageDataSetParam
+{
+	be_t<u32> fileSizeMax;
+	vm::bptr<char> title;
+	vm::bptr<void> reserved;
+};
+
+using CellStorageDataFinishCallback = void(s32 result, vm::ptr<void> userdata);

ps3fw/include/rpcsx/fw/ps3/cellSync.h

@@ -0,0 +1,366 @@
+#pragma once
+
+#include "Emu/Memory/vm_ptr.h"
+
+#include "util/BitField.h"
+
+#include "Emu/Cell/ErrorCodes.h"
+
+// Return Codes
+enum CellSyncError : u32
+{
+	CELL_SYNC_ERROR_AGAIN = 0x80410101,
+	CELL_SYNC_ERROR_INVAL = 0x80410102,
+	CELL_SYNC_ERROR_NOSYS = 0x80410103,
+	CELL_SYNC_ERROR_NOMEM = 0x80410104,
+	CELL_SYNC_ERROR_SRCH = 0x80410105,
+	CELL_SYNC_ERROR_NOENT = 0x80410106,
+	CELL_SYNC_ERROR_NOEXEC = 0x80410107,
+	CELL_SYNC_ERROR_DEADLK = 0x80410108,
+	CELL_SYNC_ERROR_PERM = 0x80410109,
+	CELL_SYNC_ERROR_BUSY = 0x8041010A,
+	CELL_SYNC_ERROR_ABORT = 0x8041010C,
+	CELL_SYNC_ERROR_FAULT = 0x8041010D,
+	CELL_SYNC_ERROR_CHILD = 0x8041010E,
+	CELL_SYNC_ERROR_STAT = 0x8041010F,
+	CELL_SYNC_ERROR_ALIGN = 0x80410110,
+	CELL_SYNC_ERROR_NULL_POINTER = 0x80410111,
+	CELL_SYNC_ERROR_NOT_SUPPORTED_THREAD = 0x80410112,
+	CELL_SYNC_ERROR_NO_NOTIFIER = 0x80410113,
+	CELL_SYNC_ERROR_NO_SPU_CONTEXT_STORAGE = 0x80410114,
+};
+
+enum CellSyncError1 : u32
+{
+	CELL_SYNC_ERROR_SHOTAGE = 0x80410112,
+	CELL_SYNC_ERROR_UNKNOWNKEY = 0x80410113,
+};
+
+struct CellSyncMutex
+{
+	struct Counter
+	{
+		be_t<u16> rel;
+		be_t<u16> acq;
+
+		auto lock_begin()
+		{
+			return acq++;
+		}
+
+		bool try_lock()
+		{
+			if (rel != acq) [[unlikely]]
+			{
+				return false;
+			}
+
+			acq++;
+			return true;
+		}
+
+		void unlock()
+		{
+			rel++;
+		}
+	};
+
+	atomic_t<Counter> ctrl;
+};
+
+CHECK_SIZE_ALIGN(CellSyncMutex, 4, 4);
+
+struct CellSyncBarrier
+{
+	struct alignas(4) ctrl_t
+	{
+		be_t<s16> value;
+		be_t<u16> count;
+	};
+
+	atomic_t<ctrl_t> ctrl;
+
+	static inline bool try_notify(ctrl_t& ctrl)
+	{
+		if (ctrl.value & 0x8000)
+		{
+			return false;
+		}
+
+		if (++ctrl.value == ctrl.count)
+		{
+			ctrl.value |= 0x8000;
+		}
+
+		return true;
+	}
+
+	static inline bool try_wait(ctrl_t& ctrl)
+	{
+		if ((ctrl.value & 0x8000) == 0)
+		{
+			return false;
+		}
+
+		if (--ctrl.value == -0x8000)
+		{
+			ctrl.value = 0;
+		}
+
+		return true;
+	}
+};
+
+CHECK_SIZE_ALIGN(CellSyncBarrier, 4, 4);
+
+struct alignas(16) CellSyncRwm
+{
+	struct alignas(4) ctrl_t
+	{
+		be_t<u16> readers;
+		be_t<u16> writers;
+	};
+
+	atomic_t<ctrl_t> ctrl;
+
+	be_t<u32> size;
+	vm::bptr<void, u64> buffer;
+
+	static inline bool try_read_begin(ctrl_t& ctrl)
+	{
+		if (ctrl.writers)
+		{
+			return false;
+		}
+
+		ctrl.readers++;
+		return true;
+	}
+
+	static inline bool try_read_end(ctrl_t& ctrl)
+	{
+		if (ctrl.readers == 0)
+		{
+			return false;
+		}
+
+		ctrl.readers--;
+		return true;
+	}
+
+	static inline bool try_write_begin(ctrl_t& ctrl)
+	{
+		if (ctrl.writers)
+		{
+			return false;
+		}
+
+		ctrl.writers = 1;
+		return true;
+	}
+};
+
+CHECK_SIZE_ALIGN(CellSyncRwm, 16, 16);
+
+struct alignas(32) CellSyncQueue
+{
+	struct ctrl_t
+	{
+		union
+		{
+			be_t<u32> x0;
+
+			bf_t<be_t<u32>, 0, 24> next;
+			bf_t<be_t<u32>, 24, 8> _pop;
+		};
+
+		union
+		{
+			be_t<u32> x4;
+
+			bf_t<be_t<u32>, 0, 24> count;
+			bf_t<be_t<u32>, 24, 8> _push;
+		};
+	};
+
+	atomic_t<ctrl_t> ctrl;
+
+	be_t<u32> size;
+	be_t<u32> depth;
+	vm::bptr<u8, u64> buffer;
+	be_t<u64> reserved;
+
+	u32 check_depth() const
+	{
+		const auto data = ctrl.load();
+
+		if (data.next > depth || data.count > depth)
+		{
+			fmt::throw_exception("Invalid queue pointers");
+		}
+
+		return depth;
+	}
+
+	static inline bool try_push_begin(ctrl_t& ctrl, u32 depth, u32* position)
+	{
+		const u32 count = ctrl.count;
+
+		if (ctrl._push || count + ctrl._pop >= depth)
+		{
+			return false;
+		}
+
+		*position = ctrl.next;
+		ctrl.next = *position + 1 != depth ? *position + 1 : 0;
+		ctrl.count = count + 1;
+		ctrl._push = 1;
+		return true;
+	}
+
+	static inline void push_end(ctrl_t& ctrl)
+	{
+		ctrl._push = 0;
+	}
+
+	static inline bool try_pop_begin(ctrl_t& ctrl, u32 depth, u32* position)
+	{
+		const u32 count = ctrl.count;
+
+		if (ctrl._pop || count <= ctrl._push)
+		{
+			return false;
+		}
+
+		ctrl._pop = 1;
+		*position = ctrl.next + depth - count;
+		ctrl.count = count - 1;
+		return true;
+	}
+
+	static inline bool try_peek_begin(ctrl_t& ctrl, u32 depth, u32* position)
+	{
+		const u32 count = ctrl.count;
+
+		if (ctrl._pop || count <= ctrl._push)
+		{
+			return false;
+		}
+
+		ctrl._pop = 1;
+		*position = ctrl.next + depth - count;
+		return true;
+	}
+
+	static inline void pop_end(ctrl_t& ctrl)
+	{
+		ctrl._pop = 0;
+	}
+
+	static inline bool try_clear_begin_1(ctrl_t& ctrl)
+	{
+		if (ctrl._pop)
+		{
+			return false;
+		}
+
+		ctrl._pop = 1;
+		return true;
+	}
+
+	static inline bool try_clear_begin_2(ctrl_t& ctrl)
+	{
+		if (ctrl._push)
+		{
+			return false;
+		}
+
+		ctrl._push = 1;
+		return true;
+	}
+};
+
+CHECK_SIZE_ALIGN(CellSyncQueue, 32, 32);
+
+enum CellSyncQueueDirection : u32 // CellSyncLFQueueDirection
+{
+	CELL_SYNC_QUEUE_SPU2SPU = 0, // SPU to SPU
+	CELL_SYNC_QUEUE_SPU2PPU = 1, // SPU to PPU
+	CELL_SYNC_QUEUE_PPU2SPU = 2, // PPU to SPU
+	CELL_SYNC_QUEUE_ANY2ANY = 3, // SPU/PPU to SPU/PPU
+};
+
+struct alignas(128) CellSyncLFQueue
+{
+	struct pop1_t
+	{
+		be_t<u16> m_h1;
+		be_t<u16> m_h2;
+		be_t<u16> m_h3;
+		be_t<u16> m_h4;
+	};
+
+	struct pop2_t
+	{
+		be_t<u16> pack;
+	};
+
+	struct pop3_t
+	{
+		be_t<u16> m_h1;
+		be_t<u16> m_h2;
+	};
+
+	struct push1_t
+	{
+		be_t<u16> m_h5;
+		be_t<u16> m_h6;
+		be_t<u16> m_h7;
+		be_t<u16> m_h8;
+	};
+
+	struct push2_t
+	{
+		be_t<u16> pack;
+	};
+
+	struct push3_t
+	{
+		be_t<u16> m_h5;
+		be_t<u16> m_h6;
+	};
+
+	union // 0x0
+	{
+		atomic_t<pop1_t> pop1;
+		atomic_t<pop3_t> pop3;
+	};
+
+	union // 0x8
+	{
+		atomic_t<push1_t> push1;
+		atomic_t<push3_t> push3;
+	};
+
+	be_t<u32> m_size;               // 0x10
+	be_t<u32> m_depth;              // 0x14
+	vm::bcptr<void, u64> m_buffer;  // 0x18
+	u8 m_bs[4];                     // 0x20
+	be_t<u32> m_direction;          // 0x24 CellSyncQueueDirection
+	be_t<u32> m_v1;                 // 0x28
+	atomic_be_t<s32> init;          // 0x2C
+	atomic_t<push2_t> push2;        // 0x30
+	be_t<u16> m_hs1[15];            // 0x32
+	atomic_t<pop2_t> pop2;          // 0x50
+	be_t<u16> m_hs2[15];            // 0x52
+	vm::bptr<void, u64> m_eaSignal; // 0x70
+	be_t<u32> m_v2;                 // 0x78
+	be_t<u32> m_eq_id;              // 0x7C
+};
+
+CHECK_SIZE_ALIGN(CellSyncLFQueue, 128, 128);
+
+// Prototypes
+error_code cellSyncLFQueueInitialize(vm::ptr<CellSyncLFQueue> queue,
+	vm::cptr<void> buffer, u32 size, u32 depth,
+	u32 direction, vm::ptr<void> eaSignal);

ps3fw/include/rpcsx/fw/ps3/cellSync2.h

@@ -0,0 +1,132 @@
+#pragma once
+
+#include "Emu/Memory/vm_ptr.h"
+
+// Return Codes
+enum CellSync2Error : u32
+{
+	CELL_SYNC2_ERROR_AGAIN = 0x80410C01,
+	CELL_SYNC2_ERROR_INVAL = 0x80410C02,
+	CELL_SYNC2_ERROR_NOMEM = 0x80410C04,
+	CELL_SYNC2_ERROR_DEADLK = 0x80410C08,
+	CELL_SYNC2_ERROR_PERM = 0x80410C09,
+	CELL_SYNC2_ERROR_BUSY = 0x80410C0A,
+	CELL_SYNC2_ERROR_STAT = 0x80410C0F,
+	CELL_SYNC2_ERROR_ALIGN = 0x80410C10,
+	CELL_SYNC2_ERROR_NULL_POINTER = 0x80410C11,
+	CELL_SYNC2_ERROR_NOT_SUPPORTED_THREAD = 0x80410C12,
+	CELL_SYNC2_ERROR_NO_NOTIFIER = 0x80410C13,
+	CELL_SYNC2_ERROR_NO_SPU_CONTEXT_STORAGE = 0x80410C14,
+};
+
+// Constants
+enum
+{
+	CELL_SYNC2_NAME_MAX_LENGTH = 31,
+	CELL_SYNC2_THREAD_TYPE_PPU_THREAD = 1 << 0,
+	CELL_SYNC2_THREAD_TYPE_PPU_FIBER = 1 << 1,
+	CELL_SYNC2_THREAD_TYPE_SPURS_TASK = 1 << 2,
+	CELL_SYNC2_THREAD_TYPE_SPURS_JOBQUEUE_JOB = 1 << 3,
+	CELL_SYNC2_THREAD_TYPE_SPURS_JOB = 1 << 8,
+};
+
+struct CellSync2MutexAttribute
+{
+	be_t<u32> sdkVersion;
+	be_t<u16> threadTypes;
+	be_t<u16> maxWaiters;
+	b8 recursive;
+	u8 padding;
+	char name[CELL_SYNC2_NAME_MAX_LENGTH + 1];
+	u8 reserved[86];
+};
+
+CHECK_SIZE(CellSync2MutexAttribute, 128);
+
+struct CellSync2CondAttribute
+{
+	be_t<u32> sdkVersion;
+	be_t<u16> maxWaiters;
+	char name[CELL_SYNC2_NAME_MAX_LENGTH + 1];
+	u8 reserved[90];
+};
+
+CHECK_SIZE(CellSync2CondAttribute, 128);
+
+struct CellSync2SemaphoreAttribute
+{
+	be_t<u32> sdkVersion;
+	be_t<u16> threadTypes;
+	be_t<u16> maxWaiters;
+	char name[CELL_SYNC2_NAME_MAX_LENGTH + 1];
+	u8 reserved[88];
+};
+
+CHECK_SIZE(CellSync2SemaphoreAttribute, 128);
+
+struct CellSync2QueueAttribute
+{
+	be_t<u32> sdkVersion;
+	be_t<u32> threadTypes;
+	be_t<u32> elementSize;
+	be_t<u32> depth;
+	be_t<u16> maxPushWaiters;
+	be_t<u16> maxPopWaiters;
+	char name[CELL_SYNC2_NAME_MAX_LENGTH + 1];
+	u8 reserved[76];
+};
+
+CHECK_SIZE(CellSync2QueueAttribute, 128);
+
+struct CellSync2CallerThreadType
+{
+	be_t<u16> threadTypeId;
+	vm::bptr<u64(u64)> self;
+	vm::bptr<s32(u64, s32, u64, u64)> waitSignal;
+	vm::bptr<s32(vm::ptr<u64>, s32, u64, u64)> allocateSignalReceiver;
+	vm::bptr<s32(u64, u64)> freeSignalReceiver;
+	be_t<u32> spinWaitNanoSec;
+	be_t<u64> callbackArg;
+};
+
+struct CellSync2Notifier
+{
+	be_t<u16> threadTypeId;
+	vm::bptr<s32(u64, u64)> sendSignal;
+	be_t<u64> callbackArg;
+};
+
+struct alignas(128) CellSync2Mutex
+{
+	u8 skip[128];
+};
+
+CHECK_SIZE_ALIGN(CellSync2Mutex, 128, 128);
+
+struct alignas(128) CellSync2Cond
+{
+	u8 skip[128];
+};
+
+CHECK_SIZE_ALIGN(CellSync2Cond, 128, 128);
+
+struct alignas(128) CellSync2Semaphore
+{
+	u8 skip[128];
+};
+
+CHECK_SIZE_ALIGN(CellSync2Semaphore, 128, 128);
+
+struct alignas(128) CellSync2Queue
+{
+	u8 skip[128];
+};
+
+CHECK_SIZE_ALIGN(CellSync2Queue, 128, 128);
+
+struct CellSync2ThreadConfig
+{
+	vm::bptr<CellSync2CallerThreadType> callerThreadType;
+	vm::bpptr<CellSync2Notifier> notifierTable;
+	be_t<u32> numNotifier;
+};

ps3fw/include/rpcsx/fw/ps3/cellSysconf.h

@@ -0,0 +1,36 @@
+#pragma once
+
+#include "Emu/Memory/vm_ptr.h"
+
+typedef void(CellSysconfCallback)(s32 result, vm::ptr<void> userdata);
+
+struct CellSysconfBtDeviceInfo
+{
+	be_t<u64> deviceId;
+	be_t<s32> deviceType; // CellSysconfBtDeviceType
+	be_t<s32> state;      // CellSysconfBtDeviceState
+	char name[64];
+	be_t<u32> reserved[4];
+};
+
+struct CellSysconfBtDeviceList
+{
+	CellSysconfBtDeviceInfo device[16];
+};
+
+enum CellSysconfBtDeviceType : s32
+{
+	CELL_SYSCONF_BT_DEVICE_TYPE_AUDIO = 0x00000001,
+	CELL_SYSCONF_BT_DEVICE_TYPE_HID = 0x00000002,
+};
+
+enum CellSysconfBtDeviceState : s32
+{
+	CELL_SYSCONF_BT_DEVICE_STATE_UNAVAILABLE = 0,
+	CELL_SYSCONF_BT_DEVICE_STATE_AVAILABLE = 1,
+};
+
+enum CellSysConfError : u32
+{
+	CELL_SYSCONF_ERROR_PARAM = 0x8002bb01
+};

ps3fw/include/rpcsx/fw/ps3/cellSysutil.h

@@ -0,0 +1,350 @@
+#pragma once
+
+#include "Emu/Memory/vm_ptr.h"
+
+using CellSysutilUserId = u32;
+
+enum
+{
+	CELL_SYSUTIL_ERROR_BASE_INTERNAL = 0x8002b000,
+	CELL_SYSUTIL_ERROR_BASE_COMMON = 0x8002b100,
+	CELL_SYSUTIL_ERROR_BASE_SYSTEMPARAM = 0x8002b200,
+	CELL_SYSUTIL_ERROR_BASE_MSGDIALOG = 0x8002b300,
+	CELL_SYSUTIL_ERROR_BASE_SAVEDATA = 0x8002b400,
+	CELL_SYSUTIL_ERROR_BASE_OSKDIALOG = 0x8002b500,
+	CELL_SYSUTIL_ERROR_BASE_GAMEDATA = 0x8002b600,
+	CELL_SYSUTIL_ERROR_BASE_AVC = 0x8002b700,
+	CELL_SYSUTIL_ERROR_BASE_NETCTL = 0x8002b800,
+	CELL_SYSUTIL_ERROR_BASE_WEBBROWSER = 0x8002b900,
+	CELL_SYSUTIL_ERROR_BASE_HDDGAME = 0x8002ba00,
+	CELL_SYSUTIL_ERROR_BASE_SYSCONF = 0x8002bb00,
+	CELL_SYSUTIL_ERROR_BASE_SYSCACHE = 0x8002bc00,
+	CELL_SYSUTIL_ERROR_BASE_DISCGAME = 0x8002bd00,
+	CELL_SYSUTIL_ERROR_BASE_STORAGEDATA = 0x8002be00,
+	CELL_SYSUTIL_ERROR_BASE_IMEJP = 0x8002bf00,
+	CELL_SYSUTIL_ERROR_BASE_FILE_SELECT = 0x8002c000,
+	CELL_SYSUTIL_ERROR_BASE_MUSIC = 0x8002c100,
+	CELL_SYSUTIL_ERROR_BASE_PHOTO_EXPORT_UTIL = 0x8002c200,
+	CELL_SYSUTIL_ERROR_BASE_USERINFO = 0x8002c300,
+	CELL_SYSUTIL_ERROR_BASE_PRINT = 0x8002c400,
+	CELL_SYSUTIL_ERROR_BASE_REC = 0x8002c500,
+	CELL_SYSUTIL_ERROR_BASE_MUSIC_EXPORT_UTIL = 0x8002c600,
+	CELL_SYSUTIL_ERROR_BASE_PHOTO_IMPORT = 0x8002c700,
+	CELL_SYSUTIL_ERROR_BASE_SEARCH = 0x8002c800,
+	CELL_SYSUTIL_ERROR_BASE_PHOTO_DECODE = 0x8002c900,
+	CELL_SYSUTIL_ERROR_BASE_VIDEO_EXPORT_UTIL = 0x8002ca00,
+	CELL_SYSUTIL_ERROR_BASE_GAME = 0x8002cb00,
+	CELL_SYSUTIL_ERROR_BASE_GAMEUPDATE = 0x8002cc00,
+	CELL_SYSUTIL_ERROR_BASE_AP = 0x8002cd00,
+	CELL_SYSUTIL_ERROR_BASE_COMBOPLAY = 0x8002cd80,
+	CELL_SYSUTIL_ERROR_BASE_BGDL = 0x8002ce00,
+	CELL_SYSUTIL_ERROR_BASE_VIDEO_UPLOAD_UTIL = 0x8002d000,
+	CELL_SYSUTIL_ERROR_BASE_SCREENSHOT = 0x8002d100,
+	CELL_SYSUTIL_ERROR_BASE_AUTHDIALOG = 0x8002d200,
+	CELL_SYSUTIL_ERROR_BASE_BGMPLAYBACK_EX = 0x8002d300,
+	CELL_SYSUTIL_ERROR_BASE_SYSTEM_CHAT = 0x8002d400,
+	CELL_SYSUTIL_ERROR_BASE_PHOTO_NETWORK_SHARING = 0x8002d500,
+};
+
+enum CellSysutilError : u32
+{
+	CELL_SYSUTIL_ERROR_TYPE = 0x8002b101,
+	CELL_SYSUTIL_ERROR_VALUE = 0x8002b102,
+	CELL_SYSUTIL_ERROR_SIZE = 0x8002b103,
+	CELL_SYSUTIL_ERROR_NUM = 0x8002b104,
+	CELL_SYSUTIL_ERROR_BUSY = 0x8002b105,
+	CELL_SYSUTIL_ERROR_STATUS = 0x8002b106,
+	CELL_SYSUTIL_ERROR_MEMORY = 0x8002b107,
+	CELL_SYSUTIL_ERROR_3D_SUPPORT = 0x8002b108,
+};
+
+// Parameter IDs
+enum CellSysutilParamId : s32
+{
+	// Integers
+	CELL_SYSUTIL_SYSTEMPARAM_ID_LANG = 0x0111,
+	CELL_SYSUTIL_SYSTEMPARAM_ID_ENTER_BUTTON_ASSIGN = 0x0112,
+	CELL_SYSUTIL_SYSTEMPARAM_ID_DATE_FORMAT = 0x0114,
+	CELL_SYSUTIL_SYSTEMPARAM_ID_TIME_FORMAT = 0x0115,
+	CELL_SYSUTIL_SYSTEMPARAM_ID_TIMEZONE = 0x0116,
+	CELL_SYSUTIL_SYSTEMPARAM_ID_SUMMERTIME = 0x0117,
+	CELL_SYSUTIL_SYSTEMPARAM_ID_GAME_PARENTAL_LEVEL = 0x0121,
+	CELL_SYSUTIL_SYSTEMPARAM_ID_LICENSE_AREA = 0x0122,
+	CELL_SYSUTIL_SYSTEMPARAM_ID_GAME_PARENTAL_LEVEL0_RESTRICT = 0x0123,
+	CELL_SYSUTIL_SYSTEMPARAM_ID_CURRENT_USER_HAS_NP_ACCOUNT = 0x0141,
+	CELL_SYSUTIL_SYSTEMPARAM_ID_CAMERA_PLFREQ = 0x0151,
+	CELL_SYSUTIL_SYSTEMPARAM_ID_PAD_RUMBLE = 0x0152,
+	CELL_SYSUTIL_SYSTEMPARAM_ID_KEYBOARD_TYPE = 0x0153,
+	CELL_SYSUTIL_SYSTEMPARAM_ID_JAPANESE_KEYBOARD_ENTRY_METHOD = 0x0154,
+	CELL_SYSUTIL_SYSTEMPARAM_ID_CHINESE_KEYBOARD_ENTRY_METHOD = 0x0155,
+	CELL_SYSUTIL_SYSTEMPARAM_ID_PAD_AUTOOFF = 0x0156,
+	CELL_SYSUTIL_SYSTEMPARAM_ID_MAGNETOMETER = 0x0157,
+
+	// Strings
+	CELL_SYSUTIL_SYSTEMPARAM_ID_NICKNAME = 0x0113,
+	CELL_SYSUTIL_SYSTEMPARAM_ID_CURRENT_USERNAME = 0x0131,
+	// Unknown strings
+	CELL_SYSUTIL_SYSTEMPARAM_ID_x1008 = 0x1008,
+	CELL_SYSUTIL_SYSTEMPARAM_ID_x1011 = 0x1011,
+	CELL_SYSUTIL_SYSTEMPARAM_ID_x1012 = 0x1012, // Equal meaning to x1011
+	CELL_SYSUTIL_SYSTEMPARAM_ID_x1024 = 0x1024,
+};
+
+enum CellSysutilLang : s32
+{
+	CELL_SYSUTIL_LANG_JAPANESE = 0,
+	CELL_SYSUTIL_LANG_ENGLISH_US = 1,
+	CELL_SYSUTIL_LANG_FRENCH = 2,
+	CELL_SYSUTIL_LANG_SPANISH = 3,
+	CELL_SYSUTIL_LANG_GERMAN = 4,
+	CELL_SYSUTIL_LANG_ITALIAN = 5,
+	CELL_SYSUTIL_LANG_DUTCH = 6,
+	CELL_SYSUTIL_LANG_PORTUGUESE_PT = 7,
+	CELL_SYSUTIL_LANG_RUSSIAN = 8,
+	CELL_SYSUTIL_LANG_KOREAN = 9,
+	CELL_SYSUTIL_LANG_CHINESE_T = 10,
+	CELL_SYSUTIL_LANG_CHINESE_S = 11,
+	CELL_SYSUTIL_LANG_FINNISH = 12,
+	CELL_SYSUTIL_LANG_SWEDISH = 13,
+	CELL_SYSUTIL_LANG_DANISH = 14,
+	CELL_SYSUTIL_LANG_NORWEGIAN = 15,
+	CELL_SYSUTIL_LANG_POLISH = 16,
+	CELL_SYSUTIL_LANG_PORTUGUESE_BR = 17, // FW 4.00
+	CELL_SYSUTIL_LANG_ENGLISH_GB = 18,    // FW 4.00
+	CELL_SYSUTIL_LANG_TURKISH = 19,       // FW 4.30
+};
+
+enum
+{
+	CELL_SYSUTIL_SYSTEMPARAM_NICKNAME_SIZE = 0x80,
+	CELL_SYSUTIL_SYSTEMPARAM_CURRENT_USERNAME_SIZE = 0x40
+};
+
+enum
+{
+	CELL_SYSUTIL_KEYBOARD_ENTRY_METHOD_ROMAJI_INPUT = 0,
+	CELL_SYSUTIL_KEYBOARD_ENTRY_METHOD_KANA_INPUT = 1,
+};
+
+enum
+{
+	CELL_SYSUTIL_KEYBOARD_ENTRY_METHOD_ZHUYIN_INPUT = 0,
+	CELL_SYSUTIL_KEYBOARD_ENTRY_METHOD_PINYIN_INPUT = 1,
+	CELL_SYSUTIL_KEYBOARD_ENTRY_METHOD_CANGJIE_INPUT = 2,
+};
+
+enum
+{
+	CELL_SYSUTIL_REQUEST_EXITGAME = 0x0101,
+	CELL_SYSUTIL_DRAWING_BEGIN = 0x0121,
+	CELL_SYSUTIL_DRAWING_END = 0x0122,
+	CELL_SYSUTIL_SYSTEM_MENU_OPEN = 0x0131,
+	CELL_SYSUTIL_SYSTEM_MENU_CLOSE = 0x0132,
+	CELL_SYSUTIL_BGMPLAYBACK_PLAY = 0x0141,
+	CELL_SYSUTIL_BGMPLAYBACK_STOP = 0x0142,
+
+	CELL_SYSUTIL_NP_INVITATION_SELECTED = 0x0151,
+	CELL_SYSUTIL_NP_DATA_MESSAGE_SELECTED = 0x0152,
+
+	CELL_SYSUTIL_SYSCHAT_START = 0x0161,
+	CELL_SYSUTIL_SYSCHAT_STOP = 0x0162,
+	CELL_SYSUTIL_SYSCHAT_VOICE_STREAMING_RESUMED = 0x0163,
+	CELL_SYSUTIL_SYSCHAT_VOICE_STREAMING_PAUSED = 0x0164,
+};
+
+using CellSysutilCallback = void(u64 status, u64 param, vm::ptr<void> userdata);
+
+enum
+{
+	CELL_SYSUTIL_ENTER_BUTTON_ASSIGN_CIRCLE = 0,
+	CELL_SYSUTIL_ENTER_BUTTON_ASSIGN_CROSS = 1,
+};
+
+enum
+{
+	CELL_SYSUTIL_DATE_FMT_YYYYMMDD = 0,
+	CELL_SYSUTIL_DATE_FMT_DDMMYYYY = 1,
+	CELL_SYSUTIL_DATE_FMT_MMDDYYYY = 2,
+};
+
+enum
+{
+	CELL_SYSUTIL_TIME_FMT_CLOCK12 = 0,
+	CELL_SYSUTIL_TIME_FMT_CLOCK24 = 1,
+};
+
+enum
+{
+	CELL_SYSUTIL_GAME_PARENTAL_OFF = 0,
+	CELL_SYSUTIL_GAME_PARENTAL_LEVEL01 = 1,
+	CELL_SYSUTIL_GAME_PARENTAL_LEVEL02 = 2,
+	CELL_SYSUTIL_GAME_PARENTAL_LEVEL03 = 3,
+	CELL_SYSUTIL_GAME_PARENTAL_LEVEL04 = 4,
+	CELL_SYSUTIL_GAME_PARENTAL_LEVEL05 = 5,
+	CELL_SYSUTIL_GAME_PARENTAL_LEVEL06 = 6,
+	CELL_SYSUTIL_GAME_PARENTAL_LEVEL07 = 7,
+	CELL_SYSUTIL_GAME_PARENTAL_LEVEL08 = 8,
+	CELL_SYSUTIL_GAME_PARENTAL_LEVEL09 = 9,
+	CELL_SYSUTIL_GAME_PARENTAL_LEVEL10 = 10,
+	CELL_SYSUTIL_GAME_PARENTAL_LEVEL11 = 11,
+};
+
+enum
+{
+	CELL_SYSUTIL_GAME_PARENTAL_LEVEL0_RESTRICT_OFF = 0,
+	CELL_SYSUTIL_GAME_PARENTAL_LEVEL0_RESTRICT_ON = 1,
+};
+
+enum
+{
+	CELL_SYSUTIL_CAMERA_PLFREQ_DISABLED = 0,
+	CELL_SYSUTIL_CAMERA_PLFREQ_50HZ = 1,
+	CELL_SYSUTIL_CAMERA_PLFREQ_60HZ = 2,
+	CELL_SYSUTIL_CAMERA_PLFREQ_DEVCIE_DEPEND = 4,
+};
+
+enum
+{
+	CELL_SYSUTIL_PAD_RUMBLE_OFF = 0,
+	CELL_SYSUTIL_PAD_RUMBLE_ON = 1,
+};
+
+// License areas
+enum CellSysutilLicenseArea : s32 // Made up name
+{
+	CELL_SYSUTIL_LICENSE_AREA_J = 0,       // SCEJ (Japan)
+	CELL_SYSUTIL_LICENSE_AREA_A = 1,       // SCEA (North America, South America, Canada, Brazil)
+	CELL_SYSUTIL_LICENSE_AREA_E = 2,       // SCEE (UK, Europe, Eastern Europe, Oceania, Russia)
+	CELL_SYSUTIL_LICENSE_AREA_H = 3,       // SCEH (Hong Kong, Taiwan, Southeast Asia)
+	CELL_SYSUTIL_LICENSE_AREA_K = 4,       // SCEK (Korea)
+	CELL_SYSUTIL_LICENSE_AREA_C = 5,       // SCH  (China)
+	CELL_SYSUTIL_LICENSE_AREA_OTHER = 100, // Other
+};
+
+enum
+{
+	CELL_SYSUTIL_PAD_AUTOOFF_OFF = 0,
+	CELL_SYSUTIL_PAD_AUTOOFF_ON = 1,
+};
+
+enum
+{
+	CELL_SYSUTIL_MAGNETOMETER_OFF = 0,
+	CELL_SYSUTIL_MAGNETOMETER_ON = 1,
+};
+
+enum
+{
+	CELL_SYSUTIL_INTERNET_BROWSER_START_RESTRICT_OFF = 0,
+	CELL_SYSUTIL_INTERNET_BROWSER_START_RESTRICT_ON = 1,
+};
+
+enum
+{
+	CELL_SYSCACHE_RET_OK_CLEARED = 0,
+	CELL_SYSCACHE_RET_OK_RELAYED = 1,
+
+	CELL_SYSCACHE_ID_SIZE = 32,
+	CELL_SYSCACHE_PATH_MAX = 1055,
+};
+
+enum CellSysCacheError : u32
+{
+	CELL_SYSCACHE_ERROR_ACCESS_ERROR = 0x8002bc01, // I don't think we need this
+	CELL_SYSCACHE_ERROR_INTERNAL = 0x8002bc02,     // Not really useful, if we run out of HDD space sys_fs should handle that
+
+	CELL_SYSCACHE_ERROR_PARAM = 0x8002bc03,
+	CELL_SYSCACHE_ERROR_NOTMOUNTED = 0x8002bc04, // We don't really need to simulate the mounting, so this is probably useless
+};
+
+enum CellBgmplaybackError : u32
+{
+	CELL_SYSUTIL_BGMPLAYBACK_ERROR_PARAM = 0x8002b101,
+	CELL_SYSUTIL_BGMPLAYBACK_ERROR_BUSY = 0x8002b102,
+	CELL_SYSUTIL_BGMPLAYBACK_ERROR_GENERIC = 0x8002b1FF,
+
+	CELL_SYSUTIL_BGMPLAYBACK_EX_ERROR_PARAM = 0x8002d301,
+	CELL_SYSUTIL_BGMPLAYBACK_EX_ERROR_ALREADY_SETPARAM = 0x8002d302,
+	CELL_SYSUTIL_BGMPLAYBACK_EX_ERROR_DISABLE_SETPARAM = 0x8002d303,
+	CELL_SYSUTIL_BGMPLAYBACK_EX_ERROR_GENERIC = 0x8002d3FF,
+};
+
+enum CellSysutilBgmPlaybackStatusState
+{
+	CELL_SYSUTIL_BGMPLAYBACK_STATUS_PLAY = 0,
+	CELL_SYSUTIL_BGMPLAYBACK_STATUS_STOP = 1
+};
+
+enum CellSysutilBgmPlaybackStatusEnabled
+{
+	CELL_SYSUTIL_BGMPLAYBACK_STATUS_ENABLE = 0,
+	CELL_SYSUTIL_BGMPLAYBACK_STATUS_DISABLE = 1
+};
+
+enum
+{
+	CELL_SYSUTIL_BGMPLAYBACK_FADE_INVALID = -1
+};
+
+struct CellSysutilBgmPlaybackStatus
+{
+	u8 playerState;
+	u8 enableState;
+	char contentId[16];  // CellSearchContentId
+	u8 currentFadeRatio; // current volume ratio (0=0%, 255=100%)
+	char reserved[13];
+};
+
+struct CellSysutilBgmPlaybackStatus2
+{
+	u8 playerState;
+	char reserved[7];
+};
+
+struct CellSysutilBgmPlaybackExtraParam
+{
+	be_t<s32> systemBgmFadeInTime;
+	be_t<s32> systemBgmFadeOutTime;
+	be_t<s32> gameBgmFadeInTime;
+	be_t<s32> gameBgmFadeOutTime;
+	char reserved[8];
+};
+
+struct CellSysCacheParam
+{
+	char cacheId[CELL_SYSCACHE_ID_SIZE];
+	char getCachePath[CELL_SYSCACHE_PATH_MAX];
+	vm::bptr<void> reserved;
+};
+
+template <u32 BaseEvent>
+struct SysutilEventStatus
+{
+	atomic_t<bool> active = false;
+};
+
+extern atomic_t<usz> g_sysutil_callback_id_assigner;
+
+extern void sysutil_register_cb_with_id_internal(std::function<s32(ppu_thread&)>&& cb, usz call_id);
+extern void sysutil_unregister_cb_with_id_internal(usz call_id);
+
+template <typename T>
+const usz g_sysutil_dispatcher_id = g_sysutil_callback_id_assigner++;
+
+template <typename T>
+void sysutil_register_cb_with_id(std::function<s32(ppu_thread&)>&& cb)
+{
+	sysutil_register_cb_with_id_internal(std::move(cb), g_sysutil_dispatcher_id<T>);
+}
+
+template <typename T>
+void sysutil_unregister_cb_with_id()
+{
+	sysutil_unregister_cb_with_id_internal(g_sysutil_dispatcher_id<T>);
+}
+
+using SysutilMenuOpenStatus = SysutilEventStatus<CELL_SYSUTIL_SYSTEM_MENU_OPEN>;
+
+extern void sysutil_register_cb(std::function<s32(ppu_thread&)>&&);
+extern s32 sysutil_send_system_cmd(u64 status, u64 param);
+s32 sysutil_check_name_string(const char* src, s32 minlen, s32 maxlen);

ps3fw/include/rpcsx/fw/ps3/cellSysutilAvc.h

@@ -0,0 +1,155 @@
+#pragma once
+
+#include "sceNp.h"
+
+enum CellAvcError : u32
+{
+	CELL_AVC_ERROR_UNKNOWN = 0x8002b701,
+	CELL_AVC_ERROR_NOT_SUPPORTED = 0x8002b702,
+	CELL_AVC_ERROR_NOT_INITIALIZED = 0x8002b703,
+	CELL_AVC_ERROR_ALREADY_INITIALIZED = 0x8002b704,
+	CELL_AVC_ERROR_INVALID_ARGUMENT = 0x8002b705,
+	CELL_AVC_ERROR_OUT_OF_MEMORY = 0x8002b706,
+	CELL_AVC_ERROR_BAD_ID = 0x8002b707,
+	CELL_AVC_ERROR_INVALID_STATUS = 0x8002b70a,
+	CELL_AVC_ERROR_TIMEOUT = 0x8002b70b,
+	CELL_AVC_ERROR_NO_SESSION = 0x8002b70d,
+	CELL_AVC_ERROR_INCOMPATIBLE_PROTOCOL = 0x8002b70e,
+	CELL_AVC_ERROR_PEER_UNREACHABLE = 0x8002b710,
+};
+
+enum CellSysutilAvcTransitionType : u32
+{
+	CELL_SYSUTIL_AVC_TRANSITION_LINEAR = 0x00000000,
+	CELL_SYSUTIL_AVC_TRANSITION_SLOWDOWN = 0x00000001,
+	CELL_SYSUTIL_AVC_TRANSITION_FASTUP = 0x00000002,
+	CELL_SYSUTIL_AVC_TRANSITION_ANGULAR = 0x00000003,
+	CELL_SYSUTIL_AVC_TRANSITION_EXPONENT = 0x00000004,
+	CELL_SYSUTIL_AVC_TRANSITION_NONE = 0xffffffff
+};
+
+enum CellSysutilAvcWindowZorderMode : u32
+{
+	CELL_SYSUTIL_AVC_ZORDER_FORWARD_MOST = 0x00000002,
+	CELL_SYSUTIL_AVC_ZORDER_BEHIND_MOST = 0x00000003,
+};
+
+enum : u32
+{
+	CELL_AVC_REQUEST_ID_SYSTEM_EVENT = 0x00000000,
+
+	CELL_SYSUTIL_AVC_VIDEO_MEMORY_SIZE = 26 * 1024 * 1024,
+	CELL_SYSUTIL_AVC_VOICE_MEMORY_SIZE = 8 * 1024 * 1024,
+	CELL_SYSUTIL_AVC_EXTRA_MEMORY_SIZE_FOR_SHARING_VIDEO_BUFFER = 2 * 1024 * 1024,
+
+	CELL_SYSUTIL_AVC_OPTION_PARAM_VERSION = 100,
+};
+
+enum CellSysutilAvcEvent : u32
+{
+	CELL_AVC_EVENT_LOAD_SUCCEEDED = 0x00000001,
+	CELL_AVC_EVENT_LOAD_FAILED = 0x00000002,
+	CELL_AVC_EVENT_UNLOAD_SUCCEEDED = 0x00000003,
+	CELL_AVC_EVENT_UNLOAD_FAILED = 0x00000004,
+	CELL_AVC_EVENT_JOIN_SUCCEEDED = 0x00000005,
+	CELL_AVC_EVENT_JOIN_FAILED = 0x00000006,
+	CELL_AVC_EVENT_BYE_SUCCEEDED = 0x00000007,
+	CELL_AVC_EVENT_BYE_FAILED = 0x00000008,
+
+	CELL_AVC_EVENT_SYSTEM_NEW_MEMBER_JOINED = 0x10000001,
+	CELL_AVC_EVENT_SYSTEM_MEMBER_LEFT = 0x10000002,
+	CELL_AVC_EVENT_SYSTEM_SESSION_ESTABLISHED = 0x10000003,
+	CELL_AVC_EVENT_SYSTEM_SESSION_CANNOT_ESTABLISHED = 0x10000004,
+	CELL_AVC_EVENT_SYSTEM_SESSION_DISCONNECTED = 0x10000005,
+	CELL_AVC_EVENT_SYSTEM_VOICE_DETECTED = 0x10000006,
+	CELL_AVC_EVENT_SYSTEM_MIC_DETECTED = 0x10000007,
+	CELL_AVC_EVENT_SYSTEM_CAMERA_DETECTED = 0x10000008,
+};
+
+enum CellSysUtilAvcEventParam : u64
+{
+	CELL_AVC_EVENT_PARAM_ERROR_UNKNOWN = 0x00000001,
+	CELL_AVC_EVENT_PARAM_ERROR_NOT_SUPPORTED = 0x00000002,
+	CELL_AVC_EVENT_PARAM_ERROR_INVALID_ARGUMENT = 0x00000003,
+	CELL_AVC_EVENT_PARAM_ERROR_OUT_OF_MEMORY = 0x00000004,
+	CELL_AVC_EVENT_PARAM_ERROR_INVALID_STATUS = 0x00000005,
+	CELL_AVC_EVENT_PARAM_ERROR_TIMEOUT = 0x00000006,
+	CELL_AVC_EVENT_PARAM_ERROR_CONTEXT_DOES_NOT_EXIST = 0x00000007,
+	CELL_AVC_EVENT_PARAM_ERROR_ROOM_DOES_NOT_EXIST = 0x00000008,
+	CELL_AVC_EVENT_PARAM_ERROR_MEDIA_MISMATCHED = 0x00000009,
+	CELL_AVC_EVENT_PARAM_ERROR_MEMBER_EXCEEDED = 0x0000000A,
+	CELL_AVC_EVENT_PARAM_ERROR_MASTER_LEFT = 0x0000000B,
+	CELL_AVC_EVENT_PARAM_ERROR_NETWORK_ERROR = 0x0000000C,
+	CELL_AVC_EVENT_PARAM_ERROR_INCOMPATIBLE_PROTOCOL = 0x0000000D,
+};
+
+enum CellSysUtilAvcAttribute : u32
+{
+	CELL_SYSUTIL_AVC_ATTRIBUTE_DEFAULT_TRANSITION_TYPE = 0x00000001,
+	CELL_SYSUTIL_AVC_ATTRIBUTE_DEFAULT_TRANSITION_DURATION = 0x00000002,
+	CELL_SYSUTIL_AVC_ATTRIBUTE_DEFAULT_INITIAL_SHOW_STATUS = 0x00000003,
+	CELL_SYSUTIL_AVC_ATTRIBUTE_VOICE_DETECT_EVENT_TYPE = 0x00000004,
+	CELL_SYSUTIL_AVC_ATTRIBUTE_VOICE_DETECT_INTERVAL_TIME = 0x00000005,
+	CELL_SYSUTIL_AVC_ATTRIBUTE_VOICE_DETECT_SIGNAL_LEVEL = 0x00000006,
+	CELL_SYSUTIL_AVC_ATTRIBUTE_ROOM_PRIVILEGE_TYPE = 0x00000007,
+	CELL_SYSUTIL_AVC_ATTRIBUTE_VIDEO_MAX_BITRATE = 0x00000008,
+};
+
+enum CellSysutilAvcLayoutMode : u32
+{
+	CELL_SYSUTIL_AVC_LAYOUT_LEFT = 0x00000000,
+	CELL_SYSUTIL_AVC_LAYOUT_RIGHT = 0x00000001,
+	CELL_SYSUTIL_AVC_LAYOUT_TOP = 0x00000002,
+	CELL_SYSUTIL_AVC_LAYOUT_BOTTOM = 0x00000003,
+};
+
+enum CellSysUtilAvcMediaType : u32
+{
+	CELL_SYSUTIL_AVC_VOICE_CHAT = 0x00000001,
+	CELL_SYSUTIL_AVC_VIDEO_CHAT = 0x00000002,
+};
+
+enum CellSysutilAvcRoomPrivilegeType : u32
+{
+	CELL_SYSUTIL_AVC_ROOM_PRIVILEGE_TYPE_NO_AUTO_GRANT = 0x00000000,
+	CELL_SYSUTIL_AVC_ROOM_PRIVILEGE_TYPE_AUTO_GRANT = 0x00000001
+};
+
+enum CellSysUtilAvcVideoQuality : u32
+{
+	CELL_SYSUTIL_AVC_VIDEO_QUALITY_DEFAULT = 0x00000001
+};
+
+enum CellSysutilAvcVoiceDetectEventType : u32
+{
+	CELL_SYSUTIL_AVC_VOICE_DETECT_EVENT_TYPE_SIGNAL = 0x00000001,
+	CELL_SYSUTIL_AVC_VOICE_DETECT_EVENT_TYPE_SPEAK = 0x00000002
+};
+
+enum CellSysutilAvcVoiceDetectSpeakData : u32
+{
+	CELL_SYSUTIL_AVC_VOICE_DETECT_DATA_SPEAK_STOP = 0x00000000,
+	CELL_SYSUTIL_AVC_VOICE_DETECT_DATA_SPEAK_START = 0x00000001
+};
+
+enum CellSysUtilAvcVoiceQuality : u32
+{
+	CELL_SYSUTIL_AVC_VOICE_QUALITY_DEFAULT = 0x00000001
+};
+
+struct CellSysutilAvcOptionParam
+{
+	be_t<s32> avcOptionParamVersion;
+	b8 sharingVideoBuffer;
+	be_t<s32> maxPlayers; // Not in FW 1.70
+};
+
+struct CellSysutilAvcVoiceDetectData
+{
+	SceNpId npid;
+	be_t<s32> data;
+};
+
+typedef u32 CellSysutilAvcRequestId;
+
+using CellSysutilAvcCallback = void(CellSysutilAvcRequestId request_id, CellSysutilAvcEvent event_id, CellSysUtilAvcEventParam event_param, vm::ptr<void> userdata);

ps3fw/include/rpcsx/fw/ps3/cellSysutilAvc2.h

@@ -0,0 +1,302 @@
+#pragma once
+
+#include "sceNp2.h"
+
+#include "Emu/Memory/vm_ptr.h"
+
+// Error codes
+enum CellSysutilAvc2Error : u32
+{
+	CELL_AVC2_ERROR_UNKNOWN = 0x8002b701,
+	CELL_AVC2_ERROR_NOT_SUPPORTED = 0x8002b702,
+	CELL_AVC2_ERROR_NOT_INITIALIZED = 0x8002b703,
+	CELL_AVC2_ERROR_ALREADY_INITIALIZED = 0x8002b704,
+	CELL_AVC2_ERROR_INVALID_ARGUMENT = 0x8002b705,
+	CELL_AVC2_ERROR_OUT_OF_MEMORY = 0x8002b706,
+	CELL_AVC2_ERROR_ERROR_BAD_ID = 0x8002b707,
+	CELL_AVC2_ERROR_INVALID_STATUS = 0x8002b70a,
+	CELL_AVC2_ERROR_TIMEOUT = 0x8002b70b,
+	CELL_AVC2_ERROR_NO_SESSION = 0x8002b70d,
+	CELL_AVC2_ERROR_WINDOW_ALREADY_EXISTS = 0x8002b70f,
+	CELL_AVC2_ERROR_TOO_MANY_WINDOWS = 0x8002b710,
+	CELL_AVC2_ERROR_TOO_MANY_PEER_WINDOWS = 0x8002b711,
+	CELL_AVC2_ERROR_WINDOW_NOT_FOUND = 0x8002b712,
+};
+
+enum CellSysutilAvc2MediaType : u32
+{
+	CELL_SYSUTIL_AVC2_VOICE_CHAT = 0x00000001,
+	CELL_SYSUTIL_AVC2_VIDEO_CHAT = 0x00000010,
+};
+
+enum CellSysutilAvc2VoiceQuality : u32
+{
+	CELL_SYSUTIL_AVC2_VOICE_QUALITY_NORMAL = 0x00000001,
+};
+
+enum CellSysutilAvc2VideoQuality : u32
+{
+	CELL_SYSUTIL_AVC2_VIDEO_QUALITY_NORMAL = 0x00000001,
+};
+
+enum CellSysutilAvc2FrameMode : u32
+{
+	CELL_SYSUTIL_AVC2_FRAME_MODE_NORMAL = 0x00000001,
+	CELL_SYSUTIL_AVC2_FRAME_MODE_INTRA_ONLY = 0x00000002,
+};
+
+enum CellSysutilAvc2CoordinatesForm : u32
+{
+	CELL_SYSUTIL_AVC2_VIRTUAL_COORDINATES = 0x00000001,
+	CELL_SYSUTIL_AVC2_ABSOLUTE_COORDINATES = 0x00000002,
+};
+
+enum CellSysutilAvc2VideoResolution : u32
+{
+	CELL_SYSUTIL_AVC2_VIDEO_RESOLUTION_QQVGA = 0x00000001,
+	CELL_SYSUTIL_AVC2_VIDEO_RESOLUTION_QVGA = 0x00000002,
+};
+
+enum CellSysutilAvc2ChatTargetMode : u32
+{
+	CELL_SYSUTIL_AVC2_CHAT_TARGET_MODE_ROOM = 0x00000100,
+	CELL_SYSUTIL_AVC2_CHAT_TARGET_MODE_TEAM = 0x00000200,
+	CELL_SYSUTIL_AVC2_CHAT_TARGET_MODE_PRIVATE = 0x00000300,
+	CELL_SYSUTIL_AVC2_CHAT_TARGET_MODE_DIRECT = 0x00001000,
+};
+
+enum CellSysutilAvc2AttributeId : u32
+{
+	CELL_SYSUTIL_AVC2_ATTRIBUTE_VOICE_DETECT_EVENT_TYPE = 0x00001001,
+	CELL_SYSUTIL_AVC2_ATTRIBUTE_VOICE_DETECT_INTERVAL_TIME = 0x00001002,
+	CELL_SYSUTIL_AVC2_ATTRIBUTE_VOICE_DETECT_SIGNAL_LEVEL = 0x00001003,
+	CELL_SYSUTIL_AVC2_ATTRIBUTE_VOICE_MAX_BITRATE = 0x00001004,
+	CELL_SYSUTIL_AVC2_ATTRIBUTE_VOICE_DATA_FEC = 0x00001005,
+	CELL_SYSUTIL_AVC2_ATTRIBUTE_VOICE_PACKET_CONTENTION = 0x00001006,
+	CELL_SYSUTIL_AVC2_ATTRIBUTE_VOICE_DTX_MODE = 0x00001007,
+	CELL_SYSUTIL_AVC2_ATTRIBUTE_MIC_STATUS_DETECTION = 0x00001008,
+	CELL_SYSUTIL_AVC2_ATTRIBUTE_MIC_SETTING_NOTIFICATION = 0x00001009,
+	CELL_SYSUTIL_AVC2_ATTRIBUTE_VOICE_MUTING_NOTIFICATION = 0x0000100A,
+	CELL_SYSUTIL_AVC2_ATTRIBUTE_CAMERA_STATUS_DETECTION = 0x0000100B,
+};
+
+enum CellSysutilAvc2WindowAttributeId : u32
+{
+	CELL_SYSUTIL_AVC2_WINDOW_ATTRIBUTE_ALPHA = 0x00002001,
+	CELL_SYSUTIL_AVC2_WINDOW_ATTRIBUTE_TRANSITION_TYPE = 0x00002002,
+	CELL_SYSUTIL_AVC2_WINDOW_ATTRIBUTE_TRANSITION_DURATION = 0x00002003,
+	CELL_SYSUTIL_AVC2_WINDOW_ATTRIBUTE_STRING_VISIBLE = 0x00002004,
+	CELL_SYSUTIL_AVC2_WINDOW_ATTRIBUTE_ROTATION = 0x00002005,
+	CELL_SYSUTIL_AVC2_WINDOW_ATTRIBUTE_ZORDER = 0x00002006,
+	CELL_SYSUTIL_AVC2_WINDOW_ATTRIBUTE_SURFACE = 0x00002007,
+};
+
+enum CellSysutilAvc2TransitionType : u32
+{
+	CELL_SYSUTIL_AVC2_TRANSITION_NONE = 0xffffffff,
+	CELL_SYSUTIL_AVC2_TRANSITION_LINEAR = 0x00000000,
+	CELL_SYSUTIL_AVC2_TRANSITION_SLOWDOWN = 0x00000001,
+	CELL_SYSUTIL_AVC2_TRANSITION_FASTUP = 0x00000002,
+	CELL_SYSUTIL_AVC2_TRANSITION_ANGULAR = 0x00000003,
+	CELL_SYSUTIL_AVC2_TRANSITION_EXPONENT = 0x00000004,
+};
+
+enum CellSysutilAvc2WindowZorderMode : u32
+{
+	CELL_SYSUTIL_AVC2_ZORDER_FORWARD_MOST = 0x00000001,
+	CELL_SYSUTIL_AVC2_ZORDER_BEHIND_MOST = 0x00000002,
+};
+
+enum
+{
+	CELL_AVC2_CAMERA_STATUS_DETACHED = 0,
+	CELL_AVC2_CAMERA_STATUS_ATTACHED_OFF = 1,
+	CELL_AVC2_CAMERA_STATUS_ATTACHED_ON = 2,
+	CELL_AVC2_CAMERA_STATUS_UNKNOWN = 3,
+};
+
+enum
+{
+	CELL_AVC2_MIC_STATUS_DETACHED = 0,
+	CELL_AVC2_MIC_STATUS_ATTACHED_OFF = 1,
+	CELL_AVC2_MIC_STATUS_ATTACHED_ON = 2,
+	CELL_AVC2_MIC_STATUS_UNKNOWN = 3,
+};
+
+enum
+{
+	CELL_SYSUTIL_AVC2_STREAMING_MODE_NORMAL = 0,
+	CELL_SYSUTIL_AVC2_STREAMING_MODE_DIRECT_WAN = 1,
+	CELL_SYSUTIL_AVC2_STREAMING_MODE_DIRECT_LAN = 2,
+};
+
+enum
+{
+	CELL_SYSUTIL_AVC2_VIDEO_SHARING_MODE_DISABLE = 0,
+	CELL_SYSUTIL_AVC2_VIDEO_SHARING_MODE_1 = 1,
+	CELL_SYSUTIL_AVC2_VIDEO_SHARING_MODE_2 = 2,
+	CELL_SYSUTIL_AVC2_VIDEO_SHARING_MODE_3 = 3,
+};
+
+enum
+{
+	CELL_AVC2_EVENT_LOAD_SUCCEEDED = 0x00000001,
+	CELL_AVC2_EVENT_LOAD_FAILED = 0x00000002,
+	CELL_AVC2_EVENT_UNLOAD_SUCCEEDED = 0x00000003,
+	CELL_AVC2_EVENT_UNLOAD_FAILED = 0x00000004,
+	CELL_AVC2_EVENT_JOIN_SUCCEEDED = 0x00000005,
+	CELL_AVC2_EVENT_JOIN_FAILED = 0x00000006,
+	CELL_AVC2_EVENT_LEAVE_SUCCEEDED = 0x00000007,
+	CELL_AVC2_EVENT_LEAVE_FAILED = 0x00000008,
+};
+
+enum
+{
+	CELL_AVC2_EVENT_SYSTEM_NEW_MEMBER_JOINED = 0x10000001,
+	CELL_AVC2_EVENT_SYSTEM_MEMBER_LEFT = 0x10000002,
+	CELL_AVC2_EVENT_SYSTEM_SESSION_ESTABLISHED = 0x10000003,
+	CELL_AVC2_EVENT_SYSTEM_SESSION_CANNOT_ESTABLISHED = 0x10000004,
+	CELL_AVC2_EVENT_SYSTEM_SESSION_DISCONNECTED = 0x10000005,
+	CELL_AVC2_EVENT_SYSTEM_VOICE_DETECTED = 0x10000006,
+	CELL_AVC2_EVENT_SYSTEM_MIC_DETECTED = 0x10000007,
+	CELL_AVC2_EVENT_SYSTEM_CAMERA_DETECTED = 0x10000008,
+};
+
+enum
+{
+	CELL_AVC2_EVENT_PARAM_ERROR_UNKNOWN = 0x0000000000000001,
+	CELL_AVC2_EVENT_PARAM_ERROR_NOT_SUPPORTED = 0x0000000000000002,
+	CELL_AVC2_EVENT_PARAM_ERROR_INVALID_ARGUMENT = 0x0000000000000003,
+	CELL_AVC2_EVENT_PARAM_ERROR_OUT_OF_MEMORY = 0x0000000000000004,
+	CELL_AVC2_EVENT_PARAM_ERROR_INVALID_STATUS = 0x0000000000000005,
+	CELL_AVC2_EVENT_PARAM_ERROR_CONTEXT_DOES_NOT_EXIST = 0x0000000000000006,
+	CELL_AVC2_EVENT_PARAM_ERROR_ROOM_DOES_NOT_EXIST = 0x0000000000000007,
+	CELL_AVC2_EVENT_PARAM_ERROR_NETWORK_ERROR = 0x0000000000000008,
+};
+
+enum
+{
+	CELL_AVC2_REQUEST_ID_SYSTEM_EVENT = 0x00000000
+};
+
+enum
+{
+	CELL_SYSUTIL_AVC2_INIT_PARAM_VERSION = 140 // Older versions may be 100, 110, 120, 130
+};
+
+enum
+{
+	AVC2_SPECIAL_ROOM_MEMBER_ID_CUSTOM_VIDEO_WINDOW = 0xfff0
+};
+
+typedef u32 CellSysutilAvc2EventId;
+typedef u64 CellSysutilAvc2EventParam;
+
+using CellSysutilAvc2Callback = void(CellSysutilAvc2EventId event_id, CellSysutilAvc2EventParam event_param, vm::ptr<void> userdata);
+
+struct CellSysutilAvc2VoiceInitParam
+{
+	be_t<CellSysutilAvc2VoiceQuality> voice_quality;
+	be_t<u16> max_speakers;
+	u8 mic_out_stream_sharing;
+	u8 reserved[25];
+};
+
+struct CellSysutilAvc2VideoInitParam
+{
+	be_t<u32> video_quality;
+	be_t<u32> frame_mode;
+	be_t<u32> max_video_resolution;
+	be_t<u16> max_video_windows;
+	be_t<u16> max_video_framerate;
+	be_t<u32> max_video_bitrate;
+	be_t<u32> coordinates_form;
+	u8 video_stream_sharing;
+	u8 no_use_camera_device;
+	u8 reserved[6];
+};
+
+struct CellSysutilAvc2StreamingModeParam
+{
+	be_t<u16> mode;
+	be_t<u16> port;
+	u8 reserved[10];
+};
+
+struct CellSysutilAvc2InitParam
+{
+	be_t<u16> avc_init_param_version;
+	be_t<u16> max_players;
+	be_t<u16> spu_load_average;
+	union
+	{
+		be_t<u16> direct_streaming_mode;
+		CellSysutilAvc2StreamingModeParam streaming_mode;
+	};
+	u8 reserved[18];
+	be_t<u32> media_type;
+	CellSysutilAvc2VoiceInitParam voice_param;
+	CellSysutilAvc2VideoInitParam video_param;
+	u8 reserved2[22];
+};
+
+struct CellSysutilAvc2RoomMemberList
+{
+	vm::bptr<SceNpMatching2RoomMemberId> member_id;
+	u8 member_num;
+};
+
+struct CellSysutilAvc2MemberIpAndPortList
+{
+	vm::bptr<SceNpMatching2RoomMemberId> member_id;
+	vm::bptr<u32> dst_addr; // in_addr
+	vm::bptr<u16> dst_port; // in_port_t
+	be_t<SceNpMatching2RoomMemberId> my_member_id;
+	u8 member_num;
+};
+
+union CellSysutilAvc2AttributeParam
+{
+	be_t<u64> int_param;
+	be_t<f32> float_param;
+	vm::bptr<void> ptr_param;
+};
+
+struct CellSysutilAvc2Attribute
+{
+	be_t<CellSysutilAvc2AttributeId> attr_id;
+	CellSysutilAvc2AttributeParam attr_param;
+};
+
+union CellSysutilAvc2WindowAttributeParam
+{
+	be_t<s32> int_vector[4];
+	be_t<f32> float_vector[4];
+	vm::bptr<void> ptr_vector[4];
+};
+
+struct CellSysutilAvc2WindowAttribute
+{
+	be_t<CellSysutilAvc2WindowAttributeId> attr_id;
+	CellSysutilAvc2WindowAttributeParam attr_param;
+};
+
+struct CellSysutilAvc2PlayerInfo
+{
+	be_t<SceNpMatching2RoomMemberId> member_id;
+	u8 joined;
+	u8 connected;
+	u8 mic_attached;
+	u8 reserved[11];
+};
+
+struct CellSysutilAvc2StreamingTarget
+{
+	be_t<CellSysutilAvc2ChatTargetMode> target_mode;
+	union
+	{
+		CellSysutilAvc2RoomMemberList room_member_list;
+		SceNpMatching2TeamId team_id;
+		CellSysutilAvc2MemberIpAndPortList ip_and_port_list;
+	};
+};

ps3fw/include/rpcsx/fw/ps3/cellUsbd.h

@@ -0,0 +1,41 @@
+#pragma once
+
+// Return Codes
+enum CellUsbdError : u32
+{
+	CELL_USBD_ERROR_NOT_INITIALIZED = 0x80110001,
+	CELL_USBD_ERROR_ALREADY_INITIALIZED = 0x80110002,
+	CELL_USBD_ERROR_NO_MEMORY = 0x80110003,
+	CELL_USBD_ERROR_INVALID_PARAM = 0x80110004,
+	CELL_USBD_ERROR_INVALID_TRANSFER_TYPE = 0x80110005,
+	CELL_USBD_ERROR_LDD_ALREADY_REGISTERED = 0x80110006,
+	CELL_USBD_ERROR_LDD_NOT_ALLOCATED = 0x80110007,
+	CELL_USBD_ERROR_LDD_NOT_RELEASED = 0x80110008,
+	CELL_USBD_ERROR_LDD_NOT_FOUND = 0x80110009,
+	CELL_USBD_ERROR_DEVICE_NOT_FOUND = 0x8011000a,
+	CELL_USBD_ERROR_PIPE_NOT_ALLOCATED = 0x8011000b,
+	CELL_USBD_ERROR_PIPE_NOT_RELEASED = 0x8011000c,
+	CELL_USBD_ERROR_PIPE_NOT_FOUND = 0x8011000d,
+	CELL_USBD_ERROR_IOREQ_NOT_ALLOCATED = 0x8011000e,
+	CELL_USBD_ERROR_IOREQ_NOT_RELEASED = 0x8011000f,
+	CELL_USBD_ERROR_IOREQ_NOT_FOUND = 0x80110010,
+	CELL_USBD_ERROR_CANNOT_GET_DESCRIPTOR = 0x80110011,
+	CELL_USBD_ERROR_FATAL = 0x801100ff,
+};
+
+// TCC (Transfer Completion Codes)
+enum
+{
+	HC_CC_NOERR = 0x0,
+	EHCI_CC_MISSMF = 0x10,
+	EHCI_CC_XACT = 0x20,
+	EHCI_CC_BABBLE = 0x30,
+	EHCI_CC_DATABUF = 0x40,
+	EHCI_CC_HALTED = 0x50,
+
+	USBD_HC_CC_NOERR = 0x0,
+	USBD_HC_CC_MISSMF = 0x1,
+	USBD_HC_CC_XACT = 0x2,
+	USBD_HC_CC_BABBLE = 0x4,
+	USBD_HC_CC_DATABUF = 0x8,
+};

ps3fw/include/rpcsx/fw/ps3/cellUserInfo.h

@@ -0,0 +1,74 @@
+#pragma once
+
+#include "Emu/Memory/vm_ptr.h"
+
+// Error Codes
+enum CellUserInfoError : u32
+{
+	CELL_USERINFO_ERROR_BUSY = 0x8002c301,
+	CELL_USERINFO_ERROR_INTERNAL = 0x8002c302,
+	CELL_USERINFO_ERROR_PARAM = 0x8002c303,
+	CELL_USERINFO_ERROR_NOUSER = 0x8002c304,
+};
+
+// Enums
+enum CellUserInfoParamSize
+{
+	CELL_USERINFO_USER_MAX = 16,
+	CELL_USERINFO_TITLE_SIZE = 256,
+	CELL_USERINFO_USERNAME_SIZE = 64,
+};
+
+enum CellUserInfoListType
+{
+	CELL_USERINFO_LISTTYPE_ALL = 0,
+	CELL_USERINFO_LISTTYPE_NOCURRENT = 1,
+};
+
+enum cell_user_callback_result : u32
+{
+	CELL_USERINFO_RET_OK = 0,
+	CELL_USERINFO_RET_CANCEL = 1,
+};
+
+enum : u32
+{
+	CELL_SYSUTIL_USERID_CURRENT = 0,
+	CELL_SYSUTIL_USERID_MAX = 99999999,
+};
+
+enum : u32
+{
+	CELL_USERINFO_FOCUS_LISTHEAD = 0xffffffff
+};
+
+// Structs
+struct CellUserInfoUserStat
+{
+	be_t<u32> id;
+	char name[CELL_USERINFO_USERNAME_SIZE];
+};
+
+struct CellUserInfoUserList
+{
+	be_t<u32> userId[CELL_USERINFO_USER_MAX];
+};
+
+struct CellUserInfoListSet
+{
+	vm::bptr<char> title;
+	be_t<u32> focus; // id
+	be_t<u32> fixedListNum;
+	vm::bptr<CellUserInfoUserList> fixedList;
+	vm::bptr<void> reserved;
+};
+
+struct CellUserInfoTypeSet
+{
+	vm::bptr<char> title;
+	be_t<u32> focus; // id
+	be_t<u32> type;  // CellUserInfoListType
+	vm::bptr<void> reserved;
+};
+
+using CellUserInfoFinishCallback = void(s32 result, vm::ptr<CellUserInfoUserStat> selectedUser, vm::ptr<void> userdata);

ps3fw/include/rpcsx/fw/ps3/cellVdec.h

@@ -0,0 +1,674 @@
+#pragma once
+
+// Error Codes
+enum CellVdecError : u32
+{
+	CELL_VDEC_ERROR_ARG = 0x80610101,
+	CELL_VDEC_ERROR_SEQ = 0x80610102,
+	CELL_VDEC_ERROR_BUSY = 0x80610103,
+	CELL_VDEC_ERROR_EMPTY = 0x80610104,
+	CELL_VDEC_ERROR_AU = 0x80610105,
+	CELL_VDEC_ERROR_PIC = 0x80610106,
+	CELL_VDEC_ERROR_FATAL = 0x80610180,
+};
+
+enum CellVdecCodecType : s32
+{
+	CELL_VDEC_CODEC_TYPE_MPEG2 = 0,
+	CELL_VDEC_CODEC_TYPE_AVC = 1,
+	CELL_VDEC_CODEC_TYPE_DIVX = 5,
+	CELL_VDEC_CODEC_TYPE_MAX
+};
+
+// Callback Messages
+enum CellVdecMsgType : s32
+{
+	CELL_VDEC_MSG_TYPE_AUDONE = 0,  // decoding finished
+	CELL_VDEC_MSG_TYPE_PICOUT = 1,  // picture done
+	CELL_VDEC_MSG_TYPE_SEQDONE = 2, // finishing done
+	CELL_VDEC_MSG_TYPE_ERROR = 3,   // fatal error
+};
+
+// Decoder Operation Mode
+enum CellVdecDecodeMode : s32
+{
+	CELL_VDEC_DEC_MODE_NORMAL,
+	CELL_VDEC_DEC_MODE_B_SKIP,
+	CELL_VDEC_DEC_MODE_PB_SKIP,
+};
+
+// Output Picture Format Type
+enum CellVdecPicFormatType : u32
+{
+	CELL_VDEC_PICFMT_ARGB32_ILV,
+	CELL_VDEC_PICFMT_RGBA32_ILV,
+	CELL_VDEC_PICFMT_UYVY422_ILV,
+	CELL_VDEC_PICFMT_YUV420_PLANAR,
+};
+
+// Output Color Matrix Coef
+enum CellVdecColorMatrixType : u32
+{
+	CELL_VDEC_COLOR_MATRIX_TYPE_BT601,
+	CELL_VDEC_COLOR_MATRIX_TYPE_BT709,
+};
+
+enum CellVdecPicAttr : s32
+{
+	CELL_VDEC_PICITEM_ATTR_NORMAL,
+	CELL_VDEC_PICITEM_ATTR_SKIPPED,
+};
+
+// Universal Frame Rate Code
+enum CellVdecFrameRate : s32
+{
+	CELL_VDEC_FRC_24000DIV1001 = 0x80,
+	CELL_VDEC_FRC_24 = 0x81,
+	CELL_VDEC_FRC_25 = 0x82,
+	CELL_VDEC_FRC_30000DIV1001 = 0x83,
+	CELL_VDEC_FRC_30 = 0x84,
+	CELL_VDEC_FRC_50 = 0x85,
+	CELL_VDEC_FRC_60000DIV1001 = 0x86,
+	CELL_VDEC_FRC_60 = 0x87,
+};
+
+enum
+{
+	CELL_CODEC_PTS_INVALID = 0xffffffff,
+	CELL_CODEC_DTS_INVALID = 0xffffffff,
+};
+
+// Codec Type Information
+struct CellVdecType
+{
+	be_t<s32> codecType; // CellVdecCodecType
+	be_t<u32> profileLevel;
+};
+
+// Extended Codec Type Information
+struct CellVdecTypeEx
+{
+	be_t<s32> codecType; // CellVdecCodecType
+	be_t<u32> profileLevel;
+	be_t<u32> codecSpecificInfo_addr;
+};
+
+// Library Attributes
+struct CellVdecAttr
+{
+	be_t<u32> memSize; // required memory
+	u8 cmdDepth;       // command queue depth
+	be_t<u32> decoderVerUpper;
+	be_t<u32> decoderVerLower;
+};
+
+// Configurable Information
+struct CellVdecResource
+{
+	be_t<u32> memAddr;
+	be_t<u32> memSize;
+	be_t<s32> ppuThreadPriority;
+	be_t<u32> ppuThreadStackSize;
+	be_t<s32> spuThreadPriority;
+	be_t<u32> numOfSpus;
+};
+
+// SPURS Information
+struct CellVdecResourceSpurs
+{
+	be_t<u32> spursAddr;
+	u8 tasksetPriority[8];
+	be_t<u32> tasksetMaxContention;
+};
+
+// Extended Configurable Information
+struct CellVdecResourceEx
+{
+	be_t<u32> memAddr;
+	be_t<u32> memSize;
+	be_t<s32> ppuThreadPriority;
+	be_t<u32> ppuThreadStackSize;
+	be_t<s32> spuThreadPriority;
+	be_t<u32> numOfSpus;
+	be_t<u32> spursResource_addr;
+};
+
+struct CellVdecResourceExt // speculative
+{
+	be_t<u32> memAddr;
+	be_t<u32> memSize;
+	be_t<s32> ppuThreadPriority;
+	be_t<u32> ppuThreadStackSize;
+	u8 unk[12];
+	be_t<u32> numOfSpus;
+};
+
+// Access Unit Information
+struct CellVdecAuInfo
+{
+	be_t<u32> startAddr;
+	be_t<u32> size;
+	CellCodecTimeStamp pts;
+	CellCodecTimeStamp dts;
+	be_t<u64> userData;
+	be_t<u64> codecSpecificData;
+};
+
+// Access Unit Information
+struct CellVdecAuInfoEx2 // Speculative name
+{
+	be_t<u32> startAddr;
+	be_t<u32> unk1; // Speculative
+	be_t<u32> size;
+	be_t<u32> unk2; // Speculative
+	CellCodecTimeStamp pts;
+	CellCodecTimeStamp dts;
+	be_t<u64> userData;
+	be_t<u64> codecSpecificData;
+};
+
+// Output Picture Information
+struct CellVdecPicItem
+{
+	be_t<s32> codecType; // CellVdecCodecType
+	be_t<u32> startAddr;
+	be_t<u32> size;
+	u8 auNum;
+	CellCodecTimeStamp auPts[2];
+	CellCodecTimeStamp auDts[2];
+	be_t<u64> auUserData[2];
+	be_t<s32> status;
+	be_t<s32> attr; // CellVdecPicAttr
+	be_t<u32> picInfo_addr;
+};
+
+// Output Picture Format
+struct CellVdecPicFormat
+{
+	be_t<u32> formatType;      // CellVdecPicFormatType
+	be_t<u32> colorMatrixType; // CellVdecColorMatrixType
+	u8 alpha;
+};
+
+struct CellVdecPicFormat2
+{
+	be_t<u32> formatType;      // CellVdecPicFormatType
+	be_t<u32> colorMatrixType; // CellVdecColorMatrixType
+	be_t<u32> unk0;
+	u8 alpha;
+	be_t<u32> unk1;
+};
+
+using CellVdecCbMsg = u32(u32 handle, CellVdecMsgType msgType, s32 msgData, u32 cbArg);
+
+// Callback Function Information
+struct CellVdecCb
+{
+	vm::bptr<CellVdecCbMsg> cbFunc;
+	be_t<u32> cbArg;
+};
+
+// Max CC Data Length
+enum
+{
+	CELL_VDEC_AVC_CCD_MAX = 128,
+};
+
+enum AVC_level : u8
+{
+	CELL_VDEC_AVC_LEVEL_1P0 = 10,
+	CELL_VDEC_AVC_LEVEL_1P1 = 11,
+	CELL_VDEC_AVC_LEVEL_1P2 = 12,
+	CELL_VDEC_AVC_LEVEL_1P3 = 13,
+	CELL_VDEC_AVC_LEVEL_2P0 = 20,
+	CELL_VDEC_AVC_LEVEL_2P1 = 21,
+	CELL_VDEC_AVC_LEVEL_2P2 = 22,
+	CELL_VDEC_AVC_LEVEL_3P0 = 30,
+	CELL_VDEC_AVC_LEVEL_3P1 = 31,
+	CELL_VDEC_AVC_LEVEL_3P2 = 32,
+	CELL_VDEC_AVC_LEVEL_4P0 = 40,
+	CELL_VDEC_AVC_LEVEL_4P1 = 41,
+	CELL_VDEC_AVC_LEVEL_4P2 = 42,
+};
+
+struct CellVdecAvcSpecificInfo
+{
+	be_t<u32> thisSize;
+	be_t<u16> maxDecodedFrameWidth;
+	be_t<u16> maxDecodedFrameHeight;
+	b8 disableDeblockingFilter;
+	u8 numberOfDecodedFrameBuffer;
+};
+
+enum AVC_video_format : u8
+{
+	CELL_VDEC_AVC_VF_COMPONENT = 0x00,
+	CELL_VDEC_AVC_VF_PAL = 0x01,
+	CELL_VDEC_AVC_VF_NTSC = 0x02,
+	CELL_VDEC_AVC_VF_SECAM = 0x03,
+	CELL_VDEC_AVC_VF_MAC = 0x04,
+	CELL_VDEC_AVC_VF_UNSPECIFIED = 0x05,
+};
+
+enum AVC_colour_primaries : u8
+{
+	CELL_VDEC_AVC_CP_ITU_R_BT_709_5 = 0x01,
+	CELL_VDEC_AVC_CP_UNSPECIFIED = 0x02,
+	CELL_VDEC_AVC_CP_ITU_R_BT_470_6_SYS_M = 0x04,
+	CELL_VDEC_AVC_CP_ITU_R_BT_470_6_SYS_BG = 0x05,
+	CELL_VDEC_AVC_CP_SMPTE_170_M = 0x06,
+	CELL_VDEC_AVC_CP_SMPTE_240_M = 0x07,
+	CELL_VDEC_AVC_CP_GENERIC_FILM = 0x08,
+};
+
+enum AVC_transfer_characteristics : u8
+{
+	CELL_VDEC_AVC_TC_ITU_R_BT_709_5 = 0x01,
+	CELL_VDEC_AVC_TC_UNSPECIFIED = 0x02,
+	CELL_VDEC_AVC_TC_ITU_R_BT_470_6_SYS_M = 0x04,
+	CELL_VDEC_AVC_TC_ITU_R_BT_470_6_SYS_BG = 0x05,
+	CELL_VDEC_AVC_TC_SMPTE_170_M = 0x06,
+	CELL_VDEC_AVC_TC_SMPTE_240_M = 0x07,
+	CELL_VDEC_AVC_TC_LINEAR = 0x08,
+	CELL_VDEC_AVC_TC_LOG_100_1 = 0x09,
+	CELL_VDEC_AVC_TC_LOG_316_1 = 0x0a,
+};
+
+enum AVC_matrix_coefficients : u8
+{
+	CELL_VDEC_AVC_MXC_GBR = 0x00,
+	CELL_VDEC_AVC_MXC_ITU_R_BT_709_5 = 0x01,
+	CELL_VDEC_AVC_MXC_UNSPECIFIED = 0x02,
+	CELL_VDEC_AVC_MXC_FCC = 0x04,
+	CELL_VDEC_AVC_MXC_ITU_R_BT_470_6_SYS_BG = 0x05,
+	CELL_VDEC_AVC_MXC_SMPTE_170_M = 0x06,
+	CELL_VDEC_AVC_MXC_SMPTE_240_M = 0x07,
+	CELL_VDEC_AVC_MXC_YCGCO = 0x08,
+};
+
+enum AVC_FrameRateCode : u8
+{
+	CELL_VDEC_AVC_FRC_24000DIV1001 = 0x00,
+	CELL_VDEC_AVC_FRC_24 = 0x01,
+	CELL_VDEC_AVC_FRC_25 = 0x02,
+	CELL_VDEC_AVC_FRC_30000DIV1001 = 0x03,
+	CELL_VDEC_AVC_FRC_30 = 0x04,
+	CELL_VDEC_AVC_FRC_50 = 0x05,
+	CELL_VDEC_AVC_FRC_60000DIV1001 = 0x06,
+	CELL_VDEC_AVC_FRC_60 = 0x07,
+};
+
+enum AVC_NulUnitPresentFlags : u16
+{
+	CELL_VDEC_AVC_FLG_SPS = 0x0001,
+	CELL_VDEC_AVC_FLG_PPS = 0x0002,
+	CELL_VDEC_AVC_FLG_AUD = 0x0004,
+	CELL_VDEC_AVC_FLG_EO_SEQ = 0x0008,
+	CELL_VDEC_AVC_FLG_EO_STREAM = 0x0100,
+	CELL_VDEC_AVC_FLG_FILLER_DATA = 0x0200,
+	CELL_VDEC_AVC_FLG_PIC_TIMING_SEI = 0x0400,
+	CELL_VDEC_AVC_FLG_BUFF_PERIOD_SEI = 0x0800,
+	CELL_VDEC_AVC_FLG_USER_DATA_UNREG_SEI = 0x1000,
+};
+
+enum AVC_aspect_ratio_idc : u8
+{
+	CELL_VDEC_AVC_ARI_SAR_UNSPECIFIED = 0x00,
+	CELL_VDEC_AVC_ARI_SAR_1_1 = 0x01,
+	CELL_VDEC_AVC_ARI_SAR_12_11 = 0x02,
+	CELL_VDEC_AVC_ARI_SAR_10_11 = 0x03,
+	CELL_VDEC_AVC_ARI_SAR_16_11 = 0x04,
+	CELL_VDEC_AVC_ARI_SAR_40_33 = 0x05,
+	CELL_VDEC_AVC_ARI_SAR_24_11 = 0x06,
+	CELL_VDEC_AVC_ARI_SAR_20_11 = 0x07,
+	CELL_VDEC_AVC_ARI_SAR_32_11 = 0x08,
+	CELL_VDEC_AVC_ARI_SAR_80_33 = 0x09,
+	CELL_VDEC_AVC_ARI_SAR_18_11 = 0x0a,
+	CELL_VDEC_AVC_ARI_SAR_15_11 = 0x0b,
+	CELL_VDEC_AVC_ARI_SAR_64_33 = 0x0c,
+	CELL_VDEC_AVC_ARI_SAR_160_99 = 0x0d,
+	CELL_VDEC_AVC_ARI_SAR_4_3 = 0x0e,
+	CELL_VDEC_AVC_ARI_SAR_3_2 = 0x0f,
+	CELL_VDEC_AVC_ARI_SAR_2_1 = 0x10,
+	CELL_VDEC_AVC_ARI_SAR_EXTENDED_SAR = 0xff,
+};
+
+enum AVC_PictureType : u8
+{
+	CELL_VDEC_AVC_PCT_I = 0x00,
+	CELL_VDEC_AVC_PCT_P = 0x01,
+	CELL_VDEC_AVC_PCT_B = 0x02,
+	CELL_VDEC_AVC_PCT_UNKNOWN = 0x03,
+};
+
+enum AVC_pic_struct : u8
+{
+	CELL_VDEC_AVC_PSTR_FRAME = 0x00,
+	CELL_VDEC_AVC_PSTR_FIELD_TOP = 0x01,
+	CELL_VDEC_AVC_PSTR_FIELD_BTM = 0x02,
+	CELL_VDEC_AVC_PSTR_FIELD_TOP_BTM = 0x03,
+	CELL_VDEC_AVC_PSTR_FIELD_BTM_TOP = 0x04,
+	CELL_VDEC_AVC_PSTR_FIELD_TOP_BTM_TOP = 0x05,
+	CELL_VDEC_AVC_PSTR_FIELD_BTM_TOP_BTM = 0x06,
+	CELL_VDEC_AVC_PSTR_FRAME_DOUBLING = 0x07,
+	CELL_VDEC_AVC_PSTR_FRAME_TRIPLING = 0x08,
+};
+
+struct CellVdecAvcInfo
+{
+	be_t<u16> horizontalSize;
+	be_t<u16> verticalSize;
+	AVC_PictureType pictureType[2];
+	b8 idrPictureFlag;
+	AVC_aspect_ratio_idc aspect_ratio_idc;
+	be_t<u16> sar_height;
+	be_t<u16> sar_width;
+	AVC_pic_struct pic_struct;
+	be_t<s16> picOrderCount[2];
+	b8 vui_parameters_present_flag;
+	b8 frame_mbs_only_flag;
+	b8 video_signal_type_present_flag;
+	AVC_video_format video_format;
+	b8 video_full_range_flag;
+	b8 colour_description_present_flag;
+	AVC_colour_primaries colour_primaries;
+	AVC_transfer_characteristics transfer_characteristics;
+	AVC_matrix_coefficients matrix_coefficients;
+	b8 timing_info_present_flag;
+	AVC_FrameRateCode frameRateCode; // ???
+	b8 fixed_frame_rate_flag;
+	b8 low_delay_hrd_flag;
+	b8 entropy_coding_mode_flag;
+	be_t<u16> nalUnitPresentFlags;
+	u8 ccDataLength[2];
+	u8 ccData[2][CELL_VDEC_AVC_CCD_MAX];
+	be_t<u64> reserved[2];
+};
+
+// DIVX Profile
+enum DIVX_level : u8
+{
+	CELL_VDEC_DIVX_QMOBILE = 10,
+	CELL_VDEC_DIVX_MOBILE = 11,
+	CELL_VDEC_DIVX_HOME_THEATER = 12,
+	CELL_VDEC_DIVX_HD_720 = 13,
+	CELL_VDEC_DIVX_HD_1080 = 14,
+};
+
+struct CellVdecDivxSpecificInfo
+{
+	be_t<u32> thisSize;
+	be_t<u16> maxDecodedFrameWidth;
+	be_t<u16> maxDecodedFrameHeight;
+};
+
+struct CellVdecDivxSpecificInfo2
+{
+	be_t<u32> thisSize;
+	be_t<u16> maxDecodedFrameWidth;
+	be_t<u16> maxDecodedFrameHeight;
+	be_t<u16> numberOfDecodedFrameBuffer;
+};
+
+enum DIVX_frameRateCode : u16
+{
+	CELL_VDEC_DIVX_FRC_UNDEFINED = 0x00,
+	CELL_VDEC_DIVX_FRC_24000DIV1001 = 0x01,
+	CELL_VDEC_DIVX_FRC_24 = 0x02,
+	CELL_VDEC_DIVX_FRC_25 = 0x03,
+	CELL_VDEC_DIVX_FRC_30000DIV1001 = 0x04,
+	CELL_VDEC_DIVX_FRC_30 = 0x05,
+	CELL_VDEC_DIVX_FRC_50 = 0x06,
+	CELL_VDEC_DIVX_FRC_60000DIV1001 = 0x07,
+	CELL_VDEC_DIVX_FRC_60 = 0x08,
+};
+
+enum DIVX_pixelAspectRatio : u8
+{
+	CELL_VDEC_DIVX_ARI_PAR_1_1 = 0x1,
+	CELL_VDEC_DIVX_ARI_PAR_12_11 = 0x2,
+	CELL_VDEC_DIVX_ARI_PAR_10_11 = 0x3,
+	CELL_VDEC_DIVX_ARI_PAR_16_11 = 0x4,
+	CELL_VDEC_DIVX_ARI_PAR_40_33 = 0x5,
+	CELL_VDEC_DIVX_ARI_PAR_EXTENDED_PAR = 0xF,
+};
+
+enum DIVX_pictureType : u8
+{
+	CELL_VDEC_DIVX_VCT_I = 0x0,
+	CELL_VDEC_DIVX_VCT_P = 0x1,
+	CELL_VDEC_DIVX_VCT_B = 0x2,
+};
+
+enum DIVX_pictureStruct : u8
+{
+	CELL_VDEC_DIVX_PSTR_FRAME = 0x0,
+	CELL_VDEC_DIVX_PSTR_TOP_BTM = 0x1,
+	CELL_VDEC_DIVX_PSTR_BTM_TOP = 0x2,
+};
+
+enum DIVX_colourPrimaries : u8
+{
+	CELL_VDEC_DIVX_CP_ITU_R_BT_709 = 0x01,
+	CELL_VDEC_DIVX_CP_UNSPECIFIED = 0x02,
+	CELL_VDEC_DIVX_CP_ITU_R_BT_470_SYS_M = 0x04,
+	CELL_VDEC_DIVX_CP_ITU_R_BT_470_SYS_BG = 0x05,
+	CELL_VDEC_DIVX_CP_SMPTE_170_M = 0x06,
+	CELL_VDEC_DIVX_CP_SMPTE_240_M = 0x07,
+	CELL_VDEC_DIVX_CP_GENERIC_FILM = 0x08,
+};
+
+enum DIVX_transferCharacteristics : u8
+{
+	CELL_VDEC_DIVX_TC_ITU_R_BT_709 = 0x01,
+	CELL_VDEC_DIVX_TC_UNSPECIFIED = 0x02,
+	CELL_VDEC_DIVX_TC_ITU_R_BT_470_SYS_M = 0x04,
+	CELL_VDEC_DIVX_TC_ITU_R_BT_470_SYS_BG = 0x05,
+	CELL_VDEC_DIVX_TC_SMPTE_170_M = 0x06,
+	CELL_VDEC_DIVX_TC_SMPTE_240_M = 0x07,
+	CELL_VDEC_DIVX_TC_LINEAR = 0x08,
+	CELL_VDEC_DIVX_TC_LOG_100_1 = 0x09,
+	CELL_VDEC_DIVX_TC_LOG_316_1 = 0x0a,
+};
+
+enum DIVX_matrixCoefficients : u8
+{
+	CELL_VDEC_DIVX_MXC_ITU_R_BT_709 = 0x01,
+	CELL_VDEC_DIVX_MXC_UNSPECIFIED = 0x02,
+	CELL_VDEC_DIVX_MXC_FCC = 0x04,
+	CELL_VDEC_DIVX_MXC_ITU_R_BT_470_SYS_BG = 0x05,
+	CELL_VDEC_DIVX_MXC_SMPTE_170_M = 0x06,
+	CELL_VDEC_DIVX_MXC_SMPTE_240_M = 0x07,
+	CELL_VDEC_DIVX_MXC_YCGCO = 0x08,
+};
+
+struct CellVdecDivxInfo
+{
+	DIVX_pictureType pictureType;
+	be_t<u16> horizontalSize;
+	be_t<u16> verticalSize;
+	DIVX_pixelAspectRatio pixelAspectRatio;
+	u8 parWidth;
+	u8 parHeight;
+	b8 colourDescription;
+	DIVX_colourPrimaries colourPrimaries;
+	DIVX_transferCharacteristics transferCharacteristics;
+	DIVX_matrixCoefficients matrixCoefficients;
+	DIVX_pictureStruct pictureStruct;
+	be_t<u16> frameRateCode; // DIVX_frameRateCode
+};
+
+enum MPEG2_level
+{
+	CELL_VDEC_MPEG2_MP_LL,
+	CELL_VDEC_MPEG2_MP_ML,
+	CELL_VDEC_MPEG2_MP_H14,
+	CELL_VDEC_MPEG2_MP_HL,
+};
+
+struct CellVdecMpeg2SpecificInfo
+{
+	be_t<u32> thisSize;
+	be_t<u16> maxDecodedFrameWidth;
+	be_t<u16> maxDecodedFrameHeight;
+};
+
+enum MPEG2_headerFlags : u32
+{
+	CELL_VDEC_MPEG2_FLG_SEQ_HDR = 0x00000001,
+	CELL_VDEC_MPEG2_FLG_SEQ_EXT = 0x00000002,
+	CELL_VDEC_MPEG2_FLG_SEQ_DSP_EXT = 0x00000004,
+	CELL_VDEC_MPEG2_FLG_SEQ_USR_DAT = 0x00000008,
+	CELL_VDEC_MPEG2_FLG_SEQ_END = 0x00000010,
+	CELL_VDEC_MPEG2_FLG_GOP_HDR = 0x00000020,
+	CELL_VDEC_MPEG2_FLG_GOP_USR_DAT = 0x00000040,
+	CELL_VDEC_MPEG2_FLG_PIC_HDR_1 = 0x00000100,
+	CELL_VDEC_MPEG2_FLG_PIC_EXT_1 = 0x00000200,
+	CELL_VDEC_MPEG2_FLG_PIC_DSP_EXT_1 = 0x00000400,
+	CELL_VDEC_MPEG2_FLG_PIC_USR_DAT_1 = 0x00000800,
+	CELL_VDEC_MPEG2_FLG_PIC_HDR_2 = 0x00001000,
+	CELL_VDEC_MPEG2_FLG_PIC_EXT_2 = 0x00002000,
+	CELL_VDEC_MPEG2_FLG_PIC_DSP_EXT_2 = 0x00004000,
+	CELL_VDEC_MPEG2_FLG_PIC_USR_DAT_2 = 0x00008000,
+};
+
+enum MPEG2_aspectRatio : u8
+{
+	CELL_VDEC_MPEG2_ARI_SAR_1_1 = 0x01,
+	CELL_VDEC_MPEG2_ARI_DAR_4_3 = 0x02,
+	CELL_VDEC_MPEG2_ARI_DAR_16_9 = 0x03,
+	CELL_VDEC_MPEG2_ARI_DAR_2P21_1 = 0x04,
+};
+
+enum MPEG1_aspectRatio : u8
+{
+	CELL_VDEC_MPEG1_ARI_SAR_1P0 = 0x01,
+	CELL_VDEC_MPEG1_ARI_SAR_0P6735 = 0x02,
+	CELL_VDEC_MPEG1_ARI_SAR_0P7031 = 0x03,
+	CELL_VDEC_MPEG1_ARI_SAR_0P7615 = 0x04,
+	CELL_VDEC_MPEG1_ARI_SAR_0P8055 = 0x05,
+	CELL_VDEC_MPEG1_ARI_SAR_0P8437 = 0x06,
+	CELL_VDEC_MPEG1_ARI_SAR_0P8935 = 0x07,
+	CELL_VDEC_MPEG1_ARI_SAR_0P9157 = 0x08,
+	CELL_VDEC_MPEG1_ARI_SAR_0P9815 = 0x09,
+	CELL_VDEC_MPEG1_ARI_SAR_1P0255 = 0x0a,
+	CELL_VDEC_MPEG1_ARI_SAR_1P0695 = 0x0b,
+	CELL_VDEC_MPEG1_ARI_SAR_1P0950 = 0x0c,
+	CELL_VDEC_MPEG1_ARI_SAR_1P1575 = 0x0d,
+	CELL_VDEC_MPEG1_ARI_SAR_1P2015 = 0x0e,
+};
+
+enum MPEG2_frameRate : u8
+{
+	CELL_VDEC_MPEG2_FRC_FORBIDDEN = 0x00,
+	CELL_VDEC_MPEG2_FRC_24000DIV1001 = 0x01,
+	CELL_VDEC_MPEG2_FRC_24 = 0x02,
+	CELL_VDEC_MPEG2_FRC_25 = 0x03,
+	CELL_VDEC_MPEG2_FRC_30000DIV1001 = 0x04,
+	CELL_VDEC_MPEG2_FRC_30 = 0x05,
+	CELL_VDEC_MPEG2_FRC_50 = 0x06,
+	CELL_VDEC_MPEG2_FRC_60000DIV1001 = 0x07,
+	CELL_VDEC_MPEG2_FRC_60 = 0x08,
+};
+
+enum MPEG2_videoFormat : u8
+{
+	CELL_VDEC_MPEG2_VF_COMPONENT = 0x00,
+	CELL_VDEC_MPEG2_VF_PAL = 0x01,
+	CELL_VDEC_MPEG2_VF_NTSC = 0x02,
+	CELL_VDEC_MPEG2_VF_SECAM = 0x03,
+	CELL_VDEC_MPEG2_VF_MAC = 0x04,
+	CELL_VDEC_MPEG2_VF_UNSPECIFIED = 0x05,
+};
+
+enum MPEG2_colourPrimaries : u8
+{
+	CELL_VDEC_MPEG2_CP_FORBIDDEN = 0x00,
+	CELL_VDEC_MPEG2_CP_ITU_R_BT_709 = 0x01,
+	CELL_VDEC_MPEG2_CP_UNSPECIFIED = 0x02,
+	CELL_VDEC_MPEG2_CP_ITU_R_BT_470_2_SYS_M = 0x04,
+	CELL_VDEC_MPEG2_CP_ITU_R_BT_470_2_SYS_BG = 0x05,
+	CELL_VDEC_MPEG2_CP_SMPTE_170_M = 0x06,
+	CELL_VDEC_MPEG2_CP_SMPTE_240_M = 0x07,
+};
+
+enum MPEG2_transferCharacteristics : u8
+{
+	CELL_VDEC_MPEG2_TC_FORBIDDEN = 0x00,
+	CELL_VDEC_MPEG2_TC_ITU_R_BT_709 = 0x01,
+	CELL_VDEC_MPEG2_TC_UNSPECIFIED = 0x02,
+	CELL_VDEC_MPEG2_TC_ITU_R_BT_470_2_SYS_M = 0x04,
+	CELL_VDEC_MPEG2_TC_ITU_R_BT_470_2_SYS_BG = 0x05,
+	CELL_VDEC_MPEG2_TC_SMPTE_170_M = 0x06,
+	CELL_VDEC_MPEG2_TC_SMPTE_240_M = 0x07,
+	CELL_VDEC_MPEG2_TC_LINEAR = 0x08,
+	CELL_VDEC_MPEG2_TC_LOG_100_1 = 0x09,
+	CELL_VDEC_MPEG2_TC_LOG_316_1 = 0x0a,
+};
+
+enum MPEG2_matrixCoefficients : u8
+{
+	CELL_VDEC_MPEG2_MXC_FORBIDDEN = 0x00,
+	CELL_VDEC_MPEG2_MXC_ITU_R_BT_709 = 0x01,
+	CELL_VDEC_MPEG2_MXC_UNSPECIFIED = 0x02,
+	CELL_VDEC_MPEG2_MXC_FCC = 0x04,
+	CELL_VDEC_MPEG2_MXC_ITU_R_BT_470_2_SYS_BG = 0x05,
+	CELL_VDEC_MPEG2_MXC_SMPTE_170_M = 0x06,
+	CELL_VDEC_MPEG2_MXC_SMPTE_240_M = 0x07,
+};
+
+enum MPEG2_pictureCodingType : u8
+{
+	CELL_VDEC_MPEG2_PCT_FORBIDDEN = 0x00,
+	CELL_VDEC_MPEG2_PCT_I = 0x01,
+	CELL_VDEC_MPEG2_PCT_P = 0x02,
+	CELL_VDEC_MPEG2_PCT_B = 0x03,
+	CELL_VDEC_MPEG2_PCT_D = 0x04,
+};
+
+enum MPEG2_pictureStructure : u8
+{
+	CELL_VDEC_MPEG2_PSTR_TOP_FIELD = 0x01,
+	CELL_VDEC_MPEG2_PSTR_BOTTOM_FIELD = 0x02,
+	CELL_VDEC_MPEG2_PSTR_FRAME = 0x03,
+};
+
+struct CellVdecMpeg2Info
+{
+	be_t<u16> horizontal_size;
+	be_t<u16> vertical_size;
+	union
+	{
+		MPEG2_aspectRatio aspect_ratio_information;
+		MPEG1_aspectRatio aspect_ratio_information1;
+	};
+	MPEG2_frameRate frame_rate_code;
+	b8 progressive_sequence;
+	b8 low_delay;
+	MPEG2_videoFormat video_format;
+	b8 colour_description;
+	MPEG2_colourPrimaries colour_primaries;
+	MPEG2_transferCharacteristics transfer_characteristics;
+	MPEG2_matrixCoefficients matrix_coefficients;
+	be_t<u16> temporal_reference[2];
+	MPEG2_pictureCodingType picture_coding_type[2];
+	MPEG2_pictureStructure picture_structure[2];
+	b8 top_field_first;
+	b8 repeat_first_field;
+	b8 progressive_frame;
+	be_t<u32> time_code;
+	b8 closed_gop;
+	b8 broken_link;
+	be_t<u16> vbv_delay[2];
+	be_t<u16> display_horizontal_size;
+	be_t<u16> display_vertical_size;
+	u8 number_of_frame_centre_offsets[2];
+	be_t<u16> frame_centre_horizontal_offset[2][3];
+	be_t<u16> frame_centre_vertical_offset[2][3];
+	be_t<u32> headerPresentFlags;   // MPEG2_headerFlags
+	be_t<u32> headerRetentionFlags; // MPEG2_headerFlags
+	b8 mpeg1Flag;
+	u8 ccDataLength[2];
+	u8 ccData[2][128];
+	be_t<u64> reserved[2];
+};

ps3fw/include/rpcsx/fw/ps3/cellVideoOut.h

@@ -0,0 +1,241 @@
+#pragma once
+
+#include "Emu/Memory/vm_ptr.h"
+
+// Video Out Error Codes
+enum CellVideoOutError : u32
+{
+	CELL_VIDEO_OUT_ERROR_NOT_IMPLEMENTED = 0x8002b220,
+	CELL_VIDEO_OUT_ERROR_ILLEGAL_CONFIGURATION = 0x8002b221,
+	CELL_VIDEO_OUT_ERROR_ILLEGAL_PARAMETER = 0x8002b222,
+	CELL_VIDEO_OUT_ERROR_PARAMETER_OUT_OF_RANGE = 0x8002b223,
+	CELL_VIDEO_OUT_ERROR_DEVICE_NOT_FOUND = 0x8002b224,
+	CELL_VIDEO_OUT_ERROR_UNSUPPORTED_VIDEO_OUT = 0x8002b225,
+	CELL_VIDEO_OUT_ERROR_UNSUPPORTED_DISPLAY_MODE = 0x8002b226,
+	CELL_VIDEO_OUT_ERROR_CONDITION_BUSY = 0x8002b227,
+	CELL_VIDEO_OUT_ERROR_VALUE_IS_NOT_SET = 0x8002b228,
+};
+
+enum CellVideoOut : s32
+{
+	CELL_VIDEO_OUT_PRIMARY = 0,
+	CELL_VIDEO_OUT_SECONDARY = 1,
+};
+
+enum CellVideoOutResolutionId : s32
+{
+	CELL_VIDEO_OUT_RESOLUTION_UNDEFINED = 0,
+	CELL_VIDEO_OUT_RESOLUTION_1080 = 1,
+	CELL_VIDEO_OUT_RESOLUTION_720 = 2,
+	CELL_VIDEO_OUT_RESOLUTION_480 = 4,
+	CELL_VIDEO_OUT_RESOLUTION_576 = 5,
+	CELL_VIDEO_OUT_RESOLUTION_1600x1080 = 0xa,
+	CELL_VIDEO_OUT_RESOLUTION_1440x1080 = 0xb,
+	CELL_VIDEO_OUT_RESOLUTION_1280x1080 = 0xc,
+	CELL_VIDEO_OUT_RESOLUTION_960x1080 = 0xd,
+	CELL_VIDEO_OUT_RESOLUTION_720_3D_FRAME_PACKING = 0x81,
+	CELL_VIDEO_OUT_RESOLUTION_1024x720_3D_FRAME_PACKING = 0x88,
+	CELL_VIDEO_OUT_RESOLUTION_960x720_3D_FRAME_PACKING = 0x89,
+	CELL_VIDEO_OUT_RESOLUTION_800x720_3D_FRAME_PACKING = 0x8a,
+	CELL_VIDEO_OUT_RESOLUTION_640x720_3D_FRAME_PACKING = 0x8b,
+	CELL_VIDEO_OUT_RESOLUTION_720_DUALVIEW_FRAME_PACKING = 0x91,
+	CELL_VIDEO_OUT_RESOLUTION_720_SIMULVIEW_FRAME_PACKING = 0x91,
+	CELL_VIDEO_OUT_RESOLUTION_1024x720_DUALVIEW_FRAME_PACKING = 0x98,
+	CELL_VIDEO_OUT_RESOLUTION_1024x720_SIMULVIEW_FRAME_PACKING = 0x98,
+	CELL_VIDEO_OUT_RESOLUTION_960x720_DUALVIEW_FRAME_PACKING = 0x99,
+	CELL_VIDEO_OUT_RESOLUTION_960x720_SIMULVIEW_FRAME_PACKING = 0x99,
+	CELL_VIDEO_OUT_RESOLUTION_800x720_DUALVIEW_FRAME_PACKING = 0x9a,
+	CELL_VIDEO_OUT_RESOLUTION_800x720_SIMULVIEW_FRAME_PACKING = 0x9a,
+	CELL_VIDEO_OUT_RESOLUTION_640x720_DUALVIEW_FRAME_PACKING = 0x9b,
+	CELL_VIDEO_OUT_RESOLUTION_640x720_SIMULVIEW_FRAME_PACKING = 0x9b,
+};
+
+enum CellVideoOutScanMode : s32
+{
+	CELL_VIDEO_OUT_SCAN_MODE_INTERLACE,
+	CELL_VIDEO_OUT_SCAN_MODE_PROGRESSIVE,
+};
+
+enum CellVideoOutScanMode2 : s32
+{
+	CELL_VIDEO_OUT_SCAN_MODE2_AUTO,
+	CELL_VIDEO_OUT_SCAN_MODE2_INTERLACE,
+	CELL_VIDEO_OUT_SCAN_MODE2_PROGRESSIVE,
+};
+
+enum CellVideoOutRefreshRate : s32
+{
+	CELL_VIDEO_OUT_REFRESH_RATE_AUTO = 0x0000,
+	CELL_VIDEO_OUT_REFRESH_RATE_59_94HZ = 0x0001,
+	CELL_VIDEO_OUT_REFRESH_RATE_50HZ = 0x0002,
+	CELL_VIDEO_OUT_REFRESH_RATE_60HZ = 0x0004,
+	CELL_VIDEO_OUT_REFRESH_RATE_30HZ = 0x0008,
+};
+
+enum CellVideoOutPortType : s32
+{
+	CELL_VIDEO_OUT_PORT_NONE = 0x00,
+	CELL_VIDEO_OUT_PORT_HDMI = 0x01,
+	CELL_VIDEO_OUT_PORT_NETWORK = 0x41,
+	CELL_VIDEO_OUT_PORT_COMPOSITE_S = 0x81,
+	CELL_VIDEO_OUT_PORT_D = 0x82,
+	CELL_VIDEO_OUT_PORT_COMPONENT = 0x83,
+	CELL_VIDEO_OUT_PORT_RGB = 0x84,
+	CELL_VIDEO_OUT_PORT_AVMULTI_SCART = 0x85,
+	CELL_VIDEO_OUT_PORT_DSUB = 0x86,
+};
+
+enum CellVideoOutDisplayAspect : s32
+{
+	CELL_VIDEO_OUT_ASPECT_AUTO,
+	CELL_VIDEO_OUT_ASPECT_4_3,
+	CELL_VIDEO_OUT_ASPECT_16_9,
+};
+
+enum CellVideoOutBufferColorFormat : s32
+{
+	CELL_VIDEO_OUT_BUFFER_COLOR_FORMAT_X8R8G8B8 = 0,
+	CELL_VIDEO_OUT_BUFFER_COLOR_FORMAT_X8B8G8R8 = 1,
+	CELL_VIDEO_OUT_BUFFER_COLOR_FORMAT_R16G16B16X16_FLOAT = 2,
+};
+
+enum CellVideoOutOutputState : s32
+{
+	CELL_VIDEO_OUT_OUTPUT_STATE_ENABLED,
+	CELL_VIDEO_OUT_OUTPUT_STATE_DISABLED,
+	CELL_VIDEO_OUT_OUTPUT_STATE_PREPARING,
+};
+
+enum CellVideoOutDeviceState : s32
+{
+	CELL_VIDEO_OUT_DEVICE_STATE_UNAVAILABLE,
+	CELL_VIDEO_OUT_DEVICE_STATE_AVAILABLE,
+};
+
+enum CellVideoOutColorSpace : s32
+{
+	CELL_VIDEO_OUT_COLOR_SPACE_RGB = 0x01,
+	CELL_VIDEO_OUT_COLOR_SPACE_YUV = 0x02,
+	CELL_VIDEO_OUT_COLOR_SPACE_XVYCC = 0x04,
+};
+
+enum CellVideoOutDebugMonitorType : s32
+{
+	CELL_VIDEO_OUT_DEBUG_MONITOR_TYPE_UNDEFINED = 0,
+	CELL_VIDEO_OUT_DEBUG_MONITOR_TYPE_480I_59_94HZ = 1,
+	CELL_VIDEO_OUT_DEBUG_MONITOR_TYPE_576I_50HZ = 2,
+	CELL_VIDEO_OUT_DEBUG_MONITOR_TYPE_480P_59_94HZ = 3,
+	CELL_VIDEO_OUT_DEBUG_MONITOR_TYPE_576P_50HZ = 4,
+	CELL_VIDEO_OUT_DEBUG_MONITOR_TYPE_1080I_59_94HZ = 5,
+	CELL_VIDEO_OUT_DEBUG_MONITOR_TYPE_720P_59_94HZ = 7,
+	CELL_VIDEO_OUT_DEBUG_MONITOR_TYPE_1080P_59_94HZ = 9,
+	CELL_VIDEO_OUT_DEBUG_MONITOR_TYPE_WXGA_60HZ = 11,
+	CELL_VIDEO_OUT_DEBUG_MONITOR_TYPE_SXGA_60HZ = 12,
+	CELL_VIDEO_OUT_DEBUG_MONITOR_TYPE_WUXGA_60HZ = 13,
+};
+
+struct CellVideoOutColorInfo
+{
+	be_t<u16> redX;
+	be_t<u16> redY;
+	be_t<u16> greenX;
+	be_t<u16> greenY;
+	be_t<u16> blueX;
+	be_t<u16> blueY;
+	be_t<u16> whiteX;
+	be_t<u16> whiteY;
+	be_t<u32> gamma;
+};
+
+struct CellVideoOutKSVList
+{
+	u8 ksv[32 * 5];
+	u8 reserved[4];
+	be_t<u32> count;
+};
+
+enum CellVideoOutDisplayConversion : s32
+{
+	CELL_VIDEO_OUT_DISPLAY_CONVERSION_NONE = 0x00,
+	CELL_VIDEO_OUT_DISPLAY_CONVERSION_TO_WXGA = 0x01,
+	CELL_VIDEO_OUT_DISPLAY_CONVERSION_TO_SXGA = 0x02,
+	CELL_VIDEO_OUT_DISPLAY_CONVERSION_TO_WUXGA = 0x03,
+	CELL_VIDEO_OUT_DISPLAY_CONVERSION_TO_1080 = 0x05,
+	CELL_VIDEO_OUT_DISPLAY_CONVERSION_TO_REMOTEPLAY = 0x10,
+	CELL_VIDEO_OUT_DISPLAY_CONVERSION_TO_720_3D_FRAME_PACKING = 0x80,
+};
+
+struct CellVideoOutDisplayMode
+{
+	u8 resolutionId;
+	u8 scanMode;
+	u8 conversion;
+	u8 aspect;
+	u8 reserved[2];
+	be_t<u16> refreshRates;
+};
+
+struct CellVideoOutResolution
+{
+	be_t<u16> width;
+	be_t<u16> height;
+};
+
+struct CellVideoOutDeviceInfo
+{
+	u8 portType;
+	u8 colorSpace;
+	be_t<u16> latency;
+	u8 availableModeCount;
+	u8 state;
+	u8 rgbOutputRange;
+	u8 reserved[5];
+	CellVideoOutColorInfo colorInfo;
+	CellVideoOutDisplayMode availableModes[32];
+	CellVideoOutKSVList ksvList;
+};
+
+struct CellVideoOutState
+{
+	u8 state;
+	u8 colorSpace;
+	u8 reserved[6];
+	CellVideoOutDisplayMode displayMode;
+};
+
+struct CellVideoOutConfiguration
+{
+	u8 resolutionId;
+	u8 format;
+	u8 aspect;
+	u8 reserved[9];
+	be_t<u32> pitch;
+};
+
+struct CellVideoOutOption
+{
+	be_t<u32> reserved;
+};
+
+enum CellVideoOutEvent : s32
+{
+	CELL_VIDEO_OUT_EVENT_DEVICE_CHANGED = 0,
+	CELL_VIDEO_OUT_EVENT_OUTPUT_DISABLED = 1,
+	CELL_VIDEO_OUT_EVENT_DEVICE_AUTHENTICATED = 2,
+	CELL_VIDEO_OUT_EVENT_OUTPUT_ENABLED = 3,
+};
+
+enum CellVideoOutCopyControl : s32
+{
+	CELL_VIDEO_OUT_COPY_CONTROL_COPY_FREE = 0,
+	CELL_VIDEO_OUT_COPY_CONTROL_COPY_ONCE = 1,
+	CELL_VIDEO_OUT_COPY_CONTROL_COPY_NEVER = 2,
+};
+
+enum CellVideoOutRGBOutputRange : s32
+{
+	CELL_VIDEO_OUT_RGB_OUTPUT_RANGE_LIMITED = 0,
+	CELL_VIDEO_OUT_RGB_OUTPUT_RANGE_FULL = 1,
+};
+
+using CellVideoOutCallback = s32(u32 slot, u32 videoOut, u32 deviceIndex, u32 event, vm::ptr<CellVideoOutDeviceInfo> info, vm::ptr<void> userData);

ps3fw/include/rpcsx/fw/ps3/cellVideoUpload.h

@@ -0,0 +1,67 @@
+#pragma once
+
+#include "Emu/Memory/vm_ptr.h"
+
+struct CellVideoUploadOption
+{
+	be_t<s32> type;
+	be_t<u64> value;
+};
+
+struct CellVideoUploadParam
+{
+	be_t<s32> siteID;
+	vm::bcptr<char> pFilePath;
+	union
+	{
+		struct
+		{
+			vm::bcptr<char> pClientId;
+			vm::bcptr<char> pDeveloperKey;
+			vm::bcptr<char> pTitle_UTF8;
+			vm::bcptr<char> pDescription_UTF8;
+			vm::bcptr<char> pKeyword_1_UTF8;
+			vm::bcptr<char> pKeyword_2_UTF8;
+			vm::bcptr<char> pKeyword_3_UTF8;
+			u8 isPrivate;
+			u8 rating;
+		} youtube;
+	} u;
+	be_t<s32> numOfOption;
+	vm::bptr<CellVideoUploadOption> pOption;
+};
+
+using CellVideoUploadCallback = void(s32 status, s32 errorCode, vm::cptr<char> pResultURL, vm::ptr<void> userdata);
+
+enum
+{
+	CELL_VIDEO_UPLOAD_MAX_FILE_PATH_LEN = 1023,
+	CELL_VIDEO_UPLOAD_MAX_YOUTUBE_CLIENT_ID_LEN = 64,
+	CELL_VIDEO_UPLOAD_MAX_YOUTUBE_DEVELOPER_KEY_LEN = 128,
+	CELL_VIDEO_UPLOAD_MAX_YOUTUBE_TITLE_LEN = 61,
+	CELL_VIDEO_UPLOAD_MAX_YOUTUBE_DESCRIPTION_LEN = 1024,
+	CELL_VIDEO_UPLOAD_MAX_YOUTUBE_KEYWORD_LEN = 25
+};
+
+// Return Codes
+enum CellVideoUploadError : u32
+{
+	CELL_VIDEO_UPLOAD_ERROR_CANCEL = 0x8002d000,
+	CELL_VIDEO_UPLOAD_ERROR_NETWORK = 0x8002d001,
+	CELL_VIDEO_UPLOAD_ERROR_SERVICE_STOP = 0x8002d002,
+	CELL_VIDEO_UPLOAD_ERROR_SERVICE_BUSY = 0x8002d003,
+	CELL_VIDEO_UPLOAD_ERROR_SERVICE_UNAVAILABLE = 0x8002d004,
+	CELL_VIDEO_UPLOAD_ERROR_SERVICE_QUOTA = 0x8002d005,
+	CELL_VIDEO_UPLOAD_ERROR_ACCOUNT_STOP = 0x8002d006,
+	CELL_VIDEO_UPLOAD_ERROR_OUT_OF_MEMORY = 0x8002d020,
+	CELL_VIDEO_UPLOAD_ERROR_FATAL = 0x8002d021,
+	CELL_VIDEO_UPLOAD_ERROR_INVALID_VALUE = 0x8002d022,
+	CELL_VIDEO_UPLOAD_ERROR_FILE_OPEN = 0x8002d023,
+	CELL_VIDEO_UPLOAD_ERROR_INVALID_STATE = 0x8002d024
+};
+
+enum
+{
+	CELL_VIDEO_UPLOAD_STATUS_INITIALIZED = 1,
+	CELL_VIDEO_UPLOAD_STATUS_FINALIZED = 2
+};

ps3fw/include/rpcsx/fw/ps3/cellVoice.h

@@ -0,0 +1,221 @@
+#pragma once
+
+// libvoice = 0x80310801 - 0x803108ff
+// libvoice version 100
+
+// Error Codes
+enum CellVoiceError : u32
+{
+	CELL_VOICE_ERROR_ADDRESS_INVALID = 0x8031080a,
+	CELL_VOICE_ERROR_ARGUMENT_INVALID = 0x80310805,
+	CELL_VOICE_ERROR_CONTAINER_INVALID = 0x80310806,
+	CELL_VOICE_ERROR_DEVICE_NOT_PRESENT = 0x80310812,
+	CELL_VOICE_ERROR_EVENT_DISPATCH = 0x80310811,
+	CELL_VOICE_ERROR_EVENT_QUEUE = 0x8031080f,
+	CELL_VOICE_ERROR_GENERAL = 0x80310803,
+	CELL_VOICE_ERROR_LIBVOICE_INITIALIZED = 0x80310802,
+	CELL_VOICE_ERROR_LIBVOICE_NOT_INIT = 0x80310801,
+	CELL_VOICE_ERROR_NOT_IMPLEMENTED = 0x80310809,
+	CELL_VOICE_ERROR_PORT_INVALID = 0x80310804,
+	CELL_VOICE_ERROR_RESOURCE_INSUFFICIENT = 0x80310808,
+	CELL_VOICE_ERROR_SERVICE_ATTACHED = 0x8031080c,
+	CELL_VOICE_ERROR_SERVICE_DETACHED = 0x8031080b,
+	CELL_VOICE_ERROR_SERVICE_HANDLE = 0x80310810,
+	CELL_VOICE_ERROR_SERVICE_NOT_FOUND = 0x8031080d,
+	CELL_VOICE_ERROR_SHAREDMEMORY = 0x8031080e,
+	CELL_VOICE_ERROR_TOPOLOGY = 0x80310807,
+};
+
+enum CellVoiceAppType : u32
+{
+	CELLVOICE_APPTYPE_GAME_1MB = 1 << 29
+};
+
+enum CellVoiceBitRate : u32
+{
+	CELLVOICE_BITRATE_NULL = ~0u,
+	CELLVOICE_BITRATE_3850 = 3850,
+	CELLVOICE_BITRATE_4650 = 4650,
+	CELLVOICE_BITRATE_5700 = 5700,
+	CELLVOICE_BITRATE_7300 = 7300,
+	CELLVOICE_BITRATE_14400 = 14400,
+	CELLVOICE_BITRATE_16000 = 16000,
+	CELLVOICE_BITRATE_22533 = 22533,
+};
+
+enum CellVoiceEventType : u32
+{
+	CELLVOICE_EVENT_DATA_ERROR = 1 << 0,
+	CELLVOICE_EVENT_PORT_ATTACHED = 1 << 1,
+	CELLVOICE_EVENT_PORT_DETACHED = 1 << 2,
+	CELLVOICE_EVENT_SERVICE_ATTACHED = 1 << 3,
+	CELLVOICE_EVENT_SERVICE_DETACHED = 1 << 4,
+	CELLVOICE_EVENT_PORT_WEAK_ATTACHED = 1 << 5,
+	CELLVOICE_EVENT_PORT_WEAK_DETACHED = 1 << 6,
+};
+
+enum CellVoicePcmDataType : u32
+{
+	CELLVOICE_PCM_NULL = ~0u,
+	CELLVOICE_PCM_FLOAT = 0,
+	CELLVOICE_PCM_FLOAT_LITTLE_ENDIAN = 1,
+	CELLVOICE_PCM_SHORT = 2,
+	CELLVOICE_PCM_SHORT_LITTLE_ENDIAN = 3,
+	CELLVOICE_PCM_INTEGER = 4,
+	CELLVOICE_PCM_INTEGER_LITTLE_ENDIAN = 5,
+};
+
+enum CellVoicePortAttr : u32
+{
+	CELLVOICE_ATTR_ENERGY_LEVEL = 1000,
+	CELLVOICE_ATTR_VAD = 1001,
+	CELLVOICE_ATTR_DTX = 1002,
+	CELLVOICE_ATTR_AUTO_RESAMPLE = 1003,
+	CELLVOICE_ATTR_LATENCY = 1004,
+	CELLVOICE_ATTR_SILENCE_THRESHOLD = 1005,
+};
+
+enum CellVoicePortState : u32
+{
+	CELLVOICE_PORTSTATE_NULL = ~0u,
+	CELLVOICE_PORTSTATE_IDLE = 0,
+	CELLVOICE_PORTSTATE_READY = 1,
+	CELLVOICE_PORTSTATE_BUFFERING = 2,
+	CELLVOICE_PORTSTATE_RUNNING = 3,
+};
+
+enum CellVoicePortType : u32
+{
+	CELLVOICE_PORTTYPE_NULL = ~0u,
+	CELLVOICE_PORTTYPE_IN_MIC = 0,
+	CELLVOICE_PORTTYPE_IN_PCMAUDIO = 1,
+	CELLVOICE_PORTTYPE_IN_VOICE = 2,
+	CELLVOICE_PORTTYPE_OUT_PCMAUDIO = 3,
+	CELLVOICE_PORTTYPE_OUT_VOICE = 4,
+	CELLVOICE_PORTTYPE_OUT_SECONDARY = 5,
+};
+
+enum CellVoiceSamplingRate : u32
+{
+	CELLVOICE_SAMPLINGRATE_NULL = ~0u,
+	CELLVOICE_SAMPLINGRATE_16000 = 16000,
+};
+
+enum CellVoiceVersionCheck : u32
+{
+	CELLVOICE_VERSION_100 = 100
+};
+
+// Definitions
+enum
+{
+	CELLVOICE_MAX_IN_VOICE_PORT = 32,
+	CELLVOICE_MAX_OUT_VOICE_PORT = 4,
+	CELLVOICE_GAME_1MB_MAX_IN_VOICE_PORT = 8,
+	CELLVOICE_GAME_1MB_MAX_OUT_VOICE_PORT = 2,
+	CELLVOICE_MAX_PORT = 128,
+	CELLVOICE_INVALID_PORT_ID = 0xff,
+};
+
+struct CellVoiceBasePortInfo // aligned(64)
+{
+	be_t<CellVoicePortType> portType;
+	be_t<CellVoicePortState> state;
+	be_t<u16> numEdge;
+	vm::bptr<u32> pEdge;
+	be_t<u32> numByte;
+	be_t<u32> frameSize;
+};
+
+struct CellVoiceInitParam // aligned(32)
+{
+	be_t<CellVoiceEventType> eventMask;
+	be_t<CellVoiceVersionCheck> version;
+	be_t<s32> appType;
+	u8 reserved[32 - sizeof(s32) * 3];
+};
+
+struct CellVoicePCMFormat
+{
+	u8 numChannels;
+	u8 sampleAlignment;
+	be_t<CellVoicePcmDataType> dataType;
+	be_t<CellVoiceSamplingRate> sampleRate;
+};
+
+struct CellVoicePortParam // aligned(64)
+{
+	be_t<CellVoicePortType> portType;
+	be_t<u16> threshold;
+	be_t<u16> bMute;
+	be_t<f32> volume;
+	union
+	{
+		struct
+		{
+			be_t<CellVoiceBitRate> bitrate;
+		} voice;
+		struct
+		{
+			be_t<u32> bufSize;
+			CellVoicePCMFormat format;
+		} pcmaudio;
+		struct
+		{
+			be_t<u32> playerId;
+		} device;
+	};
+};
+
+struct CellVoiceStartParam // aligned(32)
+{
+	be_t<u32> container;
+	u8 reserved[32 - sizeof(s32) * 1];
+};
+
+struct voice_manager
+{
+	struct port_t
+	{
+		s32 state = CELLVOICE_PORTSTATE_NULL;
+		CellVoicePortParam info;
+
+		ENABLE_BITWISE_SERIALIZATION;
+	};
+
+	// See cellVoiceCreatePort
+	u8 id_ctr = 0;
+
+	// For cellVoiceSetNotifyEventQueue
+	u32 port_source = 0;
+
+	std::unordered_map<u16, port_t> ports;
+	std::unordered_map<u64, std::deque<u64>> queue_keys;
+	bool voice_service_started = false;
+
+	port_t* access_port(u32 id)
+	{
+		// Upper 16 bits are ignored
+		auto pos = ports.find(static_cast<u16>(id));
+
+		if (pos == ports.end())
+		{
+			return nullptr;
+		}
+
+		return &pos->second;
+	}
+
+	void reset();
+	shared_mutex mtx;
+	atomic_t<bool> is_init{false};
+
+	SAVESTATE_INIT_POS(17);
+
+	voice_manager() = default;
+	voice_manager(utils::serial& ar)
+	{
+		save(ar);
+	}
+	void save(utils::serial& ar);
+};

ps3fw/include/rpcsx/fw/ps3/cellVpost.h

@@ -0,0 +1,358 @@
+#pragma once
+
+#ifdef _MSC_VER
+#pragma warning(push, 0)
+#else
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wall"
+#pragma GCC diagnostic ignored "-Wextra"
+#pragma GCC diagnostic ignored "-Wold-style-cast"
+#endif
+extern "C"
+{
+#include "libswscale/swscale.h"
+}
+#ifdef _MSC_VER
+#pragma warning(pop)
+#else
+#pragma GCC diagnostic pop
+#endif
+
+// Error Codes
+enum CellVpostError : u32
+{
+	CELL_VPOST_ERROR_Q_ARG_CFG_NULL = 0x80610410,
+	CELL_VPOST_ERROR_Q_ARG_CFG_INVALID = 0x80610411,
+	CELL_VPOST_ERROR_Q_ARG_ATTR_NULL = 0x80610412,
+	CELL_VPOST_ERROR_O_ARG_CFG_NULL = 0x80610440,
+	CELL_VPOST_ERROR_O_ARG_CFG_INVALID = 0x80610441,
+	CELL_VPOST_ERROR_O_ARG_RSRC_NULL = 0x80610442,
+	CELL_VPOST_ERROR_O_ARG_RSRC_INVALID = 0x80610443,
+	CELL_VPOST_ERROR_O_ARG_HDL_NULL = 0x80610444,
+	CELL_VPOST_ERROR_O_FATAL_QUERY_FAIL = 0x80610460,
+	CELL_VPOST_ERROR_O_FATAL_CREATEMON_FAIL = 0x80610461,
+	CELL_VPOST_ERROR_O_FATAL_INITSPURS_FAIL = 0x80610462,
+	CELL_VPOST_ERROR_C_ARG_HDL_NULL = 0x80610470,
+	CELL_VPOST_ERROR_C_ARG_HDL_INVALID = 0x80610471,
+	CELL_VPOST_ERROR_C_FATAL_LOCKMON_FAIL = 0x80610490,
+	CELL_VPOST_ERROR_C_FATAL_UNLOCKMON_FAIL = 0x80610491,
+	CELL_VPOST_ERROR_C_FATAL_DESTROYMON_FAIL = 0x80610492,
+	CELL_VPOST_ERROR_C_FATAL_FINSPURS_FAIL = 0x80610463,
+	CELL_VPOST_ERROR_E_ARG_HDL_NULL = 0x806104a0,
+	CELL_VPOST_ERROR_E_ARG_HDL_INVALID = 0x806104a1,
+	CELL_VPOST_ERROR_E_ARG_INPICBUF_NULL = 0x806104a2,
+	CELL_VPOST_ERROR_E_ARG_INPICBUF_INVALID = 0x806104a3,
+	CELL_VPOST_ERROR_E_ARG_CTRL_NULL = 0x806104a4,
+	CELL_VPOST_ERROR_E_ARG_CTRL_INVALID = 0x806104a5,
+	CELL_VPOST_ERROR_E_ARG_OUTPICBUF_NULL = 0x806104a6,
+	CELL_VPOST_ERROR_E_ARG_OUTPICBUF_INVALID = 0x806104a7,
+	CELL_VPOST_ERROR_E_ARG_PICINFO_NULL = 0x806104a8,
+	CELL_VPOST_ERROR_E_FATAL_LOCKMON_FAIL = 0x806104c0,
+	CELL_VPOST_ERROR_E_FATAL_UNLOCKMON_FAIL = 0x806104c1,
+	CELL_VPOST_ENT_ERROR_Q_ARG_ATTR_NULL = 0x80618110,
+	CELL_VPOST_ENT_ERROR_O_ARG_RSRC_NULL = 0x80618140,
+	CELL_VPOST_ENT_ERROR_O_ARG_RSRC_INVALID = 0x80618141,
+	CELL_VPOST_ENT_ERROR_O_ARG_HDL_NULL = 0x80618142,
+	CELL_VPOST_ENT_ERROR_O_FATAL_QUERY_FAIL = 0x80618160,
+	CELL_VPOST_ENT_ERROR_O_FATAL_CSPUCORE_FAIL = 0x80618161,
+	CELL_VPOST_ENT_ERROR_C_ARG_HDL_NULL = 0x80618170,
+	CELL_VPOST_ENT_ERROR_C_ARG_HDL_INVALID = 0x80618171,
+	CELL_VPOST_ENT_ERROR_C_FATAL_SNDCMD_FAIL = 0x80618190,
+	CELL_VPOST_ENT_ERROR_C_FATAL_RCVRES_FAIL = 0x80618191,
+	CELL_VPOST_ENT_ERROR_C_FATAL_DSPUCORE_FAIL = 0x80618192,
+	CELL_VPOST_ENT_ERROR_E_ARG_HDL_NULL = 0x806181a0,
+	CELL_VPOST_ENT_ERROR_E_ARG_HDL_INVALID = 0x806181a1,
+	CELL_VPOST_ENT_ERROR_E_ARG_INPICBUF_NULL = 0x806181a2,
+	CELL_VPOST_ENT_ERROR_E_ARG_INPICBUF_INVALID = 0x806181a3,
+	CELL_VPOST_ENT_ERROR_E_ARG_INPICINFO_NULL = 0x806181a4,
+	CELL_VPOST_ENT_ERROR_E_ARG_INPICINFO_INVALID = 0x806181a5,
+	CELL_VPOST_ENT_ERROR_E_ARG_CTRL_NULL = 0x806181a6,
+	CELL_VPOST_ENT_ERROR_E_ARG_CTRL_INVALID = 0x806181a7,
+	CELL_VPOST_ENT_ERROR_E_ARG_COMB_INVALID = 0x806181a8,
+	CELL_VPOST_ENT_ERROR_E_ARG_OUTPICBUF_NULL = 0x806181a9,
+	CELL_VPOST_ENT_ERROR_E_ARG_OUTPICBUF_INVALID = 0x806181aa,
+	CELL_VPOST_ENT_ERROR_E_ARG_OUTPICINFO_NULL = 0x806181ab,
+	CELL_VPOST_ENT_ERROR_E_FATAL_SNDCMD_FAIL = 0x806181c0,
+	CELL_VPOST_ENT_ERROR_E_FATAL_RCVRES_FAIL = 0x806181c1,
+	CELL_VPOST_ENT_ERROR_E_FATAL_SPUCORE_FAIL = 0x806181c2,
+	CELL_VPOST_IPC_ERROR_Q_ARG_ATTR_NULL = 0x80618210,
+	CELL_VPOST_IPC_ERROR_O_ARG_RSRC_NULL = 0x80618240,
+	CELL_VPOST_IPC_ERROR_O_ARG_RSRC_INVALID = 0x80618241,
+	CELL_VPOST_IPC_ERROR_O_ARG_HDL_NULL = 0x80618242,
+	CELL_VPOST_IPC_ERROR_O_FATAL_QUERY_FAIL = 0x80618260,
+	CELL_VPOST_IPC_ERROR_O_FATAL_CSPUCORE_FAIL = 0x80618261,
+	CELL_VPOST_IPC_ERROR_C_ARG_HDL_NULL = 0x80618270,
+	CELL_VPOST_IPC_ERROR_C_ARG_HDL_INVALID = 0x80618271,
+	CELL_VPOST_IPC_ERROR_C_FATAL_SNDCMD_FAIL = 0x80618290,
+	CELL_VPOST_IPC_ERROR_C_FATAL_RCVRES_FAIL = 0x80618291,
+	CELL_VPOST_IPC_ERROR_C_FATAL_DSPUCORE_FAIL = 0x80618292,
+	CELL_VPOST_IPC_ERROR_E_ARG_HDL_NULL = 0x806182a0,
+	CELL_VPOST_IPC_ERROR_E_ARG_HDL_INVALID = 0x806182a1,
+	CELL_VPOST_IPC_ERROR_E_ARG_INPICBUF_NULL = 0x806182a2,
+	CELL_VPOST_IPC_ERROR_E_ARG_INPICBUF_INVALID = 0x806182a3,
+	CELL_VPOST_IPC_ERROR_E_ARG_INPICINFO_NULL = 0x806182a4,
+	CELL_VPOST_IPC_ERROR_E_ARG_INPICINFO_INVALID = 0x806182a5,
+	CELL_VPOST_IPC_ERROR_E_ARG_CTRL_NULL = 0x806182a6,
+	CELL_VPOST_IPC_ERROR_E_ARG_CTRL_INVALID = 0x806182a7,
+	CELL_VPOST_IPC_ERROR_E_ARG_COMB_INVALID = 0x806182a8,
+	CELL_VPOST_IPC_ERROR_E_ARG_OUTPICBUF_NULL = 0x806182a9,
+	CELL_VPOST_IPC_ERROR_E_ARG_OUTPICBUF_INVALID = 0x806182aa,
+	CELL_VPOST_IPC_ERROR_E_ARG_OUTPICINFO_NULL = 0x806182ab,
+	CELL_VPOST_IPC_ERROR_E_FATAL_SNDCMD_FAIL = 0x806182c0,
+	CELL_VPOST_IPC_ERROR_E_FATAL_RCVRES_FAIL = 0x806182c1,
+	CELL_VPOST_IPC_ERROR_E_FATAL_SPUCORE_FAIL = 0x806182c2,
+	CELL_VPOST_VSC_ERROR_Q_ARG_ATTR_NULL = 0x80618310,
+	CELL_VPOST_VSC_ERROR_O_ARG_RSRC_NULL = 0x80618340,
+	CELL_VPOST_VSC_ERROR_O_ARG_RSRC_INVALID = 0x80618341,
+	CELL_VPOST_VSC_ERROR_O_ARG_HDL_NULL = 0x80618342,
+	CELL_VPOST_VSC_ERROR_O_FATAL_QUERY_FAIL = 0x80618360,
+	CELL_VPOST_VSC_ERROR_O_FATAL_CSPUCORE_FAIL = 0x80618361,
+	CELL_VPOST_VSC_ERROR_C_ARG_HDL_NULL = 0x80618370,
+	CELL_VPOST_VSC_ERROR_C_ARG_HDL_INVALID = 0x80618371,
+	CELL_VPOST_VSC_ERROR_C_FATAL_SNDCMD_FAIL = 0x80618390,
+	CELL_VPOST_VSC_ERROR_C_FATAL_RCVRES_FAIL = 0x80618391,
+	CELL_VPOST_VSC_ERROR_C_FATAL_DSPUCORE_FAIL = 0x80618392,
+	CELL_VPOST_VSC_ERROR_E_ARG_HDL_NULL = 0x806183a0,
+	CELL_VPOST_VSC_ERROR_E_ARG_HDL_INVALID = 0x806183a1,
+	CELL_VPOST_VSC_ERROR_E_ARG_INPICBUF_NULL = 0x806183a2,
+	CELL_VPOST_VSC_ERROR_E_ARG_INPICBUF_INVALID = 0x806183a3,
+	CELL_VPOST_VSC_ERROR_E_ARG_INPICINFO_NULL = 0x806183a4,
+	CELL_VPOST_VSC_ERROR_E_ARG_INPICINFO_INVALID = 0x806183a5,
+	CELL_VPOST_VSC_ERROR_E_ARG_CTRL_NULL = 0x806183a6,
+	CELL_VPOST_VSC_ERROR_E_ARG_CTRL_INVALID = 0x806183a7,
+	CELL_VPOST_VSC_ERROR_E_ARG_COMB_INVALID = 0x806183a8,
+	CELL_VPOST_VSC_ERROR_E_ARG_OUTPICBUF_NULL = 0x806183a9,
+	CELL_VPOST_VSC_ERROR_E_ARG_OUTPICBUF_INVALID = 0x806183aa,
+	CELL_VPOST_VSC_ERROR_E_ARG_OUTPICINFO_NULL = 0x806183ab,
+	CELL_VPOST_VSC_ERROR_E_FATAL_SNDCMD_FAIL = 0x806183c0,
+	CELL_VPOST_VSC_ERROR_E_FATAL_RCVRES_FAIL = 0x806183c1,
+	CELL_VPOST_VSC_ERROR_E_FATAL_SPUCORE_FAIL = 0x806183c2,
+	CELL_VPOST_CSC_ERROR_Q_ARG_ATTR_NULL = 0x80618410,
+	CELL_VPOST_CSC_ERROR_O_ARG_RSRC_NULL = 0x80618440,
+	CELL_VPOST_CSC_ERROR_O_ARG_RSRC_INVALID = 0x80618441,
+	CELL_VPOST_CSC_ERROR_O_ARG_HDL_NULL = 0x80618442,
+	CELL_VPOST_CSC_ERROR_O_FATAL_QUERY_FAIL = 0x80618460,
+	CELL_VPOST_CSC_ERROR_O_FATAL_CSPUCORE_FAIL = 0x80618461,
+	CELL_VPOST_CSC_ERROR_C_ARG_HDL_NULL = 0x80618470,
+	CELL_VPOST_CSC_ERROR_C_ARG_HDL_INVALID = 0x80618471,
+	CELL_VPOST_CSC_ERROR_C_FATAL_SNDCMD_FAIL = 0x80618490,
+	CELL_VPOST_CSC_ERROR_C_FATAL_RCVRES_FAIL = 0x80618491,
+	CELL_VPOST_CSC_ERROR_C_FATAL_DSPUCORE_FAIL = 0x80618492,
+	CELL_VPOST_CSC_ERROR_E_ARG_HDL_NULL = 0x806184a0,
+	CELL_VPOST_CSC_ERROR_E_ARG_HDL_INVALID = 0x806184a1,
+	CELL_VPOST_CSC_ERROR_E_ARG_INPICBUF_NULL = 0x806184a2,
+	CELL_VPOST_CSC_ERROR_E_ARG_INPICBUF_INVALID = 0x806184a3,
+	CELL_VPOST_CSC_ERROR_E_ARG_INPICINFO_NULL = 0x806184a4,
+	CELL_VPOST_CSC_ERROR_E_ARG_INPICINFO_INVALID = 0x806184a5,
+	CELL_VPOST_CSC_ERROR_E_ARG_CTRL_NULL = 0x806184a6,
+	CELL_VPOST_CSC_ERROR_E_ARG_CTRL_INVALID = 0x806184a7,
+	CELL_VPOST_CSC_ERROR_E_ARG_COMB_INVALID = 0x806184a8,
+	CELL_VPOST_CSC_ERROR_E_ARG_OUTPICBUF_NULL = 0x806184a9,
+	CELL_VPOST_CSC_ERROR_E_ARG_OUTPICBUF_INVALID = 0x806184aa,
+	CELL_VPOST_CSC_ERROR_E_ARG_OUTPICINFO_NULL = 0x806184ab,
+	CELL_VPOST_CSC_ERROR_E_FATAL_SNDCMD_FAIL = 0x806184c0,
+	CELL_VPOST_CSC_ERROR_E_FATAL_RCVRES_FAIL = 0x806184c1,
+	CELL_VPOST_CSC_ERROR_E_FATAL_SPUCORE_FAIL = 0x806184c2,
+};
+
+enum CellVpostPictureDepth : s32
+{
+	CELL_VPOST_PIC_DEPTH_8,
+};
+
+enum CellVpostPictureFormatIn : s32
+{
+	CELL_VPOST_PIC_FMT_IN_YUV420_PLANAR,
+};
+
+enum CellVpostPictureFormatOut : s32
+{
+	CELL_VPOST_PIC_FMT_OUT_RGBA_ILV,
+	CELL_VPOST_PIC_FMT_OUT_YUV420_PLANAR,
+};
+
+enum CellVpostPictureStructure : s32
+{
+	CELL_VPOST_PIC_STRUCT_PFRM,
+	CELL_VPOST_PIC_STRUCT_IFRM,
+	CELL_VPOST_PIC_STRUCT_ITOP,
+	CELL_VPOST_PIC_STRUCT_IBTM,
+};
+
+enum CellVpostExecType : s32
+{
+	CELL_VPOST_EXEC_TYPE_PFRM_PFRM,
+	CELL_VPOST_EXEC_TYPE_PTOP_ITOP,
+	CELL_VPOST_EXEC_TYPE_PBTM_IBTM,
+	CELL_VPOST_EXEC_TYPE_ITOP_PFRM,
+	CELL_VPOST_EXEC_TYPE_IBTM_PFRM,
+	CELL_VPOST_EXEC_TYPE_IFRM_IFRM,
+	CELL_VPOST_EXEC_TYPE_ITOP_ITOP,
+	CELL_VPOST_EXEC_TYPE_IBTM_IBTM,
+};
+
+enum CellVpostChromaPositionType : s32
+{
+	CELL_VPOST_CHROMA_POS_TYPE_A,
+	CELL_VPOST_CHROMA_POS_TYPE_B,
+};
+
+enum CellVpostScanType : s32
+{
+	CELL_VPOST_SCAN_TYPE_P,
+	CELL_VPOST_SCAN_TYPE_I,
+};
+
+enum CellVpostQuantRange : s32
+{
+	CELL_VPOST_QUANT_RANGE_FULL,
+	CELL_VPOST_QUANT_RANGE_BROADCAST,
+};
+
+enum CellVpostColorMatrix : s32
+{
+	CELL_VPOST_COLOR_MATRIX_BT601,
+	CELL_VPOST_COLOR_MATRIX_BT709,
+};
+
+enum CellVpostScalerType : s32
+{
+	CELL_VPOST_SCALER_TYPE_BILINEAR,
+	CELL_VPOST_SCALER_TYPE_LINEAR_SHARP,
+	CELL_VPOST_SCALER_TYPE_2X4TAP,
+	CELL_VPOST_SCALER_TYPE_8X4TAP,
+};
+
+enum CellVpostIpcType : s32
+{
+	CELL_VPOST_IPC_TYPE_DOUBLING,
+	CELL_VPOST_IPC_TYPE_LINEAR,
+	CELL_VPOST_IPC_TYPE_MAVG,
+};
+
+struct CellVpostCfgParam
+{
+	be_t<u32> inMaxWidth;
+	be_t<u32> inMaxHeight;
+	be_t<s32> inDepth;  // CellVpostPictureDepth
+	be_t<s32> inPicFmt; // CellVpostPictureFormatIn
+
+	be_t<u32> outMaxWidth;
+	be_t<u32> outMaxHeight;
+	be_t<s32> outDepth;  // CellVpostPictureDepth
+	be_t<s32> outPicFmt; // CellVpostPictureFormatOut
+
+	be_t<u32> reserved1;
+	be_t<u32> reserved2;
+};
+
+struct CellVpostAttr
+{
+	be_t<u32> memSize;
+	u8 delay;
+	be_t<u32> vpostVerUpper;
+	be_t<u32> vpostVerLower;
+};
+
+struct CellVpostResource
+{
+	be_t<u32> memAddr;
+	be_t<u32> memSize;
+	be_t<s32> ppuThreadPriority;
+	be_t<u32> ppuThreadStackSize;
+	be_t<s32> spuThreadPriority;
+	be_t<u32> numOfSpus;
+};
+
+struct CellVpostResourceEx
+{
+	be_t<u32> memAddr;
+	be_t<u32> memSize;
+	be_t<u32> spurs_addr;
+	u8 priority[8];
+	be_t<u32> maxContention;
+};
+
+struct CellVpostWindow
+{
+	be_t<u32> x;
+	be_t<u32> y;
+	be_t<u32> width;
+	be_t<u32> height;
+};
+
+struct CellVpostCtrlParam
+{
+	be_t<s32> execType; // CellVpostExecType
+
+	be_t<s32> scalerType; // CellVpostScalerType
+	be_t<s32> ipcType;    // CellVpostIpcType
+
+	be_t<u32> inWidth;
+	be_t<u32> inHeight;
+	be_t<s32> inChromaPosType; // CellVpostChromaPositionType
+	be_t<s32> inQuantRange;    // CellVpostQuantRange
+	be_t<s32> inColorMatrix;   // CellVpostColorMatrix
+	CellVpostWindow inWindow;
+
+	be_t<u32> outWidth;
+	be_t<u32> outHeight;
+	CellVpostWindow outWindow;
+	u8 outAlpha;
+
+	be_t<u64> userData;
+
+	be_t<u32> reserved1;
+	be_t<u32> reserved2;
+};
+
+struct CellVpostPictureInfo
+{
+	be_t<u32> inWidth;
+	be_t<u32> inHeight;
+	be_t<s32> inDepth;         // CellVpostPictureDepth
+	be_t<s32> inScanType;      // CellVpostScanType
+	be_t<s32> inPicFmt;        // CellVpostPictureFormatIn
+	be_t<s32> inChromaPosType; // CellVpostChromaPositionType
+	be_t<s32> inPicStruct;     // CellVpostPictureStructure
+	be_t<s32> inQuantRange;    // CellVpostQuantRange
+	be_t<s32> inColorMatrix;   // CellVpostColorMatrix
+
+	be_t<u32> outWidth;
+	be_t<u32> outHeight;
+	be_t<s32> outDepth;         // CellVpostPictureDepth
+	be_t<s32> outScanType;      // CellVpostScanType
+	be_t<s32> outPicFmt;        // CellVpostPictureFormatOut
+	be_t<s32> outChromaPosType; // CellVpostChromaPositionType
+	be_t<s32> outPicStruct;     // CellVpostPictureStructure
+	be_t<s32> outQuantRange;    // CellVpostQuantRange
+	be_t<s32> outColorMatrix;   // CellVpostColorMatrix
+
+	be_t<u64> userData;
+
+	be_t<u32> reserved1;
+	be_t<u32> reserved2;
+};
+
+class VpostInstance
+{
+public:
+	static const u32 id_base = 1;
+	static const u32 id_step = 1;
+	static const u32 id_count = 1023;
+	SAVESTATE_INIT_POS(23);
+
+	const bool to_rgba;
+
+	SwsContext* sws{};
+
+	VpostInstance(bool rgba)
+		: to_rgba(rgba)
+	{
+	}
+
+	~VpostInstance()
+	{
+		sws_freeContext(sws);
+	}
+};

ps3fw/include/rpcsx/fw/ps3/cellWebBrowser.h

@@ -0,0 +1,79 @@
+#pragma once
+
+#include "Emu/Memory/vm_ptr.h"
+
+// events
+enum CellWebBrowserEvent : s32
+{
+	CELL_SYSUTIL_WEBBROWSER_INITIALIZING_FINISHED = 1,
+	CELL_SYSUTIL_WEBBROWSER_SHUTDOWN_FINISHED = 4,
+	CELL_SYSUTIL_WEBBROWSER_LOADING_FINISHED = 5,
+	CELL_SYSUTIL_WEBBROWSER_UNLOADING_FINISHED = 7,
+	CELL_SYSUTIL_WEBBROWSER_RELEASED = 9,
+	CELL_SYSUTIL_WEBBROWSER_GRABBED = 11,
+};
+
+using CellWebBrowserCallback = void(s32 cb_type, vm::ptr<void> client_session, vm::ptr<void> usrdata);
+using CellWebComponentCallback = void(s32 web_browser_id, s32 cb_type, vm::ptr<void> client_session, vm::ptr<void> usrdata);
+using CellWebBrowserSystemCallback = void(s32 cb_type, vm::ptr<void> usrdata);
+
+using CellWebBrowserMIMETypeCallback = void(vm::cptr<char> mimetype, vm::cptr<char> url, vm::ptr<void> usrdata);
+using CellWebBrowserErrorCallback = void(s32 err_type, vm::ptr<void> usrdata);
+using CellWebBrowserStatusCallback = void(s32 err_type, vm::ptr<void> usrdata);
+using CellWebBrowserNotify = void(vm::cptr<char> message, vm::ptr<void> usrdata);
+using CellWebBrowserUsrdata = void(vm::ptr<void> usrdata);
+
+struct CellWebBrowserMimeSet
+{
+	vm::bcptr<char> type;
+	vm::bcptr<char> directory;
+};
+
+struct CellWebBrowserPos
+{
+	be_t<s32> x;
+	be_t<s32> y;
+};
+
+struct CellWebBrowserSize
+{
+	be_t<s32> width;
+	be_t<s32> height;
+};
+
+struct CellWebBrowserRect
+{
+	CellWebBrowserPos pos;
+	CellWebBrowserSize size;
+};
+
+struct CellWebBrowserConfig
+{
+	be_t<s32> version;
+	be_t<s32> heap_size;
+	vm::bcptr<CellWebBrowserMimeSet> mimesets;
+	be_t<s32> mimeset_num;
+	be_t<s32> functions;
+	be_t<s32> tab_count;
+	vm::bptr<CellWebBrowserCallback> exit_cb;
+	vm::bptr<CellWebBrowserCallback> download_cb;
+	vm::bptr<CellWebBrowserCallback> navigated_cb;
+};
+
+struct CellWebBrowserConfig2
+{
+	be_t<s32> version;
+	be_t<s32> heap_size;
+	be_t<s32> functions;
+	be_t<s32> tab_count;
+	be_t<s32> size_mode;
+	be_t<s32> view_restriction;
+	vm::bptr<CellWebBrowserMIMETypeCallback> unknown_mimetype_cb;
+	vm::bptr<CellWebBrowserErrorCallback> error_cb;
+	vm::bptr<CellWebBrowserStatusCallback> status_error_cb;
+	vm::bptr<CellWebBrowserNotify> notify_cb;
+	vm::bptr<CellWebBrowserCallback> request_cb;
+	CellWebBrowserRect rect;
+	be_t<f32> resolution_factor;
+	be_t<s32> magic_number_;
+};

ps3fw/include/rpcsx/fw/ps3/libfs_utility_init.h

@@ -0,0 +1 @@
+#pragma once

ps3fw/include/rpcsx/fw/ps3/libmixer.h

@@ -0,0 +1,168 @@
+#pragma once
+
+#include "Emu/Memory/vm_ptr.h"
+
+// Error Codes
+enum CellLibmixerError : u32
+{
+	CELL_LIBMIXER_ERROR_NOT_INITIALIZED = 0x80310002,
+	CELL_LIBMIXER_ERROR_INVALID_PARAMATER = 0x80310003,
+	CELL_LIBMIXER_ERROR_NO_MEMORY = 0x80310005,
+	CELL_LIBMIXER_ERROR_ALREADY_EXIST = 0x80310006,
+	CELL_LIBMIXER_ERROR_FULL = 0x80310007,
+	CELL_LIBMIXER_ERROR_NOT_EXIST = 0x80310008,
+	CELL_LIBMIXER_ERROR_TYPE_MISMATCH = 0x80310009,
+	CELL_LIBMIXER_ERROR_NOT_FOUND = 0x8031000a,
+};
+
+enum
+{
+	CELL_SURBUS_LEFT = 0,
+	CELL_SURBUS_RIGHT = 1,
+	CELL_SURBUS_CENTER = 2,
+	CELL_SURBUS_LFE = 3,
+	CELL_SURBUS_LEFT_SUR = 4,
+	CELL_SURBUS_RIGHT_SUR = 5,
+	CELL_SURBUS_LEFT_EXT = 6,
+	CELL_SURBUS_RIGHT_EXT = 7,
+	CELL_SURBUS_REVERB_LEFT = 8,
+	CELL_SURBUS_REVERB_RIGHT = 9,
+	CELL_SURBUS_REVERB_LEFT_SUR = 10,
+	CELL_SURBUS_REVERB_RIGHT_SUR = 11,
+};
+
+enum
+{
+	CELL_SURMIXER_PARAM_TOTALLEVEL_LINEAR = 8,
+	CELL_SURMIXER_PARAM_REVERBLEVEL_LINEAR = 9,
+	CELL_SURMIXER_PARAM_TOTALMUTE = 12,
+
+	CELL_SURMIXER_PARAM_TOTALLEVEL = 40,  // in dB
+	CELL_SURMIXER_PARAM_REVERBLEVEL = 41, // in dB
+};
+
+static const float CELL_SURMIXER_CONT_MUTEON = 1.0;
+static const float CELL_SURMIXER_CONT_MUTEOFF = 0.0;
+
+enum
+{
+	CELL_SURMIXER_CONT_DBSWITCHON = 1,
+	CELL_SURMIXER_CONT_DBSWITCHOFF = 0,
+	CELL_SURMIXER_CONT_PAUSE_OFF = 0,
+	CELL_SURMIXER_CONT_PAUSE_ON = 1,
+	CELL_SURMIXER_CONT_PAUSE_ON_IMMEDIATE = 2,
+};
+
+enum
+{
+	CELL_SURMIXER_CHSTRIP_TYPE1A = 1,
+	CELL_SURMIXER_CHSTRIP_TYPE2A = 2,
+	CELL_SURMIXER_CHSTRIP_TYPE6A = 3,
+	CELL_SURMIXER_CHSTRIP_TYPE8A = 4,
+
+	CELL_SURMIXER_CH1PARAM_LEVEL = 0,
+	CELL_SURMIXER_CH1PARAM_EXPRESSIONLEVEL = 1,
+	CELL_SURMIXER_CH1PARAM_CENTERLEVEL = 2,
+	CELL_SURMIXER_CH1PARAM_REVERBSENDLEVEL = 3,
+	CELL_SURMIXER_CH1PARAM_MUTE = 4,
+	CELL_SURMIXER_CH1PARAM_REVSENDPOSITION = 5,
+	CELL_SURMIXER_CH1PARAM_POSITION = 6,
+
+	CELL_SURMIXER_CH2PARAM_LEVEL = 0,
+	CELL_SURMIXER_CH2PARAM_EXPRESSIONLEVEL = 1,
+	CELL_SURMIXER_CH2PARAM_CENTERLEVEL = 2,
+	CELL_SURMIXER_CH2PARAM_REVERBSENDLEVEL = 3,
+	CELL_SURMIXER_CH2PARAM_MUTE = 4,
+	CELL_SURMIXER_CH2PARAM_REVSENDPOSITION = 5,
+	CELL_SURMIXER_CH2PARAM_POSITION = 6,
+
+	CELL_SURMIXER_CH6PARAM_LEVEL = 0,
+	CELL_SURMIXER_CH6PARAM_EXPRESSIONLEVEL = 1,
+	CELL_SURMIXER_CH6PARAM_REVERBSENDLEVEL = 2,
+	CELL_SURMIXER_CH6PARAM_CENTER_REVERBSENDLEVEL = 3,
+	CELL_SURMIXER_CH6PARAM_MUTE = 4,
+
+	CELL_SURMIXER_CH8PARAM_LEVEL = 0,
+	CELL_SURMIXER_CH8PARAM_EXPRESSIONLEVEL = 1,
+	CELL_SURMIXER_CH8PARAM_REVERBSENDLEVEL = 2,
+	CELL_SURMIXER_CH8PARAM_CENTER_REVERBSENDLEVEL = 3,
+	CELL_SURMIXER_CH8PARAM_MUTE = 4,
+
+	CELL_SURMIXER_CH1CONT_MUTE_OFF = 0,
+	CELL_SURMIXER_CH1CONT_MUTE_ON = 1,
+	CELL_SURMIXER_CH2CONT_MUTE_OFF = 0,
+	CELL_SURMIXER_CH2CONT_MUTE_ON = 1,
+	CELL_SURMIXER_CH6CONT_MUTE_OFF = 0,
+	CELL_SURMIXER_CH6CONT_MUTE_ON = 1,
+	CELL_SURMIXER_CH8CONT_MUTE_OFF = 0,
+	CELL_SURMIXER_CH8CONT_MUTE_ON = 1,
+};
+
+enum
+{
+	CELL_SSPLAYER_ONESHOT = 0,
+	CELL_SSPLAYER_ONESHOT_CONT = 2,
+	CELL_SSPLAYER_LOOP_ON = 16,
+
+	CELL_SSPLAYER_STATE_ERROR = 0xffffffff,
+	CELL_SSPLAYER_STATE_NOTREADY = 0x88888888,
+	CELL_SSPLAYER_STATE_OFF = 0x00,
+	CELL_SSPLAYER_STATE_PAUSE = 0x01,
+	CELL_SSPLAYER_STATE_CLOSING = 0x08,
+	CELL_SSPLAYER_STATE_ON = 0x20,
+};
+
+using CellSurMixerNotifyCallbackFunction = s32(vm::ptr<void> arg, u32 counter, u32 samples);
+
+struct CellSSPlayerConfig
+{
+	be_t<u32> channels;
+	be_t<u32> outputMode;
+};
+
+struct CellSSPlayerWaveParam
+{
+	be_t<u32> addr;
+	be_t<s32> format;
+	be_t<u32> samples;
+	be_t<u32> loopStartOffset;
+	be_t<u32> startOffset;
+};
+
+struct CellSSPlayerCommonParam
+{
+	be_t<u32> loopMode;
+	be_t<u32> attackMode;
+};
+
+struct CellSurMixerPosition
+{
+	be_t<float> x;
+	be_t<float> y;
+	be_t<float> z;
+};
+
+struct CellSSPlayerRuntimeInfo
+{
+	be_t<float> level;
+	be_t<float> speed;
+	CellSurMixerPosition position;
+};
+
+struct CellSurMixerConfig
+{
+	be_t<s32> priority;
+	be_t<u32> chStrips1;
+	be_t<u32> chStrips2;
+	be_t<u32> chStrips6;
+	be_t<u32> chStrips8;
+};
+
+struct CellSurMixerChStripParam
+{
+	be_t<u32> param;
+	be_t<u32> attribute_addr;
+	be_t<s32> dBSwitch;
+	be_t<float> floatVal;
+	be_t<s32> intVal;
+};

ps3fw/include/rpcsx/fw/ps3/libsnd3.h

@@ -0,0 +1,55 @@
+#pragma once
+
+#include "Emu/Memory/vm_ptr.h"
+
+// Error Codes
+enum CellSnd3Error : u32
+{
+	CELL_SND3_ERROR_PARAM = 0x80310301,
+	CELL_SND3_ERROR_CREATE_MUTEX = 0x80310302,
+	CELL_SND3_ERROR_SYNTH = 0x80310303,
+	CELL_SND3_ERROR_ALREADY = 0x80310304,
+	CELL_SND3_ERROR_NOTINIT = 0x80310305,
+	CELL_SND3_ERROR_SMFFULL = 0x80310306,
+	CELL_SND3_ERROR_HD3ID = 0x80310307,
+	CELL_SND3_ERROR_SMF = 0x80310308,
+	CELL_SND3_ERROR_SMFCTX = 0x80310309,
+	CELL_SND3_ERROR_FORMAT = 0x8031030a,
+	CELL_SND3_ERROR_SMFID = 0x8031030b,
+	CELL_SND3_ERROR_SOUNDDATAFULL = 0x8031030c,
+	CELL_SND3_ERROR_VOICENUM = 0x8031030d,
+	CELL_SND3_ERROR_RESERVEDVOICE = 0x8031030e,
+	CELL_SND3_ERROR_REQUESTQUEFULL = 0x8031030f,
+	CELL_SND3_ERROR_OUTPUTMODE = 0x80310310,
+};
+
+struct CellSnd3KeyOnParam
+{
+	u8 vel;
+	u8 pan;
+	u8 panEx;
+	be_t<s32> addPitch;
+};
+
+struct CellSnd3VoiceBitCtx
+{
+	be_t<u32> core[4];
+};
+
+struct CellSnd3DataCtx
+{
+	s8 system[32];
+};
+
+struct CellSnd3SmfCtx
+{
+	s8 system[352];
+};
+
+struct CellSnd3RequestQueueCtx
+{
+	vm::bptr<void> frontQueue;
+	be_t<u32> frontQueueSize;
+	vm::bptr<void> rearQueue;
+	be_t<u32> rearQueueSize;
+};

ps3fw/include/rpcsx/fw/ps3/libsynth2.h

@@ -0,0 +1,19 @@
+#pragma once
+
+// Error Codes
+enum CellSoundSynth2Error : u32
+{
+	CELL_SOUND_SYNTH2_ERROR_FATAL = 0x80310201,
+	CELL_SOUND_SYNTH2_ERROR_INVALID_PARAMETER = 0x80310202,
+	CELL_SOUND_SYNTH2_ERROR_ALREADY_INITIALIZED = 0x80310203,
+};
+
+struct CellSoundSynth2EffectAttr
+{
+	be_t<u16> core;
+	be_t<u16> mode;
+	be_t<s16> depth_L;
+	be_t<s16> depth_R;
+	be_t<u16> delay;
+	be_t<u16> feedback;
+};

ps3fw/include/rpcsx/fw/ps3/sceNpClans.h

@@ -0,0 +1,289 @@
+#pragma once
+
+#include "sceNp.h"
+
+// Return codes
+enum SceNpClansError : u32
+{
+	SCE_NP_CLANS_ERROR_ALREADY_INITIALIZED = 0x80022701,
+	SCE_NP_CLANS_ERROR_NOT_INITIALIZED = 0x80022702,
+	SCE_NP_CLANS_ERROR_NOT_SUPPORTED = 0x80022703,
+	SCE_NP_CLANS_ERROR_OUT_OF_MEMORY = 0x80022704,
+	SCE_NP_CLANS_ERROR_INVALID_ARGUMENT = 0x80022705,
+	SCE_NP_CLANS_ERROR_EXCEEDS_MAX = 0x80022706,
+	SCE_NP_CLANS_ERROR_BAD_RESPONSE = 0x80022707,
+	SCE_NP_CLANS_ERROR_BAD_DATA = 0x80022708,
+	SCE_NP_CLANS_ERROR_BAD_REQUEST = 0x80022709,
+	SCE_NP_CLANS_ERROR_INVALID_SIGNATURE = 0x8002270a,
+	SCE_NP_CLANS_ERROR_INSUFFICIENT = 0x8002270b,
+	SCE_NP_CLANS_ERROR_INTERNAL_BUFFER = 0x8002270c,
+	SCE_NP_CLANS_ERROR_SERVER_MAINTENANCE = 0x8002270d,
+	SCE_NP_CLANS_ERROR_SERVER_END_OF_SERVICE = 0x8002270e,
+	SCE_NP_CLANS_ERROR_SERVER_BEFORE_START_OF_SERVICE = 0x8002270f,
+	SCE_NP_CLANS_ERROR_ABORTED = 0x80022710,
+	SCE_NP_CLANS_ERROR_SERVICE_UNAVAILABLE = 0x80022711,
+	SCE_NP_CLANS_SERVER_ERROR_BAD_REQUEST = 0x80022801,
+	SCE_NP_CLANS_SERVER_ERROR_INVALID_TICKET = 0x80022802,
+	SCE_NP_CLANS_SERVER_ERROR_INVALID_SIGNATURE = 0x80022803,
+	SCE_NP_CLANS_SERVER_ERROR_TICKET_EXPIRED = 0x80022804,
+	SCE_NP_CLANS_SERVER_ERROR_INVALID_NPID = 0x80022805,
+	SCE_NP_CLANS_SERVER_ERROR_FORBIDDEN = 0x80022806,
+	SCE_NP_CLANS_SERVER_ERROR_INTERNAL_SERVER_ERROR = 0x80022807,
+	SCE_NP_CLANS_SERVER_ERROR_BANNED = 0x8002280a,
+	SCE_NP_CLANS_SERVER_ERROR_BLACKLISTED = 0x80022811,
+	SCE_NP_CLANS_SERVER_ERROR_INVALID_ENVIRONMENT = 0x8002281d,
+	SCE_NP_CLANS_SERVER_ERROR_NO_SUCH_CLAN_SERVICE = 0x8002282f,
+	SCE_NP_CLANS_SERVER_ERROR_NO_SUCH_CLAN = 0x80022830,
+	SCE_NP_CLANS_SERVER_ERROR_NO_SUCH_CLAN_MEMBER = 0x80022831,
+	SCE_NP_CLANS_SERVER_ERROR_BEFORE_HOURS = 0x80022832,
+	SCE_NP_CLANS_SERVER_ERROR_CLOSED_SERVICE = 0x80022833,
+	SCE_NP_CLANS_SERVER_ERROR_PERMISSION_DENIED = 0x80022834,
+	SCE_NP_CLANS_SERVER_ERROR_CLAN_LIMIT_REACHED = 0x80022835,
+	SCE_NP_CLANS_SERVER_ERROR_CLAN_LEADER_LIMIT_REACHED = 0x80022836,
+	SCE_NP_CLANS_SERVER_ERROR_CLAN_MEMBER_LIMIT_REACHED = 0x80022837,
+	SCE_NP_CLANS_SERVER_ERROR_CLAN_JOINED_LIMIT_REACHED = 0x80022838,
+	SCE_NP_CLANS_SERVER_ERROR_MEMBER_STATUS_INVALID = 0x80022839,
+	SCE_NP_CLANS_SERVER_ERROR_DUPLICATED_CLAN_NAME = 0x8002283a,
+	SCE_NP_CLANS_SERVER_ERROR_CLAN_LEADER_CANNOT_LEAVE = 0x8002283b,
+	SCE_NP_CLANS_SERVER_ERROR_INVALID_ROLE_PRIORITY = 0x8002283c,
+	SCE_NP_CLANS_SERVER_ERROR_ANNOUNCEMENT_LIMIT_REACHED = 0x8002283d,
+	SCE_NP_CLANS_SERVER_ERROR_CLAN_CONFIG_MASTER_NOT_FOUND = 0x8002283e,
+	SCE_NP_CLANS_SERVER_ERROR_DUPLICATED_CLAN_TAG = 0x8002283f,
+	SCE_NP_CLANS_SERVER_ERROR_EXCEEDS_CREATE_CLAN_FREQUENCY = 0x80022840,
+	SCE_NP_CLANS_SERVER_ERROR_CLAN_PASSPHRASE_INCORRECT = 0x80022841,
+	SCE_NP_CLANS_SERVER_ERROR_CANNOT_RECORD_BLACKLIST_ENTRY = 0x80022842,
+	SCE_NP_CLANS_SERVER_ERROR_NO_SUCH_CLAN_ANNOUNCEMENT = 0x80022843,
+	SCE_NP_CLANS_SERVER_ERROR_VULGAR_WORDS_POSTED = 0x80022844,
+	SCE_NP_CLANS_SERVER_ERROR_BLACKLIST_LIMIT_REACHED = 0x80022845,
+	SCE_NP_CLANS_SERVER_ERROR_NO_SUCH_BLACKLIST_ENTRY = 0x80022846,
+	SCE_NP_CLANS_SERVER_ERROR_INVALID_NP_MESSAGE_FORMAT = 0x8002284b,
+	SCE_NP_CLANS_SERVER_ERROR_FAILED_TO_SEND_NP_MESSAGE = 0x8002284c,
+};
+
+// Clan roles
+enum
+{
+	SCE_NP_CLANS_ROLE_UNKNOWN = 0,
+	SCE_NP_CLANS_ROLE_NON_MEMBER = 1,
+	SCE_NP_CLANS_ROLE_MEMBER = 2,
+	SCE_NP_CLANS_ROLE_SUB_LEADER = 3,
+	SCE_NP_CLANS_ROLE_LEADER = 4,
+};
+
+// Clan member status
+enum
+{
+	SCE_NP_CLANS_MEMBER_STATUS_UNKNOWN = 0,
+	SCE_NP_CLANS_MEMBER_STATUS_NORMAL = 1,
+	SCE_NP_CLANS_MEMBER_STATUS_INVITED = 2,
+	SCE_NP_CLANS_MEMBER_STATUS_PENDING = 3,
+};
+
+// Clan search operators
+enum
+{
+	SCE_NP_CLANS_SEARCH_OPERATOR_EQUAL_TO = 0,
+	SCE_NP_CLANS_SEARCH_OPERATOR_NOT_EQUAL_TO = 1,
+	SCE_NP_CLANS_SEARCH_OPERATOR_GREATER_THAN = 2,
+	SCE_NP_CLANS_SEARCH_OPERATOR_GREATER_THAN_OR_EQUAL_TO = 3,
+	SCE_NP_CLANS_SEARCH_OPERATOR_LESS_THAN = 4,
+	SCE_NP_CLANS_SEARCH_OPERATOR_LESS_THAN_OR_EQUAL_TO = 5,
+	SCE_NP_CLANS_SEARCH_OPERATOR_SIMILAR_TO = 6,
+};
+
+// Constants for clan functions and structures
+enum
+{
+	SCE_NP_CLANS_ANNOUNCEMENT_MESSAGE_BODY_MAX_LENGTH = 1536,
+	SCE_NP_CLANS_CLAN_BINARY_ATTRIBUTE1_MAX_SIZE = 190,
+	SCE_NP_CLANS_CLAN_BINARY_DATA_MAX_SIZE = 10240,
+	SCE_NP_CLANS_MEMBER_BINARY_ATTRIBUTE1_MAX_SIZE = 16,
+	SCE_NP_CLANS_MEMBER_DESCRIPTION_MAX_LENGTH = 255,
+	SCE_NP_CLANS_MEMBER_BINARY_DATA_MAX_SIZE = 1024,
+	SCE_NP_CLANS_MESSAGE_BODY_MAX_LENGTH = 1536,
+	SCE_NP_CLANS_MESSAGE_SUBJECT_MAX_LENGTH = 54,
+	SCE_NP_CLANS_MESSAGE_BODY_CHARACTER_MAX = 512,
+	SCE_NP_CLANS_MESSAGE_SUBJECT_CHARACTER_MAX = 18,
+	SCE_NP_CLANS_MESSAGE_BINARY_DATA_MAX_SIZE = 1024,
+	SCE_NP_CLANS_PAGING_REQUEST_START_POSITION_MAX = 1000000,
+	SCE_NP_CLANS_PAGING_REQUEST_PAGE_MAX = 100,
+};
+
+enum
+{
+	SCE_NP_CLANS_FIELDS_SEARCHABLE_ATTR_INT_ATTR1 = 0x00000001,
+	SCE_NP_CLANS_FIELDS_SEARCHABLE_ATTR_INT_ATTR2 = 0x00000002,
+	SCE_NP_CLANS_FIELDS_SEARCHABLE_ATTR_INT_ATTR3 = 0x00000004,
+	SCE_NP_CLANS_FIELDS_SEARCHABLE_ATTR_BIN_ATTR1 = 0x00000008,
+	SCE_NP_CLANS_FIELDS_SEARCHABLE_PROFILE_TAG = 0x00000010,
+	SCE_NP_CLANS_FIELDS_SEARCHABLE_PROFILE_NUM_MEMBERS = 0x00000020,
+	SCE_NP_CLANS_FIELDS_UPDATABLE_CLAN_INFO_DESCR = 0x00000040,
+	SCE_NP_CLANS_FIELDS_UPDATABLE_CLAN_INFO_BIN_DATA1 = 0x00000080,
+	SCE_NP_CLANS_FIELDS_UPDATABLE_MEMBER_INFO_DESCR = 0x00000100,
+	SCE_NP_CLANS_FIELDS_UPDATABLE_MEMBER_INFO_BIN_ATTR1 = 0x00000200,
+	SCE_NP_CLANS_FIELDS_UPDATABLE_MEMBER_INFO_BIN_DATA1 = 0x00000400,
+	SCE_NP_CLANS_FIELDS_UPDATABLE_MEMBER_INFO_ALLOW_MSG = 0x00000800,
+};
+
+enum
+{
+	SCE_NP_CLANS_MESSAGE_OPTIONS_NONE = 0x00000000,
+	SCE_NP_CLANS_MESSAGE_OPTIONS_CENSOR = 0x00000001,
+};
+
+enum
+{
+	SCE_NP_CLANS_INVALID_ID = 0,
+	SCE_NP_CLANS_INVALID_REQUEST_HANDLE = 0,
+};
+
+// Request handle for clan API
+using SceNpClansRequestHandle = vm::ptr<struct SceNpClansRequest>;
+
+// Paging request structure
+struct SceNpClansPagingRequest
+{
+	be_t<u32> startPos;
+	be_t<u32> max;
+};
+
+// Paging result structure
+struct SceNpClansPagingResult
+{
+	be_t<u32> count;
+	be_t<u32> total;
+};
+
+// Basic clan information
+struct SceNpClansClanBasicInfo
+{
+	be_t<u32> clanId;
+	be_t<u32> numMembers;
+	s8 name[SCE_NP_CLANS_CLAN_NAME_MAX_LENGTH + 1];
+	s8 tag[SCE_NP_CLANS_CLAN_TAG_MAX_LENGTH + 1];
+	u8 reserved[2];
+};
+
+// Clan entry structure
+struct SceNpClansEntry
+{
+	SceNpClansClanBasicInfo info;
+	be_t<u32> role;
+	be_t<s32> status;
+	b8 allowMsg;
+	u8 reserved[3];
+};
+
+// Clan search attribute structure
+struct SceNpClansSearchableAttr
+{
+	be_t<u32> fields;
+	be_t<u32> intAttr1;
+	be_t<u32> intAttr2;
+	be_t<u32> intAttr3;
+	u8 binAttr1[SCE_NP_CLANS_CLAN_BINARY_ATTRIBUTE1_MAX_SIZE];
+	u8 reserved[2];
+};
+
+// Clan search profile structure
+struct SceNpClansSearchableProfile
+{
+	SceNpClansSearchableAttr attr;
+	be_t<u32> fields;
+	be_t<u32> numMembers;
+	be_t<s32> tagSearchOp;
+	be_t<s32> numMemberSearchOp;
+	be_t<s32> intAttr1SearchOp;
+	be_t<s32> intAttr2SearchOp;
+	be_t<s32> intAttr3SearchOp;
+	be_t<s32> binAttr1SearchOp;
+	s8 tag[SCE_NP_CLANS_CLAN_TAG_MAX_LENGTH + 1];
+	u8 reserved[3];
+};
+
+// Clan search name structure
+struct SceNpClansSearchableName
+{
+	be_t<s32> nameSearchOp;
+	s8 name[SCE_NP_CLANS_CLAN_NAME_MAX_LENGTH + 1];
+	u8 reserved[3];
+};
+
+// Updatable clan information structure
+struct SceNpClansUpdatableClanInfo
+{
+	be_t<u32> fields;
+	s8 description[SCE_NP_CLANS_CLAN_DESCRIPTION_MAX_LENGTH + 1];
+	SceNpClansSearchableAttr attr;
+	u8 binData1;
+	be_t<u32> binData1Size;
+};
+
+// Clan information structure
+struct SceNpClansClanInfo
+{
+	CellRtcTick dateCreated;
+	SceNpClansClanBasicInfo info;
+	SceNpClansUpdatableClanInfo updatable;
+};
+
+// Updatable member information structure
+struct SceNpClansUpdatableMemberInfo
+{
+	be_t<u32> fields;
+	u8 binData1;
+	be_t<u32> binData1Size;
+	u8 binAttr1[SCE_NP_CLANS_CLAN_BINARY_ATTRIBUTE1_MAX_SIZE + 1];
+	s8 description[SCE_NP_CLANS_MEMBER_DESCRIPTION_MAX_LENGTH + 1];
+	b8 allowMsg;
+	u8 reserved[3];
+};
+
+// Member entry structure
+struct SceNpClansMemberEntry
+{
+	SceNpId npid;
+	be_t<u32> role;
+	be_t<s32> status;
+	SceNpClansUpdatableMemberInfo updatable;
+};
+
+// Clan message structure
+struct SceNpClansMessage
+{
+	char subject[SCE_NP_CLANS_MESSAGE_SUBJECT_MAX_LENGTH + 1];
+	char body[SCE_NP_CLANS_MESSAGE_BODY_MAX_LENGTH + 1];
+	be_t<u32> options;
+};
+
+// Clan message data structure
+struct SceNpClansMessageData
+{
+	u8 binData1;
+	be_t<u32> binData1Size;
+};
+
+// Clan message entry structure
+struct SceNpClansMessageEntry
+{
+	CellRtcTick postDate;
+	be_t<u32> mId;
+	SceNpClansMessage message;
+	SceNpClansMessageData data;
+	SceNpId npid;
+	u8 reserved[4];
+};
+
+// Blacklist entry structure
+struct SceNpClansBlacklistEntry
+{
+	SceNpId entry;
+	SceNpId registeredBy;
+};
+
+// fxm objects
+
+struct sce_np_clans_manager
+{
+	atomic_t<bool> is_initialized = false;
+};

ps3fw/include/rpcsx/fw/ps3/sceNpCommerce2.h

@@ -0,0 +1,335 @@
+#pragma once
+
+#include "cellRtc.h"
+
+// Return codes
+enum SceNpCommerce2Error
+{
+	SCE_NP_COMMERCE2_ERROR_NOT_INITIALIZED = 0x80023001,
+	SCE_NP_COMMERCE2_ERROR_ALREADY_INITIALIZED = 0x80023002,
+	SCE_NP_COMMERCE2_ERROR_INVALID_ARGUMENT = 0x80023003,
+	SCE_NP_COMMERCE2_ERROR_UNSUPPORTED_VERSION = 0x80023004,
+	SCE_NP_COMMERCE2_ERROR_CTX_MAX = 0x80023005,
+	SCE_NP_COMMERCE2_ERROR_INVALID_INDEX = 0x80023006,
+	SCE_NP_COMMERCE2_ERROR_INVALID_SKUID = 0x80023007,
+	SCE_NP_COMMERCE2_ERROR_INVALID_SKU_NUM = 0x80023008,
+	SCE_NP_COMMERCE2_ERROR_INVALID_MEMORY_CONTAINER = 0x80023009,
+	SCE_NP_COMMERCE2_ERROR_INSUFFICIENT_MEMORY_CONTAINER = 0x8002300a,
+	SCE_NP_COMMERCE2_ERROR_OUT_OF_MEMORY = 0x8002300b,
+	SCE_NP_COMMERCE2_ERROR_CTX_NOT_FOUND = 0x8002300c,
+	SCE_NP_COMMERCE2_ERROR_CTXID_NOT_AVAILABLE = 0x8002300d,
+	SCE_NP_COMMERCE2_ERROR_REQ_NOT_FOUND = 0x8002300e,
+	SCE_NP_COMMERCE2_ERROR_REQID_NOT_AVAILABLE = 0x8002300f,
+	SCE_NP_COMMERCE2_ERROR_ABORTED = 0x80023010,
+	SCE_NP_COMMERCE2_ERROR_RESPONSE_BUF_TOO_SMALL = 0x80023012,
+	SCE_NP_COMMERCE2_ERROR_COULD_NOT_RECV_WHOLE_RESPONSE_DATA = 0x80023013,
+	SCE_NP_COMMERCE2_ERROR_INVALID_RESULT_DATA = 0x80023014,
+	SCE_NP_COMMERCE2_ERROR_UNKNOWN = 0x80023015,
+	SCE_NP_COMMERCE2_ERROR_SERVER_MAINTENANCE = 0x80023016,
+	SCE_NP_COMMERCE2_ERROR_SERVER_UNKNOWN = 0x80023017,
+	SCE_NP_COMMERCE2_ERROR_INSUFFICIENT_BUF_SIZE = 0x80023018,
+	SCE_NP_COMMERCE2_ERROR_REQ_MAX = 0x80023019,
+	SCE_NP_COMMERCE2_ERROR_INVALID_TARGET_TYPE = 0x8002301a,
+	SCE_NP_COMMERCE2_ERROR_INVALID_TARGET_ID = 0x8002301b,
+	SCE_NP_COMMERCE2_ERROR_INVALID_SIZE = 0x8002301c,
+	SCE_NP_COMMERCE2_ERROR_DATA_NOT_FOUND = 0x80023087,
+	SCE_NP_COMMERCE2_SERVER_ERROR_BAD_REQUEST = 0x80023101,
+	SCE_NP_COMMERCE2_SERVER_ERROR_UNKNOWN_ERROR = 0x80023102,
+	SCE_NP_COMMERCE2_SERVER_ERROR_SESSION_EXPIRED = 0x80023105,
+	SCE_NP_COMMERCE2_SERVER_ERROR_ACCESS_PERMISSION_DENIED = 0x80023107,
+	SCE_NP_COMMERCE2_SERVER_ERROR_NO_SUCH_CATEGORY = 0x80023110,
+	SCE_NP_COMMERCE2_SERVER_ERROR_NO_SUCH_PRODUCT = 0x80023111,
+	SCE_NP_COMMERCE2_SERVER_ERROR_NOT_ELIGIBILITY = 0x80023113,
+	SCE_NP_COMMERCE2_SERVER_ERROR_INVALID_SKU = 0x8002311a,
+	SCE_NP_COMMERCE2_SERVER_ERROR_ACCOUNT_SUSPENDED1 = 0x8002311b,
+	SCE_NP_COMMERCE2_SERVER_ERROR_ACCOUNT_SUSPENDED2 = 0x8002311c,
+	SCE_NP_COMMERCE2_SERVER_ERROR_OVER_SPENDING_LIMIT = 0x80023120,
+	SCE_NP_COMMERCE2_SERVER_ERROR_INVALID_VOUCHER = 0x8002312f,
+	SCE_NP_COMMERCE2_SERVER_ERROR_VOUCHER_ALREADY_CONSUMED = 0x80023130,
+	SCE_NP_COMMERCE2_SERVER_ERROR_EXCEEDS_AGE_LIMIT_IN_BROWSING = 0x80023139,
+	SCE_NP_COMMERCE2_SYSTEM_UTIL_ERROR_INVALID_VOUCHER = 0x80024002,
+};
+
+// Event types
+enum
+{
+	SCE_NP_COMMERCE2_EVENT_REQUEST_ERROR = 0x0001,
+	SCE_NP_COMMERCE2_EVENT_CREATE_SESSION_DONE = 0x0011,
+	SCE_NP_COMMERCE2_EVENT_CREATE_SESSION_ABORT = 0x0012,
+	SCE_NP_COMMERCE2_EVENT_DO_CHECKOUT_STARTED = 0x0021,
+	SCE_NP_COMMERCE2_EVENT_DO_CHECKOUT_SUCCESS = 0x0022,
+	SCE_NP_COMMERCE2_EVENT_DO_CHECKOUT_BACK = 0x0023,
+	SCE_NP_COMMERCE2_EVENT_DO_CHECKOUT_FINISHED = 0x0024,
+	SCE_NP_COMMERCE2_EVENT_DO_DL_LIST_STARTED = 0x0031,
+	SCE_NP_COMMERCE2_EVENT_DO_DL_LIST_SUCCESS = 0x0032,
+	SCE_NP_COMMERCE2_EVENT_DO_DL_LIST_FINISHED = 0x0034,
+	SCE_NP_COMMERCE2_EVENT_DO_PROD_BROWSE_STARTED = 0x0041,
+	SCE_NP_COMMERCE2_EVENT_DO_PROD_BROWSE_SUCCESS = 0x0042,
+	SCE_NP_COMMERCE2_EVENT_DO_PROD_BROWSE_BACK = 0x0043,
+	SCE_NP_COMMERCE2_EVENT_DO_PROD_BROWSE_FINISHED = 0x0044,
+	SCE_NP_COMMERCE2_EVENT_DO_PROD_BROWSE_OPENED = 0x0045,
+	SCE_NP_COMMERCE2_EVENT_DO_PRODUCT_CODE_STARTED = 0x0051,
+	SCE_NP_COMMERCE2_EVENT_DO_PRODUCT_CODE_SUCCESS = 0x0052,
+	SCE_NP_COMMERCE2_EVENT_DO_PRODUCT_CODE_BACK = 0x0053,
+	SCE_NP_COMMERCE2_EVENT_DO_PRODUCT_CODE_FINISHED = 0x0054,
+	SCE_NP_COMMERCE2_EVENT_EMPTY_STORE_CHECK_DONE = 0x0061,
+	SCE_NP_COMMERCE2_EVENT_EMPTY_STORE_CHECK_ABORT = 0x0062,
+	SCE_NP_COMMERCE2_EVENT_RESERVED01_STARTED = 0x0071,
+	SCE_NP_COMMERCE2_EVENT_RESERVED01_SUCCESS = 0x0072,
+	SCE_NP_COMMERCE2_EVENT_RESERVED01_BACK = 0x0073,
+	SCE_NP_COMMERCE2_EVENT_RESERVED01_FINISHED = 0x0074,
+};
+
+// Category data type
+enum SceNpCommerce2CategoryDataType
+{
+	SCE_NP_COMMERCE2_CAT_DATA_TYPE_THIN = 0,
+	SCE_NP_COMMERCE2_CAT_DATA_TYPE_NORMAL,
+	SCE_NP_COMMERCE2_CAT_DATA_TYPE_MAX
+};
+
+// Game product data type
+enum SceNpCommerce2GameProductDataType
+{
+	SCE_NP_COMMERCE2_GAME_PRODUCT_DATA_TYPE_THIN = 0,
+	SCE_NP_COMMERCE2_GAME_PRODUCT_DATA_TYPE_NORMAL,
+	SCE_NP_COMMERCE2_GAME_PRODUCT_DATA_TYPE_MAX
+};
+
+// SKU data type
+enum SceNpCommerce2GameSkuDataType
+{
+	SCE_NP_COMMERCE2_GAME_SKU_DATA_TYPE_THIN = 0,
+	SCE_NP_COMMERCE2_GAME_SKU_DATA_TYPE_NORMAL,
+	SCE_NP_COMMERCE2_GAME_SKU_DATA_TYPE_MAX
+};
+
+// Store stuff
+enum
+{
+	SCE_NP_COMMERCE2_STORE_IS_NOT_EMPTY = 0,
+	SCE_NP_COMMERCE2_STORE_IS_EMPTY = 1,
+
+	SCE_NP_COMMERCE2_STORE_CHECK_TYPE_CATEGORY = 1,
+
+	SCE_NP_COMMERCE2_STORE_BROWSE_TYPE_CATEGORY = 1,
+	SCE_NP_COMMERCE2_STORE_BROWSE_TYPE_PRODUCT = 2,
+	SCE_NP_COMMERCE2_STORE_BROWSE_TYPE_PRODUCT_CODE = 3,
+};
+
+// Content Stuff
+enum
+{
+	SCE_NP_COMMERCE2_CONTENT_TYPE_CATEGORY = 1,
+	SCE_NP_COMMERCE2_CONTENT_TYPE_PRODUCT = 2,
+
+	SCE_NP_COMMERCE2_CONTENT_RATING_DESC_TYPE_ICON = 1,
+	SCE_NP_COMMERCE2_CONTENT_RATING_DESC_TYPE_TEXT = 2,
+};
+
+// Game SKU
+enum
+{
+	SCE_NP_COMMERCE2_SKU_CHECKOUT_MAX = 16,
+	SCE_NP_COMMERCE2_SKU_DL_LIST_MAX = 16,
+
+	SCE_NP_COMMERCE2_SKU_PURCHASABILITY_FLAG_ON = 1,
+	SCE_NP_COMMERCE2_SKU_PURCHASABILITY_FLAG_OFF = 0,
+
+	SCE_NP_COMMERCE2_SKU_ANN_PURCHASED_CANNOT_PURCHASE_AGAIN = 0x80000000,
+	SCE_NP_COMMERCE2_SKU_ANN_PURCHASED_CAN_PURCHASE_AGAIN = 0x40000000,
+	SCE_NP_COMMERCE2_SKU_ANN_IN_THE_CART = 0x20000000,
+	SCE_NP_COMMERCE2_SKU_ANN_CONTENTLINK_SKU = 0x10000000,
+	SCE_NP_COMMERCE2_SKU_ANN_CREDIT_CARD_REQUIRED = 0x08000000,
+	SCE_NP_COMMERCE2_SKU_ANN_CHARGE_IMMEDIATELY = 0x04000000,
+};
+
+// Constants for commerce functions and structures
+enum
+{
+	SCE_NP_COMMERCE2_VERSION = 2,
+	SCE_NP_COMMERCE2_CTX_MAX = 1,
+	SCE_NP_COMMERCE2_REQ_MAX = 1,
+	SCE_NP_COMMERCE2_CURRENCY_CODE_LEN = 3,
+	SCE_NP_COMMERCE2_CURRENCY_SYMBOL_LEN = 3,
+	SCE_NP_COMMERCE2_THOUSAND_SEPARATOR_LEN = 4,
+	SCE_NP_COMMERCE2_DECIMAL_LETTER_LEN = 4,
+	SCE_NP_COMMERCE2_SP_NAME_LEN = 256,
+	SCE_NP_COMMERCE2_CATEGORY_ID_LEN = 56,
+	SCE_NP_COMMERCE2_CATEGORY_NAME_LEN = 256,
+	SCE_NP_COMMERCE2_CATEGORY_DESCRIPTION_LEN = 1024,
+	SCE_NP_COMMERCE2_PRODUCT_ID_LEN = 48,
+	SCE_NP_COMMERCE2_PRODUCT_NAME_LEN = 256,
+	SCE_NP_COMMERCE2_PRODUCT_SHORT_DESCRIPTION_LEN = 1024,
+	SCE_NP_COMMERCE2_PRODUCT_LONG_DESCRIPTION_LEN = 4000,
+	SCE_NP_COMMERCE2_SKU_ID_LEN = 56,
+	SCE_NP_COMMERCE2_SKU_NAME_LEN = 180,
+	SCE_NP_COMMERCE2_URL_LEN = 256,
+	SCE_NP_COMMERCE2_RATING_SYSTEM_ID_LEN = 16,
+	SCE_NP_COMMERCE2_RATING_DESCRIPTION_LEN = 60,
+	SCE_NP_COMMERCE2_RECV_BUF_SIZE = 262144,
+	SCE_NP_COMMERCE2_PRODUCT_CODE_BLOCK_LEN = 4,
+	SCE_NP_COMMERCE2_PRODUCT_CODE_INPUT_MODE_USER_INPUT = 0,
+	SCE_NP_COMMERCE2_PRODUCT_CODE_INPUT_MODE_CODE_SPECIFIED = 1,
+	SCE_NP_COMMERCE2_GETCAT_MAX_COUNT = 60,
+	SCE_NP_COMMERCE2_GETPRODLIST_MAX_COUNT = 60,
+	SCE_NP_COMMERCE2_DO_CHECKOUT_MEMORY_CONTAINER_SIZE = 10485760,
+	SCE_NP_COMMERCE2_DO_PROD_BROWSE_MEMORY_CONTAINER_SIZE = 16777216,
+	SCE_NP_COMMERCE2_DO_DL_LIST_MEMORY_CONTAINER_SIZE = 10485760,
+	SCE_NP_COMMERCE2_DO_PRODUCT_CODE_MEMORY_CONTAINER_SIZE = 16777216,
+	SCE_NP_COMMERCE2_SYM_POS_PRE = 0,
+	SCE_NP_COMMERCE2_SYM_POS_POST = 1,
+};
+
+// Common structure used when receiving data
+struct SceNpCommerce2CommonData
+{
+	be_t<u32> version;
+	be_t<u32> buf_head;
+	be_t<u32> buf_size;
+	be_t<u32> data;
+	be_t<u32> data_size;
+	be_t<u32> data2;
+	be_t<u32> reserved[4];
+};
+
+// Structure indicating the range of results obtained
+struct SceNpCommerce2Range
+{
+	be_t<u32> startPosition;
+	be_t<u32> count;
+	be_t<u32> totalCountOfResults;
+};
+
+// Structure for session information
+struct SceNpCommerce2SessionInfo
+{
+	s8 currencyCode[SCE_NP_COMMERCE2_CURRENCY_CODE_LEN + 1];
+	be_t<u32> decimals;
+	s8 currencySymbol[SCE_NP_COMMERCE2_CURRENCY_SYMBOL_LEN + 1];
+	be_t<u32> symbolPosition;
+	b8 symbolWithSpace;
+	u8 padding1[3];
+	s8 thousandSeparator[SCE_NP_COMMERCE2_THOUSAND_SEPARATOR_LEN + 1];
+	s8 decimalLetter[SCE_NP_COMMERCE2_DECIMAL_LETTER_LEN + 1];
+	u8 padding2[1];
+	be_t<u32> reserved[4];
+};
+
+// Structure for category information
+struct SceNpCommerce2CategoryInfo
+{
+	SceNpCommerce2CommonData commonData;
+	SceNpCommerce2CategoryDataType dataType;
+	s8 categoryId;
+	CellRtcTick releaseDate;
+	s8 categoryName;
+	s8 categoryDescription;
+	s8 imageUrl;
+	s8 spName;
+	be_t<u32> countOfSubCategory;
+	be_t<u32> countOfProduct;
+};
+
+// Structure for content information within the category
+struct SceNpCommerce2ContentInfo
+{
+	SceNpCommerce2CommonData commonData;
+	be_t<u32> contentType;
+};
+
+// Structure for initialized product data
+struct SceNpCommerce2GetProductInfoResult
+{
+	SceNpCommerce2CommonData commonData;
+};
+
+// Structure for game product information
+struct SceNpCommerce2GameProductInfo
+{
+	SceNpCommerce2CommonData commonData;
+	SceNpCommerce2GameProductDataType dataType;
+	s8 productId;
+	be_t<u32> countOfSku;
+	u8 padding[4];
+	CellRtcTick releaseDate;
+	s8 productName;
+	s8 productShortDescription;
+	s8 imageUrl;
+	s8 spName;
+	s8 productLongDescription;
+	s8 legalDescription;
+};
+
+// Structure for initialized product info list
+struct SceNpCommerce2GetProductInfoListResult
+{
+	SceNpCommerce2CommonData commonData;
+	be_t<u32> countOfProductInfo;
+};
+
+// Structure for rating information
+struct SceNpCommerce2ContentRatingInfo
+{
+	SceNpCommerce2CommonData commonData;
+	s8 ratingSystemId;
+	s8 imageUrl;
+	be_t<u32> countOfContentRatingDescriptor;
+};
+
+// Structure for a rating descriptor
+struct SceNpCommerce2ContentRatingDescriptor
+{
+	SceNpCommerce2CommonData commonData;
+	be_t<u32> descriptorType;
+	s8 imageUrl;
+	s8 contentRatingDescription;
+};
+
+// Structure for SKU information
+struct SceNpCommerce2GameSkuInfo
+{
+	SceNpCommerce2CommonData commonData;
+	SceNpCommerce2GameSkuDataType dataType;
+	s8 skuId;
+	be_t<u32> skuType;
+	be_t<u32> countUntilExpiration;
+	be_t<u32> timeUntilExpiration;
+	be_t<u32> purchasabilityFlag;
+	be_t<u32> annotation;
+	b8 downloadable;
+	u8 padding[3];
+	be_t<u32> price;
+	s8 skuName;
+	s8 productId;
+	s8 contentLinkUrl;
+	be_t<u32> countOfRewardInfo;
+	be_t<u32> reserved[8];
+};
+
+// Structure of parameters for in-game product browsing
+struct SceNpCommerce2ProductBrowseParam
+{
+	be_t<u32> size;
+};
+
+// Structure of parameters for promotion code input
+struct SceNpCommerce2ProductCodeParam
+{
+	be_t<u32> size;
+	be_t<u32> inputMode;
+	s8 code1[SCE_NP_COMMERCE2_PRODUCT_CODE_BLOCK_LEN + 1];
+	s8 padding1[3];
+	s8 code2[SCE_NP_COMMERCE2_PRODUCT_CODE_BLOCK_LEN + 1];
+	s8 padding2[3];
+	s8 code3[SCE_NP_COMMERCE2_PRODUCT_CODE_BLOCK_LEN + 1];
+	s8 padding3[3];
+};
+
+struct SceNpCommerce2GetCategoryContentsResult
+{
+	SceNpCommerce2CommonData commonData;
+	SceNpCommerce2Range rangeOfContents;
+};
+
+using SceNpCommerce2Handler = void(u32 ctx_id, u32 subject_id, s32 event, s32 error_code, vm::ptr<void> arg);

ps3fw/include/rpcsx/fw/ps3/sceNpPlus.h

@@ -0,0 +1,3 @@
+#pragma once
+
+error_code sceNpManagerIsSP();

ps3fw/include/rpcsx/fw/ps3/sceNpSns.h

@@ -0,0 +1,88 @@
+#pragma once
+
+#include "Emu/Memory/vm_ptr.h"
+
+// Return codes
+enum sceNpSnsError : u32
+{
+	SCE_NP_SNS_ERROR_UNKNOWN = 0x80024501,
+	SCE_NP_SNS_ERROR_NOT_SIGN_IN = 0x80024502,
+	SCE_NP_SNS_ERROR_INVALID_ARGUMENT = 0x80024503,
+	SCE_NP_SNS_ERROR_OUT_OF_MEMORY = 0x80024504,
+	SCE_NP_SNS_ERROR_SHUTDOWN = 0x80024505,
+	SCE_NP_SNS_ERROR_BUSY = 0x80024506,
+	SCE_NP_SNS_FB_ERROR_ALREADY_INITIALIZED = 0x80024511,
+	SCE_NP_SNS_FB_ERROR_NOT_INITIALIZED = 0x80024512,
+	SCE_NP_SNS_FB_ERROR_EXCEEDS_MAX = 0x80024513,
+	SCE_NP_SNS_FB_ERROR_UNKNOWN_HANDLE = 0x80024514,
+	SCE_NP_SNS_FB_ERROR_ABORTED = 0x80024515,
+	SCE_NP_SNS_FB_ERROR_ALREADY_ABORTED = 0x80024516,
+	SCE_NP_SNS_FB_ERROR_CONFIG_DISABLED = 0x80024517,
+	SCE_NP_SNS_FB_ERROR_FBSERVER_ERROR_RESPONSE = 0x80024518,
+	SCE_NP_SNS_FB_ERROR_THROTTLE_CLOSED = 0x80024519,
+	SCE_NP_SNS_FB_ERROR_OPERATION_INTERVAL_VIOLATION = 0x8002451a,
+	SCE_NP_SNS_FB_ERROR_UNLOADED_THROTTLE = 0x8002451b,
+	SCE_NP_SNS_FB_ERROR_ACCESS_NOT_ALLOWED = 0x8002451c,
+};
+
+// Access token param options
+enum
+{
+	SCE_NP_SNS_FB_ACCESS_TOKEN_PARAM_OPTIONS_SILENT = 0x00000001
+};
+
+// Constants for SNS functions
+enum
+{
+	SCE_NP_SNS_FB_INVALID_HANDLE = 0,
+	SCE_NP_SNS_FB_HANDLE_SLOT_MAX = 4,
+	SCE_NP_SNS_FB_PERMISSIONS_LENGTH_MAX = 255,
+	SCE_NP_SNS_FB_ACCESS_TOKEN_LENGTH_MAX = 255,
+	SCE_NP_SNS_FB_LONG_ACCESS_TOKEN_LENGTH_MAX = 4096
+};
+
+struct sns_fb_handle_t
+{
+	static const u32 id_base = 1;
+	static const u32 id_step = 1;
+	static const u32 id_count = SCE_NP_SNS_FB_HANDLE_SLOT_MAX + 1;
+	static const u32 invalid = SCE_NP_SNS_FB_INVALID_HANDLE;
+
+	SAVESTATE_INIT_POS(20);
+	sns_fb_handle_t() = default;
+	sns_fb_handle_t(utils::serial&) {}
+	void save(utils::serial&) {}
+};
+
+// Initialization parameters for functionalities coordinated with Facebook
+struct SceNpSnsFbInitParams
+{
+	vm::bptr<void> pool;
+	be_t<u32> poolSize;
+};
+
+struct SceNpSnsFbAccessTokenParam
+{
+	be_t<u64> fb_app_id;
+	char permissions[SCE_NP_SNS_FB_PERMISSIONS_LENGTH_MAX + 1];
+	be_t<u32> options;
+};
+
+struct SceNpSnsFbAccessTokenResult
+{
+	be_t<u64> expiration;
+	char access_token[SCE_NP_SNS_FB_ACCESS_TOKEN_LENGTH_MAX + 1];
+};
+
+struct SceNpSnsFbLongAccessTokenResult
+{
+	be_t<u64> expiration;
+	char access_token[SCE_NP_SNS_FB_LONG_ACCESS_TOKEN_LENGTH_MAX + 1];
+};
+
+// fxm objects
+
+struct sce_np_sns_manager
+{
+	atomic_t<bool> is_initialized = false;
+};

ps3fw/include/rpcsx/fw/ps3/sceNpTrophy.h

@@ -0,0 +1,177 @@
+#pragma once
+
+#include "util/types.hpp"
+#include "Emu/Memory/vm_ptr.h"
+#include "Emu/Cell/ErrorCodes.h"
+#include <mutex>
+#include <vector>
+#include <mutex>
+
+// Error codes
+enum SceNpTrophyError : u32
+{
+	SCE_NP_TROPHY_ERROR_ALREADY_INITIALIZED = 0x80022901,
+	SCE_NP_TROPHY_ERROR_NOT_INITIALIZED = 0x80022902,
+	SCE_NP_TROPHY_ERROR_NOT_SUPPORTED = 0x80022903,
+	SCE_NP_TROPHY_ERROR_CONTEXT_NOT_REGISTERED = 0x80022904,
+	SCE_NP_TROPHY_ERROR_OUT_OF_MEMORY = 0x80022905,
+	SCE_NP_TROPHY_ERROR_INVALID_ARGUMENT = 0x80022906,
+	SCE_NP_TROPHY_ERROR_EXCEEDS_MAX = 0x80022907,
+	SCE_NP_TROPHY_ERROR_INSUFFICIENT = 0x80022909,
+	SCE_NP_TROPHY_ERROR_UNKNOWN_CONTEXT = 0x8002290a,
+	SCE_NP_TROPHY_ERROR_INVALID_FORMAT = 0x8002290b,
+	SCE_NP_TROPHY_ERROR_BAD_RESPONSE = 0x8002290c,
+	SCE_NP_TROPHY_ERROR_INVALID_GRADE = 0x8002290d,
+	SCE_NP_TROPHY_ERROR_INVALID_CONTEXT = 0x8002290e,
+	SCE_NP_TROPHY_ERROR_PROCESSING_ABORTED = 0x8002290f,
+	SCE_NP_TROPHY_ERROR_ABORT = 0x80022910,
+	SCE_NP_TROPHY_ERROR_UNKNOWN_HANDLE = 0x80022911,
+	SCE_NP_TROPHY_ERROR_LOCKED = 0x80022912,
+	SCE_NP_TROPHY_ERROR_HIDDEN = 0x80022913,
+	SCE_NP_TROPHY_ERROR_CANNOT_UNLOCK_PLATINUM = 0x80022914,
+	SCE_NP_TROPHY_ERROR_ALREADY_UNLOCKED = 0x80022915,
+	SCE_NP_TROPHY_ERROR_INVALID_TYPE = 0x80022916,
+	SCE_NP_TROPHY_ERROR_INVALID_HANDLE = 0x80022917,
+	SCE_NP_TROPHY_ERROR_INVALID_NP_COMM_ID = 0x80022918,
+	SCE_NP_TROPHY_ERROR_UNKNOWN_NP_COMM_ID = 0x80022919,
+	SCE_NP_TROPHY_ERROR_DISC_IO = 0x8002291a,
+	SCE_NP_TROPHY_ERROR_CONF_DOES_NOT_EXIST = 0x8002291b,
+	SCE_NP_TROPHY_ERROR_UNSUPPORTED_FORMAT = 0x8002291c,
+	SCE_NP_TROPHY_ERROR_ALREADY_INSTALLED = 0x8002291d,
+	SCE_NP_TROPHY_ERROR_BROKEN_DATA = 0x8002291e,
+	SCE_NP_TROPHY_ERROR_VERIFICATION_FAILURE = 0x8002291f,
+	SCE_NP_TROPHY_ERROR_INVALID_TROPHY_ID = 0x80022920,
+	SCE_NP_TROPHY_ERROR_UNKNOWN_TROPHY_ID = 0x80022921,
+	SCE_NP_TROPHY_ERROR_UNKNOWN_TITLE = 0x80022922,
+	SCE_NP_TROPHY_ERROR_UNKNOWN_FILE = 0x80022923,
+	SCE_NP_TROPHY_ERROR_DISC_NOT_MOUNTED = 0x80022924,
+	SCE_NP_TROPHY_ERROR_SHUTDOWN = 0x80022925,
+	SCE_NP_TROPHY_ERROR_TITLE_ICON_NOT_FOUND = 0x80022926,
+	SCE_NP_TROPHY_ERROR_TROPHY_ICON_NOT_FOUND = 0x80022927,
+	SCE_NP_TROPHY_ERROR_INSUFFICIENT_DISK_SPACE = 0x80022928,
+	SCE_NP_TROPHY_ERROR_ILLEGAL_UPDATE = 0x8002292a,
+	SCE_NP_TROPHY_ERROR_SAVEDATA_USER_DOES_NOT_MATCH = 0x8002292b,
+	SCE_NP_TROPHY_ERROR_TROPHY_ID_DOES_NOT_EXIST = 0x8002292c,
+	SCE_NP_TROPHY_ERROR_SERVICE_UNAVAILABLE = 0x8002292d,
+	SCE_NP_TROPHY_ERROR_UNKNOWN = 0x800229ff,
+};
+
+enum
+{
+	SCE_NP_TROPHY_TITLE_MAX_SIZE = 128,
+	SCE_NP_TROPHY_GAME_DESCR_MAX_SIZE = 1024,
+	SCE_NP_TROPHY_NAME_MAX_SIZE = 128,
+	SCE_NP_TROPHY_DESCR_MAX_SIZE = 1024,
+
+	SCE_NP_TROPHY_FLAG_SETSIZE = 128,
+	SCE_NP_TROPHY_FLAG_BITS_SHIFT = 5,
+
+	SCE_NP_TROPHY_INVALID_CONTEXT = 0,
+	SCE_NP_TROPHY_INVALID_HANDLE = 0,
+};
+
+enum : u32
+{
+	SCE_NP_TROPHY_INVALID_TROPHY_ID = 0xffffffff,
+};
+
+enum SceNpTrophyGrade
+{
+	SCE_NP_TROPHY_GRADE_UNKNOWN = 0,
+	SCE_NP_TROPHY_GRADE_PLATINUM = 1,
+	SCE_NP_TROPHY_GRADE_GOLD = 2,
+	SCE_NP_TROPHY_GRADE_SILVER = 3,
+	SCE_NP_TROPHY_GRADE_BRONZE = 4,
+};
+
+enum
+{
+	SCE_NP_TROPHY_OPTIONS_CREATE_CONTEXT_READ_ONLY = 1,
+
+	SCE_NP_TROPHY_OPTIONS_REGISTER_CONTEXT_SHOW_ERROR_EXIT = 1
+};
+
+struct SceNpTrophyGameDetails
+{
+	be_t<u32> numTrophies;
+	be_t<u32> numPlatinum;
+	be_t<u32> numGold;
+	be_t<u32> numSilver;
+	be_t<u32> numBronze;
+	char title[SCE_NP_TROPHY_TITLE_MAX_SIZE];
+	char description[SCE_NP_TROPHY_GAME_DESCR_MAX_SIZE];
+	u8 reserved[4];
+};
+
+struct SceNpTrophyGameData
+{
+	be_t<u32> unlockedTrophies;
+	be_t<u32> unlockedPlatinum;
+	be_t<u32> unlockedGold;
+	be_t<u32> unlockedSilver;
+	be_t<u32> unlockedBronze;
+};
+
+struct SceNpTrophyDetails
+{
+	be_t<s32> trophyId;    // SceNpTrophyId
+	be_t<u32> trophyGrade; // SceNpTrophyGrade
+	char name[SCE_NP_TROPHY_NAME_MAX_SIZE];
+	char description[SCE_NP_TROPHY_DESCR_MAX_SIZE];
+	b8 hidden;
+	u8 reserved[3];
+};
+
+struct SceNpTrophyData
+{
+	be_t<u64> timestamp; // CellRtcTick
+	be_t<s32> trophyId;  // SceNpTrophyId
+	b8 unlocked;
+	u8 reserved[3];
+};
+
+struct SceNpTrophyFlagArray
+{
+	be_t<u32> flag_bits[SCE_NP_TROPHY_FLAG_SETSIZE >> SCE_NP_TROPHY_FLAG_BITS_SHIFT];
+};
+
+enum
+{
+	SCE_NP_TROPHY_STATUS_UNKNOWN = 0,
+	SCE_NP_TROPHY_STATUS_NOT_INSTALLED = 1,
+	SCE_NP_TROPHY_STATUS_DATA_CORRUPT = 2,
+	SCE_NP_TROPHY_STATUS_INSTALLED = 3,
+	SCE_NP_TROPHY_STATUS_REQUIRES_UPDATE = 4,
+
+	SCE_NP_TROPHY_STATUS_PROCESSING_SETUP = 5,
+	SCE_NP_TROPHY_STATUS_PROCESSING_PROGRESS = 6,
+	SCE_NP_TROPHY_STATUS_PROCESSING_FINALIZE = 7,
+
+	SCE_NP_TROPHY_STATUS_PROCESSING_COMPLETE = 8,
+
+	SCE_NP_TROPHY_STATUS_CHANGES_DETECTED = 9,
+};
+
+enum : u32
+{
+	NP_TROPHY_COMM_SIGN_MAGIC = 0xB9DDE13B,
+};
+
+using SceNpTrophyStatusCallback = s32(u32 context, u32 status, s32 completed, s32 total, vm::ptr<void> arg);
+
+// Forward declare this function since trophyunlock needs it
+error_code sceNpTrophyGetTrophyInfo(u32 context, u32 handle, s32 trophyId, vm::ptr<SceNpTrophyDetails> details, vm::ptr<SceNpTrophyData> data);
+
+class TrophyNotificationBase
+{
+public:
+	virtual ~TrophyNotificationBase();
+
+	virtual s32 ShowTrophyNotification(const SceNpTrophyDetails& trophy, const std::vector<uchar>& trophyIconBfr) = 0;
+};
+
+struct current_trophy_name
+{
+	std::mutex mtx;
+	std::string name;
+};

ps3fw/include/rpcsx/fw/ps3/sceNpTus.h

@@ -0,0 +1,173 @@
+#pragma once
+
+#include "cellRtc.h"
+#include "sceNp.h"
+
+#include <map>
+
+// Constants for TUS functions and structures
+enum
+{
+	SCE_NP_TUS_DATA_INFO_MAX_SIZE = 384,
+	SCE_NP_TUS_MAX_CTX_NUM = 32,
+	SCE_NP_TUS_MAX_SLOT_NUM_PER_TRANS = 64,
+	SCE_NP_TUS_MAX_USER_NUM_PER_TRANS = 101,
+	SCE_NP_TUS_MAX_SELECTED_FRIENDS_NUM = 100,
+};
+
+enum
+{
+	SCE_NP_TUS_OPETYPE_EQUAL = 1,
+	SCE_NP_TUS_OPETYPE_NOT_EQUAL,
+	SCE_NP_TUS_OPETYPE_GREATER_THAN,
+	SCE_NP_TUS_OPETYPE_GREATER_OR_EQUAL,
+	SCE_NP_TUS_OPETYPE_LESS_THAN,
+	SCE_NP_TUS_OPETYPE_LESS_OR_EQUAL
+};
+
+enum
+{
+	SCE_NP_TUS_VARIABLE_SORTTYPE_DESCENDING_DATE = 1,
+	SCE_NP_TUS_VARIABLE_SORTTYPE_ASCENDING_DATE,
+	SCE_NP_TUS_VARIABLE_SORTTYPE_DESCENDING_VALUE,
+	SCE_NP_TUS_VARIABLE_SORTTYPE_ASCENDING_VALUE
+};
+
+enum
+{
+	SCE_NP_TUS_DATASTATUS_SORTTYPE_DESCENDING_DATE = 1,
+	SCE_NP_TUS_DATASTATUS_SORTTYPE_ASCENDING_DATE
+};
+
+enum SceNpTssStatusCodeType
+{
+	SCE_NP_TSS_STATUS_TYPE_OK,
+	SCE_NP_TSS_STATUS_TYPE_PARTIAL,
+	SCE_NP_TSS_STATUS_TYPE_NOT_MODIFIED
+};
+
+enum SceNpTssIfType
+{
+	SCE_NP_TSS_IFTYPE_IF_MODIFIED_SINCE,
+	SCE_NP_TSS_IFTYPE_IF_RANGE
+};
+
+using SceNpTssSlotId = s32;
+using SceNpTusSlotId = s32;
+using SceNpTusVirtualUserId = SceNpOnlineId;
+
+// Structure for representing a TUS variable
+struct SceNpTusVariable
+{
+	SceNpId ownerId;
+	be_t<s32> hasData;
+	CellRtcTick lastChangedDate;
+	u8 pad[4];
+	SceNpId lastChangedAuthorId;
+	be_t<s64> variable;
+	be_t<s64> oldVariable;
+	u8 reserved[16];
+};
+
+// Structure for representing the accessory information of a TUS data
+struct SceNpTusDataInfo
+{
+	be_t<u32> infoSize;
+	u8 pad[4];
+	u8 data[SCE_NP_TUS_DATA_INFO_MAX_SIZE];
+};
+
+// Structure for respreseting the status of TUS data
+struct SceNpTusDataStatus
+{
+	SceNpId ownerId;
+	be_t<s32> hasData;
+	CellRtcTick lastChangedDate;
+	SceNpId lastChangedAuthorId;
+	vm::bptr<void> data;
+	be_t<u32> dataSize;
+	u8 pad[4];
+	SceNpTusDataInfo info;
+};
+
+struct SceNpTusAddAndGetVariableOptParam
+{
+	be_t<u32> size;
+	vm::bptr<CellRtcTick> isLastChangedDate;
+	vm::bptr<SceNpId> isLastChangedAuthorId;
+};
+
+struct SceNpTusTryAndSetVariableOptParam
+{
+	be_t<u32> size;
+	vm::bptr<CellRtcTick> isLastChangedDate;
+	vm::bptr<SceNpId> isLastChangedAuthorId;
+	vm::bptr<s64> compareValue;
+};
+
+struct SceNpTusSetDataOptParam
+{
+	be_t<u32> size;
+	vm::bptr<CellRtcTick> isLastChangedDate;
+	vm::bptr<SceNpId> isLastChangedAuthorId;
+};
+
+struct SceNpTssDataStatus
+{
+	CellRtcTick lastModified;
+	be_t<s32> statusCodeType;
+	be_t<u32> contentLength;
+};
+
+struct SceNpTssIfModifiedSinceParam
+{
+	be_t<s32> ifType;
+	u8 padding[4];
+	CellRtcTick lastModified;
+};
+
+struct SceNpTssGetDataOptParam
+{
+	be_t<u32> size;
+	vm::bptr<u64> offset;
+	vm::bptr<u64> lastByte;
+	vm::bptr<SceNpTssIfModifiedSinceParam> ifParam;
+};
+
+// fxm objects
+
+struct sce_np_tus_transaction_context
+{
+	s32 id = 0;
+	u32 timeout = 0;
+	bool abort = false;
+};
+
+struct sce_np_tus_title_context
+{
+	std::map<s32 /*transaction_context_id*/, sce_np_tus_transaction_context> transaction_contexts;
+};
+
+struct sce_np_tus_manager
+{
+private:
+	s32 next_title_context_id = 1;
+	s32 next_transaction_context_id = 1;
+	std::map<s32 /*title_context_id*/, sce_np_tus_title_context> title_contexts;
+
+public:
+	std::mutex mtx;
+	atomic_t<bool> is_initialized = false;
+
+	s32 add_title_context();
+	bool check_title_context_id(s32 titleCtxId);
+	bool remove_title_context_id(s32 titleCtxId);
+	sce_np_tus_title_context* get_title_context(s32 titleCtxId);
+
+	s32 add_transaction_context(s32 titleCtxId);
+	bool check_transaction_context_id(s32 transId);
+	bool remove_transaction_context_id(s32 transId);
+	sce_np_tus_transaction_context* get_transaction_context(s32 transId);
+
+	void terminate();
+};

ps3fw/include/rpcsx/fw/ps3/sceNpUtil.h

@@ -0,0 +1,16 @@
+#pragma once
+
+enum
+{
+	SCE_NP_UTIL_BANDWIDTH_TEST_STATUS_NONE = 0,
+	SCE_NP_UTIL_BANDWIDTH_TEST_STATUS_RUNNING = 1,
+	SCE_NP_UTIL_BANDWIDTH_TEST_STATUS_FINISHED = 2
+};
+
+struct SceNpUtilBandwidthTestResult
+{
+	be_t<f64> upload_bps;
+	be_t<f64> download_bps;
+	be_t<s32> result;
+	s8 padding[4];
+};

ps3fw/include/rpcsx/fw/ps3/sysPrxForUser.h

@@ -0,0 +1,65 @@
+#pragma once
+
+#include "Emu/Memory/vm_ptr.h"
+#include "Emu/Cell/ErrorCodes.h"
+
+enum
+{
+	RANDOM_NUMBER_MAX_SIZE = 4096
+};
+
+using spu_printf_cb_t = vm::ptr<s32(u32 arg)>;
+
+// Aux
+
+extern spu_printf_cb_t g_spu_printf_agcb;
+extern spu_printf_cb_t g_spu_printf_dgcb;
+extern spu_printf_cb_t g_spu_printf_atcb;
+extern spu_printf_cb_t g_spu_printf_dtcb;
+
+// Functions
+
+vm::ptr<void> _sys_memset(vm::ptr<void> dst, s32 value, u32 size);
+
+struct sys_lwmutex_t;
+struct sys_lwmutex_attribute_t;
+
+error_code sys_lwmutex_create(ppu_thread& ppu, vm::ptr<sys_lwmutex_t> lwmutex, vm::ptr<sys_lwmutex_attribute_t> attr);
+error_code sys_lwmutex_lock(ppu_thread& CPU, vm::ptr<sys_lwmutex_t> lwmutex, u64 timeout);
+error_code sys_lwmutex_trylock(ppu_thread& CPU, vm::ptr<sys_lwmutex_t> lwmutex);
+error_code sys_lwmutex_unlock(ppu_thread& CPU, vm::ptr<sys_lwmutex_t> lwmutex);
+error_code sys_lwmutex_destroy(ppu_thread& CPU, vm::ptr<sys_lwmutex_t> lwmutex);
+
+struct sys_lwmutex_locker
+{
+	ppu_thread& ppu;
+	vm::ptr<sys_lwmutex_t> mutex;
+
+	sys_lwmutex_locker(ppu_thread& ppu, vm::ptr<sys_lwmutex_t> mutex)
+		: ppu(ppu), mutex(mutex)
+	{
+		ensure(sys_lwmutex_lock(ppu, mutex, 0) == CELL_OK);
+	}
+
+	~sys_lwmutex_locker() noexcept(false)
+	{
+		ensure(sys_lwmutex_unlock(ppu, mutex) == CELL_OK);
+	}
+};
+
+struct sys_lwcond_t;
+struct sys_lwcond_attribute_t;
+
+error_code sys_lwcond_create(ppu_thread& ppu, vm::ptr<sys_lwcond_t> lwcond, vm::ptr<sys_lwmutex_t> lwmutex, vm::ptr<sys_lwcond_attribute_t> attr);
+error_code sys_lwcond_destroy(ppu_thread& ppu, vm::ptr<sys_lwcond_t> lwcond);
+error_code sys_lwcond_signal(ppu_thread& CPU, vm::ptr<sys_lwcond_t> lwcond);
+error_code sys_lwcond_signal_all(ppu_thread& CPU, vm::ptr<sys_lwcond_t> lwcond);
+error_code sys_lwcond_signal_to(ppu_thread& CPU, vm::ptr<sys_lwcond_t> lwcond, u64 ppu_thread_id);
+error_code sys_lwcond_wait(ppu_thread& CPU, vm::ptr<sys_lwcond_t> lwcond, u64 timeout);
+
+error_code sys_ppu_thread_create(ppu_thread& ppu, vm::ptr<u64> thread_id, u32 entry, u64 arg, s32 prio, u32 stacksize, u64 flags, vm::cptr<char> threadname);
+error_code sys_interrupt_thread_disestablish(ppu_thread& ppu, u32 ih);
+
+void sys_ppu_thread_exit(ppu_thread& CPU, u64 val);
+void sys_game_process_exitspawn(ppu_thread& ppu, vm::cptr<char> path, vm::cpptr<char> argv, vm::cpptr<char> envp, u32 data, u32 data_size, s32 prio, u64 flags);
+void sys_game_process_exitspawn2(ppu_thread& ppu, vm::cptr<char> path, vm::cpptr<char> argv, vm::cpptr<char> envp, u32 data, u32 data_size, s32 prio, u64 flags);

ps3fw/include/rpcsx/fw/ps3/sys_crashdump.h

@@ -0,0 +1,15 @@
+#pragma once
+#include "Emu/Memory/vm_ptr.h"
+
+enum
+{
+	SYS_CRASH_DUMP_MAX_LABEL_SIZE = 16,
+	SYS_CRASH_DUMP_MAX_LOG_AREA = 127 // not actually defined in CELL
+};
+
+struct sys_crash_dump_log_area_info_t
+{
+	char label[SYS_CRASH_DUMP_MAX_LABEL_SIZE]; // 15 + 1 (0 terminated)
+	vm::bptr<void> addr;
+	be_t<u32> size;
+};

ps3fw/include/rpcsx/fw/ps3/sys_lv2dbg.h

@@ -0,0 +1,290 @@
+#pragma once
+
+#include "Emu/Cell/lv2/sys_mutex.h"
+#include "Emu/Cell/lv2/sys_cond.h"
+#include "Emu/Cell/lv2/sys_rwlock.h"
+#include "Emu/Cell/lv2/sys_event.h"
+#include "Emu/Cell/lv2/sys_semaphore.h"
+#include "Emu/Cell/lv2/sys_lwmutex.h"
+#include "Emu/Cell/lv2/sys_lwcond.h"
+#include "Emu/Cell/lv2/sys_event_flag.h"
+
+#include "Emu/Memory/vm_ptr.h"
+
+// Error Codes
+enum CellLv2DbgError : u32
+{
+	CELL_LV2DBG_ERROR_DEINVALIDPROCESSID = 0x80010401,
+	CELL_LV2DBG_ERROR_DEINVALIDTHREADID = 0x80010402,
+	CELL_LV2DBG_ERROR_DEILLEGALREGISTERTYPE = 0x80010403,
+	CELL_LV2DBG_ERROR_DEILLEGALREGISTERNUMBER = 0x80010404,
+	CELL_LV2DBG_ERROR_DEILLEGALTHREADSTATE = 0x80010405,
+	CELL_LV2DBG_ERROR_DEINVALIDEFFECTIVEADDRESS = 0x80010406,
+	CELL_LV2DBG_ERROR_DENOTFOUNDPROCESSID = 0x80010407,
+	CELL_LV2DBG_ERROR_DENOMEM = 0x80010408,
+	CELL_LV2DBG_ERROR_DEINVALIDARGUMENTS = 0x80010409,
+	CELL_LV2DBG_ERROR_DENOTFOUNDFILE = 0x8001040a,
+	CELL_LV2DBG_ERROR_DEINVALIDFILETYPE = 0x8001040b,
+	CELL_LV2DBG_ERROR_DENOTFOUNDTHREADID = 0x8001040c,
+	CELL_LV2DBG_ERROR_DEINVALIDTHREADSTATUS = 0x8001040d,
+	CELL_LV2DBG_ERROR_DENOAVAILABLEPROCESSID = 0x8001040e,
+	CELL_LV2DBG_ERROR_DENOTFOUNDEVENTHANDLER = 0x8001040f,
+	CELL_LV2DBG_ERROR_DESPNOROOM = 0x80010410,
+	CELL_LV2DBG_ERROR_DESPNOTFOUND = 0x80010411,
+	CELL_LV2DBG_ERROR_DESPINPROCESS = 0x80010412,
+	CELL_LV2DBG_ERROR_DEINVALIDPRIMARYSPUTHREADID = 0x80010413,
+	CELL_LV2DBG_ERROR_DETHREADSTATEISNOTSTOPPED = 0x80010414,
+	CELL_LV2DBG_ERROR_DEINVALIDTHREADTYPE = 0x80010415,
+	CELL_LV2DBG_ERROR_DECONTINUEFAILED = 0x80010416,
+	CELL_LV2DBG_ERROR_DESTOPFAILED = 0x80010417,
+	CELL_LV2DBG_ERROR_DENOEXCEPTION = 0x80010418,
+	CELL_LV2DBG_ERROR_DENOMOREEVENTQUE = 0x80010419,
+	CELL_LV2DBG_ERROR_DEEVENTQUENOTCREATED = 0x8001041a,
+	CELL_LV2DBG_ERROR_DEEVENTQUEOVERFLOWED = 0x8001041b,
+	CELL_LV2DBG_ERROR_DENOTIMPLEMENTED = 0x8001041c,
+	CELL_LV2DBG_ERROR_DEQUENOTREGISTERED = 0x8001041d,
+	CELL_LV2DBG_ERROR_DENOMOREEVENTPROCESS = 0x8001041e,
+	CELL_LV2DBG_ERROR_DEPROCESSNOTREGISTERED = 0x8001041f,
+	CELL_LV2DBG_ERROR_DEEVENTDISCARDED = 0x80010420,
+	CELL_LV2DBG_ERROR_DENOMORESYNCID = 0x80010421,
+	CELL_LV2DBG_ERROR_DESYNCIDALREADYADDED = 0x80010422,
+	CELL_LV2DBG_ERROR_DESYNCIDNOTFOUND = 0x80010423,
+	CELL_LV2DBG_ERROR_DESYNCIDNOTACQUIRED = 0x80010424,
+	CELL_LV2DBG_ERROR_DEPROCESSALREADYREGISTERED = 0x80010425,
+	CELL_LV2DBG_ERROR_DEINVALIDLSADDRESS = 0x80010426,
+	CELL_LV2DBG_ERROR_DEINVALIDOPERATION = 0x80010427,
+	CELL_LV2DBG_ERROR_DEINVALIDMODULEID = 0x80010428,
+	CELL_LV2DBG_ERROR_DEHANDLERALREADYREGISTERED = 0x80010429,
+	CELL_LV2DBG_ERROR_DEINVALIDHANDLER = 0x8001042a,
+	CELL_LV2DBG_ERROR_DEHANDLENOTREGISTERED = 0x8001042b,
+	CELL_LV2DBG_ERROR_DEOPERATIONDENIED = 0x8001042c,
+	CELL_LV2DBG_ERROR_DEHANDLERNOTINITIALIZED = 0x8001042d,
+	CELL_LV2DBG_ERROR_DEHANDLERALREADYINITIALIZED = 0x8001042e,
+	CELL_LV2DBG_ERROR_DEILLEGALCOREDUMPPARAMETER = 0x8001042f,
+};
+
+enum : u64
+{
+	SYS_DBG_PPU_THREAD_STOP = 0x0000000000000001ull,
+	SYS_DBG_SPU_THREAD_GROUP_STOP = 0x0000000000000002ull,
+	SYS_DBG_SYSTEM_PPU_THREAD_NOT_STOP = 0x0000000000000004ull,
+	SYS_DBG_SYSTEM_SPU_THREAD_GROUP_NOT_STOP = 0x0000000000000008ull,
+	SYS_DBG_NOT_EXE_CTRL_BY_COREDUMP_EVENT = 0x0000000000000010ull,
+};
+
+enum : u64
+{
+	SYS_DBG_PPU_EXCEPTION_TRAP = 0x0000000001000000ull,
+	SYS_DBG_PPU_EXCEPTION_PREV_INST = 0x0000000002000000ull,
+	SYS_DBG_PPU_EXCEPTION_ILL_INST = 0x0000000004000000ull,
+	SYS_DBG_PPU_EXCEPTION_TEXT_HTAB_MISS = 0x0000000008000000ull,
+	SYS_DBG_PPU_EXCEPTION_TEXT_SLB_MISS = 0x0000000010000000ull,
+	SYS_DBG_PPU_EXCEPTION_DATA_HTAB_MISS = 0x0000000020000000ull,
+	SYS_DBG_PPU_EXCEPTION_DATA_SLB_MISS = 0x0000000040000000ull,
+	SYS_DBG_PPU_EXCEPTION_FLOAT = 0x0000000080000000ull,
+	SYS_DBG_PPU_EXCEPTION_DABR_MATCH = 0x0000000100000000ull,
+	SYS_DBG_PPU_EXCEPTION_ALIGNMENT = 0x0000000200000000ull,
+	SYS_DBG_PPU_EXCEPTION_DATA_MAT = 0x0000002000000000ull,
+};
+
+enum : u64
+{
+	SYS_DBG_EVENT_CORE_DUMPED = 0x0000000000001000ull,
+	SYS_DBG_EVENT_PPU_EXCEPTION_HANDLER_SIGNALED = 0x0000000000002000ull,
+};
+
+union sys_dbg_vr_t
+{
+	u8 byte[16];
+	be_t<u16> halfword[8];
+	be_t<u32> word[8];
+	be_t<u64> dw[2];
+};
+
+struct sys_dbg_ppu_thread_context_t
+{
+	be_t<u64> gpr[32];
+	be_t<u32> cr;
+	be_t<u64> xer;
+	be_t<u64> lr;
+	be_t<u64> ctr;
+	be_t<u64> pc;
+	be_t<u64> fpr[32];
+	be_t<u32> fpscr;
+	sys_dbg_vr_t vr[32];
+	sys_dbg_vr_t vscr;
+};
+
+union sys_dbg_spu_gpr_t
+{
+	u8 byte[16];
+	be_t<u16> halfword[8];
+	be_t<u32> word[4];
+	be_t<u64> dw[2];
+};
+
+union sys_dbg_spu_fpscr_t
+{
+	u8 byte[16];
+	be_t<u16> halfword[8];
+	be_t<u32> word[4];
+	be_t<u64> dw[2];
+};
+
+struct sys_dbg_spu_thread_context_t
+{
+	sys_dbg_spu_gpr_t gpr[128];
+	be_t<u32> npc;
+	be_t<u32> fpscr;
+	be_t<u32> srr0;
+	be_t<u32> spu_status;
+	be_t<u64> spu_cfg;
+	be_t<u32> mb_stat;
+	be_t<u32> ppu_mb;
+	be_t<u32> spu_mb[4];
+	be_t<u32> decrementer;
+	be_t<u64> mfc_cq_sr[96];
+};
+
+struct sys_dbg_spu_thread_context2_t
+{
+	sys_dbg_spu_gpr_t gpr[128];
+	be_t<u32> npc;
+	sys_dbg_spu_fpscr_t fpscr;
+	be_t<u32> srr0;
+	be_t<u32> spu_status;
+	be_t<u64> spu_cfg;
+	be_t<u32> mb_stat;
+	be_t<u32> ppu_mb;
+	be_t<u32> spu_mb[4];
+	be_t<u32> decrementer;
+	be_t<u64> mfc_cq_sr[96];
+};
+
+struct sys_dbg_mutex_information_t
+{
+	sys_mutex_attribute_t attr;
+	be_t<u64> owner;
+	be_t<s32> lock_counter;
+	be_t<s32> cond_ref_counter;
+	be_t<u32> cond_id; // zero
+	vm::bptr<u64> wait_id_list;
+	be_t<u32> wait_threads_num;
+	be_t<u32> wait_all_threads_num;
+};
+
+struct sys_dbg_cond_information_t
+{
+	sys_cond_attribute_t attr;
+	be_t<u32> mutex_id;
+	vm::bptr<u64> wait_id_list;
+	be_t<u32> wait_threads_num;
+	be_t<u32> wait_all_threads_num;
+};
+
+struct sys_dbg_rwlock_information_t
+{
+	sys_rwlock_attribute_t attr;
+	be_t<u64> owner;
+	vm::bptr<u64> r_wait_id_list;
+	be_t<u32> r_wait_threads_num;
+	be_t<u32> r_wait_all_threads_num;
+	vm::bptr<u64> w_wait_id_list;
+	be_t<u32> w_wait_threads_num;
+	be_t<u32> w_wait_all_threads_num;
+};
+
+struct sys_dbg_event_queue_information_t
+{
+	sys_event_queue_attribute_t attr;
+	be_t<u64> event_queue_key;
+	be_t<s32> queue_size;
+	vm::bptr<u64> wait_id_list;
+	be_t<u32> wait_threads_num;
+	be_t<u32> wait_all_threads_num;
+	vm::bptr<sys_event_t> equeue_list;
+	be_t<u32> readable_equeue_num;
+	be_t<u32> readable_all_equeue_num;
+};
+
+struct sys_dbg_semaphore_information_t
+{
+	sys_semaphore_attribute_t attr;
+	be_t<s32> max_val;
+	be_t<s32> cur_val;
+	vm::bptr<u64> wait_id_list;
+	be_t<u32> wait_threads_num;
+	be_t<u32> wait_all_threads_num;
+};
+
+struct sys_dbg_lwmutex_information_t
+{
+	sys_lwmutex_attribute_t attr;
+	be_t<u64> owner;
+	be_t<s32> lock_counter;
+	vm::bptr<u64> wait_id_list;
+	be_t<u32> wait_threads_num;
+	be_t<u32> wait_all_threads_num;
+};
+
+struct sys_dbg_lwcond_information_t
+{
+	sys_lwcond_attribute_t attr;
+	vm::bptr<sys_lwmutex_t> lwmutex;
+	vm::bptr<u64> wait_id_list;
+	be_t<u32> wait_threads_num;
+	be_t<u32> wait_all_threads_num;
+};
+
+struct sys_dbg_event_flag_wait_information_t
+{
+	be_t<u64> bitptn;
+	be_t<u32> mode;
+};
+
+struct sys_dbg_event_flag_information_t
+{
+	sys_event_flag_attribute_t attr;
+	be_t<u64> cur_bitptn;
+	vm::bptr<u64> wait_id_list;
+	vm::bptr<sys_dbg_event_flag_wait_information_t> wait_info_list;
+	be_t<u32> wait_threads_num;
+	be_t<u32> wait_all_threads_num;
+};
+
+using dbg_exception_handler_t = void(u64 exception_type, u64 thread_id, u64 dar);
+
+enum : u64
+{
+	SYS_VM_STATE_LOCKED = 0x0008ull,
+	SYS_VM_STATE_DIRTY = 0x0010ull,
+};
+
+struct sys_vm_page_information_t
+{
+	be_t<u64> state;
+};
+
+enum : u64
+{
+	SYS_DBG_DABR_CTRL_READ = 0x0000000000000005ull,
+	SYS_DBG_DABR_CTRL_WRITE = 0x0000000000000006ull,
+	SYS_DBG_DABR_CTRL_CLEAR = 0x0000000000000000ull,
+};
+
+enum
+{
+	SYS_DBG_MAT_TRANSPARENT = 1,
+	SYS_DBG_MAT_WRITE = 2,
+	SYS_DBG_MAT_READ_WRITE = 4,
+	SYS_MAT_GRANULARITY = 4096,
+};
+
+enum sys_dbg_coredump_parameter_t : s32
+{
+	SYS_DBG_COREDUMP_OFF,
+	SYS_DBG_COREDUMP_ON_SAVE_TO_APP_HOME,
+	SYS_DBG_COREDUMP_ON_SAVE_TO_DEV_MS,
+	SYS_DBG_COREDUMP_ON_SAVE_TO_DEV_USB,
+	SYS_DBG_COREDUMP_ON_SAVE_TO_DEV_HDD0,
+};

ps3fw/include/rpcsx/fw/ps3/sys_net_.h

@@ -0,0 +1,40 @@
+#pragma once
+
+#include "Emu/Cell/lv2/sys_net.h"
+
+struct sys_net_sockinfo_t
+{
+	be_t<s32> s;
+	be_t<s32> proto;
+	be_t<s32> recv_queue_length;
+	be_t<s32> send_queue_length;
+	sys_net_in_addr local_adr;
+	be_t<s32> local_port;
+	sys_net_in_addr remote_adr;
+	be_t<s32> remote_port;
+	be_t<s32> state;
+};
+
+struct sys_net_sockinfo_ex_t
+{
+	be_t<s32> s;
+	be_t<s32> proto;
+	be_t<s32> recv_queue_length;
+	be_t<s32> send_queue_length;
+	sys_net_in_addr local_adr;
+	be_t<s32> local_port;
+	sys_net_in_addr remote_adr;
+	be_t<s32> remote_port;
+	be_t<s32> state;
+	be_t<s32> socket_type;
+	be_t<s32> local_vport;
+	be_t<s32> remote_vport;
+	be_t<s32> reserved[8];
+};
+
+struct sys_net_initialize_parameter_t
+{
+	vm::bptr<void> memory;
+	be_t<s32> memory_size;
+	be_t<s32> flags;
+};