More dummy modules

* 41 new dummy modules created.

NOTE: I have detached the previous 4 dummy modules of my last commit
(1a85ccbbf4) from the project since they will consume space of the
executable, and compilation time and don't provide anything useful yet,
the same applies to this commit. The only reason to provide this dummy
modules is to avoid that developers have to spend too much time on
creating the template of the module before implementing functions. If
you want to implement a function of any of these modules, add the
corresponding file to the project first.

rpcs3/Emu/SysCalls/Modules/cellAdec.cpp

@@ -0,0 +1,83 @@
+#include "stdafx.h"
+#include "Emu/SysCalls/SysCalls.h"
+#include "Emu/SysCalls/SC_FUNC.h"
+
+void cellAdec_init();
+Module cellAdec(0x0006, cellAdec_init);
+
+// Error Codes
+enum
+{
+	CELL_ADEC_ERROR_FATAL	= 0x80610001,
+	CELL_ADEC_ERROR_SEQ		= 0x80610002,
+	CELL_ADEC_ERROR_ARG		= 0x80610003,
+	CELL_ADEC_ERROR_BUSY	= 0x80610004,
+	CELL_ADEC_ERROR_EMPTY	= 0x80610005,
+};
+
+int cellAdecQueryAttr()
+{
+	UNIMPLEMENTED_FUNC(cellAdec);
+	return CELL_OK;
+}
+
+int cellAdecOpen()
+{
+	UNIMPLEMENTED_FUNC(cellAdec);
+	return CELL_OK;
+}
+
+int cellAdecOpenEx()
+{
+	UNIMPLEMENTED_FUNC(cellAdec);
+	return CELL_OK;
+}
+
+int cellAdecClose()
+{
+	UNIMPLEMENTED_FUNC(cellAdec);
+	return CELL_OK;
+}
+
+int cellAdecStartSeq()
+{
+	UNIMPLEMENTED_FUNC(cellAdec);
+	return CELL_OK;
+}
+
+int cellAdecEndSeq()
+{
+	UNIMPLEMENTED_FUNC(cellAdec);
+	return CELL_OK;
+}
+
+int cellAdecDecodeAu()
+{
+	UNIMPLEMENTED_FUNC(cellAdec);
+	return CELL_OK;
+}
+
+int cellAdecGetPcm()
+{
+	UNIMPLEMENTED_FUNC(cellAdec);
+	return CELL_OK;
+}
+
+int cellAdecGetPcmItem()
+{
+	UNIMPLEMENTED_FUNC(cellAdec);
+	return CELL_OK;
+}
+
+void cellAdec_init()
+{
+	cellAdec.AddFunc(0x7e4a4a49, cellAdecQueryAttr);
+	cellAdec.AddFunc(0xd00a6988, cellAdecOpen);
+	cellAdec.AddFunc(0x8b5551a4, cellAdecOpenEx);
+	cellAdec.AddFunc(0x847d2380, cellAdecClose);
+	cellAdec.AddFunc(0x487b613e, cellAdecStartSeq);
+	cellAdec.AddFunc(0xe2ea549b, cellAdecEndSeq);
+	cellAdec.AddFunc(0x1529e506, cellAdecDecodeAu);
+	cellAdec.AddFunc(0x97ff2af1, cellAdecGetPcm);
+	cellAdec.AddFunc(0xbd75f78b, cellAdecGetPcmItem);
+}

rpcs3/Emu/SysCalls/Modules/cellAtrac.cpp

@@ -0,0 +1,205 @@
+#include "stdafx.h"
+#include "Emu/SysCalls/SysCalls.h"
+#include "Emu/SysCalls/SC_FUNC.h"
+
+void cellAtrac_init();
+Module cellAtrac(0x0013, cellAtrac_init);
+
+// Return Codes
+enum
+{
+	CELL_ATRAC_OK									= 0x00000000,
+	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,
+};
+
+int cellAtracSetDataAndGetMemSize()
+{
+	UNIMPLEMENTED_FUNC(cellAtrac);
+	return CELL_OK;
+}
+
+int cellAtracCreateDecoder()
+{
+	UNIMPLEMENTED_FUNC(cellAtrac);
+	return CELL_OK;
+}
+
+int cellAtracCreateDecoderExt()
+{
+	UNIMPLEMENTED_FUNC(cellAtrac);
+	return CELL_OK;
+}
+
+int cellAtracDeleteDecoder()
+{
+	UNIMPLEMENTED_FUNC(cellAtrac);
+	return CELL_OK;
+}
+
+int cellAtracDecode()
+{
+	UNIMPLEMENTED_FUNC(cellAtrac);
+	return CELL_OK;
+}
+
+int cellAtracGetStreamDataInfo()
+{
+	UNIMPLEMENTED_FUNC(cellAtrac);
+	return CELL_OK;
+}
+
+int cellAtracAddStreamData()
+{
+	UNIMPLEMENTED_FUNC(cellAtrac);
+	return CELL_OK;
+}
+
+int cellAtracGetRemainFrame()
+{
+	UNIMPLEMENTED_FUNC(cellAtrac);
+	return CELL_OK;
+}
+
+int cellAtracGetVacantSize()
+{
+	UNIMPLEMENTED_FUNC(cellAtrac);
+	return CELL_OK;
+}
+
+int cellAtracIsSecondBufferNeeded()
+{
+	UNIMPLEMENTED_FUNC(cellAtrac);
+	return CELL_OK;
+}
+
+int cellAtracGetSecondBufferInfo()
+{
+	UNIMPLEMENTED_FUNC(cellAtrac);
+	return CELL_OK;
+}
+
+int cellAtracSetSecondBuffer()
+{
+	UNIMPLEMENTED_FUNC(cellAtrac);
+	return CELL_OK;
+}
+
+int cellAtracGetChannel()
+{
+	UNIMPLEMENTED_FUNC(cellAtrac);
+	return CELL_OK;
+}
+
+int cellAtracGetMaxSample()
+{
+	UNIMPLEMENTED_FUNC(cellAtrac);
+	return CELL_OK;
+}
+
+int cellAtracGetNextSample()
+{
+	UNIMPLEMENTED_FUNC(cellAtrac);
+	return CELL_OK;
+}
+
+int cellAtracGetSoundInfo()
+{
+	UNIMPLEMENTED_FUNC(cellAtrac);
+	return CELL_OK;
+}
+
+int cellAtracGetNextDecodePosition()
+{
+	UNIMPLEMENTED_FUNC(cellAtrac);
+	return CELL_OK;
+}
+
+int cellAtracGetBitrate()
+{
+	UNIMPLEMENTED_FUNC(cellAtrac);
+	return CELL_OK;
+}
+
+int cellAtracGetLoopInfo()
+{
+	UNIMPLEMENTED_FUNC(cellAtrac);
+	return CELL_OK;
+}
+
+int cellAtracSetLoopNum()
+{
+	UNIMPLEMENTED_FUNC(cellAtrac);
+	return CELL_OK;
+}
+
+int cellAtracGetBufferInfoForResetting()
+{
+	UNIMPLEMENTED_FUNC(cellAtrac);
+	return CELL_OK;
+}
+
+int cellAtracResetPlayPosition()
+{
+	UNIMPLEMENTED_FUNC(cellAtrac);
+	return CELL_OK;
+}
+
+int cellAtracGetInternalErrorInfo()
+{
+	UNIMPLEMENTED_FUNC(cellAtrac);
+	return CELL_OK;
+}
+
+void cellAtrac_init()
+{
+	cellAtrac.AddFunc(0x66afc68e, cellAtracSetDataAndGetMemSize);
+
+	cellAtrac.AddFunc(0xfa293e88, cellAtracCreateDecoder);
+	cellAtrac.AddFunc(0x2642d4cc, cellAtracCreateDecoderExt);
+	cellAtrac.AddFunc(0x761cb9be, cellAtracDeleteDecoder);
+
+	cellAtrac.AddFunc(0x8eb0e65f, cellAtracDecode);
+
+	cellAtrac.AddFunc(0x2bfff084, cellAtracGetStreamDataInfo);
+	cellAtrac.AddFunc(0x46cfc013, cellAtracAddStreamData);
+	cellAtrac.AddFunc(0xdfab73aa, cellAtracGetRemainFrame);
+	cellAtrac.AddFunc(0xc9a95fcb, cellAtracGetVacantSize);
+	cellAtrac.AddFunc(0x99efe171, cellAtracIsSecondBufferNeeded);
+	cellAtrac.AddFunc(0xbe07f05e, cellAtracGetSecondBufferInfo);
+	cellAtrac.AddFunc(0x06ddb53e, cellAtracSetSecondBuffer);
+
+	cellAtrac.AddFunc(0x0f9667b6, cellAtracGetChannel);
+	cellAtrac.AddFunc(0x5f62d546, cellAtracGetMaxSample);
+	cellAtrac.AddFunc(0x4797d1ff, cellAtracGetNextSample);
+	cellAtrac.AddFunc(0xcf01d5d4, cellAtracGetSoundInfo);
+	cellAtrac.AddFunc(0x7b22e672, cellAtracGetNextDecodePosition);
+	cellAtrac.AddFunc(0x006016da, cellAtracGetBitrate);
+
+	cellAtrac.AddFunc(0xab6b6dbf, cellAtracGetLoopInfo);
+	cellAtrac.AddFunc(0x78ba5c41, cellAtracSetLoopNum);
+
+	cellAtrac.AddFunc(0x99fb73d1, cellAtracGetBufferInfoForResetting);
+	cellAtrac.AddFunc(0x7772eb2b, cellAtracResetPlayPosition);
+
+	cellAtrac.AddFunc(0xb5c11938, cellAtracGetInternalErrorInfo);
+}

rpcs3/Emu/SysCalls/Modules/cellBgdl.cpp

@@ -0,0 +1,49 @@
+#include "stdafx.h"
+#include "Emu/SysCalls/SysCalls.h"
+#include "Emu/SysCalls/SC_FUNC.h"
+
+void cellBgdl_init();
+Module cellBgdl(0x003f, cellBgdl_init);
+
+// Return Codes
+enum
+{
+	CELL_BGDL_UTIL_RET_OK				= 0x00000000,
+	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,
+};
+
+int cellBGDLGetInfo()
+{
+	UNIMPLEMENTED_FUNC(cellBgdl);
+	return CELL_OK;
+}
+
+int cellBGDLGetInfo2()
+{
+	UNIMPLEMENTED_FUNC(cellBgdl);
+	return CELL_OK;
+}
+
+int cellBGDLSetMode()
+{
+	UNIMPLEMENTED_FUNC(cellBgdl);
+	return CELL_OK;
+}
+
+int cellBGDLGetMode()
+{
+	UNIMPLEMENTED_FUNC(cellBgdl);
+	return CELL_OK;
+}
+
+void cellBgdl_init()
+{
+	cellBgdl.AddFunc(0x4e9bb95b, cellBGDLGetInfo);
+	cellBgdl.AddFunc(0x2ab0d183, cellBGDLGetInfo2);
+	cellBgdl.AddFunc(0x7e134a90, cellBGDLSetMode);
+	cellBgdl.AddFunc(0x74e57bdf, cellBGDLGetMode);
+}

rpcs3/Emu/SysCalls/Modules/cellCamera.cpp

@@ -0,0 +1,242 @@
+#include "stdafx.h"
+#include "Emu/SysCalls/SysCalls.h"
+#include "Emu/SysCalls/SC_FUNC.h"
+
+void cellCamera_init();
+Module cellCamera(0x0023, cellCamera_init);
+
+// Error Codes
+enum
+{
+	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_FATAL					= 0x8014080f,
+};
+
+int cellCameraInit()
+{
+	UNIMPLEMENTED_FUNC(cellCamera);
+	return CELL_OK;
+}
+
+int cellCameraEnd()
+{
+	UNIMPLEMENTED_FUNC(cellCamera);
+	return CELL_OK;
+}
+
+int cellCameraOpen()
+{
+	UNIMPLEMENTED_FUNC(cellCamera);
+	return CELL_OK;
+}
+
+int cellCameraOpenEx()
+{
+	UNIMPLEMENTED_FUNC(cellCamera);
+	return CELL_OK;
+}
+
+int cellCameraClose()
+{
+	UNIMPLEMENTED_FUNC(cellCamera);
+	return CELL_OK;
+}
+
+int cellCameraGetDeviceGUID()
+{
+	UNIMPLEMENTED_FUNC(cellCamera);
+	return CELL_OK;
+}
+
+int cellCameraGetType()
+{
+	UNIMPLEMENTED_FUNC(cellCamera);
+	return CELL_OK;
+}
+
+int cellCameraIsAvailable()
+{
+	UNIMPLEMENTED_FUNC(cellCamera);
+	return CELL_OK;
+}
+
+int cellCameraIsAttached()
+{
+	UNIMPLEMENTED_FUNC(cellCamera);
+	return CELL_OK;
+}
+
+int cellCameraIsOpen()
+{
+	UNIMPLEMENTED_FUNC(cellCamera);
+	return CELL_OK;
+}
+
+int cellCameraIsStarted()
+{
+	UNIMPLEMENTED_FUNC(cellCamera);
+	return CELL_OK;
+}
+
+int cellCameraGetAttribute()
+{
+	UNIMPLEMENTED_FUNC(cellCamera);
+	return CELL_OK;
+}
+
+int cellCameraSetAttribute()
+{
+	UNIMPLEMENTED_FUNC(cellCamera);
+	return CELL_OK;
+}
+
+int cellCameraGetBufferSize()
+{
+	UNIMPLEMENTED_FUNC(cellCamera);
+	return CELL_OK;
+}
+
+int cellCameraGetBufferInfo()
+{
+	UNIMPLEMENTED_FUNC(cellCamera);
+	return CELL_OK;
+}
+
+int cellCameraGetBufferInfoEx()
+{
+	UNIMPLEMENTED_FUNC(cellCamera);
+	return CELL_OK;
+}
+
+int cellCameraPrepExtensionUnit()
+{
+	UNIMPLEMENTED_FUNC(cellCamera);
+	return CELL_OK;
+}
+
+int cellCameraCtrlExtensionUnit()
+{
+	UNIMPLEMENTED_FUNC(cellCamera);
+	return CELL_OK;
+}
+
+int cellCameraGetExtensionUnit()
+{
+	UNIMPLEMENTED_FUNC(cellCamera);
+	return CELL_OK;
+}
+
+int cellCameraSetExtensionUnit()
+{
+	UNIMPLEMENTED_FUNC(cellCamera);
+	return CELL_OK;
+}
+
+int cellCameraReset()
+{
+	UNIMPLEMENTED_FUNC(cellCamera);
+	return CELL_OK;
+}
+
+int cellCameraStart()
+{
+	UNIMPLEMENTED_FUNC(cellCamera);
+	return CELL_OK;
+}
+
+int cellCameraRead()
+{
+	UNIMPLEMENTED_FUNC(cellCamera);
+	return CELL_OK;
+}
+
+int cellCameraReadEx()
+{
+	UNIMPLEMENTED_FUNC(cellCamera);
+	return CELL_OK;
+}
+
+int cellCameraReadComplete()
+{
+	UNIMPLEMENTED_FUNC(cellCamera);
+	return CELL_OK;
+}
+
+int cellCameraStop()
+{
+	UNIMPLEMENTED_FUNC(cellCamera);
+	return CELL_OK;
+}
+
+int cellCameraSetNotifyEventQueue()
+{
+	UNIMPLEMENTED_FUNC(cellCamera);
+	return CELL_OK;
+}
+
+int cellCameraRemoveNotifyEventQueue()
+{
+	UNIMPLEMENTED_FUNC(cellCamera);
+	return CELL_OK;
+}
+
+int cellCameraSetNotifyEventQueue2()
+{
+	UNIMPLEMENTED_FUNC(cellCamera);
+	return CELL_OK;
+}
+
+int cellCameraRemoveNotifyEventQueue2()
+{
+	UNIMPLEMENTED_FUNC(cellCamera);
+	return CELL_OK;
+}
+
+void cellCamera_init()
+{
+	cellCamera.AddFunc(0xbf47c5dd, cellCameraInit);
+	cellCamera.AddFunc(0x5ad46570, cellCameraEnd);
+	cellCamera.AddFunc(0x85e1b8da, cellCameraOpen);
+	cellCamera.AddFunc(0x5d25f866, cellCameraOpenEx);
+	cellCamera.AddFunc(0x379c5dd6, cellCameraClose);
+
+	cellCamera.AddFunc(0x602e2052, cellCameraGetDeviceGUID);
+	cellCamera.AddFunc(0x58bc5870, cellCameraGetType);
+	cellCamera.AddFunc(0x8ca53dde, cellCameraIsAvailable);
+	cellCamera.AddFunc(0x7e063bbc, cellCameraIsAttached);
+	cellCamera.AddFunc(0xfa160f24, cellCameraIsOpen);
+	cellCamera.AddFunc(0x5eebf24e, cellCameraIsStarted);
+	cellCamera.AddFunc(0x532b8aaa, cellCameraGetAttribute);
+	cellCamera.AddFunc(0x8cd56eee, cellCameraSetAttribute);
+	cellCamera.AddFunc(0x7dac520c, cellCameraGetBufferSize);
+	cellCamera.AddFunc(0x10697d7f, cellCameraGetBufferInfo);
+	cellCamera.AddFunc(0x0e63c444, cellCameraGetBufferInfoEx);
+
+	cellCamera.AddFunc(0x61dfbe83, cellCameraPrepExtensionUnit);
+	cellCamera.AddFunc(0xeb6f95fb, cellCameraCtrlExtensionUnit);
+	cellCamera.AddFunc(0xb602e328, cellCameraGetExtensionUnit);
+	cellCamera.AddFunc(0x2dea3e9b, cellCameraSetExtensionUnit);
+
+	cellCamera.AddFunc(0x81f83db9, cellCameraReset);
+	cellCamera.AddFunc(0x456dc4aa, cellCameraStart);
+	cellCamera.AddFunc(0x3845d39b, cellCameraRead);
+	cellCamera.AddFunc(0x21fc151f, cellCameraReadEx);
+	cellCamera.AddFunc(0xe28b206b, cellCameraReadComplete);
+	cellCamera.AddFunc(0x02f5ced0, cellCameraStop);
+
+	cellCamera.AddFunc(0xb0647e5a, cellCameraSetNotifyEventQueue);
+	cellCamera.AddFunc(0x9b98d258, cellCameraRemoveNotifyEventQueue);
+	cellCamera.AddFunc(0xa7fd2f5b, cellCameraSetNotifyEventQueue2);
+	cellCamera.AddFunc(0x44673f07, cellCameraRemoveNotifyEventQueue2);
+}

rpcs3/Emu/SysCalls/Modules/cellCelp8Enc.cpp

@@ -0,0 +1,84 @@
+#include "stdafx.h"
+#include "Emu/SysCalls/SysCalls.h"
+#include "Emu/SysCalls/SC_FUNC.h"
+
+void cellCelp8Enc_init();
+Module cellCelp8Enc(0x0048, cellCelp8Enc_init);
+
+// Return Codes
+enum
+{
+	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,
+};
+
+int cellCelp8EncQueryAttr()
+{
+	UNIMPLEMENTED_FUNC(cellCelp8Enc);
+	return CELL_OK;
+}
+
+int cellCelp8EncOpen()
+{
+	UNIMPLEMENTED_FUNC(cellCelp8Enc);
+	return CELL_OK;
+}
+
+int cellCelp8EncOpenEx()
+{
+	UNIMPLEMENTED_FUNC(cellCelp8Enc);
+	return CELL_OK;
+}
+
+int cellCelp8EncClose()
+{
+	UNIMPLEMENTED_FUNC(cellCelp8Enc);
+	return CELL_OK;
+}
+
+int cellCelp8EncStart()
+{
+	UNIMPLEMENTED_FUNC(cellCelp8Enc);
+	return CELL_OK;
+}
+
+int cellCelp8EncEnd()
+{
+	UNIMPLEMENTED_FUNC(cellCelp8Enc);
+	return CELL_OK;
+}
+
+int cellCelp8EncEncodeFrame()
+{
+	UNIMPLEMENTED_FUNC(cellCelp8Enc);
+	return CELL_OK;
+}
+
+int cellCelp8EncWaitForOutput()
+{
+	UNIMPLEMENTED_FUNC(cellCelp8Enc);
+	return CELL_OK;
+}
+
+int cellCelp8EncGetAu()
+{
+	UNIMPLEMENTED_FUNC(cellCelp8Enc);
+	return CELL_OK;
+}
+
+void cellCelp8Enc_init()
+{
+	cellCelp8Enc.AddFunc(0x2d677e0c, cellCelp8EncQueryAttr);
+	cellCelp8Enc.AddFunc(0x2eb6efee, cellCelp8EncOpen);
+	cellCelp8Enc.AddFunc(0xcd48ad62, cellCelp8EncOpenEx);
+	cellCelp8Enc.AddFunc(0xfd2566b4, cellCelp8EncClose);
+	cellCelp8Enc.AddFunc(0x0f6ab57b, cellCelp8EncStart);
+	cellCelp8Enc.AddFunc(0xbbbc2c1c, cellCelp8EncEnd);
+	cellCelp8Enc.AddFunc(0x2099f86e, cellCelp8EncEncodeFrame);
+	cellCelp8Enc.AddFunc(0x29da1ea6, cellCelp8EncWaitForOutput);
+	cellCelp8Enc.AddFunc(0x48c5020d, cellCelp8EncGetAu);
+}

rpcs3/Emu/SysCalls/Modules/cellCelpEnc.cpp

@@ -0,0 +1,84 @@
+#include "stdafx.h"
+#include "Emu/SysCalls/SysCalls.h"
+#include "Emu/SysCalls/SC_FUNC.h"
+
+void cellCelpEnc_init();
+Module cellCelpEnc(0xf00a, cellCelpEnc_init);
+
+// Return Codes
+enum
+{
+	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,
+};
+
+int cellCelpEncQueryAttr()
+{
+	UNIMPLEMENTED_FUNC(cellCelpEnc);
+	return CELL_OK;
+}
+
+int cellCelpEncOpen()
+{
+	UNIMPLEMENTED_FUNC(cellCelpEnc);
+	return CELL_OK;
+}
+
+int cellCelpEncOpenEx()
+{
+	UNIMPLEMENTED_FUNC(cellCelpEnc);
+	return CELL_OK;
+}
+
+int cellCelpEncClose()
+{
+	UNIMPLEMENTED_FUNC(cellCelpEnc);
+	return CELL_OK;
+}
+
+int cellCelpEncStart()
+{
+	UNIMPLEMENTED_FUNC(cellCelpEnc);
+	return CELL_OK;
+}
+
+int cellCelpEncEnd()
+{
+	UNIMPLEMENTED_FUNC(cellCelpEnc);
+	return CELL_OK;
+}
+
+int cellCelpEncEncodeFrame()
+{
+	UNIMPLEMENTED_FUNC(cellCelpEnc);
+	return CELL_OK;
+}
+
+int cellCelpEncWaitForOutput()
+{
+	UNIMPLEMENTED_FUNC(cellCelpEnc);
+	return CELL_OK;
+}
+
+int cellCelpEncGetAu()
+{
+	UNIMPLEMENTED_FUNC(cellCelpEnc);
+	return CELL_OK;
+}
+
+void cellCelpEnc_init()
+{
+	cellCelpEnc.AddFunc(0x6b148570, cellCelpEncQueryAttr);
+	cellCelpEnc.AddFunc(0x77b3b29a, cellCelpEncOpen);
+	cellCelpEnc.AddFunc(0x9eb084db, cellCelpEncOpenEx);
+	cellCelpEnc.AddFunc(0x15ec0cca, cellCelpEncClose);
+	cellCelpEnc.AddFunc(0x55dc23de, cellCelpEncStart);
+	cellCelpEnc.AddFunc(0xf2b85dff, cellCelpEncEnd);
+	cellCelpEnc.AddFunc(0x81fe030c, cellCelpEncEncodeFrame);
+	cellCelpEnc.AddFunc(0x9b244272, cellCelpEncWaitForOutput);
+	cellCelpEnc.AddFunc(0x3773692f, cellCelpEncGetAu);
+}

rpcs3/Emu/SysCalls/Modules/cellDmux.cpp

@@ -0,0 +1,160 @@
+#include "stdafx.h"
+#include "Emu/SysCalls/SysCalls.h"
+#include "Emu/SysCalls/SC_FUNC.h"
+
+void cellDmux_init();
+Module cellDmux(0x0007, cellDmux_init);
+
+// Error Codes
+enum
+{
+	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,
+};
+
+int cellDmuxQueryAttr()
+{
+	UNIMPLEMENTED_FUNC(cellDmux);
+	return CELL_OK;
+}
+
+int cellDmuxQueryAttr2()
+{
+	UNIMPLEMENTED_FUNC(cellDmux);
+	return CELL_OK;
+}
+
+int cellDmuxOpen()
+{
+	UNIMPLEMENTED_FUNC(cellDmux);
+	return CELL_OK;
+}
+
+int cellDmuxOpenEx()
+{
+	UNIMPLEMENTED_FUNC(cellDmux);
+	return CELL_OK;
+}
+
+int cellDmuxOpen2()
+{
+	UNIMPLEMENTED_FUNC(cellDmux);
+	return CELL_OK;
+}
+
+int cellDmuxClose()
+{
+	UNIMPLEMENTED_FUNC(cellDmux);
+	return CELL_OK;
+}
+
+int cellDmuxSetStream()
+{
+	UNIMPLEMENTED_FUNC(cellDmux);
+	return CELL_OK;
+}
+
+int cellDmuxResetStream()
+{
+	UNIMPLEMENTED_FUNC(cellDmux);
+	return CELL_OK;
+}
+
+int cellDmuxResetStreamAndWaitDone()
+{
+	UNIMPLEMENTED_FUNC(cellDmux);
+	return CELL_OK;
+}
+
+int cellDmuxQueryEsAttr()
+{
+	UNIMPLEMENTED_FUNC(cellDmux);
+	return CELL_OK;
+}
+
+int cellDmuxQueryEsAttr2()
+{
+	UNIMPLEMENTED_FUNC(cellDmux);
+	return CELL_OK;
+}
+
+int cellDmuxEnableEs()
+{
+	UNIMPLEMENTED_FUNC(cellDmux);
+	return CELL_OK;
+}
+
+int cellDmuxDisableEs()
+{
+	UNIMPLEMENTED_FUNC(cellDmux);
+	return CELL_OK;
+}
+
+int cellDmuxResetEs()
+{
+	UNIMPLEMENTED_FUNC(cellDmux);
+	return CELL_OK;
+}
+
+int cellDmuxGetAu()
+{
+	UNIMPLEMENTED_FUNC(cellDmux);
+	return CELL_OK;
+}
+
+int cellDmuxPeekAu()
+{
+	UNIMPLEMENTED_FUNC(cellDmux);
+	return CELL_OK;
+}
+
+int cellDmuxGetAuEx()
+{
+	UNIMPLEMENTED_FUNC(cellDmux);
+	return CELL_OK;
+}
+
+int cellDmuxPeekAuEx()
+{
+	UNIMPLEMENTED_FUNC(cellDmux);
+	return CELL_OK;
+}
+
+int cellDmuxReleaseAu()
+{
+	UNIMPLEMENTED_FUNC(cellDmux);
+	return CELL_OK;
+}
+
+int cellDmuxFlushEs()
+{
+	UNIMPLEMENTED_FUNC(cellDmux);
+	return CELL_OK;
+}
+
+void cellDmux_init()
+{
+	cellDmux.AddFunc(0xa2d4189b, cellDmuxQueryAttr);
+	cellDmux.AddFunc(0x3f76e3cd, cellDmuxQueryAttr2);
+	cellDmux.AddFunc(0x68492de9, cellDmuxOpen);
+	cellDmux.AddFunc(0xf6c23560, cellDmuxOpenEx);
+	cellDmux.AddFunc(0x11bc3a6c, cellDmuxOpen2);
+	cellDmux.AddFunc(0x8c692521, cellDmuxClose);
+	cellDmux.AddFunc(0x04e7499f, cellDmuxSetStream);
+	cellDmux.AddFunc(0x5d345de9, cellDmuxResetStream);
+	cellDmux.AddFunc(0xccff1284, cellDmuxResetStreamAndWaitDone);
+	cellDmux.AddFunc(0x02170d1a, cellDmuxQueryEsAttr);
+	cellDmux.AddFunc(0x52911bcf, cellDmuxQueryEsAttr2);
+	cellDmux.AddFunc(0x7b56dc3f, cellDmuxEnableEs);
+	cellDmux.AddFunc(0x05371c8d, cellDmuxDisableEs);
+	cellDmux.AddFunc(0x21d424f0, cellDmuxResetEs);
+	cellDmux.AddFunc(0x42c716b5, cellDmuxGetAu);
+	cellDmux.AddFunc(0x2750c5e0, cellDmuxPeekAu);
+	cellDmux.AddFunc(0x2c9a5857, cellDmuxGetAuEx);
+	cellDmux.AddFunc(0x002e8da2, cellDmuxPeekAuEx);
+	cellDmux.AddFunc(0x24ea6474, cellDmuxReleaseAu);
+	cellDmux.AddFunc(0xebb3b2bd, cellDmuxFlushEs);
+}

rpcs3/Emu/SysCalls/Modules/cellFiber.cpp

@@ -0,0 +1,361 @@
+#include "stdafx.h"
+#include "Emu/SysCalls/SysCalls.h"
+#include "Emu/SysCalls/SC_FUNC.h"
+
+void cellFiber_init();
+Module cellFiber(0x0043, cellFiber_init);
+
+// Return Codes
+enum
+{
+	CELL_FIBER_ERROR_AGAIN			= 0x80760001,
+	CELL_FIBER_ERROR_INVAL			= 0x80760002,
+	CELL_FIBER_ERROR_NOMEM			= 0x80760004,
+	CELL_FIBER_ERROR_DEADLK			= 0x80760008,
+	CELL_FIBER_ERROR_PERM			= 0x80760009,
+	CELL_FIBER_ERROR_BUSY			= 0x8076000A,
+	CELL_FIBER_ERROR_ABORT			= 0x8076000C,
+	CELL_FIBER_ERROR_STAT			= 0x8076000F,
+	CELL_FIBER_ERROR_ALIGN			= 0x80760010,
+	CELL_FIBER_ERROR_NULL_POINTER	= 0x80760011,
+	CELL_FIBER_ERROR_NOSYSINIT		= 0x80760020,
+};
+
+int _cellFiberPpuInitialize()
+{
+	UNIMPLEMENTED_FUNC(cellFiber);
+	return CELL_OK;
+}
+
+int _cellFiberPpuSchedulerAttributeInitialize()
+{
+	UNIMPLEMENTED_FUNC(cellFiber);
+	return CELL_OK;
+}
+
+int cellFiberPpuInitializeScheduler()
+{
+	UNIMPLEMENTED_FUNC(cellFiber);
+	return CELL_OK;
+}
+
+int cellFiberPpuFinalizeScheduler()
+{
+	UNIMPLEMENTED_FUNC(cellFiber);
+	return CELL_OK;
+}
+
+int cellFiberPpuRunFibers()
+{
+	UNIMPLEMENTED_FUNC(cellFiber);
+	return CELL_OK;
+}
+
+int cellFiberPpuCheckFlags()
+{
+	UNIMPLEMENTED_FUNC(cellFiber);
+	return CELL_OK;
+}
+
+int cellFiberPpuHasRunnableFiber()
+{
+	UNIMPLEMENTED_FUNC(cellFiber);
+	return CELL_OK;
+}
+
+int _cellFiberPpuAttributeInitialize()
+{
+	UNIMPLEMENTED_FUNC(cellFiber);
+	return CELL_OK;
+}
+
+int cellFiberPpuCreateFiber()
+{
+	UNIMPLEMENTED_FUNC(cellFiber);
+	return CELL_OK;
+}
+
+int cellFiberPpuExit()
+{
+	UNIMPLEMENTED_FUNC(cellFiber);
+	return CELL_OK;
+}
+
+int cellFiberPpuYield()
+{
+	UNIMPLEMENTED_FUNC(cellFiber);
+	return CELL_OK;
+}
+
+int cellFiberPpuJoinFiber()
+{
+	UNIMPLEMENTED_FUNC(cellFiber);
+	return CELL_OK;
+}
+
+int cellFiberPpuSelf()
+{
+	UNIMPLEMENTED_FUNC(cellFiber);
+	return CELL_OK;
+}
+
+int cellFiberPpuSendSignal()
+{
+	UNIMPLEMENTED_FUNC(cellFiber);
+	return CELL_OK;
+}
+
+int cellFiberPpuWaitSignal()
+{
+	UNIMPLEMENTED_FUNC(cellFiber);
+	return CELL_OK;
+}
+
+int cellFiberPpuWaitFlag()
+{
+	UNIMPLEMENTED_FUNC(cellFiber);
+	return CELL_OK;
+}
+
+int cellFiberPpuGetScheduler()
+{
+	UNIMPLEMENTED_FUNC(cellFiber);
+	return CELL_OK;
+}
+
+int cellFiberPpuSetPriority()
+{
+	UNIMPLEMENTED_FUNC(cellFiber);
+	return CELL_OK;
+}
+
+int cellFiberPpuCheckStackLimit()
+{
+	UNIMPLEMENTED_FUNC(cellFiber);
+	return CELL_OK;
+}
+
+int _cellFiberPpuContextAttributeInitialize()
+{
+	UNIMPLEMENTED_FUNC(cellFiber);
+	return CELL_OK;
+}
+
+int cellFiberPpuContextInitialize()
+{
+	UNIMPLEMENTED_FUNC(cellFiber);
+	return CELL_OK;
+}
+
+int cellFiberPpuContextFinalize()
+{
+	UNIMPLEMENTED_FUNC(cellFiber);
+	return CELL_OK;
+}
+
+int cellFiberPpuContextRun()
+{
+	UNIMPLEMENTED_FUNC(cellFiber);
+	return CELL_OK;
+}
+
+int cellFiberPpuContextSwitch()
+{
+	UNIMPLEMENTED_FUNC(cellFiber);
+	return CELL_OK;
+}
+
+int cellFiberPpuContextSelf()
+{
+	UNIMPLEMENTED_FUNC(cellFiber);
+	return CELL_OK;
+}
+
+int cellFiberPpuContextReturnToThread()
+{
+	UNIMPLEMENTED_FUNC(cellFiber);
+	return CELL_OK;
+}
+
+int cellFiberPpuContextCheckStackLimit()
+{
+	UNIMPLEMENTED_FUNC(cellFiber);
+	return CELL_OK;
+}
+
+int cellFiberPpuContextRunScheduler()
+{
+	UNIMPLEMENTED_FUNC(cellFiber);
+	return CELL_OK;
+}
+
+int cellFiberPpuContextEnterScheduler()
+{
+	UNIMPLEMENTED_FUNC(cellFiber);
+	return CELL_OK;
+}
+
+int cellFiberPpuSchedulerTraceInitialize()
+{
+	UNIMPLEMENTED_FUNC(cellFiber);
+	return CELL_OK;
+}
+
+int cellFiberPpuSchedulerTraceFinalize()
+{
+	UNIMPLEMENTED_FUNC(cellFiber);
+	return CELL_OK;
+}
+
+int cellFiberPpuSchedulerTraceStart()
+{
+	UNIMPLEMENTED_FUNC(cellFiber);
+	return CELL_OK;
+}
+
+int cellFiberPpuSchedulerTraceStop()
+{
+	UNIMPLEMENTED_FUNC(cellFiber);
+	return CELL_OK;
+}
+
+int _cellFiberPpuUtilWorkerControlAttributeInitialize()
+{
+	UNIMPLEMENTED_FUNC(cellFiber);
+	return CELL_OK;
+}
+
+int cellFiberPpuUtilWorkerControlRunFibers()
+{
+	UNIMPLEMENTED_FUNC(cellFiber);
+	return CELL_OK;
+}
+
+int cellFiberPpuUtilWorkerControlInitialize()
+{
+	UNIMPLEMENTED_FUNC(cellFiber);
+	return CELL_OK;
+}
+
+int cellFiberPpuUtilWorkerControlSetPollingMode()
+{
+	UNIMPLEMENTED_FUNC(cellFiber);
+	return CELL_OK;
+}
+
+int cellFiberPpuUtilWorkerControlJoinFiber()
+{
+	UNIMPLEMENTED_FUNC(cellFiber);
+	return CELL_OK;
+}
+
+int cellFiberPpuUtilWorkerControlDisconnectEventQueue()
+{
+	UNIMPLEMENTED_FUNC(cellFiber);
+	return CELL_OK;
+}
+
+int cellFiberPpuUtilWorkerControlSendSignal()
+{
+	UNIMPLEMENTED_FUNC(cellFiber);
+	return CELL_OK;
+}
+
+int cellFiberPpuUtilWorkerControlConnectEventQueueToSpurs()
+{
+	UNIMPLEMENTED_FUNC(cellFiber);
+	return CELL_OK;
+}
+
+int cellFiberPpuUtilWorkerControlFinalize()
+{
+	UNIMPLEMENTED_FUNC(cellFiber);
+	return CELL_OK;
+}
+
+int cellFiberPpuUtilWorkerControlWakeup()
+{
+	UNIMPLEMENTED_FUNC(cellFiber);
+	return CELL_OK;
+}
+
+int cellFiberPpuUtilWorkerControlCreateFiber()
+{
+	UNIMPLEMENTED_FUNC(cellFiber);
+	return CELL_OK;
+}
+
+int cellFiberPpuUtilWorkerControlShutdown()
+{
+	UNIMPLEMENTED_FUNC(cellFiber);
+	return CELL_OK;
+}
+
+int cellFiberPpuUtilWorkerControlCheckFlags()
+{
+	UNIMPLEMENTED_FUNC(cellFiber);
+	return CELL_OK;
+}
+
+int cellFiberPpuUtilWorkerControlInitializeWithAttribute()
+{
+	UNIMPLEMENTED_FUNC(cellFiber);
+	return CELL_OK;
+}
+
+void cellFiber_init()
+{
+	cellFiber.AddFunc(0x55870804, _cellFiberPpuInitialize);
+
+	cellFiber.AddFunc(0x9e25c72d, _cellFiberPpuSchedulerAttributeInitialize);
+	cellFiber.AddFunc(0xee3b604d, cellFiberPpuInitializeScheduler);
+	cellFiber.AddFunc(0x8b6baa01, cellFiberPpuFinalizeScheduler);
+	cellFiber.AddFunc(0x12b1acf0, cellFiberPpuRunFibers);
+	cellFiber.AddFunc(0xf6c6900c, cellFiberPpuCheckFlags);
+	cellFiber.AddFunc(0xe492a675, cellFiberPpuHasRunnableFiber);
+
+	cellFiber.AddFunc(0xc11f8056, _cellFiberPpuAttributeInitialize);
+	cellFiber.AddFunc(0x7c2f4034, cellFiberPpuCreateFiber);
+	cellFiber.AddFunc(0xfa8d5f95, cellFiberPpuExit);
+	cellFiber.AddFunc(0x0c44f441, cellFiberPpuYield);
+	cellFiber.AddFunc(0xa6004249, cellFiberPpuJoinFiber);
+	cellFiber.AddFunc(0x5d9a7034, cellFiberPpuSelf);
+	cellFiber.AddFunc(0x8afb8356, cellFiberPpuSendSignal);
+	cellFiber.AddFunc(0x6c164b3b, cellFiberPpuWaitSignal);
+	cellFiber.AddFunc(0xa4599cf3, cellFiberPpuWaitFlag);
+	cellFiber.AddFunc(0xb0594b2d, cellFiberPpuGetScheduler);
+	cellFiber.AddFunc(0xfbf5fe40, cellFiberPpuSetPriority);
+	cellFiber.AddFunc(0xf3e81219, cellFiberPpuCheckStackLimit);
+
+	cellFiber.AddFunc(0x31252ec3, _cellFiberPpuContextAttributeInitialize);
+	cellFiber.AddFunc(0x72086315, cellFiberPpuContextInitialize);
+	cellFiber.AddFunc(0xb3a48079, cellFiberPpuContextFinalize);
+	cellFiber.AddFunc(0xaba1c563, cellFiberPpuContextRun);
+	cellFiber.AddFunc(0xd0066b17, cellFiberPpuContextSwitch);
+	cellFiber.AddFunc(0x34a81091, cellFiberPpuContextSelf);
+	cellFiber.AddFunc(0x01036193, cellFiberPpuContextReturnToThread);
+	cellFiber.AddFunc(0xb90c871b, cellFiberPpuContextCheckStackLimit);
+
+	cellFiber.AddFunc(0x081c98be, cellFiberPpuContextRunScheduler);
+	cellFiber.AddFunc(0x0a25b6c8, cellFiberPpuContextEnterScheduler);
+
+	cellFiber.AddFunc(0xbf9cd933, cellFiberPpuSchedulerTraceInitialize);
+	cellFiber.AddFunc(0x3860a12a, cellFiberPpuSchedulerTraceFinalize);
+	cellFiber.AddFunc(0xadedbebf, cellFiberPpuSchedulerTraceStart);
+	cellFiber.AddFunc(0xe665f9a9, cellFiberPpuSchedulerTraceStop);
+
+	cellFiber.AddFunc(0x68ba4568, _cellFiberPpuUtilWorkerControlAttributeInitialize);
+	cellFiber.AddFunc(0x1e7a247a, cellFiberPpuUtilWorkerControlRunFibers);
+	cellFiber.AddFunc(0x3204b146, cellFiberPpuUtilWorkerControlInitialize);
+	cellFiber.AddFunc(0x392c5aa5, cellFiberPpuUtilWorkerControlSetPollingMode);
+	cellFiber.AddFunc(0x3b417f82, cellFiberPpuUtilWorkerControlJoinFiber);
+	cellFiber.AddFunc(0x4fc86b2c, cellFiberPpuUtilWorkerControlDisconnectEventQueue);
+	cellFiber.AddFunc(0x5d3992dd, cellFiberPpuUtilWorkerControlSendSignal);
+	cellFiber.AddFunc(0x62a20f0d, cellFiberPpuUtilWorkerControlConnectEventQueueToSpurs);
+	cellFiber.AddFunc(0xa27c95ca, cellFiberPpuUtilWorkerControlFinalize);
+	cellFiber.AddFunc(0xbabf714b, cellFiberPpuUtilWorkerControlWakeup);
+	cellFiber.AddFunc(0xbfca88d3, cellFiberPpuUtilWorkerControlCreateFiber);
+	cellFiber.AddFunc(0xc04e2438, cellFiberPpuUtilWorkerControlShutdown);
+	cellFiber.AddFunc(0xea6dc1ad, cellFiberPpuUtilWorkerControlCheckFlags);
+	cellFiber.AddFunc(0xf2ccad4f, cellFiberPpuUtilWorkerControlInitializeWithAttribute);
+}

rpcs3/Emu/SysCalls/Modules/cellGame.cpp

@@ -0,0 +1,147 @@
+#include "stdafx.h"
+#include "Emu/SysCalls/SysCalls.h"
+#include "Emu/SysCalls/SC_FUNC.h"
+
+void cellGame_init();
+Module cellGame(0x003e, cellGame_init);
+
+// Return Codes
+enum
+{
+	CELL_GAME_RET_OK					= 0,
+	CELL_GAME_RET_CANCEL				= 1,
+	CELL_GAME_RET_NONE					= 2,
+	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,
+};
+
+int cellGameBootCheck()
+{
+	UNIMPLEMENTED_FUNC(cellGame);
+	return CELL_OK;
+}
+
+int cellGamePatchCheck()
+{
+	UNIMPLEMENTED_FUNC(cellGame);
+	return CELL_OK;
+}
+
+int cellGameDataCheck()
+{
+	UNIMPLEMENTED_FUNC(cellGame);
+	return CELL_OK;
+}
+
+int cellGameContentPermit()
+{
+	UNIMPLEMENTED_FUNC(cellGame);
+	return CELL_OK;
+}
+
+int cellGameCreateGameData()
+{
+	UNIMPLEMENTED_FUNC(cellGame);
+	return CELL_OK;
+}
+
+int cellGameDeleteGameData()
+{
+	UNIMPLEMENTED_FUNC(cellGame);
+	return CELL_OK;
+}
+
+int cellGameGetParamInt()
+{
+	UNIMPLEMENTED_FUNC(cellGame);
+	return CELL_OK;
+}
+
+int cellGameGetParamString()
+{
+	UNIMPLEMENTED_FUNC(cellGame);
+	return CELL_OK;
+}
+
+int cellGameSetParamString()
+{
+	UNIMPLEMENTED_FUNC(cellGame);
+	return CELL_OK;
+}
+
+int cellGameGetSizeKB()
+{
+	UNIMPLEMENTED_FUNC(cellGame);
+	return CELL_OK;
+}
+
+int cellGameGetDiscContentInfoUpdatePath()
+{
+	UNIMPLEMENTED_FUNC(cellGame);
+	return CELL_OK;
+}
+
+int cellGameGetLocalWebContentPath()
+{
+	UNIMPLEMENTED_FUNC(cellGame);
+	return CELL_OK;
+}
+
+int cellGameContentErrorDialog()
+{
+	UNIMPLEMENTED_FUNC(cellGame);
+	return CELL_OK;
+}
+
+int cellGameThemeInstall()
+{
+	UNIMPLEMENTED_FUNC(cellGame);
+	return CELL_OK;
+}
+
+int cellGameThemeInstallFromBuffer()
+{
+	UNIMPLEMENTED_FUNC(cellGame);
+	return CELL_OK;
+}
+
+void cellGame_init()
+{
+	// (TODO: Disc Exchange functions missing)
+
+	cellGame.AddFunc(0xf52639ea, cellGameBootCheck);
+	cellGame.AddFunc(0xce4374f6, cellGamePatchCheck);
+	cellGame.AddFunc(0xdb9819f3, cellGameDataCheck);
+	cellGame.AddFunc(0x70acec67, cellGameContentPermit);
+
+	cellGame.AddFunc(0x42a2e133, cellGameCreateGameData);
+	cellGame.AddFunc(0xb367c6e3, cellGameDeleteGameData);
+
+	cellGame.AddFunc(0xb7a45caf, cellGameGetParamInt);
+	//cellGame.AddFunc(, cellGameSetParamInt);
+	cellGame.AddFunc(0x3a5d726a, cellGameGetParamString);
+	cellGame.AddFunc(0xdaa5cd20, cellGameSetParamString);
+	cellGame.AddFunc(0xef9d42d5, cellGameGetSizeKB);
+	cellGame.AddFunc(0x2a8e6b92, cellGameGetDiscContentInfoUpdatePath);
+	cellGame.AddFunc(0xa80bf223, cellGameGetLocalWebContentPath);
+
+	cellGame.AddFunc(0xb0a1f8c6, cellGameContentErrorDialog);
+
+	cellGame.AddFunc(0xd24e3928, cellGameThemeInstall);
+	cellGame.AddFunc(0x87406734, cellGameThemeInstallFromBuffer);
+	//cellGame.AddFunc(, CellGameThemeInstallCallback);
+}

rpcs3/Emu/SysCalls/Modules/cellGem.cpp

@@ -0,0 +1,284 @@
+#include "stdafx.h"
+#include "Emu/SysCalls/SysCalls.h"
+#include "Emu/SysCalls/SC_FUNC.h"
+
+void cellGem_init();
+Module cellGem(0x005a, cellGem_init);
+
+// Error Codes
+enum
+{
+	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,
+};
+
+int cellGemCalibrate()
+{
+	UNIMPLEMENTED_FUNC(cellGem);
+	return CELL_OK;
+}
+
+int cellGemClearStatusFlags()
+{
+	UNIMPLEMENTED_FUNC(cellGem);
+	return CELL_OK;
+}
+
+int cellGemConvertVideoFinish()
+{
+	UNIMPLEMENTED_FUNC(cellGem);
+	return CELL_OK;
+}
+
+int cellGemConvertVideoStart()
+{
+	UNIMPLEMENTED_FUNC(cellGem);
+	return CELL_OK;
+}
+
+int cellGemEnableCameraPitchAngleCorrection()
+{
+	UNIMPLEMENTED_FUNC(cellGem);
+	return CELL_OK;
+}
+
+int cellGemEnableMagnetometer()
+{
+	UNIMPLEMENTED_FUNC(cellGem);
+	return CELL_OK;
+}
+
+int cellGemEnd()
+{
+	UNIMPLEMENTED_FUNC(cellGem);
+	return CELL_OK;
+}
+
+int cellGemFilterState()
+{
+	UNIMPLEMENTED_FUNC(cellGem);
+	return CELL_OK;
+}
+
+int cellGemForceRGB()
+{
+	UNIMPLEMENTED_FUNC(cellGem);
+	return CELL_OK;
+}
+
+int cellGemGetAccelerometerPositionInDevice()
+{
+	UNIMPLEMENTED_FUNC(cellGem);
+	return CELL_OK;
+}
+
+int cellGemGetAllTrackableHues()
+{
+	UNIMPLEMENTED_FUNC(cellGem);
+	return CELL_OK;
+}
+
+int cellGemGetCameraState()
+{
+	UNIMPLEMENTED_FUNC(cellGem);
+	return CELL_OK;
+}
+
+int cellGemGetEnvironmentLightingColor()
+{
+	UNIMPLEMENTED_FUNC(cellGem);
+	return CELL_OK;
+}
+
+int cellGemGetHuePixels()
+{
+	UNIMPLEMENTED_FUNC(cellGem);
+	return CELL_OK;
+}
+
+int cellGemGetImageState()
+{
+	UNIMPLEMENTED_FUNC(cellGem);
+	return CELL_OK;
+}
+
+int cellGemGetInertialState()
+{
+	UNIMPLEMENTED_FUNC(cellGem);
+	return CELL_OK;
+}
+
+int cellGemGetInfo()
+{
+	UNIMPLEMENTED_FUNC(cellGem);
+	return CELL_OK;
+}
+
+int cellGemGetMemorySize()
+{
+	UNIMPLEMENTED_FUNC(cellGem);
+	return CELL_OK;
+}
+
+int cellGemGetRGB()
+{
+	UNIMPLEMENTED_FUNC(cellGem);
+	return CELL_OK;
+}
+
+int cellGemGetRumble()
+{
+	UNIMPLEMENTED_FUNC(cellGem);
+	return CELL_OK;
+}
+
+int cellGemGetState()
+{
+	UNIMPLEMENTED_FUNC(cellGem);
+	return CELL_OK;
+}
+
+int cellGemGetStatusFlags()
+{
+	UNIMPLEMENTED_FUNC(cellGem);
+	return CELL_OK;
+}
+
+int cellGemGetTrackerHue()
+{
+	UNIMPLEMENTED_FUNC(cellGem);
+	return CELL_OK;
+}
+
+int cellGemHSVtoRGB()
+{
+	UNIMPLEMENTED_FUNC(cellGem);
+	return CELL_OK;
+}
+
+int cellGemInit()
+{
+	UNIMPLEMENTED_FUNC(cellGem);
+	return CELL_OK;
+}
+
+int cellGemInvalidateCalibration()
+{
+	UNIMPLEMENTED_FUNC(cellGem);
+	return CELL_OK;
+}
+
+int cellGemIsTrackableHue()
+{
+	UNIMPLEMENTED_FUNC(cellGem);
+	return CELL_OK;
+}
+
+int cellGemPrepareCamera()
+{
+	UNIMPLEMENTED_FUNC(cellGem);
+	return CELL_OK;
+}
+
+int cellGemPrepareVideoConvert()
+{
+	UNIMPLEMENTED_FUNC(cellGem);
+	return CELL_OK;
+}
+
+int cellGemReset()
+{
+	UNIMPLEMENTED_FUNC(cellGem);
+	return CELL_OK;
+}
+
+int cellGemSetRumble()
+{
+	UNIMPLEMENTED_FUNC(cellGem);
+	return CELL_OK;
+}
+
+int cellGemSetYaw()
+{
+	UNIMPLEMENTED_FUNC(cellGem);
+	return CELL_OK;
+}
+
+int cellGemTrackHues()
+{
+	UNIMPLEMENTED_FUNC(cellGem);
+	return CELL_OK;
+}
+
+int cellGemUpdateFinish()
+{
+	UNIMPLEMENTED_FUNC(cellGem);
+	return CELL_OK;
+}
+
+int cellGemUpdateStart()
+{
+	UNIMPLEMENTED_FUNC(cellGem);
+	return CELL_OK;
+}
+
+int cellGemWriteExternalPort()
+{
+	UNIMPLEMENTED_FUNC(cellGem);
+	return CELL_OK;
+}
+
+void cellGem_init()
+{
+	//cellGem.AddFunc(, cellGemAttributeInit);
+	cellGem.AddFunc(0xafa99ead, cellGemCalibrate);
+	cellGem.AddFunc(0x9b9714a4, cellGemClearStatusFlags);
+	cellGem.AddFunc(0x1a13d010, cellGemConvertVideoFinish);
+	cellGem.AddFunc(0x6dce048c, cellGemConvertVideoStart);
+	cellGem.AddFunc(0x4219de31, cellGemEnableCameraPitchAngleCorrection);
+	cellGem.AddFunc(0x1a2518a2, cellGemEnableMagnetometer);
+	cellGem.AddFunc(0xe1f85a80, cellGemEnd);
+	cellGem.AddFunc(0x6fc4c791, cellGemFilterState);
+	cellGem.AddFunc(0xce6d7791, cellGemForceRGB);
+	cellGem.AddFunc(0x6a5b7048, cellGemGetAccelerometerPositionInDevice);
+	cellGem.AddFunc(0x2d2c2764, cellGemGetAllTrackableHues);
+	cellGem.AddFunc(0x8befac67, cellGemGetCameraState);
+	cellGem.AddFunc(0x02eb41bb, cellGemGetEnvironmentLightingColor);
+	cellGem.AddFunc(0xb8ef56a6, cellGemGetHuePixels);
+	cellGem.AddFunc(0x92cc4b34, cellGemGetImageState);
+	cellGem.AddFunc(0xd37b127a, cellGemGetInertialState);
+	cellGem.AddFunc(0x9e1dff96, cellGemGetInfo);
+	cellGem.AddFunc(0x2e0a170d, cellGemGetMemorySize);
+	cellGem.AddFunc(0x1b30cc22, cellGemGetRGB);
+	cellGem.AddFunc(0x6db6b007, cellGemGetRumble);
+	cellGem.AddFunc(0x6441d38d, cellGemGetState);
+	cellGem.AddFunc(0xfee33481, cellGemGetStatusFlags);
+	cellGem.AddFunc(0x18ea899a, cellGemGetTrackerHue);
+	//cellGem.AddFunc(, cellGemGetVideoConvertSize);
+	cellGem.AddFunc(0xc7622586, cellGemHSVtoRGB);
+	cellGem.AddFunc(0x13ea7c64, cellGemInit);
+	cellGem.AddFunc(0xe3e4f0d6, cellGemInvalidateCalibration);
+	cellGem.AddFunc(0xfb5887f9, cellGemIsTrackableHue);
+	cellGem.AddFunc(0xa03ef587, cellGemPrepareCamera);
+	cellGem.AddFunc(0xc07896f9, cellGemPrepareVideoConvert);
+	//cellGem.AddFunc(, cellGemReadExternalPortDeviceInfo);
+	cellGem.AddFunc(0xde54e2fc, cellGemReset);
+	cellGem.AddFunc(0x49609306, cellGemSetRumble);
+	cellGem.AddFunc(0x77e08704, cellGemSetYaw);
+	cellGem.AddFunc(0x928ac5f8, cellGemTrackHues);
+	cellGem.AddFunc(0x41ae9c31, cellGemUpdateFinish);
+	cellGem.AddFunc(0x0ecd2261, cellGemUpdateStart);
+	//cellGem.AddFunc(, cellGemVideoConvertAttributeInit);
+	//cellGem.AddFunc(, cellGemVideoConvertAttributeInitRgba);
+	cellGem.AddFunc(0x1f6328d8, cellGemWriteExternalPort);
+
+}

rpcs3/Emu/SysCalls/Modules/cellImejp.cpp

@@ -0,0 +1,306 @@
+#include "stdafx.h"
+#include "Emu/SysCalls/SysCalls.h"
+#include "Emu/SysCalls/SC_FUNC.h"
+
+void cellImejp_init();
+Module cellImejp(0xf023, cellImejp_init);
+
+// Return Codes
+enum
+{
+	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,
+};
+
+int cellImeJpOpen()
+{
+	UNIMPLEMENTED_FUNC(cellImejp);
+	return CELL_OK;
+}
+
+int cellImeJpOpen2()
+{
+	UNIMPLEMENTED_FUNC(cellImejp);
+	return CELL_OK;
+}
+
+int cellImeJpOpen3()
+{
+	UNIMPLEMENTED_FUNC(cellImejp);
+	return CELL_OK;
+}
+
+int cellImeJpClose()
+{
+	UNIMPLEMENTED_FUNC(cellImejp);
+	return CELL_OK;
+}
+
+int cellImeJpSetKanaInputMode()
+{
+	UNIMPLEMENTED_FUNC(cellImejp);
+	return CELL_OK;
+}
+
+int cellImeJpSetInputCharType()
+{
+	UNIMPLEMENTED_FUNC(cellImejp);
+	return CELL_OK;
+}
+
+int cellImeJpSetFixInputMode()
+{
+	UNIMPLEMENTED_FUNC(cellImejp);
+	return CELL_OK;
+}
+
+int cellImeJpReset()
+{
+	UNIMPLEMENTED_FUNC(cellImejp);
+	return CELL_OK;
+}
+
+int cellImeJpGetStatus()
+{
+	UNIMPLEMENTED_FUNC(cellImejp);
+	return CELL_OK;
+}
+
+int cellImeJpEnterChar()
+{
+	UNIMPLEMENTED_FUNC(cellImejp);
+	return CELL_OK;
+}
+
+int cellImeJpEnterCharExt()
+{
+	UNIMPLEMENTED_FUNC(cellImejp);
+	return CELL_OK;
+}
+
+int cellImeJpEnterString()
+{
+	UNIMPLEMENTED_FUNC(cellImejp);
+	return CELL_OK;
+}
+
+int cellImeJpEnterStringExt()
+{
+	UNIMPLEMENTED_FUNC(cellImejp);
+	return CELL_OK;
+}
+
+int cellImeJpModeCaretRight()
+{
+	UNIMPLEMENTED_FUNC(cellImejp);
+	return CELL_OK;
+}
+
+int cellImeJpModeCaretLeft()
+{
+	UNIMPLEMENTED_FUNC(cellImejp);
+	return CELL_OK;
+}
+
+int cellImeJpBackspaceWord()
+{
+	UNIMPLEMENTED_FUNC(cellImejp);
+	return CELL_OK;
+}
+
+int cellImeJpDeleteWord()
+{
+	UNIMPLEMENTED_FUNC(cellImejp);
+	return CELL_OK;
+}
+
+int cellImeJpAllDeleteConvertString()
+{
+	UNIMPLEMENTED_FUNC(cellImejp);
+	return CELL_OK;
+}
+
+int cellImeJpConvertForward()
+{
+	UNIMPLEMENTED_FUNC(cellImejp);
+	return CELL_OK;
+}
+
+int cellImeJpConvertBackward()
+{
+	UNIMPLEMENTED_FUNC(cellImejp);
+	return CELL_OK;
+}
+
+int cellImeJpCurrentPartConfirm()
+{
+	UNIMPLEMENTED_FUNC(cellImejp);
+	return CELL_OK;
+}
+
+int cellImeJpAllConfirm()
+{
+	UNIMPLEMENTED_FUNC(cellImejp);
+	return CELL_OK;
+}
+
+int cellImeJpConvertCancel()
+{
+	UNIMPLEMENTED_FUNC(cellImejp);
+	return CELL_OK;
+}
+
+int cellImeJpAllConvertCancel()
+{
+	UNIMPLEMENTED_FUNC(cellImejp);
+	return CELL_OK;
+}
+
+int cellImeJpExtendConvertArea()
+{
+	UNIMPLEMENTED_FUNC(cellImejp);
+	return CELL_OK;
+}
+
+int cellImeJpShortenConvertArea()
+{
+	UNIMPLEMENTED_FUNC(cellImejp);
+	return CELL_OK;
+}
+
+int cellImeJpTemporalConfirm()
+{
+	UNIMPLEMENTED_FUNC(cellImejp);
+	return CELL_OK;
+}
+
+int cellImeJpPostConvert()
+{
+	UNIMPLEMENTED_FUNC(cellImejp);
+	return CELL_OK;
+}
+
+int cellImeJpMoveFocusClause()
+{
+	UNIMPLEMENTED_FUNC(cellImejp);
+	return CELL_OK;
+}
+
+int cellImeJpGetFocusTop()
+{
+	UNIMPLEMENTED_FUNC(cellImejp);
+	return CELL_OK;
+}
+
+int cellImeJpGetFocusLength()
+{
+	UNIMPLEMENTED_FUNC(cellImejp);
+	return CELL_OK;
+}
+
+int cellImeJpGetConfirmYomiString()
+{
+	UNIMPLEMENTED_FUNC(cellImejp);
+	return CELL_OK;
+}
+
+int cellImeJpGetConfirmString()
+{
+	UNIMPLEMENTED_FUNC(cellImejp);
+	return CELL_OK;
+}
+
+int cellImeJpGetConvertYomiString()
+{
+	UNIMPLEMENTED_FUNC(cellImejp);
+	return CELL_OK;
+}
+
+int cellImeJpGetConvertString()
+{
+	UNIMPLEMENTED_FUNC(cellImejp);
+	return CELL_OK;
+}
+
+int cellImeJpGetCandidateListSize()
+{
+	UNIMPLEMENTED_FUNC(cellImejp);
+	return CELL_OK;
+}
+
+int cellImeJpGetCandidateList()
+{
+	UNIMPLEMENTED_FUNC(cellImejp);
+	return CELL_OK;
+}
+
+int cellImeJpGetCandidateSelect()
+{
+	UNIMPLEMENTED_FUNC(cellImejp);
+	return CELL_OK;
+}
+
+int cellImeJpGetPredictList()
+{
+	UNIMPLEMENTED_FUNC(cellImejp);
+	return CELL_OK;
+}
+
+int cellImeJpConfirmPrediction()
+{
+	UNIMPLEMENTED_FUNC(cellImejp);
+	return CELL_OK;
+}
+
+void cellImejp_init()
+{
+	cellImejp.AddFunc(0x44608862, cellImeJpOpen);
+	cellImejp.AddFunc(0x47b43dd4, cellImeJpOpen2);
+	cellImejp.AddFunc(0x1b119958, cellImeJpOpen3);
+	cellImejp.AddFunc(0x46d1234a, cellImeJpClose);
+
+	cellImejp.AddFunc(0x24e9d8fc, cellImeJpSetKanaInputMode);
+	cellImejp.AddFunc(0xf5992ec8, cellImeJpSetInputCharType);
+	cellImejp.AddFunc(0xc1786c81, cellImeJpSetFixInputMode);
+	//cellImejp.AddFunc(, cellImeJpAllowExtensionCharacters);
+	cellImejp.AddFunc(0x36d38701, cellImeJpReset);
+
+	cellImejp.AddFunc(0x66c6cc78, cellImeJpGetStatus);
+
+	cellImejp.AddFunc(0x6ccbe3d6, cellImeJpEnterChar);
+	cellImejp.AddFunc(0x5b6ada55, cellImeJpEnterCharExt);
+	cellImejp.AddFunc(0x441a1c2b, cellImeJpEnterString);
+	cellImejp.AddFunc(0x6298b55a, cellImeJpEnterStringExt);
+	cellImejp.AddFunc(0xac6693d8, cellImeJpModeCaretRight);
+	cellImejp.AddFunc(0xe76c9700, cellImeJpModeCaretLeft);
+	cellImejp.AddFunc(0xaa1d1f57, cellImeJpBackspaceWord);
+	cellImejp.AddFunc(0x72257652, cellImeJpDeleteWord);
+	cellImejp.AddFunc(0x6319eda3, cellImeJpAllDeleteConvertString);
+	cellImejp.AddFunc(0x1e29103b, cellImeJpConvertForward);
+	cellImejp.AddFunc(0xc2bb48bc, cellImeJpConvertBackward);
+	cellImejp.AddFunc(0x7a18c2b9, cellImeJpCurrentPartConfirm);
+	cellImejp.AddFunc(0x7189430b, cellImeJpAllConfirm);
+	cellImejp.AddFunc(0xeae879dc, cellImeJpConvertCancel);
+	cellImejp.AddFunc(0xcbbc20b7, cellImeJpAllConvertCancel);
+	cellImejp.AddFunc(0x37961cc1, cellImeJpExtendConvertArea);
+	cellImejp.AddFunc(0xaa2a3287, cellImeJpShortenConvertArea);
+	cellImejp.AddFunc(0xbd679cc1, cellImeJpTemporalConfirm);
+	cellImejp.AddFunc(0x8bb41f47, cellImeJpPostConvert);
+	cellImejp.AddFunc(0x1e411261, cellImeJpMoveFocusClause);
+	cellImejp.AddFunc(0x0e363ae7, cellImeJpGetFocusTop);
+	cellImejp.AddFunc(0x5f5b3227, cellImeJpGetFocusLength);
+	cellImejp.AddFunc(0x89f8a567, cellImeJpGetConfirmYomiString);
+	cellImejp.AddFunc(0xd3fc3606, cellImeJpGetConfirmString);
+	cellImejp.AddFunc(0xea2d4881, cellImeJpGetConvertYomiString);
+	cellImejp.AddFunc(0xf91abda3, cellImeJpGetConvertString);
+	cellImejp.AddFunc(0xc4796a45, cellImeJpGetCandidateListSize);
+	cellImejp.AddFunc(0xe4cc15ba, cellImeJpGetCandidateList);
+	cellImejp.AddFunc(0x177bd218, cellImeJpGetCandidateSelect);
+	cellImejp.AddFunc(0x1986f2cd, cellImeJpGetPredictList);
+	cellImejp.AddFunc(0xeede898c, cellImeJpConfirmPrediction);
+}

rpcs3/Emu/SysCalls/Modules/cellJpgEnc.cpp

@@ -0,0 +1,91 @@
+#include "stdafx.h"
+#include "Emu/SysCalls/SysCalls.h"
+#include "Emu/SysCalls/SC_FUNC.h"
+
+void cellJpgEnc_init();
+Module cellJpgEnc(0x003d, cellJpgEnc_init);
+
+// Error Codes
+enum
+{
+	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,
+};
+
+int cellJpgEncQueryAttr()
+{
+	UNIMPLEMENTED_FUNC(cellJpgEnc);
+	return CELL_OK;
+}
+
+int cellJpgEncOpen()
+{
+	UNIMPLEMENTED_FUNC(cellJpgEnc);
+	return CELL_OK;
+}
+
+int cellJpgEncOpenEx()
+{
+	UNIMPLEMENTED_FUNC(cellJpgEnc);
+	return CELL_OK;
+}
+
+int cellJpgEncClose()
+{
+	UNIMPLEMENTED_FUNC(cellJpgEnc);
+	return CELL_OK;
+}
+
+int cellJpgEncWaitForInput()
+{
+	UNIMPLEMENTED_FUNC(cellJpgEnc);
+	return CELL_OK;
+}
+
+int cellJpgEncEncodePicture()
+{
+	UNIMPLEMENTED_FUNC(cellJpgEnc);
+	return CELL_OK;
+}
+
+int cellJpgEncEncodePicture2()
+{
+	UNIMPLEMENTED_FUNC(cellJpgEnc);
+	return CELL_OK;
+}
+
+int cellJpgEncWaitForOutput()
+{
+	UNIMPLEMENTED_FUNC(cellJpgEnc);
+	return CELL_OK;
+}
+
+int cellJpgEncGetStreamInfo()
+{
+	UNIMPLEMENTED_FUNC(cellJpgEnc);
+	return CELL_OK;
+}
+
+int cellJpgEncReset()
+{
+	UNIMPLEMENTED_FUNC(cellJpgEnc);
+	return CELL_OK;
+}
+
+void cellJpgEnc_init()
+{
+	cellJpgEnc.AddFunc(0x12d9b6c5, cellJpgEncQueryAttr);
+	cellJpgEnc.AddFunc(0xa4bfae51, cellJpgEncOpen);
+	cellJpgEnc.AddFunc(0x6f2d371c, cellJpgEncOpenEx);
+	cellJpgEnc.AddFunc(0x969fc5f7, cellJpgEncClose);
+	cellJpgEnc.AddFunc(0x2ae79be8, cellJpgEncWaitForInput);
+	cellJpgEnc.AddFunc(0xa9e81214, cellJpgEncEncodePicture);
+	cellJpgEnc.AddFunc(0x636dc89e, cellJpgEncEncodePicture2);
+	cellJpgEnc.AddFunc(0x9b4e3a74, cellJpgEncWaitForOutput);
+	cellJpgEnc.AddFunc(0x4262e880, cellJpgEncGetStreamInfo);
+	cellJpgEnc.AddFunc(0x0cf2b78b, cellJpgEncReset);
+}

rpcs3/Emu/SysCalls/Modules/cellKey2char.cpp

@@ -0,0 +1,57 @@
+#include "stdafx.h"
+#include "Emu/SysCalls/SysCalls.h"
+#include "Emu/SysCalls/SC_FUNC.h"
+
+void cellKey2char_init();
+Module cellKey2char(0x0021, cellKey2char_init);
+
+// Return Codes
+enum
+{
+	CELL_K2C_OK							= 0x00000000,
+	CELL_K2C_ERROR_FATAL				= 0x80121301,
+	CELL_K2C_ERROR_INVALID_HANDLE		= 0x80121302,
+	CELL_K2C_ERROR_INVALID_PARAMETER	= 0x80121303,
+	CELL_K2C_ERROR_ALREADY_INITIALIZED	= 0x80121304,
+	CELL_K2C_ERROR_UNINITIALIZED		= 0x80121305,
+	CELL_K2C_ERROR_OTHER				= 0x80121306,
+};
+
+int cellKey2CharOpen()
+{
+	UNIMPLEMENTED_FUNC(cellKey2char);
+	return CELL_OK;
+}
+
+int cellKey2CharClose()
+{
+	UNIMPLEMENTED_FUNC(cellKey2char);
+	return CELL_OK;
+}
+
+int cellKey2CharGetChar()
+{
+	UNIMPLEMENTED_FUNC(cellKey2char);
+	return CELL_OK;
+}
+
+int cellKey2CharSetMode()
+{
+	UNIMPLEMENTED_FUNC(cellKey2char);
+	return CELL_OK;
+}
+
+int cellKey2CharSetArrangement()
+{
+	UNIMPLEMENTED_FUNC(cellKey2char);
+	return CELL_OK;
+}
+
+void cellKey2char_init()
+{
+	cellKey2char.AddFunc(0xabf629c1, cellKey2CharOpen);
+	cellKey2char.AddFunc(0x14bf2dc1, cellKey2CharClose);
+	cellKey2char.AddFunc(0x56776c0d, cellKey2CharGetChar);
+	cellKey2char.AddFunc(0xbfc03768, cellKey2CharSetMode);
+	cellKey2char.AddFunc(0x0dfbadfa, cellKey2CharSetArrangement);
+}

rpcs3/Emu/SysCalls/Modules/cellL10n.cpp

@@ -0,0 +1,11 @@
+#include "stdafx.h"
+#include "Emu/SysCalls/SysCalls.h"
+#include "Emu/SysCalls/SC_FUNC.h"
+
+void cellL10n_init();
+Module cellL10n(0x001e, cellL10n_init);
+
+void cellL10n_init()
+{
+	// (TODO: Get addresses of cellL10n functions)
+}

rpcs3/Emu/SysCalls/Modules/cellLv2dbg.cpp

@@ -0,0 +1,269 @@
+#include "stdafx.h"
+#include "Emu/SysCalls/SysCalls.h"
+#include "Emu/SysCalls/SC_FUNC.h"
+
+void cellLv2dbg_init();
+Module cellLv2dbg(0x002e, cellLv2dbg_init);
+
+// Return Codes
+enum
+{
+	CELL_LV2DBG_ERROR_DEINVALIDARGUMENTS	= 0x80010409,
+	CELL_LV2DBG_ERROR_DEOPERATIONDENIED		= 0x8001042c,
+};
+
+int sys_dbg_read_spu_thread_context()
+{
+	UNIMPLEMENTED_FUNC(cellLv2dbg);
+	return CELL_OK;
+}
+
+int sys_dbg_initialize_ppu_exception_handler()
+{
+	UNIMPLEMENTED_FUNC(cellLv2dbg);
+	return CELL_OK;
+}
+
+int sys_dbg_register_ppu_exception_handler()
+{
+	UNIMPLEMENTED_FUNC(cellLv2dbg);
+	return CELL_OK;
+}
+
+int sys_dbg_finalize_ppu_exception_handler()
+{
+	UNIMPLEMENTED_FUNC(cellLv2dbg);
+	return CELL_OK;
+}
+
+int sys_dbg_unregister_ppu_exception_handler()
+{
+	UNIMPLEMENTED_FUNC(cellLv2dbg);
+	return CELL_OK;
+}
+
+int sys_dbg_set_stacksize_ppu_exception_handler()
+{
+	UNIMPLEMENTED_FUNC(cellLv2dbg);
+	return CELL_OK;
+}
+
+int sys_dbg_signal_to_ppu_exception_handler()
+{
+	UNIMPLEMENTED_FUNC(cellLv2dbg);
+	return CELL_OK;
+}
+
+int sys_dbg_enable_floating_point_enabled_exception()
+{
+	UNIMPLEMENTED_FUNC(cellLv2dbg);
+	return CELL_OK;
+}
+
+int sys_dbg_disable_floating_point_enabled_exception()
+{
+	UNIMPLEMENTED_FUNC(cellLv2dbg);
+	return CELL_OK;
+}
+
+int sys_dbg_set_address_to_dabr()
+{
+	UNIMPLEMENTED_FUNC(cellLv2dbg);
+	return CELL_OK;
+}
+
+int sys_dbg_get_address_from_dabr()
+{
+	UNIMPLEMENTED_FUNC(cellLv2dbg);
+	return CELL_OK;
+}
+
+int sys_dbg_set_mask_to_ppu_exception_handler()
+{
+	UNIMPLEMENTED_FUNC(cellLv2dbg);
+	return CELL_OK;
+}
+
+int sys_dbg_read_ppu_thread_context()
+{
+	UNIMPLEMENTED_FUNC(cellLv2dbg);
+	return CELL_OK;
+}
+
+int sys_dbg_read_spu_thread_context2()
+{
+	UNIMPLEMENTED_FUNC(cellLv2dbg);
+	return CELL_OK;
+}
+
+int sys_dbg_get_ppu_thread_name()
+{
+	UNIMPLEMENTED_FUNC(cellLv2dbg);
+	return CELL_OK;
+}
+
+int sys_dbg_get_spu_thread_name()
+{
+	UNIMPLEMENTED_FUNC(cellLv2dbg);
+	return CELL_OK;
+}
+
+int sys_dbg_get_spu_thread_group_name()
+{
+	UNIMPLEMENTED_FUNC(cellLv2dbg);
+	return CELL_OK;
+}
+
+int sys_dbg_get_ppu_thread_status()
+{
+	UNIMPLEMENTED_FUNC(cellLv2dbg);
+	return CELL_OK;
+}
+
+int sys_dbg_get_spu_thread_group_status()
+{
+	UNIMPLEMENTED_FUNC(cellLv2dbg);
+	return CELL_OK;
+}
+
+int sys_dbg_get_ppu_thread_ids()
+{
+	UNIMPLEMENTED_FUNC(cellLv2dbg);
+	return CELL_OK;
+}
+
+int sys_dbg_get_spu_thread_ids()
+{
+	UNIMPLEMENTED_FUNC(cellLv2dbg);
+	return CELL_OK;
+}
+
+int sys_dbg_get_spu_thread_group_ids()
+{
+	UNIMPLEMENTED_FUNC(cellLv2dbg);
+	return CELL_OK;
+}
+
+int sys_dbg_get_mutex_information()
+{
+	UNIMPLEMENTED_FUNC(cellLv2dbg);
+	return CELL_OK;
+}
+
+int sys_dbg_get_lwmutex_information()
+{
+	UNIMPLEMENTED_FUNC(cellLv2dbg);
+	return CELL_OK;
+}
+
+int sys_dbg_get_rwlock_information()
+{
+	UNIMPLEMENTED_FUNC(cellLv2dbg);
+	return CELL_OK;
+}
+
+int sys_dbg_get_semaphore_information()
+{
+	UNIMPLEMENTED_FUNC(cellLv2dbg);
+	return CELL_OK;
+}
+
+int sys_dbg_get_cond_information()
+{
+	UNIMPLEMENTED_FUNC(cellLv2dbg);
+	return CELL_OK;
+}
+
+int sys_dbg_get_lwcond_information()
+{
+	UNIMPLEMENTED_FUNC(cellLv2dbg);
+	return CELL_OK;
+}
+
+int sys_dbg_get_event_queue_information()
+{
+	UNIMPLEMENTED_FUNC(cellLv2dbg);
+	return CELL_OK;
+}
+
+int sys_dbg_get_event_flag_information()
+{
+	UNIMPLEMENTED_FUNC(cellLv2dbg);
+	return CELL_OK;
+}
+
+int sys_dbg_vm_get_page_information()
+{
+	UNIMPLEMENTED_FUNC(cellLv2dbg);
+	return CELL_OK;
+}
+
+int sys_dbg_mat_set_condition()
+{
+	UNIMPLEMENTED_FUNC(cellLv2dbg);
+	return CELL_OK;
+}
+
+int sys_dbg_mat_get_condition()
+{
+	UNIMPLEMENTED_FUNC(cellLv2dbg);
+	return CELL_OK;
+}
+
+int sys_dbg_signal_to_coredump_handler()
+{
+	UNIMPLEMENTED_FUNC(cellLv2dbg);
+	return CELL_OK;
+}
+
+int sys_dbg_get_coredump_params()
+{
+	UNIMPLEMENTED_FUNC(cellLv2dbg);
+	return CELL_OK;
+}
+
+void cellLv2dbg_init()
+{
+	cellLv2dbg.AddFunc(0xc21ee635, sys_dbg_read_spu_thread_context);
+	cellLv2dbg.AddFunc(0xc353353a, sys_dbg_initialize_ppu_exception_handler);
+	cellLv2dbg.AddFunc(0x22916f45, sys_dbg_register_ppu_exception_handler);
+	cellLv2dbg.AddFunc(0xc0eb9266, sys_dbg_finalize_ppu_exception_handler);
+	cellLv2dbg.AddFunc(0xc6d7ec13, sys_dbg_unregister_ppu_exception_handler);
+	cellLv2dbg.AddFunc(0x06a840f5, sys_dbg_set_stacksize_ppu_exception_handler);
+	cellLv2dbg.AddFunc(0x4ded9f6c, sys_dbg_signal_to_ppu_exception_handler);
+	cellLv2dbg.AddFunc(0x3147c6ca, sys_dbg_enable_floating_point_enabled_exception);
+	cellLv2dbg.AddFunc(0xf254768c, sys_dbg_disable_floating_point_enabled_exception);
+	cellLv2dbg.AddFunc(0xdb14b37b, sys_dbg_set_address_to_dabr);
+	cellLv2dbg.AddFunc(0xbb0ae221, sys_dbg_get_address_from_dabr);
+	cellLv2dbg.AddFunc(0xab475d53, sys_dbg_set_mask_to_ppu_exception_handler);
+
+	cellLv2dbg.AddFunc(0xc5eef17f, sys_dbg_read_ppu_thread_context);
+	cellLv2dbg.AddFunc(0x266c2bd3, sys_dbg_read_spu_thread_context2);
+
+	cellLv2dbg.AddFunc(0x4b55f456, sys_dbg_get_ppu_thread_name);
+	cellLv2dbg.AddFunc(0x3e5eed36, sys_dbg_get_spu_thread_name);
+	cellLv2dbg.AddFunc(0xbd69e584, sys_dbg_get_spu_thread_group_name);
+	cellLv2dbg.AddFunc(0x6b413178, sys_dbg_get_ppu_thread_status);
+	cellLv2dbg.AddFunc(0x9ddb9dc3, sys_dbg_get_spu_thread_group_status);
+
+	cellLv2dbg.AddFunc(0x113b0bea, sys_dbg_get_ppu_thread_ids);
+	cellLv2dbg.AddFunc(0x1860f909, sys_dbg_get_spu_thread_ids);
+	cellLv2dbg.AddFunc(0x08ef08a9, sys_dbg_get_spu_thread_group_ids);
+
+	cellLv2dbg.AddFunc(0x50453aa8, sys_dbg_get_mutex_information);
+	cellLv2dbg.AddFunc(0xcb377e36, sys_dbg_get_lwmutex_information);
+	cellLv2dbg.AddFunc(0x9794bb53, sys_dbg_get_rwlock_information);
+	cellLv2dbg.AddFunc(0xa2d6cbd2, sys_dbg_get_semaphore_information);
+	cellLv2dbg.AddFunc(0x63bd413e, sys_dbg_get_cond_information);
+	cellLv2dbg.AddFunc(0x7bdadb01, sys_dbg_get_lwcond_information);
+	cellLv2dbg.AddFunc(0x381ae33e, sys_dbg_get_event_queue_information);
+	cellLv2dbg.AddFunc(0xdf856979, sys_dbg_get_event_flag_information);
+
+	cellLv2dbg.AddFunc(0x580f8203, sys_dbg_vm_get_page_information);
+
+	cellLv2dbg.AddFunc(0x24a3d413, sys_dbg_mat_set_condition);
+	cellLv2dbg.AddFunc(0x590a276e, sys_dbg_mat_get_condition);
+
+	cellLv2dbg.AddFunc(0xd830062a, sys_dbg_signal_to_coredump_handler);
+	cellLv2dbg.AddFunc(0xb9da87d3, sys_dbg_get_coredump_params);
+}

rpcs3/Emu/SysCalls/Modules/cellMic.cpp

@@ -0,0 +1,331 @@
+#include "stdafx.h"
+#include "Emu/SysCalls/SysCalls.h"
+#include "Emu/SysCalls/SC_FUNC.h"
+
+void cellMic_init();
+Module cellMic(0x0022, cellMic_init);
+
+// Error Codes
+enum
+{
+	CELL_MICIN_ERROR_ALREADY_INIT		= 0x80140101,
+	CELL_MICIN_ERROR_SYSTEM				= 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_SYSTEM_NOT_FOUND	= 0x8014010e,
+	CELL_MICIN_ERROR_FATAL				= 0x8014010f,
+	CELL_MICIN_ERROR_DEVICE_NOT_SUPPORT	= 0x80140110,
+};
+
+int cellMicInit()
+{
+	UNIMPLEMENTED_FUNC(cellMic);
+	return CELL_OK;
+}
+
+int cellMicEnd()
+{
+	UNIMPLEMENTED_FUNC(cellMic);
+	return CELL_OK;
+}
+
+int cellMicOpen()
+{
+	UNIMPLEMENTED_FUNC(cellMic);
+	return CELL_OK;
+}
+
+int cellMicClose()
+{
+	UNIMPLEMENTED_FUNC(cellMic);
+	return CELL_OK;
+}
+
+int cellMicGetDeviceGUID()
+{
+	UNIMPLEMENTED_FUNC(cellMic);
+	return CELL_OK;
+}
+
+int cellMicGetType()
+{
+	UNIMPLEMENTED_FUNC(cellMic);
+	return CELL_OK;
+}
+
+int cellMicIsAttached()
+{
+	UNIMPLEMENTED_FUNC(cellMic);
+	return CELL_OK;
+}
+
+int cellMicIsOpen()
+{
+	UNIMPLEMENTED_FUNC(cellMic);
+	return CELL_OK;
+}
+
+int cellMicGetDeviceAttr()
+{
+	UNIMPLEMENTED_FUNC(cellMic);
+	return CELL_OK;
+}
+
+int cellMicSetDeviceAttr()
+{
+	UNIMPLEMENTED_FUNC(cellMic);
+	return CELL_OK;
+}
+
+int cellMicGetSignalAttr()
+{
+	UNIMPLEMENTED_FUNC(cellMic);
+	return CELL_OK;
+}
+
+int cellMicSetSignalAttr()
+{
+	UNIMPLEMENTED_FUNC(cellMic);
+	return CELL_OK;
+}
+
+int cellMicGetSignalState()
+{
+	UNIMPLEMENTED_FUNC(cellMic);
+	return CELL_OK;
+}
+
+int cellMicStart()
+{
+	UNIMPLEMENTED_FUNC(cellMic);
+	return CELL_OK;
+}
+
+int cellMicRead()
+{
+	UNIMPLEMENTED_FUNC(cellMic);
+	return CELL_OK;
+}
+
+int cellMicStop()
+{
+	UNIMPLEMENTED_FUNC(cellMic);
+	return CELL_OK;
+}
+
+int cellMicReset()
+{
+	UNIMPLEMENTED_FUNC(cellMic);
+	return CELL_OK;
+}
+
+int cellMicSetNotifyEventQueue()
+{
+	UNIMPLEMENTED_FUNC(cellMic);
+	return CELL_OK;
+}
+
+int cellMicSetNotifyEventQueue2()
+{
+	UNIMPLEMENTED_FUNC(cellMic);
+	return CELL_OK;
+}
+
+int cellMicRemoveNotifyEventQueue()
+{
+	UNIMPLEMENTED_FUNC(cellMic);
+	return CELL_OK;
+}
+
+int cellMicOpenEx()
+{
+	UNIMPLEMENTED_FUNC(cellMic);
+	return CELL_OK;
+}
+
+int cellMicStartEx()
+{
+	UNIMPLEMENTED_FUNC(cellMic);
+	return CELL_OK;
+}
+
+int cellMicGetFormatRaw()
+{
+	UNIMPLEMENTED_FUNC(cellMic);
+	return CELL_OK;
+}
+
+int cellMicGetFormatAux()
+{
+	UNIMPLEMENTED_FUNC(cellMic);
+	return CELL_OK;
+}
+
+int cellMicGetFormatDsp()
+{
+	UNIMPLEMENTED_FUNC(cellMic);
+	return CELL_OK;
+}
+
+int cellMicOpenRaw()
+{
+	UNIMPLEMENTED_FUNC(cellMic);
+	return CELL_OK;
+}
+
+int cellMicReadRaw()
+{
+	UNIMPLEMENTED_FUNC(cellMic);
+	return CELL_OK;
+}
+
+int cellMicReadAux()
+{
+	UNIMPLEMENTED_FUNC(cellMic);
+	return CELL_OK;
+}
+
+int cellMicReadDsp()
+{
+	UNIMPLEMENTED_FUNC(cellMic);
+	return CELL_OK;
+}
+
+int cellMicGetStatus()
+{
+	UNIMPLEMENTED_FUNC(cellMic);
+	return CELL_OK;
+}
+
+int cellMicStopEx()
+{
+	UNIMPLEMENTED_FUNC(cellMic);
+	return CELL_OK;
+}
+
+int cellMicSysShareClose()
+{
+	UNIMPLEMENTED_FUNC(cellMic);
+	return CELL_OK;
+}
+
+int cellMicGetFormat()
+{
+	UNIMPLEMENTED_FUNC(cellMic);
+	return CELL_OK;
+}
+
+int cellMicSetMultiMicNotifyEventQueue()
+{
+	UNIMPLEMENTED_FUNC(cellMic);
+	return CELL_OK;
+}
+
+int cellMicGetFormatEx()
+{
+	UNIMPLEMENTED_FUNC(cellMic);
+	return CELL_OK;
+}
+
+int cellMicSysShareStop()
+{
+	UNIMPLEMENTED_FUNC(cellMic);
+	return CELL_OK;
+}
+
+int cellMicSysShareOpen()
+{
+	UNIMPLEMENTED_FUNC(cellMic);
+	return CELL_OK;
+}
+
+int cellMicCommand()
+{
+	UNIMPLEMENTED_FUNC(cellMic);
+	return CELL_OK;
+}
+
+int cellMicSysShareStart()
+{
+	UNIMPLEMENTED_FUNC(cellMic);
+	return CELL_OK;
+}
+
+int cellMicSysShareInit()
+{
+	UNIMPLEMENTED_FUNC(cellMic);
+	return CELL_OK;
+}
+
+int cellMicSysShareEnd()
+{
+	UNIMPLEMENTED_FUNC(cellMic);
+	return CELL_OK;
+}
+
+int cellMicGetDeviceIdentifier()
+{
+	UNIMPLEMENTED_FUNC(cellMic);
+	return CELL_OK;
+}
+
+void cellMic_init()
+{
+	cellMic.AddFunc(0x8325e02d, cellMicInit);
+	cellMic.AddFunc(0xc6328caa, cellMicEnd);
+	cellMic.AddFunc(0xdd1b59f0, cellMicOpen);
+	cellMic.AddFunc(0x8d229f8e, cellMicClose);
+
+	cellMic.AddFunc(0x017024a8, cellMicGetDeviceGUID);
+	cellMic.AddFunc(0xa52d2ae4, cellMicGetType);
+	cellMic.AddFunc(0x1b42101b, cellMicIsAttached);
+	cellMic.AddFunc(0x186cb1fb, cellMicIsOpen);
+	cellMic.AddFunc(0x6a024aa0, cellMicGetDeviceAttr);
+	cellMic.AddFunc(0xb2c16321, cellMicSetDeviceAttr);
+	cellMic.AddFunc(0xac5ba03a, cellMicGetSignalAttr);
+	cellMic.AddFunc(0x323deb41, cellMicSetSignalAttr);
+	cellMic.AddFunc(0xb30780eb, cellMicGetSignalState);
+
+	cellMic.AddFunc(0xdd724314, cellMicStart);
+	cellMic.AddFunc(0x07e1b12c, cellMicRead);
+	cellMic.AddFunc(0xfcfaf246, cellMicStop);
+	cellMic.AddFunc(0x6bc46aab, cellMicReset);
+
+	cellMic.AddFunc(0x7903400e, cellMicSetNotifyEventQueue);
+	cellMic.AddFunc(0x6cc7ae00, cellMicSetNotifyEventQueue2);
+	cellMic.AddFunc(0x65336418, cellMicRemoveNotifyEventQueue);
+
+	cellMic.AddFunc(0x05709bbf, cellMicOpenEx);
+	cellMic.AddFunc(0xddd19a89, cellMicStartEx);
+	cellMic.AddFunc(0x4e0b69ee, cellMicGetFormatRaw);
+	cellMic.AddFunc(0xfda12276, cellMicGetFormatAux);
+	cellMic.AddFunc(0x87a08d29, cellMicGetFormatDsp);
+	cellMic.AddFunc(0xa42ac07a, cellMicOpenRaw);
+	cellMic.AddFunc(0x72165a7f, cellMicReadRaw);
+	cellMic.AddFunc(0x3acc118e, cellMicReadAux);
+	cellMic.AddFunc(0xc414faa5, cellMicReadDsp);
+
+	cellMic.AddFunc(0x25c5723f, cellMicGetStatus);
+	cellMic.AddFunc(0xe839380f, cellMicStopEx);
+	cellMic.AddFunc(0x3ace58f3, cellMicSysShareClose);
+	cellMic.AddFunc(0x48108a23, cellMicGetFormat);
+	cellMic.AddFunc(0x891c6291, cellMicSetMultiMicNotifyEventQueue);
+	cellMic.AddFunc(0xad049ecf, cellMicGetFormatEx);
+	cellMic.AddFunc(0xbdfd51e2, cellMicSysShareStop);
+	cellMic.AddFunc(0xc3610dbd, cellMicSysShareOpen);
+	cellMic.AddFunc(0xc461563c, cellMicCommand);
+	cellMic.AddFunc(0xcac7e7d7, cellMicSysShareStart);
+	cellMic.AddFunc(0xd127cd3e, cellMicSysShareInit);
+	cellMic.AddFunc(0xf82bbf7c, cellMicSysShareEnd);
+	cellMic.AddFunc(0xfdbbe469, cellMicGetDeviceIdentifier);
+}

rpcs3/Emu/SysCalls/Modules/cellMusicDecode.cpp

@@ -0,0 +1,100 @@
+#include "stdafx.h"
+#include "Emu/SysCalls/SysCalls.h"
+#include "Emu/SysCalls/SC_FUNC.h"
+
+void cellMusicDecode_init();
+Module cellMusicDecode(0x004f, cellMusicDecode_init);
+
+// Return Codes
+enum
+{
+	CELL_MUSIC_DECODE_OK						= 0,
+	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,
+};
+
+int cellMusicDecodeInitialize()
+{
+	UNIMPLEMENTED_FUNC(cellMusicDecode);
+	return CELL_OK;
+}
+
+int cellMusicDecodeInitializeSystemWorkload()
+{
+	UNIMPLEMENTED_FUNC(cellMusicDecode);
+	return CELL_OK;
+}
+
+int cellMusicDecodeFinalize()
+{
+	UNIMPLEMENTED_FUNC(cellMusicDecode);
+	return CELL_OK;
+}
+
+int cellMusicDecodeSelectContents()
+{
+	UNIMPLEMENTED_FUNC(cellMusicDecode);
+	return CELL_OK;
+}
+
+int cellMusicDecodeSetDecodeCommand()
+{
+	UNIMPLEMENTED_FUNC(cellMusicDecode);
+	return CELL_OK;
+}
+
+int cellMusicDecodeGetDecodeStatus()
+{
+	UNIMPLEMENTED_FUNC(cellMusicDecode);
+	return CELL_OK;
+}
+
+int cellMusicDecodeRead()
+{
+	UNIMPLEMENTED_FUNC(cellMusicDecode);
+	return CELL_OK;
+}
+
+int cellMusicDecodeGetSelectionContext()
+{
+	UNIMPLEMENTED_FUNC(cellMusicDecode);
+	return CELL_OK;
+}
+
+int cellMusicDecodeSetSelectionContext()
+{
+	UNIMPLEMENTED_FUNC(cellMusicDecode);
+	return CELL_OK;
+}
+
+int cellMusicDecodeGetContentsId()
+{
+	UNIMPLEMENTED_FUNC(cellMusicDecode);
+	return CELL_OK;
+}
+
+void cellMusicDecode_init()
+{
+	cellMusicDecode.AddFunc(0xd55dbc11, cellMusicDecodeInitialize);
+	cellMusicDecode.AddFunc(0x84f154b2, cellMusicDecodeInitializeSystemWorkload);
+	cellMusicDecode.AddFunc(0xa8615dc8, cellMusicDecodeFinalize);
+	cellMusicDecode.AddFunc(0xf24cb963, cellMusicDecodeSelectContents);
+	cellMusicDecode.AddFunc(0x066bb1cf, cellMusicDecodeSetDecodeCommand);
+	cellMusicDecode.AddFunc(0x5af74c50, cellMusicDecodeGetDecodeStatus);
+	cellMusicDecode.AddFunc(0xa881b744, cellMusicDecodeRead);
+	cellMusicDecode.AddFunc(0xdbf70550, cellMusicDecodeGetSelectionContext);
+	cellMusicDecode.AddFunc(0xb84f5c81, cellMusicDecodeSetSelectionContext);
+	cellMusicDecode.AddFunc(0x58ab1999, cellMusicDecodeGetContentsId);
+}

rpcs3/Emu/SysCalls/Modules/cellMusicExport.cpp

@@ -0,0 +1,62 @@
+#include "stdafx.h"
+#include "Emu/SysCalls/SysCalls.h"
+#include "Emu/SysCalls/SC_FUNC.h"
+
+void cellMusicExport_init();
+Module cellMusicExport(0xf02c, cellMusicExport_init);
+
+// Return Codes
+enum
+{
+	CELL_MUSIC_EXPORT_UTIL_RET_OK				= 0,
+	CELL_MUSIC_EXPORT_UTIL_RET_CANCEL			= 1,
+	CELL_MUSIC_EXPORT_UTIL_ERROR_BUSY			= 0x8002c601,
+	CELL_MUSIC_EXPORT_UTIL_ERROR_INTERNAL		= 0x8002c602,
+	CELL_MUSIC_EXPORT_UTIL_ERROR_PARAM			= 0x8002c603,
+	CELL_MUSIC_EXPORT_UTIL_ERROR_ACCESS_ERROR	= 0x8002c604,
+	CELL_MUSIC_EXPORT_UTIL_ERROR_DB_INTERNAL	= 0x8002c605,
+	CELL_MUSIC_EXPORT_UTIL_ERROR_DB_REGIST		= 0x8002c606,
+	CELL_MUSIC_EXPORT_UTIL_ERROR_SET_META		= 0x8002c607,
+	CELL_MUSIC_EXPORT_UTIL_ERROR_FLUSH_META		= 0x8002c608,
+	CELL_MUSIC_EXPORT_UTIL_ERROR_MOVE			= 0x8002c609,
+	CELL_MUSIC_EXPORT_UTIL_ERROR_INITIALIZE		= 0x8002c60a,
+};
+
+int cellMusicExportInitialize()
+{
+	UNIMPLEMENTED_FUNC(cellMusicExport);
+	return CELL_OK;
+}
+
+int cellMusicExportInitialize2()
+{
+	UNIMPLEMENTED_FUNC(cellMusicExport);
+	return CELL_OK;
+}
+
+int cellMusicExportFinalize()
+{
+	UNIMPLEMENTED_FUNC(cellMusicExport);
+	return CELL_OK;
+}
+
+int cellMusicExportFromFile()
+{
+	UNIMPLEMENTED_FUNC(cellMusicExport);
+	return CELL_OK;
+}
+
+int cellMusicExportProgress()
+{
+	UNIMPLEMENTED_FUNC(cellMusicExport);
+	return CELL_OK;
+}
+
+void cellMusicExport_init()
+{
+	cellMusicExport.AddFunc(0xb4c9b4f9, cellMusicExportInitialize);
+	cellMusicExport.AddFunc(0xe0443a44, cellMusicExportInitialize2);
+	cellMusicExport.AddFunc(0xe90effea, cellMusicExportFinalize);
+	cellMusicExport.AddFunc(0xb202f0e8, cellMusicExportFromFile);
+	cellMusicExport.AddFunc(0x92b50ebc, cellMusicExportProgress);
+}

rpcs3/Emu/SysCalls/Modules/cellNetCtl.cpp

@@ -0,0 +1,124 @@
+#include "stdafx.h"
+#include "Emu/SysCalls/SysCalls.h"
+#include "Emu/SysCalls/SC_FUNC.h"
+
+void cellNetCtl_init();
+Module cellNetCtl(0x0014, cellNetCtl_init);
+
+// Error Codes
+enum
+{
+	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,
+};
+
+int cellNetCtlInit()
+{
+	UNIMPLEMENTED_FUNC(cellNetCtl);
+	return CELL_OK;
+}
+
+int cellNetCtlTerm()
+{
+	UNIMPLEMENTED_FUNC(cellNetCtl);
+	return CELL_OK;
+}
+
+int cellNetCtlGetState()
+{
+	UNIMPLEMENTED_FUNC(cellNetCtl);
+	return CELL_OK;
+}
+
+int cellNetCtlAddHandler()
+{
+	UNIMPLEMENTED_FUNC(cellNetCtl);
+	return CELL_OK;
+}
+
+int cellNetCtlDelHandler()
+{
+	UNIMPLEMENTED_FUNC(cellNetCtl);
+	return CELL_OK;
+}
+
+int cellNetCtlGetInfo()
+{
+	UNIMPLEMENTED_FUNC(cellNetCtl);
+	return CELL_OK;
+}
+
+int cellNetCtlNetStartDialogLoadAsync()
+{
+	UNIMPLEMENTED_FUNC(cellNetCtl);
+	return CELL_OK;
+}
+
+int cellNetCtlNetStartDialogAbortAsync()
+{
+	UNIMPLEMENTED_FUNC(cellNetCtl);
+	return CELL_OK;
+}
+
+int cellNetCtlNetStartDialogUnloadAsync()
+{
+	UNIMPLEMENTED_FUNC(cellNetCtl);
+	return CELL_OK;
+}
+
+int cellNetCtlGetNatInfo()
+{
+	UNIMPLEMENTED_FUNC(cellNetCtl);
+	return CELL_OK;
+}
+
+void cellNetCtl_init()
+{
+	cellNetCtl.AddFunc(0xbd5a59fc, cellNetCtlInit);
+	cellNetCtl.AddFunc(0x105ee2cb, cellNetCtlTerm);
+
+	cellNetCtl.AddFunc(0x8b3eba69, cellNetCtlGetState);
+	cellNetCtl.AddFunc(0x0ce13c6b, cellNetCtlAddHandler);
+	cellNetCtl.AddFunc(0x901815c3, cellNetCtlDelHandler);
+
+	cellNetCtl.AddFunc(0x1e585b5d, cellNetCtlGetInfo);
+
+	cellNetCtl.AddFunc(0x04459230, cellNetCtlNetStartDialogLoadAsync);
+	cellNetCtl.AddFunc(0x71d53210, cellNetCtlNetStartDialogAbortAsync);
+	cellNetCtl.AddFunc(0x0f1f13d3, cellNetCtlNetStartDialogUnloadAsync);
+
+	cellNetCtl.AddFunc(0x3a12865f, cellNetCtlGetNatInfo);
+}

rpcs3/Emu/SysCalls/Modules/cellOvis.cpp

@@ -0,0 +1,46 @@
+#include "stdafx.h"
+#include "Emu/SysCalls/SysCalls.h"
+#include "Emu/SysCalls/SC_FUNC.h"
+
+void cellOvis_init();
+Module cellOvis(0x000b, cellOvis_init);
+
+// Return Codes
+enum
+{
+	CELL_OVIS_ERROR_INVAL = 0x80410402,
+	CELL_OVIS_ERROR_ABORT = 0x8041040C,
+	CELL_OVIS_ERROR_ALIGN = 0x80410410,
+};
+
+int cellOvisGetOverlayTableSize()
+{
+	UNIMPLEMENTED_FUNC(cellOvis);
+	return CELL_OK;
+}
+
+int cellOvisInitializeOverlayTable()
+{
+	UNIMPLEMENTED_FUNC(cellOvis);
+	return CELL_OK;
+}
+
+int cellOvisFixSpuSegments()
+{
+	UNIMPLEMENTED_FUNC(cellOvis);
+	return CELL_OK;
+}
+
+int cellOvisInvalidateOverlappedSegments()
+{
+	UNIMPLEMENTED_FUNC(cellOvis);
+	return CELL_OK;
+}
+
+void cellOvis_init()
+{
+	cellOvis.AddFunc(0x82f294b2, cellOvisGetOverlayTableSize);
+	cellOvis.AddFunc(0xa876c911, cellOvisInitializeOverlayTable);
+	cellOvis.AddFunc(0xce6cb776, cellOvisFixSpuSegments);
+	cellOvis.AddFunc(0x629ba0c0, cellOvisInvalidateOverlappedSegments);
+}

rpcs3/Emu/SysCalls/Modules/cellPamf.cpp

@@ -0,0 +1,183 @@
+#include "stdafx.h"
+#include "Emu/SysCalls/SysCalls.h"
+#include "Emu/SysCalls/SC_FUNC.h"
+
+void cellPamf_init();
+Module cellPamf(0x0012, cellPamf_init);
+
+// Error Codes
+enum
+{
+	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,
+};
+
+int cellPamfGetHeaderSize()
+{
+	UNIMPLEMENTED_FUNC(cellPamf);
+	return CELL_OK;
+}
+
+int cellPamfGetHeaderSize2()
+{
+	UNIMPLEMENTED_FUNC(cellPamf);
+	return CELL_OK;
+}
+
+int cellPamfGetStreamOffsetAndSize()
+{
+	UNIMPLEMENTED_FUNC(cellPamf);
+	return CELL_OK;
+}
+
+int cellPamfVerify()
+{
+	UNIMPLEMENTED_FUNC(cellPamf);
+	return CELL_OK;
+}
+
+int cellPamfReaderInitialize()
+{
+	UNIMPLEMENTED_FUNC(cellPamf);
+	return CELL_OK;
+}
+
+int cellPamfReaderGetPresentationStartTime()
+{
+	UNIMPLEMENTED_FUNC(cellPamf);
+	return CELL_OK;
+}
+
+int cellPamfReaderGetPresentationEndTime()
+{
+	UNIMPLEMENTED_FUNC(cellPamf);
+	return CELL_OK;
+}
+
+int cellPamfReaderGetMuxRateBound()
+{
+	UNIMPLEMENTED_FUNC(cellPamf);
+	return CELL_OK;
+}
+
+int cellPamfReaderGetNumberOfStreams()
+{
+	UNIMPLEMENTED_FUNC(cellPamf);
+	return CELL_OK;
+}
+
+int cellPamfReaderGetNumberOfSpecificStreams()
+{
+	UNIMPLEMENTED_FUNC(cellPamf);
+	return CELL_OK;
+}
+
+int cellPamfReaderSetStreamWithIndex()
+{
+	UNIMPLEMENTED_FUNC(cellPamf);
+	return CELL_OK;
+}
+
+int cellPamfReaderSetStreamWithTypeAndChannel()
+{
+	UNIMPLEMENTED_FUNC(cellPamf);
+	return CELL_OK;
+}
+
+int cellPamfReaderSetStreamWithTypeAndIndex()
+{
+	UNIMPLEMENTED_FUNC(cellPamf);
+	return CELL_OK;
+}
+
+int cellPamfStreamTypeToEsFilterId()
+{
+	UNIMPLEMENTED_FUNC(cellPamf);
+	return CELL_OK;
+}
+
+int cellPamfReaderGetStreamIndex()
+{
+	UNIMPLEMENTED_FUNC(cellPamf);
+	return CELL_OK;
+}
+
+int cellPamfReaderGetStreamTypeAndChannel()
+{
+	UNIMPLEMENTED_FUNC(cellPamf);
+	return CELL_OK;
+}
+
+int cellPamfReaderGetEsFilterId()
+{
+	UNIMPLEMENTED_FUNC(cellPamf);
+	return CELL_OK;
+}
+
+int cellPamfReaderGetStreamInfo()
+{
+	UNIMPLEMENTED_FUNC(cellPamf);
+	return CELL_OK;
+}
+
+int cellPamfReaderGetNumberOfEp()
+{
+	UNIMPLEMENTED_FUNC(cellPamf);
+	return CELL_OK;
+}
+
+int cellPamfReaderGetEpIteratorWithIndex()
+{
+	UNIMPLEMENTED_FUNC(cellPamf);
+	return CELL_OK;
+}
+
+int cellPamfReaderGetEpIteratorWithTimeStamp()
+{
+	UNIMPLEMENTED_FUNC(cellPamf);
+	return CELL_OK;
+}
+
+int cellPamfEpIteratorGetEp()
+{
+	UNIMPLEMENTED_FUNC(cellPamf);
+	return CELL_OK;
+}
+
+int cellPamfEpIteratorMove()
+{
+	UNIMPLEMENTED_FUNC(cellPamf);
+	return CELL_OK;
+}
+
+void cellPamf_init()
+{
+	cellPamf.AddFunc(0xca8181c1, cellPamfGetHeaderSize);
+	cellPamf.AddFunc(0x90fc9a59, cellPamfGetHeaderSize2);
+	cellPamf.AddFunc(0x44f5c9e3, cellPamfGetStreamOffsetAndSize);
+	cellPamf.AddFunc(0xd1a40ef4, cellPamfVerify);
+	cellPamf.AddFunc(0xb8436ee5, cellPamfReaderInitialize);
+	cellPamf.AddFunc(0x4de501b1, cellPamfReaderGetPresentationStartTime);
+	cellPamf.AddFunc(0xf61609d6, cellPamfReaderGetPresentationEndTime);
+	cellPamf.AddFunc(0xdb70296c, cellPamfReaderGetMuxRateBound);
+	cellPamf.AddFunc(0x37f723f7, cellPamfReaderGetNumberOfStreams);
+	cellPamf.AddFunc(0xd0230671, cellPamfReaderGetNumberOfSpecificStreams);
+	cellPamf.AddFunc(0x461534b4, cellPamfReaderSetStreamWithIndex);
+	cellPamf.AddFunc(0x03fd2caa, cellPamfReaderSetStreamWithTypeAndChannel);
+	cellPamf.AddFunc(0x28b4e2c1, cellPamfReaderSetStreamWithTypeAndIndex);
+	cellPamf.AddFunc(0x01067e22, cellPamfStreamTypeToEsFilterId);
+	cellPamf.AddFunc(0x041cc708, cellPamfReaderGetStreamIndex);
+	cellPamf.AddFunc(0x9ab20793, cellPamfReaderGetStreamTypeAndChannel);
+	cellPamf.AddFunc(0x71df326a, cellPamfReaderGetEsFilterId);
+	cellPamf.AddFunc(0x67fd273b, cellPamfReaderGetStreamInfo);
+	cellPamf.AddFunc(0xd9ea3457, cellPamfReaderGetNumberOfEp);
+	cellPamf.AddFunc(0xe8586ec6, cellPamfReaderGetEpIteratorWithIndex);
+	cellPamf.AddFunc(0x439fba17, cellPamfReaderGetEpIteratorWithTimeStamp);
+	cellPamf.AddFunc(0x1abeb9d6, cellPamfEpIteratorGetEp);
+	cellPamf.AddFunc(0x50b83205, cellPamfEpIteratorMove);
+}

rpcs3/Emu/SysCalls/Modules/cellPhotoDecode.cpp

@@ -0,0 +1,51 @@
+#include "stdafx.h"
+#include "Emu/SysCalls/SysCalls.h"
+#include "Emu/SysCalls/SC_FUNC.h"
+
+void cellPhotoDecode_init();
+Module cellPhotoDecode(0xf02e, cellPhotoDecode_init);
+
+// Return Codes
+enum
+{
+	CELL_PHOTO_DECODE_RET_OK				= 0,
+	CELL_PHOTO_DECODE_RET_CANCEL			= 1,
+	CELL_PHOTO_DECODE_ERROR_BUSY			= 0x8002c901,
+	CELL_PHOTO_DECODE_ERROR_INTERNAL		= 0x8002c902,
+	CELL_PHOTO_DECODE_ERROR_PARAM			= 0x8002c903,
+	CELL_PHOTO_DECODE_ERROR_ACCESS_ERROR	= 0x8002c904,
+	CELL_PHOTO_DECODE_ERROR_INITIALIZE		= 0x8002c905,
+	CELL_PHOTO_DECODE_ERROR_DECODE			= 0x8002c906,
+};
+
+int cellPhotoDecodeInitialize()
+{
+	UNIMPLEMENTED_FUNC(cellPhotoDecode);
+	return CELL_OK;
+}
+
+int cellPhotoDecodeInitialize2()
+{
+	UNIMPLEMENTED_FUNC(cellPhotoDecode);
+	return CELL_OK;
+}
+
+int cellPhotoDecodeFinalize()
+{
+	UNIMPLEMENTED_FUNC(cellPhotoDecode);
+	return CELL_OK;
+}
+
+int cellPhotoDecodeFromFile()
+{
+	UNIMPLEMENTED_FUNC(cellPhotoDecode);
+	return CELL_OK;
+}
+
+void cellPhotoDecode_init()
+{
+	cellPhotoDecode.AddFunc(0x596f0a56, cellPhotoDecodeInitialize);
+	cellPhotoDecode.AddFunc(0x0f424ecb, cellPhotoDecodeInitialize2);
+	cellPhotoDecode.AddFunc(0xad7d8f38, cellPhotoDecodeFinalize);
+	cellPhotoDecode.AddFunc(0x28b22e44, cellPhotoDecodeFromFile);
+}

rpcs3/Emu/SysCalls/Modules/cellPhotoExport.cpp

@@ -0,0 +1,63 @@
+#include "stdafx.h"
+#include "Emu/SysCalls/SysCalls.h"
+#include "Emu/SysCalls/SC_FUNC.h"
+
+void cellPhotoExport_init();
+Module cellPhotoExport(0xf029, cellPhotoExport_init);
+
+// Return Codes
+enum
+{
+	CELL_PHOTO_EXPORT_UTIL_RET_OK				= 0,
+	CELL_PHOTO_EXPORT_UTIL_RET_CANCEL			= 1,
+	CELL_PHOTO_EXPORT_UTIL_ERROR_BUSY			= 0x8002c201,
+	CELL_PHOTO_EXPORT_UTIL_ERROR_INTERNAL		= 0x8002c202,
+	CELL_PHOTO_EXPORT_UTIL_ERROR_PARAM			= 0x8002c203,
+	CELL_PHOTO_EXPORT_UTIL_ERROR_ACCESS_ERROR	= 0x8002c204,
+	CELL_PHOTO_EXPORT_UTIL_ERROR_DB_INTERNAL	= 0x8002c205,
+	CELL_PHOTO_EXPORT_UTIL_ERROR_DB_REGIST		= 0x8002c206,
+	CELL_PHOTO_EXPORT_UTIL_ERROR_SET_META		= 0x8002c207,
+	CELL_PHOTO_EXPORT_UTIL_ERROR_FLUSH_META		= 0x8002c208,
+	CELL_PHOTO_EXPORT_UTIL_ERROR_MOVE			= 0x8002c209,
+	CELL_PHOTO_EXPORT_UTIL_ERROR_INITIALIZE		= 0x8002c20a,
+};
+
+int cellPhotoExportInitialize()
+{
+	UNIMPLEMENTED_FUNC(cellPhotoExport);
+	return CELL_OK;
+}
+
+int cellPhotoExportInitialize2()
+{
+	UNIMPLEMENTED_FUNC(cellPhotoExport);
+	return CELL_OK;
+}
+
+int cellPhotoExportFinalize()
+{
+	UNIMPLEMENTED_FUNC(cellPhotoExport);
+	return CELL_OK;
+}
+
+int cellPhotoExportFromFile()
+{
+	UNIMPLEMENTED_FUNC(cellPhotoExport);
+	return CELL_OK;
+}
+
+int cellPhotoExportProgress()
+{
+	UNIMPLEMENTED_FUNC(cellPhotoExport);
+	return CELL_OK;
+}
+
+void cellPhotoExport_init()
+{
+	cellPhotoExport.AddFunc(0x4357c77f, cellPhotoExportInitialize);
+	cellPhotoExport.AddFunc(0x08cbd8e1, cellPhotoExportInitialize2);
+	cellPhotoExport.AddFunc(0xed4a0148, cellPhotoExportFinalize);
+	cellPhotoExport.AddFunc(0x09ce84ac, cellPhotoExportFromFile);
+	//cellPhotoExport.AddFunc(, cellPhotoExportFromFileWithCopy);
+	cellPhotoExport.AddFunc(0xde509ead, cellPhotoExportProgress);
+}

rpcs3/Emu/SysCalls/Modules/cellPhotoImport.cpp

@@ -0,0 +1,37 @@
+#include "stdafx.h"
+#include "Emu/SysCalls/SysCalls.h"
+#include "Emu/SysCalls/SC_FUNC.h"
+
+void cellPhotoImport_init();
+Module cellPhotoImport(0xf02b, cellPhotoImport_init);
+
+// Return Codes
+enum
+{
+	CELL_PHOTO_IMPORT_RET_OK				= 0,
+	CELL_PHOTO_IMPORT_RET_CANCEL			= 1,
+	CELL_PHOTO_IMPORT_ERROR_BUSY			= 0x8002c701,
+	CELL_PHOTO_IMPORT_ERROR_INTERNAL		= 0x8002c702,
+	CELL_PHOTO_IMPORT_ERROR_PARAM			= 0x8002c703,
+	CELL_PHOTO_IMPORT_ERROR_ACCESS_ERROR	= 0x8002c704,
+	CELL_PHOTO_IMPORT_ERROR_COPY			= 0x8002c705,
+	CELL_PHOTO_IMPORT_ERROR_INITIALIZE		= 0x8002c706,
+};
+
+int _cellPhotoImport()
+{
+	UNIMPLEMENTED_FUNC(cellPhotoImport);
+	return CELL_OK;
+}
+
+int _cellPhotoImport2()
+{
+	UNIMPLEMENTED_FUNC(cellPhotoImport);
+	return CELL_OK;
+}
+
+void cellPhotoImport_init()
+{
+	cellPhotoImport.AddFunc(0x0783bce0, _cellPhotoImport);
+	cellPhotoImport.AddFunc(0x1ab8df55, _cellPhotoImport2);
+}

rpcs3/Emu/SysCalls/Modules/cellPngEnc.cpp

@@ -0,0 +1,84 @@
+#include "stdafx.h"
+#include "Emu/SysCalls/SysCalls.h"
+#include "Emu/SysCalls/SC_FUNC.h"
+
+void cellPngEnc_init();
+Module cellPngEnc(0x0052, cellPngEnc_init);
+
+// Error Codes
+enum
+{
+	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,
+};
+
+int cellPngEncQueryAttr()
+{
+	UNIMPLEMENTED_FUNC(cellPngEnc);
+	return CELL_OK;
+}
+
+int cellPngEncOpen()
+{
+	UNIMPLEMENTED_FUNC(cellPngEnc);
+	return CELL_OK;
+}
+
+int cellPngEncOpenEx()
+{
+	UNIMPLEMENTED_FUNC(cellPngEnc);
+	return CELL_OK;
+}
+
+int cellPngEncClose()
+{
+	UNIMPLEMENTED_FUNC(cellPngEnc);
+	return CELL_OK;
+}
+
+int cellPngEncWaitForInput()
+{
+	UNIMPLEMENTED_FUNC(cellPngEnc);
+	return CELL_OK;
+}
+
+int cellPngEncEncodePicture()
+{
+	UNIMPLEMENTED_FUNC(cellPngEnc);
+	return CELL_OK;
+}
+
+int cellPngEncWaitForOutput()
+{
+	UNIMPLEMENTED_FUNC(cellPngEnc);
+	return CELL_OK;
+}
+
+int cellPngEncGetStreamInfo()
+{
+	UNIMPLEMENTED_FUNC(cellPngEnc);
+	return CELL_OK;
+}
+
+int cellPngEncReset()
+{
+	UNIMPLEMENTED_FUNC(cellPngEnc);
+	return CELL_OK;
+}
+
+void cellPngEnc_init()
+{
+	cellPngEnc.AddFunc(0x496cfcd0, cellPngEncQueryAttr);
+	cellPngEnc.AddFunc(0x19256dc5, cellPngEncOpen);
+	cellPngEnc.AddFunc(0xc82558ce, cellPngEncOpenEx);
+	cellPngEnc.AddFunc(0x117cd726, cellPngEncClose);
+	cellPngEnc.AddFunc(0x662bd637, cellPngEncWaitForInput);
+	cellPngEnc.AddFunc(0x5b546ca4, cellPngEncEncodePicture);
+	cellPngEnc.AddFunc(0x90ef2963, cellPngEncWaitForOutput);
+	cellPngEnc.AddFunc(0x585269bc, cellPngEncGetStreamInfo);
+	cellPngEnc.AddFunc(0x6ac91de3, cellPngEncReset);
+}

rpcs3/Emu/SysCalls/Modules/cellPrint.cpp

@@ -0,0 +1,107 @@
+#include "stdafx.h"
+#include "Emu/SysCalls/SysCalls.h"
+#include "Emu/SysCalls/SC_FUNC.h"
+
+void cellPrint_init();
+Module cellPrint(0xf02a, cellPrint_init);
+
+// Error Codes
+enum
+{
+	CELL_PRINT_ERROR_INTERNAL				= 0x8002c401,
+	CELL_PRINT_ERROR_NO_MEMORY				= 0x8002c402,
+	CELL_PRINT_ERROR_PRINTER_NOT_FOUND		= 0x8002c403,
+	CELL_PRINT_ERROR_INVALID_PARAM			= 0x8002c404,
+	CELL_PRINT_ERROR_INVALID_FUNCTION		= 0x8002c405,
+	CELL_PRINT_ERROR_NOT_SUPPORT			= 0x8002c406,
+	CELL_PRINT_ERROR_OCCURRED				= 0x8002c407,
+	CELL_PRINT_ERROR_CANCELED_BY_PRINTER	= 0x8002c408,
+};
+
+int cellPrintLoadAsync()
+{
+	UNIMPLEMENTED_FUNC(cellPrint);
+	return CELL_OK;
+}
+
+int cellPrintLoadAsync2()
+{
+	UNIMPLEMENTED_FUNC(cellPrint);
+	return CELL_OK;
+}
+
+int cellPrintUnloadAsync()
+{
+	UNIMPLEMENTED_FUNC(cellPrint);
+	return CELL_OK;
+}
+
+int cellPrintGetStatus()
+{
+	UNIMPLEMENTED_FUNC(cellPrint);
+	return CELL_OK;
+}
+
+int cellPrintOpenConfig()
+{
+	UNIMPLEMENTED_FUNC(cellPrint);
+	return CELL_OK;
+}
+
+int cellPrintGetPrintableArea()
+{
+	UNIMPLEMENTED_FUNC(cellPrint);
+	return CELL_OK;
+}
+
+int cellPrintStartJob()
+{
+	UNIMPLEMENTED_FUNC(cellPrint);
+	return CELL_OK;
+}
+
+int cellPrintEndJob()
+{
+	UNIMPLEMENTED_FUNC(cellPrint);
+	return CELL_OK;
+}
+
+int cellPrintCancelJob()
+{
+	UNIMPLEMENTED_FUNC(cellPrint);
+	return CELL_OK;
+}
+
+int cellPrintStartPage()
+{
+	UNIMPLEMENTED_FUNC(cellPrint);
+	return CELL_OK;
+}
+
+int cellPrintEndPage()
+{
+	UNIMPLEMENTED_FUNC(cellPrint);
+	return CELL_OK;
+}
+
+int cellPrintSendBand()
+{
+	UNIMPLEMENTED_FUNC(cellPrint);
+	return CELL_OK;
+}
+
+void cellPrint_init()
+{
+	cellPrint.AddFunc(0xc9c3ef14, cellPrintLoadAsync);
+	cellPrint.AddFunc(0xf0865182, cellPrintLoadAsync2);
+	cellPrint.AddFunc(0xeb51aa38, cellPrintUnloadAsync);
+	cellPrint.AddFunc(0x6802dfb5, cellPrintGetStatus);
+	cellPrint.AddFunc(0xf9a53f35, cellPrintOpenConfig);
+	cellPrint.AddFunc(0x6e952645, cellPrintGetPrintableArea);
+	cellPrint.AddFunc(0x795b12b3, cellPrintStartJob);
+	cellPrint.AddFunc(0xc04a7d42, cellPrintEndJob);
+	cellPrint.AddFunc(0x293d9e9c, cellPrintCancelJob);
+	cellPrint.AddFunc(0x865acf74, cellPrintStartPage);
+	cellPrint.AddFunc(0x0d44f661, cellPrintEndPage);
+	cellPrint.AddFunc(0x0a373522, cellPrintSendBand);
+}

rpcs3/Emu/SysCalls/Modules/cellRtc.cpp

@@ -0,0 +1,267 @@
+#include "stdafx.h"
+#include "Emu/SysCalls/SysCalls.h"
+#include "Emu/SysCalls/SC_FUNC.h"
+
+void cellRtc_init();
+Module cellRtc(0x0009, cellRtc_init);
+
+// Return Codes
+enum
+{
+	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,
+};
+
+int cellRtcGetCurrentTick()
+{
+	UNIMPLEMENTED_FUNC(cellRtc);
+	return CELL_OK;
+}
+
+int cellRtcGetCurrentClock()
+{
+	UNIMPLEMENTED_FUNC(cellRtc);
+	return CELL_OK;
+}
+
+int cellRtcGetCurrentClockLocalTime()
+{
+	UNIMPLEMENTED_FUNC(cellRtc);
+	return CELL_OK;
+}
+
+int cellRtcFormatRfc2822()
+{
+	UNIMPLEMENTED_FUNC(cellRtc);
+	return CELL_OK;
+}
+
+int cellRtcFormatRfc2822LocalTime()
+{
+	UNIMPLEMENTED_FUNC(cellRtc);
+	return CELL_OK;
+}
+
+int cellRtcFormatRfc3339()
+{
+	UNIMPLEMENTED_FUNC(cellRtc);
+	return CELL_OK;
+}
+
+int cellRtcFormatRfc3339LocalTime()
+{
+	UNIMPLEMENTED_FUNC(cellRtc);
+	return CELL_OK;
+}
+
+int cellRtcParseDateTime()
+{
+	UNIMPLEMENTED_FUNC(cellRtc);
+	return CELL_OK;
+}
+
+int cellRtcParseRfc3339()
+{
+	UNIMPLEMENTED_FUNC(cellRtc);
+	return CELL_OK;
+}
+
+int cellRtcGetTick()
+{
+	UNIMPLEMENTED_FUNC(cellRtc);
+	return CELL_OK;
+}
+
+int cellRtcSetTick()
+{
+	UNIMPLEMENTED_FUNC(cellRtc);
+	return CELL_OK;
+}
+
+int cellRtcTickAddTicks()
+{
+	UNIMPLEMENTED_FUNC(cellRtc);
+	return CELL_OK;
+}
+
+int cellRtcTickAddMicroseconds()
+{
+	UNIMPLEMENTED_FUNC(cellRtc);
+	return CELL_OK;
+}
+
+int cellRtcTickAddSeconds()
+{
+	UNIMPLEMENTED_FUNC(cellRtc);
+	return CELL_OK;
+}
+
+int cellRtcTickAddMinutes()
+{
+	UNIMPLEMENTED_FUNC(cellRtc);
+	return CELL_OK;
+}
+
+int cellRtcTickAddHours()
+{
+	UNIMPLEMENTED_FUNC(cellRtc);
+	return CELL_OK;
+}
+
+int cellRtcTickAddDays()
+{
+	UNIMPLEMENTED_FUNC(cellRtc);
+	return CELL_OK;
+}
+
+int cellRtcTickAddWeeks()
+{
+	UNIMPLEMENTED_FUNC(cellRtc);
+	return CELL_OK;
+}
+
+int cellRtcTickAddMonths()
+{
+	UNIMPLEMENTED_FUNC(cellRtc);
+	return CELL_OK;
+}
+
+int cellRtcTickAddYears()
+{
+	UNIMPLEMENTED_FUNC(cellRtc);
+	return CELL_OK;
+}
+
+int cellRtcConvertUtcToLocalTime()
+{
+	UNIMPLEMENTED_FUNC(cellRtc);
+	return CELL_OK;
+}
+
+int cellRtcConvertLocalTimeToUtc()
+{
+	UNIMPLEMENTED_FUNC(cellRtc);
+	return CELL_OK;
+}
+
+int cellRtcGetDosTime()
+{
+	UNIMPLEMENTED_FUNC(cellRtc);
+	return CELL_OK;
+}
+
+int cellRtcGetTime_t()
+{
+	UNIMPLEMENTED_FUNC(cellRtc);
+	return CELL_OK;
+}
+
+int cellRtcGetWin32FileTime()
+{
+	UNIMPLEMENTED_FUNC(cellRtc);
+	return CELL_OK;
+}
+
+int cellRtcSetDosTime()
+{
+	UNIMPLEMENTED_FUNC(cellRtc);
+	return CELL_OK;
+}
+
+int cellRtcSetTime_t()
+{
+	UNIMPLEMENTED_FUNC(cellRtc);
+	return CELL_OK;
+}
+
+int cellRtcSetWin32FileTime()
+{
+	UNIMPLEMENTED_FUNC(cellRtc);
+	return CELL_OK;
+}
+
+int cellRtcIsLeapYear()
+{
+	UNIMPLEMENTED_FUNC(cellRtc);
+	return CELL_OK;
+}
+
+int cellRtcGetDaysInMonth()
+{
+	UNIMPLEMENTED_FUNC(cellRtc);
+	return CELL_OK;
+}
+
+int cellRtcGetDayOfWeek()
+{
+	UNIMPLEMENTED_FUNC(cellRtc);
+	return CELL_OK;
+}
+
+int cellRtcCheckValid()
+{
+	UNIMPLEMENTED_FUNC(cellRtc);
+	return CELL_OK;
+}
+
+int cellRtcCompareTick()
+{
+	UNIMPLEMENTED_FUNC(cellRtc);
+	return CELL_OK;
+}
+
+void cellRtc_init()
+{
+	cellRtc.AddFunc(0x9dafc0d9, cellRtcGetCurrentTick);
+	cellRtc.AddFunc(0x32c941cf, cellRtcGetCurrentClock);
+	cellRtc.AddFunc(0x2cce9cf5, cellRtcGetCurrentClockLocalTime);
+
+	cellRtc.AddFunc(0x5491b9d5, cellRtcFormatRfc2822);
+	cellRtc.AddFunc(0xa07c3d2f, cellRtcFormatRfc2822LocalTime);
+	cellRtc.AddFunc(0xd9c0b463, cellRtcFormatRfc3339);
+	cellRtc.AddFunc(0x1324948a, cellRtcFormatRfc3339LocalTime);
+	cellRtc.AddFunc(0xc5bc0fac, cellRtcParseDateTime);
+	cellRtc.AddFunc(0xcf11c3d6, cellRtcParseRfc3339);
+
+	cellRtc.AddFunc(0xc7bdb7eb, cellRtcGetTick);
+	cellRtc.AddFunc(0x99b13034, cellRtcSetTick);
+	cellRtc.AddFunc(0x269a1882, cellRtcTickAddTicks);
+	cellRtc.AddFunc(0xf8509925, cellRtcTickAddMicroseconds);
+	cellRtc.AddFunc(0xccce71bd, cellRtcTickAddSeconds);
+	cellRtc.AddFunc(0x2f010bfa, cellRtcTickAddMinutes);
+	cellRtc.AddFunc(0xd41d3bd2, cellRtcTickAddHours);
+	cellRtc.AddFunc(0x75744e2a, cellRtcTickAddDays);
+	cellRtc.AddFunc(0x64c63fd5, cellRtcTickAddWeeks);
+	cellRtc.AddFunc(0xe0ecbb45, cellRtcTickAddMonths);
+	cellRtc.AddFunc(0x332a74dd, cellRtcTickAddYears);
+	cellRtc.AddFunc(0xc48d5002, cellRtcConvertUtcToLocalTime);
+	cellRtc.AddFunc(0x46ca7fe0, cellRtcConvertLocalTimeToUtc);
+
+	// (TODO: Time Information Manipulation Functions missing)
+
+	cellRtc.AddFunc(0xdfff32cf, cellRtcGetDosTime);
+	cellRtc.AddFunc(0xcb90c761, cellRtcGetTime_t);
+	cellRtc.AddFunc(0xe7086f05, cellRtcGetWin32FileTime);
+	cellRtc.AddFunc(0x9598d4b3, cellRtcSetDosTime);
+	cellRtc.AddFunc(0xbb543189, cellRtcSetTime_t);
+	cellRtc.AddFunc(0x5f68c268, cellRtcSetWin32FileTime);
+
+	cellRtc.AddFunc(0x5316b4a8, cellRtcIsLeapYear);
+	cellRtc.AddFunc(0x5b6a0a1d, cellRtcGetDaysInMonth);
+	cellRtc.AddFunc(0xc2d8cf95, cellRtcGetDayOfWeek);
+	cellRtc.AddFunc(0x7f1086e6, cellRtcCheckValid);
+
+	cellRtc.AddFunc(0xfb51fc61, cellRtcCompareTick);
+}

rpcs3/Emu/SysCalls/Modules/cellRudp.cpp

@@ -0,0 +1,257 @@
+#include "stdafx.h"
+#include "Emu/SysCalls/SysCalls.h"
+#include "Emu/SysCalls/SC_FUNC.h"
+
+void cellRudp_init();
+Module cellRudp(0x0057, cellRudp_init);
+
+// Return Codes
+enum
+{
+	CELL_RUDP_SUCCESS								= 0,
+	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,
+};
+
+int cellRudpInit()
+{
+	UNIMPLEMENTED_FUNC(cellRudp);
+	return CELL_OK;
+}
+
+int cellRudpEnd()
+{
+	UNIMPLEMENTED_FUNC(cellRudp);
+	return CELL_OK;
+}
+
+int cellRudpEnableInternalIOThread()
+{
+	UNIMPLEMENTED_FUNC(cellRudp);
+	return CELL_OK;
+}
+
+int cellRudpSetEventHandler()
+{
+	UNIMPLEMENTED_FUNC(cellRudp);
+	return CELL_OK;
+}
+
+int cellRudpSetMaxSegmentSize()
+{
+	UNIMPLEMENTED_FUNC(cellRudp);
+	return CELL_OK;
+}
+
+int cellRudpGetMaxSegmentSize()
+{
+	UNIMPLEMENTED_FUNC(cellRudp);
+	return CELL_OK;
+}
+
+int cellRudpCreateContext()
+{
+	UNIMPLEMENTED_FUNC(cellRudp);
+	return CELL_OK;
+}
+
+int cellRudpSetOption()
+{
+	UNIMPLEMENTED_FUNC(cellRudp);
+	return CELL_OK;
+}
+
+int cellRudpGetOption()
+{
+	UNIMPLEMENTED_FUNC(cellRudp);
+	return CELL_OK;
+}
+
+int cellRudpGetContextStatus()
+{
+	UNIMPLEMENTED_FUNC(cellRudp);
+	return CELL_OK;
+}
+
+int cellRudpGetStatus()
+{
+	UNIMPLEMENTED_FUNC(cellRudp);
+	return CELL_OK;
+}
+
+int cellRudpGetLocalInfo()
+{
+	UNIMPLEMENTED_FUNC(cellRudp);
+	return CELL_OK;
+}
+
+int cellRudpGetRemoteInfo()
+{
+	UNIMPLEMENTED_FUNC(cellRudp);
+	return CELL_OK;
+}
+
+int cellRudpBind()
+{
+	UNIMPLEMENTED_FUNC(cellRudp);
+	return CELL_OK;
+}
+
+int cellRudpInitiate()
+{
+	UNIMPLEMENTED_FUNC(cellRudp);
+	return CELL_OK;
+}
+
+int cellRudpActivate()
+{
+	UNIMPLEMENTED_FUNC(cellRudp);
+	return CELL_OK;
+}
+
+int cellRudpTerminate()
+{
+	UNIMPLEMENTED_FUNC(cellRudp);
+	return CELL_OK;
+}
+
+int cellRudpRead()
+{
+	UNIMPLEMENTED_FUNC(cellRudp);
+	return CELL_OK;
+}
+
+int cellRudpWrite()
+{
+	UNIMPLEMENTED_FUNC(cellRudp);
+	return CELL_OK;
+}
+
+int cellRudpGetSizeReadable()
+{
+	UNIMPLEMENTED_FUNC(cellRudp);
+	return CELL_OK;
+}
+
+int cellRudpGetSizeWritable()
+{
+	UNIMPLEMENTED_FUNC(cellRudp);
+	return CELL_OK;
+}
+
+int cellRudpFlush()
+{
+	UNIMPLEMENTED_FUNC(cellRudp);
+	return CELL_OK;
+}
+
+int cellRudpPollCreate()
+{
+	UNIMPLEMENTED_FUNC(cellRudp);
+	return CELL_OK;
+}
+
+int cellRudpPollDestroy()
+{
+	UNIMPLEMENTED_FUNC(cellRudp);
+	return CELL_OK;
+}
+
+int cellRudpPollControl()
+{
+	UNIMPLEMENTED_FUNC(cellRudp);
+	return CELL_OK;
+}
+
+int cellRudpPollWait()
+{
+	UNIMPLEMENTED_FUNC(cellRudp);
+	return CELL_OK;
+}
+
+int cellRudpNetReceived()
+{
+	UNIMPLEMENTED_FUNC(cellRudp);
+	return CELL_OK;
+}
+
+int cellRudpProcessEvents()
+{
+	UNIMPLEMENTED_FUNC(cellRudp);
+	return CELL_OK;
+}
+
+void cellRudp_init()
+{
+	cellRudp.AddFunc(0x63f63545, cellRudpInit);
+	cellRudp.AddFunc(0xb6bcb4a1, cellRudpEnd);
+	cellRudp.AddFunc(0x6c0cff03, cellRudpEnableInternalIOThread);
+	cellRudp.AddFunc(0x7ed95e60, cellRudpSetEventHandler);
+	cellRudp.AddFunc(0x54f81789, cellRudpSetMaxSegmentSize);
+	cellRudp.AddFunc(0xfbf7e9e4, cellRudpGetMaxSegmentSize);
+
+	cellRudp.AddFunc(0x7dadc739, cellRudpCreateContext);
+	cellRudp.AddFunc(0x384ba777, cellRudpSetOption);
+	cellRudp.AddFunc(0xff9d259c, cellRudpGetOption);
+
+	cellRudp.AddFunc(0x74bfad12, cellRudpGetContextStatus);
+	cellRudp.AddFunc(0xcd1a3f23, cellRudpGetStatus);
+	cellRudp.AddFunc(0xd666931f, cellRudpGetLocalInfo);
+	cellRudp.AddFunc(0x576831ae, cellRudpGetRemoteInfo);
+
+	cellRudp.AddFunc(0xee41e16a, cellRudpBind);
+	cellRudp.AddFunc(0xc407844f, cellRudpInitiate);
+	cellRudp.AddFunc(0xc1ad7ced, cellRudpActivate);
+	cellRudp.AddFunc(0x48d3eeac, cellRudpTerminate);
+
+	cellRudp.AddFunc(0x92e4d899, cellRudpRead);
+	cellRudp.AddFunc(0x48c001b0, cellRudpWrite);
+	cellRudp.AddFunc(0x2cde989f, cellRudpGetSizeReadable);
+	cellRudp.AddFunc(0xa86b28e3, cellRudpGetSizeWritable);
+	cellRudp.AddFunc(0xa70737da, cellRudpFlush);
+
+	cellRudp.AddFunc(0x6bc587e9, cellRudpPollCreate);
+	cellRudp.AddFunc(0x8ac398f1, cellRudpPollDestroy);
+	cellRudp.AddFunc(0xa3db855c, cellRudpPollControl);
+	cellRudp.AddFunc(0xd8310700, cellRudpPollWait);
+	//cellRudp.AddFunc(, cellRudpPollCancel);
+
+	cellRudp.AddFunc(0x6ee04954, cellRudpNetReceived);
+	cellRudp.AddFunc(0xfade48b2, cellRudpProcessEvents);
+}

rpcs3/Emu/SysCalls/Modules/cellSail.cpp

@@ -0,0 +1,920 @@
+#include "stdafx.h"
+#include "Emu/SysCalls/SysCalls.h"
+#include "Emu/SysCalls/SC_FUNC.h"
+
+void cellSail_init();
+Module cellSail(0x001d, cellSail_init);
+
+// Error Codes
+enum
+{
+	CELL_SAIL_ERROR_INVALID_ARG			= 0x80610701,
+	CELL_SAIL_ERROR_INVALID_STATE		= 0x80610702,
+	CELL_SAIL_ERROR_UNSUPPORTED_STREAM	= 0x80610703,
+	CELL_SAIL_ERROR_INDEX_OUT_OF_RANGE	= 0x80610704,
+	CELL_SAIL_ERROR_EMPTY				= 0x80610705,
+	CELL_SAIL_ERROR_FULLED				= 0x80610706,
+	CELL_SAIL_ERROR_USING				= 0x80610707,
+	CELL_SAIL_ERROR_NOT_AVAILABLE		= 0x80610708,
+	CELL_SAIL_ERROR_CANCEL				= 0x80610709,
+	CELL_SAIL_ERROR_MEMORY				= 0x806107F0,
+	CELL_SAIL_ERROR_INVALID_FD			= 0x806107F1,
+	CELL_SAIL_ERROR_FATAL				= 0x806107FF,
+};
+
+int cellSailMemAllocatorInitialize()
+{
+	UNIMPLEMENTED_FUNC(cellSail);
+	return CELL_OK;
+}
+
+int cellSailFutureInitialize()
+{
+	UNIMPLEMENTED_FUNC(cellSail);
+	return CELL_OK;
+}
+
+int cellSailFutureFinalize()
+{
+	UNIMPLEMENTED_FUNC(cellSail);
+	return CELL_OK;
+}
+
+int cellSailFutureReset()
+{
+	UNIMPLEMENTED_FUNC(cellSail);
+	return CELL_OK;
+}
+
+int cellSailFutureSet()
+{
+	UNIMPLEMENTED_FUNC(cellSail);
+	return CELL_OK;
+}
+
+int cellSailFutureGet()
+{
+	UNIMPLEMENTED_FUNC(cellSail);
+	return CELL_OK;
+}
+
+int cellSailFutureIsDone()
+{
+	UNIMPLEMENTED_FUNC(cellSail);
+	return CELL_OK;
+}
+
+int cellSailDescriptorGetStreamType()
+{
+	UNIMPLEMENTED_FUNC(cellSail);
+	return CELL_OK;
+}
+
+int cellSailDescriptorGetUri()
+{
+	UNIMPLEMENTED_FUNC(cellSail);
+	return CELL_OK;
+}
+
+int cellSailDescriptorGetMediaInfo()
+{
+	UNIMPLEMENTED_FUNC(cellSail);
+	return CELL_OK;
+}
+
+int cellSailDescriptorSetAutoSelection()
+{
+	UNIMPLEMENTED_FUNC(cellSail);
+	return CELL_OK;
+}
+
+int cellSailDescriptorIsAutoSelection()
+{
+	UNIMPLEMENTED_FUNC(cellSail);
+	return CELL_OK;
+}
+
+int cellSailDescriptorCreateDatabase()
+{
+	UNIMPLEMENTED_FUNC(cellSail);
+	return CELL_OK;
+}
+
+int cellSailDescriptorDestroyDatabase()
+{
+	UNIMPLEMENTED_FUNC(cellSail);
+	return CELL_OK;
+}
+
+int cellSailDescriptorOpen()
+{
+	UNIMPLEMENTED_FUNC(cellSail);
+	return CELL_OK;
+}
+
+int cellSailDescriptorClose()
+{
+	UNIMPLEMENTED_FUNC(cellSail);
+	return CELL_OK;
+}
+
+int cellSailDescriptorSetEs()
+{
+	UNIMPLEMENTED_FUNC(cellSail);
+	return CELL_OK;
+}
+
+int cellSailDescriptorClearEs()
+{
+	UNIMPLEMENTED_FUNC(cellSail);
+	return CELL_OK;
+}
+
+int cellSailDescriptorGetCapabilities()
+{
+	UNIMPLEMENTED_FUNC(cellSail);
+	return CELL_OK;
+}
+
+int cellSailDescriptorInquireCapability()
+{
+	UNIMPLEMENTED_FUNC(cellSail);
+	return CELL_OK;
+}
+
+int cellSailDescriptorSetParameter()
+{
+	UNIMPLEMENTED_FUNC(cellSail);
+	return CELL_OK;
+}
+
+int cellSailSoundAdapterInitialize()
+{
+	UNIMPLEMENTED_FUNC(cellSail);
+	return CELL_OK;
+}
+
+int cellSailSoundAdapterFinalize()
+{
+	UNIMPLEMENTED_FUNC(cellSail);
+	return CELL_OK;
+}
+
+int cellSailSoundAdapterSetPreferredFormat()
+{
+	UNIMPLEMENTED_FUNC(cellSail);
+	return CELL_OK;
+}
+
+int cellSailSoundAdapterGetFrame()
+{
+	UNIMPLEMENTED_FUNC(cellSail);
+	return CELL_OK;
+}
+
+int cellSailSoundAdapterGetFormat()
+{
+	UNIMPLEMENTED_FUNC(cellSail);
+	return CELL_OK;
+}
+
+int cellSailSoundAdapterUpdateAvSync()
+{
+	UNIMPLEMENTED_FUNC(cellSail);
+	return CELL_OK;
+}
+
+int cellSailSoundAdapterPtsToTimePosition()
+{
+	UNIMPLEMENTED_FUNC(cellSail);
+	return CELL_OK;
+}
+
+int cellSailGraphicsAdapterInitialize()
+{
+	UNIMPLEMENTED_FUNC(cellSail);
+	return CELL_OK;
+}
+
+int cellSailGraphicsAdapterFinalize()
+{
+	UNIMPLEMENTED_FUNC(cellSail);
+	return CELL_OK;
+}
+
+int cellSailGraphicsAdapterSetPreferredFormat()
+{
+	UNIMPLEMENTED_FUNC(cellSail);
+	return CELL_OK;
+}
+
+int cellSailGraphicsAdapterGetFrame()
+{
+	UNIMPLEMENTED_FUNC(cellSail);
+	return CELL_OK;
+}
+
+int cellSailGraphicsAdapterGetFrame2()
+{
+	UNIMPLEMENTED_FUNC(cellSail);
+	return CELL_OK;
+}
+
+int cellSailGraphicsAdapterGetFormat()
+{
+	UNIMPLEMENTED_FUNC(cellSail);
+	return CELL_OK;
+}
+
+int cellSailGraphicsAdapterUpdateAvSync()
+{
+	UNIMPLEMENTED_FUNC(cellSail);
+	return CELL_OK;
+}
+
+int cellSailGraphicsAdapterPtsToTimePosition()
+{
+	UNIMPLEMENTED_FUNC(cellSail);
+	return CELL_OK;
+}
+
+int cellSailAuReceiverInitialize()
+{
+	UNIMPLEMENTED_FUNC(cellSail);
+	return CELL_OK;
+}
+
+int cellSailAuReceiverFinalize()
+{
+	UNIMPLEMENTED_FUNC(cellSail);
+	return CELL_OK;
+}
+
+int cellSailAuReceiverGet()
+{
+	UNIMPLEMENTED_FUNC(cellSail);
+	return CELL_OK;
+}
+
+int cellSailRendererAudioInitialize()
+{
+	UNIMPLEMENTED_FUNC(cellSail);
+	return CELL_OK;
+}
+
+int cellSailRendererAudioFinalize()
+{
+	UNIMPLEMENTED_FUNC(cellSail);
+	return CELL_OK;
+}
+
+int cellSailRendererAudioNotifyCallCompleted()
+{
+	UNIMPLEMENTED_FUNC(cellSail);
+	return CELL_OK;
+}
+
+int cellSailRendererAudioNotifyFrameDone()
+{
+	UNIMPLEMENTED_FUNC(cellSail);
+	return CELL_OK;
+}
+
+int cellSailRendererAudioNotifyOutputEos()
+{
+	UNIMPLEMENTED_FUNC(cellSail);
+	return CELL_OK;
+}
+
+int cellSailRendererVideoInitialize()
+{
+	UNIMPLEMENTED_FUNC(cellSail);
+	return CELL_OK;
+}
+
+int cellSailRendererVideoFinalize()
+{
+	UNIMPLEMENTED_FUNC(cellSail);
+	return CELL_OK;
+}
+
+int cellSailRendererVideoNotifyCallCompleted()
+{
+	UNIMPLEMENTED_FUNC(cellSail);
+	return CELL_OK;
+}
+
+int cellSailRendererVideoNotifyFrameDone()
+{
+	UNIMPLEMENTED_FUNC(cellSail);
+	return CELL_OK;
+}
+
+int cellSailRendererVideoNotifyOutputEos()
+{
+	UNIMPLEMENTED_FUNC(cellSail);
+	return CELL_OK;
+}
+
+int cellSailSourceInitialize()
+{
+	UNIMPLEMENTED_FUNC(cellSail);
+	return CELL_OK;
+}
+
+int cellSailSourceFinalize()
+{
+	UNIMPLEMENTED_FUNC(cellSail);
+	return CELL_OK;
+}
+
+int cellSailSourceNotifyCallCompleted()
+{
+	UNIMPLEMENTED_FUNC(cellSail);
+	return CELL_OK;
+}
+
+int cellSailSourceNotifyInputEos()
+{
+	UNIMPLEMENTED_FUNC(cellSail);
+	return CELL_OK;
+}
+
+int cellSailSourceNotifyStreamOut()
+{
+	UNIMPLEMENTED_FUNC(cellSail);
+	return CELL_OK;
+}
+
+int cellSailSourceNotifySessionError()
+{
+	UNIMPLEMENTED_FUNC(cellSail);
+	return CELL_OK;
+}
+
+int cellSailSourceNotifyMediaStateChanged()
+{
+	UNIMPLEMENTED_FUNC(cellSail);
+	return CELL_OK;
+}
+
+int cellSailSourceCheck()
+{
+	UNIMPLEMENTED_FUNC(cellSail);
+	return CELL_OK;
+}
+
+int cellSailSourceNotifyOpenCompleted()
+{
+	UNIMPLEMENTED_FUNC(cellSail);
+	return CELL_OK;
+}
+
+int cellSailSourceNotifyStartCompleted()
+{
+	UNIMPLEMENTED_FUNC(cellSail);
+	return CELL_OK;
+}
+
+int cellSailSourceNotifyStopCompleted()
+{
+	UNIMPLEMENTED_FUNC(cellSail);
+	return CELL_OK;
+}
+
+int cellSailSourceNotifyReadCompleted()
+{
+	UNIMPLEMENTED_FUNC(cellSail);
+	return CELL_OK;
+}
+
+int cellSailSourceSetDiagHandler()
+{
+	UNIMPLEMENTED_FUNC(cellSail);
+	return CELL_OK;
+}
+
+int cellSailSourceNotifyCloseCompleted()
+{
+	UNIMPLEMENTED_FUNC(cellSail);
+	return CELL_OK;
+}
+
+int cellSailMp4MovieGetBrand()
+{
+	UNIMPLEMENTED_FUNC(cellSail);
+	return CELL_OK;
+}
+
+int cellSailMp4MovieIsCompatibleBrand()
+{
+	UNIMPLEMENTED_FUNC(cellSail);
+	return CELL_OK;
+}
+
+int cellSailMp4MovieGetMovieInfo()
+{
+	UNIMPLEMENTED_FUNC(cellSail);
+	return CELL_OK;
+}
+
+int cellSailMp4MovieGetTrackByIndex()
+{
+	UNIMPLEMENTED_FUNC(cellSail);
+	return CELL_OK;
+}
+
+int cellSailMp4MovieGetTrackById()
+{
+	UNIMPLEMENTED_FUNC(cellSail);
+	return CELL_OK;
+}
+
+int cellSailMp4MovieGetTrackByTypeAndIndex()
+{
+	UNIMPLEMENTED_FUNC(cellSail);
+	return CELL_OK;
+}
+
+int cellSailMp4TrackGetTrackInfo()
+{
+	UNIMPLEMENTED_FUNC(cellSail);
+	return CELL_OK;
+}
+
+int cellSailMp4TrackGetTrackReferenceCount()
+{
+	UNIMPLEMENTED_FUNC(cellSail);
+	return CELL_OK;
+}
+
+int cellSailMp4TrackGetTrackReference()
+{
+	UNIMPLEMENTED_FUNC(cellSail);
+	return CELL_OK;
+}
+
+int cellSailMp4ConvertTimeScale()
+{
+	UNIMPLEMENTED_FUNC(cellSail);
+	return CELL_OK;
+}
+
+int cellSailAviMovieGetMovieInfo()
+{
+	UNIMPLEMENTED_FUNC(cellSail);
+	return CELL_OK;
+}
+
+int cellSailAviMovieGetStreamByIndex()
+{
+	UNIMPLEMENTED_FUNC(cellSail);
+	return CELL_OK;
+}
+
+int cellSailAviMovieGetStreamByTypeAndIndex()
+{
+	UNIMPLEMENTED_FUNC(cellSail);
+	return CELL_OK;
+}
+
+int cellSailAviMovieGetHeader()
+{
+	UNIMPLEMENTED_FUNC(cellSail);
+	return CELL_OK;
+}
+
+int cellSailAviStreamGetMediaType()
+{
+	UNIMPLEMENTED_FUNC(cellSail);
+	return CELL_OK;
+}
+
+int cellSailAviStreamGetHeader()
+{
+	UNIMPLEMENTED_FUNC(cellSail);
+	return CELL_OK;
+}
+
+int cellSailPlayerInitialize()
+{
+	UNIMPLEMENTED_FUNC(cellSail);
+	return CELL_OK;
+}
+
+int cellSailPlayerInitialize2()
+{
+	UNIMPLEMENTED_FUNC(cellSail);
+	return CELL_OK;
+}
+
+int cellSailPlayerFinalize()
+{
+	UNIMPLEMENTED_FUNC(cellSail);
+	return CELL_OK;
+}
+
+int cellSailPlayerRegisterSource()
+{
+	UNIMPLEMENTED_FUNC(cellSail);
+	return CELL_OK;
+}
+
+int cellSailPlayerGetRegisteredProtocols()
+{
+	UNIMPLEMENTED_FUNC(cellSail);
+	return CELL_OK;
+}
+
+int cellSailPlayerSetSoundAdapter()
+{
+	UNIMPLEMENTED_FUNC(cellSail);
+	return CELL_OK;
+}
+
+int cellSailPlayerSetGraphicsAdapter()
+{
+	UNIMPLEMENTED_FUNC(cellSail);
+	return CELL_OK;
+}
+
+int cellSailPlayerSetAuReceiver()
+{
+	UNIMPLEMENTED_FUNC(cellSail);
+	return CELL_OK;
+}
+
+int cellSailPlayerSetRendererAudio()
+{
+	UNIMPLEMENTED_FUNC(cellSail);
+	return CELL_OK;
+}
+
+int cellSailPlayerSetRendererVideo()
+{
+	UNIMPLEMENTED_FUNC(cellSail);
+	return CELL_OK;
+}
+
+int cellSailPlayerSetParameter()
+{
+	UNIMPLEMENTED_FUNC(cellSail);
+	return CELL_OK;
+}
+
+int cellSailPlayerGetParameter()
+{
+	UNIMPLEMENTED_FUNC(cellSail);
+	return CELL_OK;
+}
+
+int cellSailPlayerSubscribeEvent()
+{
+	UNIMPLEMENTED_FUNC(cellSail);
+	return CELL_OK;
+}
+
+int cellSailPlayerUnsubscribeEvent()
+{
+	UNIMPLEMENTED_FUNC(cellSail);
+	return CELL_OK;
+}
+
+int cellSailPlayerReplaceEventHandler()
+{
+	UNIMPLEMENTED_FUNC(cellSail);
+	return CELL_OK;
+}
+
+int cellSailPlayerBoot()
+{
+	UNIMPLEMENTED_FUNC(cellSail);
+	return CELL_OK;
+}
+
+int cellSailPlayerCreateDescriptor()
+{
+	UNIMPLEMENTED_FUNC(cellSail);
+	return CELL_OK;
+}
+
+int cellSailPlayerDestroyDescriptor()
+{
+	UNIMPLEMENTED_FUNC(cellSail);
+	return CELL_OK;
+}
+
+int cellSailPlayerAddDescriptor()
+{
+	UNIMPLEMENTED_FUNC(cellSail);
+	return CELL_OK;
+}
+
+int cellSailPlayerRemoveDescriptor()
+{
+	UNIMPLEMENTED_FUNC(cellSail);
+	return CELL_OK;
+}
+
+int cellSailPlayerGetDescriptorCount()
+{
+	UNIMPLEMENTED_FUNC(cellSail);
+	return CELL_OK;
+}
+
+int cellSailPlayerGetCurrentDescriptor()
+{
+	UNIMPLEMENTED_FUNC(cellSail);
+	return CELL_OK;
+}
+
+int cellSailPlayerOpenStream()
+{
+	UNIMPLEMENTED_FUNC(cellSail);
+	return CELL_OK;
+}
+
+int cellSailPlayerCloseStream()
+{
+	UNIMPLEMENTED_FUNC(cellSail);
+	return CELL_OK;
+}
+
+int cellSailPlayerOpenEsAudio()
+{
+	UNIMPLEMENTED_FUNC(cellSail);
+	return CELL_OK;
+}
+
+int cellSailPlayerOpenEsVideo()
+{
+	UNIMPLEMENTED_FUNC(cellSail);
+	return CELL_OK;
+}
+
+int cellSailPlayerOpenEsUser()
+{
+	UNIMPLEMENTED_FUNC(cellSail);
+	return CELL_OK;
+}
+
+int cellSailPlayerReopenEsAudio()
+{
+	UNIMPLEMENTED_FUNC(cellSail);
+	return CELL_OK;
+}
+
+int cellSailPlayerReopenEsVideo()
+{
+	UNIMPLEMENTED_FUNC(cellSail);
+	return CELL_OK;
+}
+
+int cellSailPlayerReopenEsUser()
+{
+	UNIMPLEMENTED_FUNC(cellSail);
+	return CELL_OK;
+}
+
+int cellSailPlayerCloseEsAudio()
+{
+	UNIMPLEMENTED_FUNC(cellSail);
+	return CELL_OK;
+}
+
+int cellSailPlayerCloseEsVideo()
+{
+	UNIMPLEMENTED_FUNC(cellSail);
+	return CELL_OK;
+}
+
+int cellSailPlayerCloseEsUser()
+{
+	UNIMPLEMENTED_FUNC(cellSail);
+	return CELL_OK;
+}
+
+int cellSailPlayerStart()
+{
+	UNIMPLEMENTED_FUNC(cellSail);
+	return CELL_OK;
+}
+
+int cellSailPlayerStop()
+{
+	UNIMPLEMENTED_FUNC(cellSail);
+	return CELL_OK;
+}
+
+int cellSailPlayerNext()
+{
+	UNIMPLEMENTED_FUNC(cellSail);
+	return CELL_OK;
+}
+
+int cellSailPlayerCancel()
+{
+	UNIMPLEMENTED_FUNC(cellSail);
+	return CELL_OK;
+}
+
+int cellSailPlayerSetPaused()
+{
+	UNIMPLEMENTED_FUNC(cellSail);
+	return CELL_OK;
+}
+
+int cellSailPlayerIsPaused()
+{
+	UNIMPLEMENTED_FUNC(cellSail);
+	return CELL_OK;
+}
+
+int cellSailPlayerSetRepeatMode()
+{
+	UNIMPLEMENTED_FUNC(cellSail);
+	return CELL_OK;
+}
+
+int cellSailPlayerGetRepeatMode()
+{
+	UNIMPLEMENTED_FUNC(cellSail);
+	return CELL_OK;
+}
+
+int cellSailPlayerSetEsAudioMuted()
+{
+	UNIMPLEMENTED_FUNC(cellSail);
+	return CELL_OK;
+}
+
+int cellSailPlayerSetEsVideoMuted()
+{
+	UNIMPLEMENTED_FUNC(cellSail);
+	return CELL_OK;
+}
+
+int cellSailPlayerIsEsAudioMuted()
+{
+	UNIMPLEMENTED_FUNC(cellSail);
+	return CELL_OK;
+}
+
+int cellSailPlayerIsEsVideoMuted()
+{
+	UNIMPLEMENTED_FUNC(cellSail);
+	return CELL_OK;
+}
+
+int cellSailPlayerDumpImage()
+{
+	UNIMPLEMENTED_FUNC(cellSail);
+	return CELL_OK;
+}
+
+int cellSailPlayerUnregisterSource()
+{
+	UNIMPLEMENTED_FUNC(cellSail);
+	return CELL_OK;
+}
+
+void cellSail_init()
+{
+	cellSail.AddFunc(0x346ebba3, cellSailMemAllocatorInitialize);
+
+	cellSail.AddFunc(0x4cc54f8e, cellSailFutureInitialize);
+	cellSail.AddFunc(0x9553af65, cellSailFutureFinalize);
+	cellSail.AddFunc(0x0c4cb439, cellSailFutureReset);
+	cellSail.AddFunc(0xa37fed15, cellSailFutureSet);
+	cellSail.AddFunc(0x3a2d806c, cellSailFutureGet);
+	cellSail.AddFunc(0x51ecf361, cellSailFutureIsDone);
+
+	cellSail.AddFunc(0xd5f9a15b, cellSailDescriptorGetStreamType);
+	cellSail.AddFunc(0x4c191088, cellSailDescriptorGetUri);
+	cellSail.AddFunc(0xbd1635f4, cellSailDescriptorGetMediaInfo);
+	cellSail.AddFunc(0x76b1a425, cellSailDescriptorSetAutoSelection);
+	cellSail.AddFunc(0x277adf21, cellSailDescriptorIsAutoSelection);
+	cellSail.AddFunc(0x0abb318b, cellSailDescriptorCreateDatabase);
+	cellSail.AddFunc(0x28336e89, cellSailDescriptorDestroyDatabase);
+	cellSail.AddFunc(0xc044fab1, cellSailDescriptorOpen);
+	cellSail.AddFunc(0x15fd6a2a, cellSailDescriptorClose);
+	cellSail.AddFunc(0x0d0c2f0c, cellSailDescriptorSetEs);
+	cellSail.AddFunc(0xdf5553ef, cellSailDescriptorClearEs);
+	cellSail.AddFunc(0xac9c3b1f, cellSailDescriptorGetCapabilities);
+	cellSail.AddFunc(0x92590d52, cellSailDescriptorInquireCapability);
+	cellSail.AddFunc(0xee94b99b, cellSailDescriptorSetParameter);
+
+	cellSail.AddFunc(0x3d0d3b72, cellSailSoundAdapterInitialize);
+	cellSail.AddFunc(0xd1462438, cellSailSoundAdapterFinalize);
+	cellSail.AddFunc(0x1c9d5e5a, cellSailSoundAdapterSetPreferredFormat);
+	cellSail.AddFunc(0x7eb8d6b5, cellSailSoundAdapterGetFrame);
+	cellSail.AddFunc(0xf25f197d, cellSailSoundAdapterGetFormat);
+	cellSail.AddFunc(0xeec22809, cellSailSoundAdapterUpdateAvSync);
+	cellSail.AddFunc(0x4ae979df, cellSailSoundAdapterPtsToTimePosition);
+
+	cellSail.AddFunc(0x1c983864, cellSailGraphicsAdapterInitialize);
+	cellSail.AddFunc(0x76488bb1, cellSailGraphicsAdapterFinalize);
+	cellSail.AddFunc(0x2e3ccb5e, cellSailGraphicsAdapterSetPreferredFormat);
+	cellSail.AddFunc(0x0247c69e, cellSailGraphicsAdapterGetFrame);
+	cellSail.AddFunc(0x018281a8, cellSailGraphicsAdapterGetFrame2);
+	cellSail.AddFunc(0xffd58aa4, cellSailGraphicsAdapterGetFormat);
+	cellSail.AddFunc(0x44a20e79, cellSailGraphicsAdapterUpdateAvSync);
+	cellSail.AddFunc(0x1872331b, cellSailGraphicsAdapterPtsToTimePosition);
+
+	cellSail.AddFunc(0x3dd9639a, cellSailAuReceiverInitialize);
+	cellSail.AddFunc(0xed58e3ec, cellSailAuReceiverFinalize);
+	cellSail.AddFunc(0x3a1132ed, cellSailAuReceiverGet);
+
+	cellSail.AddFunc(0x67b4d01f, cellSailRendererAudioInitialize);
+	cellSail.AddFunc(0x06dd4174, cellSailRendererAudioFinalize);
+	cellSail.AddFunc(0xb7b4ecee, cellSailRendererAudioNotifyCallCompleted);
+	cellSail.AddFunc(0xf841a537, cellSailRendererAudioNotifyFrameDone);
+	cellSail.AddFunc(0x325039b9, cellSailRendererAudioNotifyOutputEos);
+
+	cellSail.AddFunc(0x8d1ff475, cellSailRendererVideoInitialize);
+	cellSail.AddFunc(0x47055fea, cellSailRendererVideoFinalize);
+	cellSail.AddFunc(0x954f48f8, cellSailRendererVideoNotifyCallCompleted);
+	cellSail.AddFunc(0x5f77e8df, cellSailRendererVideoNotifyFrameDone);
+	cellSail.AddFunc(0xdff1cda2, cellSailRendererVideoNotifyOutputEos);
+
+	cellSail.AddFunc(0x9d30bdce, cellSailSourceInitialize);
+	cellSail.AddFunc(0xee724c99, cellSailSourceFinalize);
+	cellSail.AddFunc(0x764ec2d2, cellSailSourceNotifyCallCompleted);
+	cellSail.AddFunc(0x54c53688, cellSailSourceNotifyInputEos);
+	cellSail.AddFunc(0x95ee1695, cellSailSourceNotifyStreamOut);
+	cellSail.AddFunc(0xf289f0cd, cellSailSourceNotifySessionError);
+	cellSail.AddFunc(0xf4009a94, cellSailSourceNotifyMediaStateChanged);
+	//cellSail.AddFunc(, cellSailSourceCheck);
+	cellSail.AddFunc(0x3df98d41, cellSailSourceNotifyOpenCompleted);
+	cellSail.AddFunc(0x640c7278, cellSailSourceNotifyStartCompleted);
+	cellSail.AddFunc(0x7473970a, cellSailSourceNotifyStopCompleted);
+	cellSail.AddFunc(0x946ecca0, cellSailSourceNotifyReadCompleted);
+	cellSail.AddFunc(0xbdb2251a, cellSailSourceSetDiagHandler);
+	cellSail.AddFunc(0xc457b203, cellSailSourceNotifyCloseCompleted);
+
+	cellSail.AddFunc(0xb980b76e, cellSailMp4MovieGetBrand);
+	cellSail.AddFunc(0xd4049de0, cellSailMp4MovieIsCompatibleBrand);
+	cellSail.AddFunc(0x5783a454, cellSailMp4MovieGetMovieInfo);
+	cellSail.AddFunc(0x5faf802b, cellSailMp4MovieGetTrackByIndex);
+	cellSail.AddFunc(0x85b07126, cellSailMp4MovieGetTrackById);
+	cellSail.AddFunc(0xc2d90ec9, cellSailMp4MovieGetTrackByTypeAndIndex);
+	cellSail.AddFunc(0xa48be428, cellSailMp4TrackGetTrackInfo);
+	cellSail.AddFunc(0x72236ec1, cellSailMp4TrackGetTrackReferenceCount);
+	cellSail.AddFunc(0x5f44f64f, cellSailMp4TrackGetTrackReference);
+	//cellSail.AddFunc(, cellSailMp4ConvertTimeScale);
+
+	cellSail.AddFunc(0x6e83f5c0, cellSailAviMovieGetMovieInfo);
+	cellSail.AddFunc(0x3e908c56, cellSailAviMovieGetStreamByIndex);
+	cellSail.AddFunc(0xddebd2a5, cellSailAviMovieGetStreamByTypeAndIndex);
+	cellSail.AddFunc(0x10298371, cellSailAviMovieGetHeader);
+	cellSail.AddFunc(0xc09e2f23, cellSailAviStreamGetMediaType);
+	cellSail.AddFunc(0xcc3cca60, cellSailAviStreamGetHeader);
+
+	cellSail.AddFunc(0x17932b26, cellSailPlayerInitialize);
+	cellSail.AddFunc(0x23654375, cellSailPlayerInitialize2);
+	cellSail.AddFunc(0x18b4629d, cellSailPlayerFinalize);
+	cellSail.AddFunc(0xbedccc74, cellSailPlayerRegisterSource);
+	cellSail.AddFunc(0x186b98d3, cellSailPlayerGetRegisteredProtocols);
+	cellSail.AddFunc(0x1139a206, cellSailPlayerSetSoundAdapter);
+	cellSail.AddFunc(0x18bcd21b, cellSailPlayerSetGraphicsAdapter);
+	cellSail.AddFunc(0xf5747e1f, cellSailPlayerSetAuReceiver);
+	cellSail.AddFunc(0x92eaf6ca, cellSailPlayerSetRendererAudio);
+	cellSail.AddFunc(0xecf56150, cellSailPlayerSetRendererVideo);
+	cellSail.AddFunc(0x5f7c7a6f, cellSailPlayerSetParameter);
+	cellSail.AddFunc(0x952269c9, cellSailPlayerGetParameter);
+	cellSail.AddFunc(0x6f0b1002, cellSailPlayerSubscribeEvent);
+	cellSail.AddFunc(0x69793952, cellSailPlayerUnsubscribeEvent);
+	cellSail.AddFunc(0x47632810, cellSailPlayerReplaceEventHandler);
+	cellSail.AddFunc(0xbdf21b0f, cellSailPlayerBoot);
+	cellSail.AddFunc(0xd7938b8d, cellSailPlayerCreateDescriptor);
+	cellSail.AddFunc(0xfc839bd4, cellSailPlayerDestroyDescriptor);
+	cellSail.AddFunc(0x7c8dff3b, cellSailPlayerAddDescriptor);
+	cellSail.AddFunc(0x9897fbd1, cellSailPlayerRemoveDescriptor);
+	cellSail.AddFunc(0x752f8585, cellSailPlayerGetDescriptorCount);
+	cellSail.AddFunc(0x75fca288, cellSailPlayerGetCurrentDescriptor);
+	cellSail.AddFunc(0x34ecc1b9, cellSailPlayerOpenStream);
+	cellSail.AddFunc(0x85beffcc, cellSailPlayerCloseStream);
+	cellSail.AddFunc(0x145f9b11, cellSailPlayerOpenEsAudio);
+	cellSail.AddFunc(0x477501f6, cellSailPlayerOpenEsVideo);
+	cellSail.AddFunc(0xa849d0a7, cellSailPlayerOpenEsUser);
+	cellSail.AddFunc(0x4fa5ad09, cellSailPlayerReopenEsAudio);
+	cellSail.AddFunc(0xf60a8a69, cellSailPlayerReopenEsVideo);
+	cellSail.AddFunc(0x7b6fa92e, cellSailPlayerReopenEsUser);
+	cellSail.AddFunc(0xbf9b8d72, cellSailPlayerCloseEsAudio);
+	cellSail.AddFunc(0x07924359, cellSailPlayerCloseEsVideo);
+	cellSail.AddFunc(0xaed9d6cd, cellSailPlayerCloseEsUser);
+	cellSail.AddFunc(0xe535b0d3, cellSailPlayerStart);
+	cellSail.AddFunc(0xeba8d4ec, cellSailPlayerStop);
+	cellSail.AddFunc(0x26563ddc, cellSailPlayerNext);
+	cellSail.AddFunc(0x950d53c1, cellSailPlayerCancel);
+	cellSail.AddFunc(0xd1d55a90, cellSailPlayerSetPaused);
+	cellSail.AddFunc(0xaafa17b8, cellSailPlayerIsPaused);
+	cellSail.AddFunc(0xfc5baf8a, cellSailPlayerSetRepeatMode);
+	cellSail.AddFunc(0x38144ecf, cellSailPlayerGetRepeatMode);
+	cellSail.AddFunc(0x91d287f6, cellSailPlayerSetEsAudioMuted);
+	cellSail.AddFunc(0xf1446a40, cellSailPlayerSetEsVideoMuted);
+	cellSail.AddFunc(0x09de25fd, cellSailPlayerIsEsAudioMuted);
+	cellSail.AddFunc(0xdbe32ed4, cellSailPlayerIsEsVideoMuted);
+	cellSail.AddFunc(0xcc987ba6, cellSailPlayerDumpImage);
+	cellSail.AddFunc(0x025b4974, cellSailPlayerUnregisterSource);
+}

rpcs3/Emu/SysCalls/Modules/cellSailRec.cpp

@@ -0,0 +1,288 @@
+#include "stdafx.h"
+#include "Emu/SysCalls/SysCalls.h"
+#include "Emu/SysCalls/SC_FUNC.h"
+
+void cellSailRec_init();
+Module cellSailRec(0xf034, cellSailRec_init);
+
+// Error Codes
+enum
+{
+	CELL_SAIL_ERROR_INVALID_ARG			= 0x80610701,
+	CELL_SAIL_ERROR_INVALID_STATE		= 0x80610702,
+	CELL_SAIL_ERROR_UNSUPPORTED_STREAM	= 0x80610703,
+	CELL_SAIL_ERROR_INDEX_OUT_OF_RANGE	= 0x80610704,
+	CELL_SAIL_ERROR_EMPTY				= 0x80610705,
+	CELL_SAIL_ERROR_FULLED				= 0x80610706,
+	CELL_SAIL_ERROR_USING				= 0x80610707,
+	CELL_SAIL_ERROR_NOT_AVAILABLE		= 0x80610708,
+	CELL_SAIL_ERROR_CANCEL				= 0x80610709,
+	CELL_SAIL_ERROR_MEMORY				= 0x806107F0,
+	CELL_SAIL_ERROR_INVALID_FD			= 0x806107F1,
+	CELL_SAIL_ERROR_FATAL				= 0x806107FF,
+};
+
+int cellSailProfileSetEsAudioParameter()
+{
+	UNIMPLEMENTED_FUNC(cellSailRec);
+	return CELL_OK;
+}
+
+int cellSailProfileSetEsVideoParameter()
+{
+	UNIMPLEMENTED_FUNC(cellSailRec);
+	return CELL_OK;
+}
+
+int cellSailProfileSetStreamParameter()
+{
+	UNIMPLEMENTED_FUNC(cellSailRec);
+	return CELL_OK;
+}
+
+int cellSailVideoConverterCanProcess()
+{
+	UNIMPLEMENTED_FUNC(cellSailRec);
+	return CELL_OK;
+}
+
+int cellSailVideoConverterProcess()
+{
+	UNIMPLEMENTED_FUNC(cellSailRec);
+	return CELL_OK;
+}
+
+int cellSailVideoConverterCanGetResult()
+{
+	UNIMPLEMENTED_FUNC(cellSailRec);
+	return CELL_OK;
+}
+
+int cellSailVideoConverterGetResult()
+{
+	UNIMPLEMENTED_FUNC(cellSailRec);
+	return CELL_OK;
+}
+
+int cellSailFeederAudioInitialize()
+{
+	UNIMPLEMENTED_FUNC(cellSailRec);
+	return CELL_OK;
+}
+
+int cellSailFeederAudioFinalize()
+{
+	UNIMPLEMENTED_FUNC(cellSailRec);
+	return CELL_OK;
+}
+
+int cellSailFeederAudioNotifyCallCompleted()
+{
+	UNIMPLEMENTED_FUNC(cellSailRec);
+	return CELL_OK;
+}
+
+int cellSailFeederAudioNotifyFrameOut()
+{
+	UNIMPLEMENTED_FUNC(cellSailRec);
+	return CELL_OK;
+}
+
+int cellSailFeederAudioNotifySessionEnd()
+{
+	UNIMPLEMENTED_FUNC(cellSailRec);
+	return CELL_OK;
+}
+
+int cellSailFeederAudioNotifySessionError()
+{
+	UNIMPLEMENTED_FUNC(cellSailRec);
+	return CELL_OK;
+}
+
+int cellSailFeederVideoInitialize()
+{
+	UNIMPLEMENTED_FUNC(cellSailRec);
+	return CELL_OK;
+}
+
+int cellSailFeederVideoFinalize()
+{
+	UNIMPLEMENTED_FUNC(cellSailRec);
+	return CELL_OK;
+}
+
+int cellSailFeederVideoNotifyCallCompleted()
+{
+	UNIMPLEMENTED_FUNC(cellSailRec);
+	return CELL_OK;
+}
+
+int cellSailFeederVideoNotifyFrameOut()
+{
+	UNIMPLEMENTED_FUNC(cellSailRec);
+	return CELL_OK;
+}
+
+int cellSailFeederVideoNotifySessionEnd()
+{
+	UNIMPLEMENTED_FUNC(cellSailRec);
+	return CELL_OK;
+}
+
+int cellSailFeederVideoNotifySessionError()
+{
+	UNIMPLEMENTED_FUNC(cellSailRec);
+	return CELL_OK;
+}
+
+int cellSailRecorderInitialize()
+{
+	UNIMPLEMENTED_FUNC(cellSailRec);
+	return CELL_OK;
+}
+
+int cellSailRecorderFinalize()
+{
+	UNIMPLEMENTED_FUNC(cellSailRec);
+	return CELL_OK;
+}
+
+int cellSailRecorderSetFeederAudio()
+{
+	UNIMPLEMENTED_FUNC(cellSailRec);
+	return CELL_OK;
+}
+
+int cellSailRecorderSetFeederVideo()
+{
+	UNIMPLEMENTED_FUNC(cellSailRec);
+	return CELL_OK;
+}
+
+int cellSailRecorderSetParameter()
+{
+	UNIMPLEMENTED_FUNC(cellSailRec);
+	return CELL_OK;
+}
+
+int cellSailRecorderGetParameter()
+{
+	UNIMPLEMENTED_FUNC(cellSailRec);
+	return CELL_OK;
+}
+
+int cellSailRecorderBoot()
+{
+	UNIMPLEMENTED_FUNC(cellSailRec);
+	return CELL_OK;
+}
+
+int cellSailRecorderCreateProfile()
+{
+	UNIMPLEMENTED_FUNC(cellSailRec);
+	return CELL_OK;
+}
+
+int cellSailRecorderDestroyProfile()
+{
+	UNIMPLEMENTED_FUNC(cellSailRec);
+	return CELL_OK;
+}
+
+int cellSailRecorderCreateVideoConverter()
+{
+	UNIMPLEMENTED_FUNC(cellSailRec);
+	return CELL_OK;
+}
+
+int cellSailRecorderDestroyVideoConverter()
+{
+	UNIMPLEMENTED_FUNC(cellSailRec);
+	return CELL_OK;
+}
+
+int cellSailRecorderOpenStream()
+{
+	UNIMPLEMENTED_FUNC(cellSailRec);
+	return CELL_OK;
+}
+
+int cellSailRecorderCloseStream()
+{
+	UNIMPLEMENTED_FUNC(cellSailRec);
+	return CELL_OK;
+}
+
+int cellSailRecorderStart()
+{
+	UNIMPLEMENTED_FUNC(cellSailRec);
+	return CELL_OK;
+}
+
+int cellSailRecorderStop()
+{
+	UNIMPLEMENTED_FUNC(cellSailRec);
+	return CELL_OK;
+}
+
+int cellSailRecorderCancel()
+{
+	UNIMPLEMENTED_FUNC(cellSailRec);
+	return CELL_OK;
+}
+
+int cellSailRecorderDumpImage()
+{
+	UNIMPLEMENTED_FUNC(cellSailRec);
+	return CELL_OK;
+}
+
+void cellSailRec_init()
+{
+	cellSailRec.AddFunc(0xe14cae97, cellSailProfileSetEsAudioParameter);
+	cellSailRec.AddFunc(0x1422a425, cellSailProfileSetEsVideoParameter);
+	cellSailRec.AddFunc(0xe8d86c43, cellSailProfileSetStreamParameter);
+
+	cellSailRec.AddFunc(0xb3d30b0d, cellSailVideoConverterCanProcess);
+	cellSailRec.AddFunc(0x855da8c6, cellSailVideoConverterProcess);
+	cellSailRec.AddFunc(0xe16de678, cellSailVideoConverterCanGetResult);
+	cellSailRec.AddFunc(0xe15679fe, cellSailVideoConverterGetResult);
+	//cellSailRec.AddFunc(, CellSailVideoConverterFuncProcessDone);
+
+	cellSailRec.AddFunc(0xbd591197, cellSailFeederAudioInitialize);
+	cellSailRec.AddFunc(0x899d1587, cellSailFeederAudioFinalize);
+	cellSailRec.AddFunc(0xc2e2f30d, cellSailFeederAudioNotifyCallCompleted);
+	cellSailRec.AddFunc(0x3c775cea, cellSailFeederAudioNotifyFrameOut);
+	cellSailRec.AddFunc(0x999c0dc5, cellSailFeederAudioNotifySessionEnd);
+	cellSailRec.AddFunc(0xaf310ae6, cellSailFeederAudioNotifySessionError);
+
+	cellSailRec.AddFunc(0x57415dd3, cellSailFeederVideoInitialize);
+	cellSailRec.AddFunc(0x81bfeae8, cellSailFeederVideoFinalize);
+	cellSailRec.AddFunc(0xd84daeb9, cellSailFeederVideoNotifyCallCompleted);
+	cellSailRec.AddFunc(0xe5e0572a, cellSailFeederVideoNotifyFrameOut);
+	cellSailRec.AddFunc(0xbff6e8d3, cellSailFeederVideoNotifySessionEnd);
+	cellSailRec.AddFunc(0x86cae679, cellSailFeederVideoNotifySessionError);
+
+	cellSailRec.AddFunc(0x7a52bf69, cellSailRecorderInitialize);
+	cellSailRec.AddFunc(0xf57d74e3, cellSailRecorderFinalize);
+	cellSailRec.AddFunc(0x3deae857, cellSailRecorderSetFeederAudio);
+	cellSailRec.AddFunc(0x4fec43a9, cellSailRecorderSetFeederVideo);
+	cellSailRec.AddFunc(0x0a3ea2a9, cellSailRecorderSetParameter);
+	cellSailRec.AddFunc(0xff20157b, cellSailRecorderGetParameter);
+	//cellSailRec.AddFunc(, cellSailRecorderSubscribeEvent);
+	//cellSailRec.AddFunc(, cellSailRecorderUnsubscribeEvent);
+	//cellSailRec.AddFunc(, cellSailRecorderReplaceEventHandler);
+	cellSailRec.AddFunc(0xc4617ddc, cellSailRecorderBoot);
+	cellSailRec.AddFunc(0x50affdc1, cellSailRecorderCreateProfile);
+	cellSailRec.AddFunc(0x376c3926, cellSailRecorderDestroyProfile);
+	cellSailRec.AddFunc(0x49476a3d, cellSailRecorderCreateVideoConverter);
+	cellSailRec.AddFunc(0x455c4709, cellSailRecorderDestroyVideoConverter);
+	cellSailRec.AddFunc(0x10c81457, cellSailRecorderOpenStream);
+	cellSailRec.AddFunc(0xe3f56f62, cellSailRecorderCloseStream);
+	cellSailRec.AddFunc(0x4830faf8, cellSailRecorderStart);
+	cellSailRec.AddFunc(0x18ecc741, cellSailRecorderStop);
+	cellSailRec.AddFunc(0xd37fb694, cellSailRecorderCancel);
+
+	cellSailRec.AddFunc(0x37aad85f, cellSailRecorderDumpImage);
+}

rpcs3/Emu/SysCalls/Modules/cellScreenshot.cpp

@@ -0,0 +1,49 @@
+#include "stdafx.h"
+#include "Emu/SysCalls/SysCalls.h"
+#include "Emu/SysCalls/SC_FUNC.h"
+
+void cellScreenshot_init();
+Module cellScreenshot(0x004e, cellScreenshot_init);
+
+// Return Codes
+enum
+{
+	CELL_SCREENSHOT_OK								= 0x0,
+	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,
+};
+
+int cellScreenShotSetParameter()
+{
+	UNIMPLEMENTED_FUNC(cellScreenshot);
+	return CELL_OK;
+}
+
+int cellScreenShotSetOverlayImage()
+{
+	UNIMPLEMENTED_FUNC(cellScreenshot);
+	return CELL_OK;
+}
+
+int cellScreenShotEnable()
+{
+	UNIMPLEMENTED_FUNC(cellScreenshot);
+	return CELL_OK;
+}
+
+int cellScreenShotDisable()
+{
+	UNIMPLEMENTED_FUNC(cellScreenshot);
+	return CELL_OK;
+}
+
+void cellScreenshot_init()
+{
+	cellScreenshot.AddFunc(0xd3ad63e4, cellScreenShotSetParameter);
+	cellScreenshot.AddFunc(0x7a9c2243, cellScreenShotSetOverlayImage);
+	cellScreenshot.AddFunc(0x9e33ab8f, cellScreenShotEnable);
+	cellScreenshot.AddFunc(0xfc6f4e74, cellScreenShotDisable);
+}

rpcs3/Emu/SysCalls/Modules/cellSearch.cpp

@@ -0,0 +1,176 @@
+#include "stdafx.h"
+#include "Emu/SysCalls/SysCalls.h"
+#include "Emu/SysCalls/SC_FUNC.h"
+
+void cellSearch_init();
+Module cellSearch(0xf02f, cellSearch_init);
+
+// Error Codes
+enum
+{
+	CELL_SEARCH_OK							= 0,
+	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,
+};
+
+int cellSearchInitialize()
+{
+	UNIMPLEMENTED_FUNC(cellSearch);
+	return CELL_OK;
+}
+
+int cellSearchFinalize()
+{
+	UNIMPLEMENTED_FUNC(cellSearch);
+	return CELL_OK;
+}
+
+int cellSearchStartListSearch()
+{
+	UNIMPLEMENTED_FUNC(cellSearch);
+	return CELL_OK;
+}
+
+int cellSearchStartContentSearchInList()
+{
+	UNIMPLEMENTED_FUNC(cellSearch);
+	return CELL_OK;
+}
+
+int cellSearchStartContentSearch()
+{
+	UNIMPLEMENTED_FUNC(cellSearch);
+	return CELL_OK;
+}
+
+int cellSearchStartSceneSearchInVideo()
+{
+	UNIMPLEMENTED_FUNC(cellSearch);
+	return CELL_OK;
+}
+
+int cellSearchStartSceneSearch()
+{
+	UNIMPLEMENTED_FUNC(cellSearch);
+	return CELL_OK;
+}
+
+int cellSearchGetContentInfoByOffset()
+{
+	UNIMPLEMENTED_FUNC(cellSearch);
+	return CELL_OK;
+}
+
+int cellSearchGetContentInfoByContentId()
+{
+	UNIMPLEMENTED_FUNC(cellSearch);
+	return CELL_OK;
+}
+
+int cellSearchGetOffsetByContentId()
+{
+	UNIMPLEMENTED_FUNC(cellSearch);
+	return CELL_OK;
+}
+
+int cellSearchGetContentIdByOffset()
+{
+	UNIMPLEMENTED_FUNC(cellSearch);
+	return CELL_OK;
+}
+
+int cellSearchGetContentInfoGameComment()
+{
+	UNIMPLEMENTED_FUNC(cellSearch);
+	return CELL_OK;
+}
+
+int cellSearchGetMusicSelectionContext()
+{
+	UNIMPLEMENTED_FUNC(cellSearch);
+	return CELL_OK;
+}
+
+int cellSearchGetMusicSelectionContextOfSingleTrack()
+{
+	UNIMPLEMENTED_FUNC(cellSearch);
+	return CELL_OK;
+}
+
+int cellSearchGetContentInfoPath()
+{
+	UNIMPLEMENTED_FUNC(cellSearch);
+	return CELL_OK;
+}
+
+int cellSearchGetContentInfoPathMovieThumb()
+{
+	UNIMPLEMENTED_FUNC(cellSearch);
+	return CELL_OK;
+}
+
+int cellSearchPrepareFile()
+{
+	UNIMPLEMENTED_FUNC(cellSearch);
+	return CELL_OK;
+}
+
+int cellSearchGetContentInfoDeveloperData()
+{
+	UNIMPLEMENTED_FUNC(cellSearch);
+	return CELL_OK;
+}
+
+int cellSearchCancel()
+{
+	UNIMPLEMENTED_FUNC(cellSearch);
+	return CELL_OK;
+}
+
+int cellSearchEnd()
+{
+	UNIMPLEMENTED_FUNC(cellSearch);
+	return CELL_OK;
+}
+
+void cellSearch_init()
+{
+	cellSearch.AddFunc(0xc81ccf8a, cellSearchInitialize);
+	cellSearch.AddFunc(0xbfab7616, cellSearchFinalize);
+	cellSearch.AddFunc(0x0a4c8295, cellSearchStartListSearch);
+	cellSearch.AddFunc(0x64fb0b76, cellSearchStartContentSearchInList);
+	cellSearch.AddFunc(0x0591826f, cellSearchStartContentSearch);
+	cellSearch.AddFunc(0xc0ed0522, cellSearchStartSceneSearchInVideo);
+	cellSearch.AddFunc(0x13524faa, cellSearchStartSceneSearch);
+	cellSearch.AddFunc(0x3b210319, cellSearchGetContentInfoByOffset);
+	cellSearch.AddFunc(0x9663a44b, cellSearchGetContentInfoByContentId);
+	cellSearch.AddFunc(0x540d9068, cellSearchGetOffsetByContentId);
+	cellSearch.AddFunc(0x94e21701, cellSearchGetContentIdByOffset);
+	cellSearch.AddFunc(0xd7a7a433, cellSearchGetContentInfoGameComment);
+	cellSearch.AddFunc(0x025ce169, cellSearchGetMusicSelectionContext);
+	cellSearch.AddFunc(0xed20e079, cellSearchGetMusicSelectionContextOfSingleTrack);
+	cellSearch.AddFunc(0xffb28491, cellSearchGetContentInfoPath);
+	cellSearch.AddFunc(0x37b5ba0c, cellSearchGetContentInfoPathMovieThumb);
+	cellSearch.AddFunc(0xe73cb0d2, cellSearchPrepareFile);
+	cellSearch.AddFunc(0x35cda406, cellSearchGetContentInfoDeveloperData);
+	cellSearch.AddFunc(0x8fe376a6, cellSearchCancel);
+	cellSearch.AddFunc(0x774033d6, cellSearchEnd);
+}

rpcs3/Emu/SysCalls/Modules/cellSheap.cpp

@@ -0,0 +1,148 @@
+#include "stdafx.h"
+#include "Emu/SysCalls/SysCalls.h"
+#include "Emu/SysCalls/SC_FUNC.h"
+
+void cellSheap_init();
+Module cellSheap(0x000c, cellSheap_init);
+
+// Return Codes
+enum
+{
+	CELL_SHEAP_ERROR_INVAL		= 0x80410302,
+	CELL_SHEAP_ERROR_BUSY		= 0x8041030A,
+	CELL_SHEAP_ERROR_ALIGN		= 0x80410310,
+	CELL_SHEAP_ERROR_SHORTAGE	= 0x80410312,
+};
+
+int cellSheapInitialize()
+{
+	UNIMPLEMENTED_FUNC(cellSheap);
+	return CELL_OK;
+}
+
+int cellSheapAllocate()
+{
+	UNIMPLEMENTED_FUNC(cellSheap);
+	return CELL_OK;
+}
+
+int cellSheapFree()
+{
+	UNIMPLEMENTED_FUNC(cellSheap);
+	return CELL_OK;
+}
+
+int cellSheapQueryMax()
+{
+	UNIMPLEMENTED_FUNC(cellSheap);
+	return CELL_OK;
+}
+
+int cellSheapQueryFree()
+{
+	UNIMPLEMENTED_FUNC(cellSheap);
+	return CELL_OK;
+}
+
+int cellKeySheapInitialize()
+{
+	UNIMPLEMENTED_FUNC(cellSheap);
+	return CELL_OK;
+}
+
+int cellKeySheapBufferNew()
+{
+	UNIMPLEMENTED_FUNC(cellSheap);
+	return CELL_OK;
+}
+
+int cellKeySheapBufferDelete()
+{
+	UNIMPLEMENTED_FUNC(cellSheap);
+	return CELL_OK;
+}
+
+int cellKeySheapMutexNew()
+{
+	UNIMPLEMENTED_FUNC(cellSheap);
+	return CELL_OK;
+}
+
+int cellKeySheapMutexDelete()
+{
+	UNIMPLEMENTED_FUNC(cellSheap);
+	return CELL_OK;
+}
+
+int cellKeySheapBarrierNew()
+{
+	UNIMPLEMENTED_FUNC(cellSheap);
+	return CELL_OK;
+}
+
+int cellKeySheapBarrierDelete()
+{
+	UNIMPLEMENTED_FUNC(cellSheap);
+	return CELL_OK;
+}
+
+int cellKeySheapSemaphoreNew()
+{
+	UNIMPLEMENTED_FUNC(cellSheap);
+	return CELL_OK;
+}
+
+int cellKeySheapSemaphoreDelete()
+{
+	UNIMPLEMENTED_FUNC(cellSheap);
+	return CELL_OK;
+}
+
+int cellKeySheapRwmNew()
+{
+	UNIMPLEMENTED_FUNC(cellSheap);
+	return CELL_OK;
+}
+
+int cellKeySheapRwmDelete()
+{
+	UNIMPLEMENTED_FUNC(cellSheap);
+	return CELL_OK;
+}
+
+int cellKeySheapQueueNew()
+{
+	UNIMPLEMENTED_FUNC(cellSheap);
+	return CELL_OK;
+}
+
+int cellKeySheapQueueDelete()
+{
+	UNIMPLEMENTED_FUNC(cellSheap);
+	return CELL_OK;
+}
+
+void cellSheap_init()
+{
+	cellSheap.AddFunc(0xbbb47cd8, cellSheapInitialize);
+	cellSheap.AddFunc(0x4b1383fb, cellSheapAllocate);
+	cellSheap.AddFunc(0x5c5994bd, cellSheapFree);
+	cellSheap.AddFunc(0x37968718, cellSheapQueryMax);
+	cellSheap.AddFunc(0x7fa23275, cellSheapQueryFree);
+
+	// (TODO: Some cellKeySheap* functions are missing)
+	cellSheap.AddFunc(0xa1b25841, cellKeySheapInitialize);
+	cellSheap.AddFunc(0x4a5b9659, cellKeySheapBufferNew);
+	cellSheap.AddFunc(0xe6b37362, cellKeySheapBufferDelete);
+
+	cellSheap.AddFunc(0x3478e1e6, cellKeySheapMutexNew);
+	cellSheap.AddFunc(0x2452679f, cellKeySheapMutexDelete);
+	cellSheap.AddFunc(0xe897c835, cellKeySheapBarrierNew);
+	cellSheap.AddFunc(0xf6f5fbca, cellKeySheapBarrierDelete);
+	cellSheap.AddFunc(0x69a5861d, cellKeySheapSemaphoreNew);
+	cellSheap.AddFunc(0x73a45cf8, cellKeySheapSemaphoreDelete);
+	cellSheap.AddFunc(0xf01ac471, cellKeySheapRwmNew);
+	cellSheap.AddFunc(0xed136702, cellKeySheapRwmDelete);
+	cellSheap.AddFunc(0x987e260e, cellKeySheapQueueNew);
+	cellSheap.AddFunc(0x79a6abd0, cellKeySheapQueueDelete);
+}

rpcs3/Emu/SysCalls/Modules/cellSubdisplay.cpp

@@ -0,0 +1,95 @@
+#include "stdafx.h"
+#include "Emu/SysCalls/SysCalls.h"
+#include "Emu/SysCalls/SC_FUNC.h"
+
+void cellSubdisplay_init();
+Module cellSubdisplay(0x0034, cellSubdisplay_init);
+
+// Return Codes
+enum
+{
+	CELL_SUBDISPLAY_ERROR_OUT_OF_MEMORY		= 0x80029851,
+	CELL_SUBDISPLAY_ERROR_FATAL				= 0x80029852,
+	CELL_SUBDISPLAY_ERROR_NOT_FOUND			= 0x80029853,
+	CELL_SUBDISPLAY_ERROR_INVALID_VALUE		= 0x80029854,
+	CELL_SUBDISPLAY_ERROR_NOT_INITIALIZED	= 0x80029855,
+	CELL_SUBDISPLAY_ERROR_SET_SAMPLE		= 0x80029860,
+	CELL_SUBDISPLAY_ERROR_AUDIOOUT_IS_BUSY	= 0x80029861,
+	CELL_SUBDISPLAY_ERROR_ZERO_REGISTERED	= 0x80029813,
+};
+
+int cellSubDisplayInit()
+{
+	UNIMPLEMENTED_FUNC(cellSubdisplay);
+	return CELL_OK;
+}
+
+int cellSubDisplayEnd()
+{
+	UNIMPLEMENTED_FUNC(cellSubdisplay);
+	return CELL_OK;
+}
+
+int cellSubDisplayGetRequiredMemory()
+{
+	UNIMPLEMENTED_FUNC(cellSubdisplay);
+	return CELL_OK;
+}
+
+int cellSubDisplayStart()
+{
+	UNIMPLEMENTED_FUNC(cellSubdisplay);
+	return CELL_OK;
+}
+
+int cellSubDisplayStop()
+{
+	UNIMPLEMENTED_FUNC(cellSubdisplay);
+	return CELL_OK;
+}
+
+int cellSubDisplayGetVideoBuffer()
+{
+	UNIMPLEMENTED_FUNC(cellSubdisplay);
+	return CELL_OK;
+}
+
+int cellSubDisplayAudioOutBlocking()
+{
+	UNIMPLEMENTED_FUNC(cellSubdisplay);
+	return CELL_OK;
+}
+
+int cellSubDisplayAudioOutNonBlocking()
+{
+	UNIMPLEMENTED_FUNC(cellSubdisplay);
+	return CELL_OK;
+}
+
+int cellSubDisplayGetPeerNum()
+{
+	UNIMPLEMENTED_FUNC(cellSubdisplay);
+	return CELL_OK;
+}
+
+int cellSubDisplayGetPeerList()
+{
+	UNIMPLEMENTED_FUNC(cellSubdisplay);
+	return CELL_OK;
+}
+
+void cellSubdisplay_init()
+{
+	cellSubdisplay.AddFunc(0xf9a7e8a5, cellSubDisplayInit);
+	cellSubdisplay.AddFunc(0x551d80a5, cellSubDisplayEnd);
+	cellSubdisplay.AddFunc(0x6595ce22, cellSubDisplayGetRequiredMemory);
+	cellSubdisplay.AddFunc(0xa5bccb47, cellSubDisplayStart);
+	cellSubdisplay.AddFunc(0x6d85ddb3, cellSubDisplayStop);
+
+	cellSubdisplay.AddFunc(0x938ac642, cellSubDisplayGetVideoBuffer);
+	cellSubdisplay.AddFunc(0xaee1e0c2, cellSubDisplayAudioOutBlocking);
+	cellSubdisplay.AddFunc(0x5468d6b0, cellSubDisplayAudioOutNonBlocking);
+
+	cellSubdisplay.AddFunc(0x8a264d71, cellSubDisplayGetPeerNum);
+	cellSubdisplay.AddFunc(0xe2485f79, cellSubDisplayGetPeerList);
+}

rpcs3/Emu/SysCalls/Modules/cellSync2.cpp

@@ -0,0 +1,254 @@
+#include "stdafx.h"
+#include "Emu/SysCalls/SysCalls.h"
+#include "Emu/SysCalls/SC_FUNC.h"
+
+void cellSync2_init();
+Module cellSync2(0x0055, cellSync2_init);
+
+// Return Codes
+enum
+{
+	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,
+};
+
+int _cellSync2MutexAttributeInitialize()
+{
+	UNIMPLEMENTED_FUNC(cellSync2);
+	return CELL_OK;
+}
+
+int cellSync2MutexEstimateBufferSize()
+{
+	UNIMPLEMENTED_FUNC(cellSync2);
+	return CELL_OK;
+}
+
+int cellSync2MutexInitialize()
+{
+	UNIMPLEMENTED_FUNC(cellSync2);
+	return CELL_OK;
+}
+
+int cellSync2MutexFinalize()
+{
+	UNIMPLEMENTED_FUNC(cellSync2);
+	return CELL_OK;
+}
+
+int cellSync2MutexLock()
+{
+	UNIMPLEMENTED_FUNC(cellSync2);
+	return CELL_OK;
+}
+
+int cellSync2MutexTryLock()
+{
+	UNIMPLEMENTED_FUNC(cellSync2);
+	return CELL_OK;
+}
+
+int cellSync2MutexUnlock()
+{
+	UNIMPLEMENTED_FUNC(cellSync2);
+	return CELL_OK;
+}
+
+int _cellSync2CondAttributeInitialize()
+{
+	UNIMPLEMENTED_FUNC(cellSync2);
+	return CELL_OK;
+}
+
+int cellSync2CondEstimateBufferSize()
+{
+	UNIMPLEMENTED_FUNC(cellSync2);
+	return CELL_OK;
+}
+
+int cellSync2CondInitialize()
+{
+	UNIMPLEMENTED_FUNC(cellSync2);
+	return CELL_OK;
+}
+
+int cellSync2CondFinalize()
+{
+	UNIMPLEMENTED_FUNC(cellSync2);
+	return CELL_OK;
+}
+
+int cellSync2CondWait()
+{
+	UNIMPLEMENTED_FUNC(cellSync2);
+	return CELL_OK;
+}
+
+int cellSync2CondSignal()
+{
+	UNIMPLEMENTED_FUNC(cellSync2);
+	return CELL_OK;
+}
+
+int cellSync2CondSignalAll()
+{
+	UNIMPLEMENTED_FUNC(cellSync2);
+	return CELL_OK;
+}
+
+int _cellSync2SemaphoreAttributeInitialize()
+{
+	UNIMPLEMENTED_FUNC(cellSync2);
+	return CELL_OK;
+}
+
+int cellSync2SemaphoreEstimateBufferSize()
+{
+	UNIMPLEMENTED_FUNC(cellSync2);
+	return CELL_OK;
+}
+
+int cellSync2SemaphoreInitialize()
+{
+	UNIMPLEMENTED_FUNC(cellSync2);
+	return CELL_OK;
+}
+
+int cellSync2SemaphoreFinalize()
+{
+	UNIMPLEMENTED_FUNC(cellSync2);
+	return CELL_OK;
+}
+
+int cellSync2SemaphoreAcquire()
+{
+	UNIMPLEMENTED_FUNC(cellSync2);
+	return CELL_OK;
+}
+
+int cellSync2SemaphoreTryAcquire()
+{
+	UNIMPLEMENTED_FUNC(cellSync2);
+	return CELL_OK;
+}
+
+int cellSync2SemaphoreRelease()
+{
+	UNIMPLEMENTED_FUNC(cellSync2);
+	return CELL_OK;
+}
+
+int cellSync2SemaphoreGetCount()
+{
+	UNIMPLEMENTED_FUNC(cellSync2);
+	return CELL_OK;
+}
+
+int _cellSync2QueueAttributeInitialize()
+{
+	UNIMPLEMENTED_FUNC(cellSync2);
+	return CELL_OK;
+}
+
+int cellSync2QueueEstimateBufferSize()
+{
+	UNIMPLEMENTED_FUNC(cellSync2);
+	return CELL_OK;
+}
+
+int cellSync2QueueInitialize()
+{
+	UNIMPLEMENTED_FUNC(cellSync2);
+	return CELL_OK;
+}
+
+int cellSync2QueueFinalize()
+{
+	UNIMPLEMENTED_FUNC(cellSync2);
+	return CELL_OK;
+}
+
+int cellSync2QueuePush()
+{
+	UNIMPLEMENTED_FUNC(cellSync2);
+	return CELL_OK;
+}
+
+int cellSync2QueueTryPush()
+{
+	UNIMPLEMENTED_FUNC(cellSync2);
+	return CELL_OK;
+}
+
+int cellSync2QueuePop()
+{
+	UNIMPLEMENTED_FUNC(cellSync2);
+	return CELL_OK;
+}
+
+int cellSync2QueueTryPop()
+{
+	UNIMPLEMENTED_FUNC(cellSync2);
+	return CELL_OK;
+}
+
+int cellSync2QueueGetSize()
+{
+	UNIMPLEMENTED_FUNC(cellSync2);
+	return CELL_OK;
+}
+
+int cellSync2QueueGetDepth()
+{
+	UNIMPLEMENTED_FUNC(cellSync2);
+	return CELL_OK;
+}
+
+void cellSync2_init()
+{
+	cellSync2.AddFunc(0x55836e73, _cellSync2MutexAttributeInitialize);
+	cellSync2.AddFunc(0xd51bfae7, cellSync2MutexEstimateBufferSize);
+	cellSync2.AddFunc(0xeb81a467, cellSync2MutexInitialize);
+	cellSync2.AddFunc(0x27f2d61c, cellSync2MutexFinalize);
+	cellSync2.AddFunc(0xa400d82e, cellSync2MutexLock);
+	cellSync2.AddFunc(0xa69c749c, cellSync2MutexTryLock);
+	cellSync2.AddFunc(0x0080fe88, cellSync2MutexUnlock);
+
+	cellSync2.AddFunc(0xdf3c532a, _cellSync2CondAttributeInitialize);
+	cellSync2.AddFunc(0x5b1e4d7a, cellSync2CondEstimateBufferSize);
+	cellSync2.AddFunc(0x58be9a0f, cellSync2CondInitialize);
+	cellSync2.AddFunc(0x63062249, cellSync2CondFinalize);
+	cellSync2.AddFunc(0xbc96d751, cellSync2CondWait);
+	cellSync2.AddFunc(0x871af804, cellSync2CondSignal);
+	cellSync2.AddFunc(0x8aae07c2, cellSync2CondSignalAll);
+
+	cellSync2.AddFunc(0x2d77fe17, _cellSync2SemaphoreAttributeInitialize);
+	cellSync2.AddFunc(0x74c2780f, cellSync2SemaphoreEstimateBufferSize);
+	cellSync2.AddFunc(0xc5dee254, cellSync2SemaphoreInitialize);
+	cellSync2.AddFunc(0x164843a7, cellSync2SemaphoreFinalize);
+	cellSync2.AddFunc(0xd1b0d146, cellSync2SemaphoreAcquire);
+	cellSync2.AddFunc(0x5e4b0f87, cellSync2SemaphoreTryAcquire);
+	cellSync2.AddFunc(0x0c2983ac, cellSync2SemaphoreRelease);
+	cellSync2.AddFunc(0x4e2ee031, cellSync2SemaphoreGetCount);
+
+	cellSync2.AddFunc(0x5e00d433, _cellSync2QueueAttributeInitialize);
+	cellSync2.AddFunc(0xc08cc0f9, cellSync2QueueEstimateBufferSize);
+	cellSync2.AddFunc(0xf125e044, cellSync2QueueInitialize);
+	cellSync2.AddFunc(0x6af85cdf, cellSync2QueueFinalize);
+	cellSync2.AddFunc(0x7d967d91, cellSync2QueuePush);
+	cellSync2.AddFunc(0x7fd479fe, cellSync2QueueTryPush);
+	cellSync2.AddFunc(0xd83ab0c9, cellSync2QueuePop);
+	cellSync2.AddFunc(0x0c9a0ea9, cellSync2QueueTryPop);
+	cellSync2.AddFunc(0x12f0a27d, cellSync2QueueGetSize);
+	cellSync2.AddFunc(0xf0e1471c, cellSync2QueueGetDepth);
+}

rpcs3/Emu/SysCalls/Modules/cellSysutilAp.cpp

@@ -0,0 +1,44 @@
+#include "stdafx.h"
+#include "Emu/SysCalls/SysCalls.h"
+#include "Emu/SysCalls/SC_FUNC.h"
+
+void cellSysutilAp_init();
+Module cellSysutilAp(0x0039, cellSysutilAp_init);
+
+// Return Codes
+enum
+{
+	CELL_SYSUTIL_AP_ERROR_OUT_OF_MEMORY			= 0x8002cd00,
+	CELL_SYSUTIL_AP_ERROR_FATAL					= 0x8002cd01,
+	CELL_SYSUTIL_AP_ERROR_INVALID_VALUE			= 0x8002cd02,
+	CELL_SYSUTIL_AP_ERROR_NOT_INITIALIZED		= 0x8002cd03,
+	CELL_SYSUTIL_AP_ERROR_ZERO_REGISTERED		= 0x8002cd13,
+	CELL_SYSUTIL_AP_ERROR_NETIF_DISABLED		= 0x8002cd14,
+	CELL_SYSUTIL_AP_ERROR_NETIF_NO_CABLE		= 0x8002cd15,
+	CELL_SYSUTIL_AP_ERROR_NETIF_CANNOT_CONNECT	= 0x8002cd16,
+};
+
+int cellSysutilApGetRequiredMemSize()
+{
+	UNIMPLEMENTED_FUNC(cellSysutilAp);
+	return CELL_OK;
+}
+
+int cellSysutilApOn()
+{
+	UNIMPLEMENTED_FUNC(cellSysutilAp);
+	return CELL_OK;
+}
+
+int cellSysutilApOff()
+{
+	UNIMPLEMENTED_FUNC(cellSysutilAp);
+	return CELL_OK;
+}
+
+void cellSysutilAp_init()
+{
+	cellSysutilAp.AddFunc(0x9e67e0dd, cellSysutilApGetRequiredMemSize);
+	cellSysutilAp.AddFunc(0x3343824c, cellSysutilApOn);
+	cellSysutilAp.AddFunc(0x90c2bb19, cellSysutilApOff);
+}

rpcs3/Emu/SysCalls/Modules/cellUsbd.cpp

@@ -0,0 +1,208 @@
+#include "stdafx.h"
+#include "Emu/SysCalls/SysCalls.h"
+#include "Emu/SysCalls/SC_FUNC.h"
+
+void cellUsbd_init();
+Module cellUsbd(0x001c, cellUsbd_init);
+
+// Return Codes
+enum
+{
+	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,
+};
+
+int cellUsbdInit()
+{
+	UNIMPLEMENTED_FUNC(cellUsbd);
+	return CELL_OK;
+}
+
+int cellUsbdEnd()
+{
+	UNIMPLEMENTED_FUNC(cellUsbd);
+	return CELL_OK;
+}
+
+int cellUsbdSetThreadPriority()
+{
+	UNIMPLEMENTED_FUNC(cellUsbd);
+	return CELL_OK;
+}
+
+int cellUsbdSetThreadPriority2()
+{
+	UNIMPLEMENTED_FUNC(cellUsbd);
+	return CELL_OK;
+}
+
+int cellUsbdGetThreadPriority()
+{
+	UNIMPLEMENTED_FUNC(cellUsbd);
+	return CELL_OK;
+}
+
+int cellUsbdRegisterLdd()
+{
+	UNIMPLEMENTED_FUNC(cellUsbd);
+	return CELL_OK;
+}
+
+int cellUsbdRegisterExtraLdd()
+{
+	UNIMPLEMENTED_FUNC(cellUsbd);
+	return CELL_OK;
+}
+
+int cellUsbdRegisterExtraLdd2()
+{
+	UNIMPLEMENTED_FUNC(cellUsbd);
+	return CELL_OK;
+}
+
+int cellUsbdUnregisterLdd()
+{
+	UNIMPLEMENTED_FUNC(cellUsbd);
+	return CELL_OK;
+}
+
+int cellUsbdUnregisterExtraLdd()
+{
+	UNIMPLEMENTED_FUNC(cellUsbd);
+	return CELL_OK;
+}
+
+int cellUsbdOpenPipe()
+{
+	UNIMPLEMENTED_FUNC(cellUsbd);
+	return CELL_OK;
+}
+
+int cellUsbdClosePipe()
+{
+	UNIMPLEMENTED_FUNC(cellUsbd);
+	return CELL_OK;
+}
+
+int cellUsbdControlTransfer()
+{
+	UNIMPLEMENTED_FUNC(cellUsbd);
+	return CELL_OK;
+}
+
+int cellUsbdBulkTransfer()
+{
+	UNIMPLEMENTED_FUNC(cellUsbd);
+	return CELL_OK;
+}
+
+int cellUsbdInterruptTransfer()
+{
+	UNIMPLEMENTED_FUNC(cellUsbd);
+	return CELL_OK;
+}
+
+int cellUsbdIsochronousTransfer()
+{
+	UNIMPLEMENTED_FUNC(cellUsbd);
+	return CELL_OK;
+}
+
+int cellUsbdHSIsochronousTransfer()
+{
+	UNIMPLEMENTED_FUNC(cellUsbd);
+	return CELL_OK;
+}
+
+int cellUsbdScanStaticDescriptor()
+{
+	UNIMPLEMENTED_FUNC(cellUsbd);
+	return CELL_OK;
+}
+
+int cellUsbdGetDeviceSpeed()
+{
+	UNIMPLEMENTED_FUNC(cellUsbd);
+	return CELL_OK;
+}
+
+int cellUsbdGetDeviceLocation()
+{
+	UNIMPLEMENTED_FUNC(cellUsbd);
+	return CELL_OK;
+}
+
+int cellUsbdSetPrivateData()
+{
+	UNIMPLEMENTED_FUNC(cellUsbd);
+	return CELL_OK;
+}
+
+int cellUsbdGetPrivateData()
+{
+	UNIMPLEMENTED_FUNC(cellUsbd);
+	return CELL_OK;
+}
+
+int cellUsbdAllocateMemory()
+{
+	UNIMPLEMENTED_FUNC(cellUsbd);
+	return CELL_OK;
+}
+
+int cellUsbdFreeMemory()
+{
+	UNIMPLEMENTED_FUNC(cellUsbd);
+	return CELL_OK;
+}
+
+void cellUsbd_init()
+{
+	cellUsbd.AddFunc(0xd0e766fe, cellUsbdInit);
+	cellUsbd.AddFunc(0x35f22ac3, cellUsbdEnd);
+
+	cellUsbd.AddFunc(0xc24af1d7, cellUsbdSetThreadPriority);
+	cellUsbd.AddFunc(0x5c832bd7, cellUsbdSetThreadPriority2);
+	cellUsbd.AddFunc(0xd5263dea, cellUsbdGetThreadPriority);
+
+	cellUsbd.AddFunc(0x359befba, cellUsbdRegisterLdd);
+	cellUsbd.AddFunc(0x7fe92c54, cellUsbdRegisterExtraLdd);
+	cellUsbd.AddFunc(0xbd554bcb, cellUsbdRegisterExtraLdd2);
+	cellUsbd.AddFunc(0x64951ac7, cellUsbdUnregisterLdd);
+	cellUsbd.AddFunc(0x90460081, cellUsbdUnregisterExtraLdd);
+
+	cellUsbd.AddFunc(0x254289ac, cellUsbdOpenPipe);
+	cellUsbd.AddFunc(0x9763e962, cellUsbdClosePipe);
+
+	cellUsbd.AddFunc(0x97cf128e, cellUsbdControlTransfer);
+	cellUsbd.AddFunc(0xac77eb78, cellUsbdBulkTransfer);
+	cellUsbd.AddFunc(0x0f411262, cellUsbdInterruptTransfer);
+	cellUsbd.AddFunc(0xde58c4c2, cellUsbdIsochronousTransfer);
+	cellUsbd.AddFunc(0x7a1b6eab, cellUsbdHSIsochronousTransfer);
+
+	cellUsbd.AddFunc(0x2fb08e1e, cellUsbdScanStaticDescriptor);
+	cellUsbd.AddFunc(0xbdbd2428, cellUsbdGetDeviceSpeed);
+	cellUsbd.AddFunc(0xdb819e03, cellUsbdGetDeviceLocation);
+
+	cellUsbd.AddFunc(0x63bfdb97, cellUsbdSetPrivateData);
+	cellUsbd.AddFunc(0x5de3af36, cellUsbdGetPrivateData);
+
+	cellUsbd.AddFunc(0x074dbb39, cellUsbdAllocateMemory);
+	cellUsbd.AddFunc(0x4e456e81, cellUsbdFreeMemory);
+}

rpcs3/Emu/SysCalls/Modules/cellUsbpspcm.cpp

@@ -0,0 +1,216 @@
+#include "stdafx.h"
+#include "Emu/SysCalls/SysCalls.h"
+#include "Emu/SysCalls/SC_FUNC.h"
+
+void cellUsbpspcm_init();
+Module cellUsbpspcm(0x0030, cellUsbpspcm_init);
+
+// Return Codes
+enum
+{
+	CELL_USBPSPCM_ERROR_NOT_INITIALIZED	= 0x80110401,
+	CELL_USBPSPCM_ERROR_ALREADY			= 0x80110402,
+	CELL_USBPSPCM_ERROR_INVALID			= 0x80110403,
+	CELL_USBPSPCM_ERROR_NO_MEMORY		= 0x80110404,
+	CELL_USBPSPCM_ERROR_BUSY			= 0x80110405,
+	CELL_USBPSPCM_ERROR_INPROGRESS		= 0x80110406,
+	CELL_USBPSPCM_ERROR_NO_SPACE		= 0x80110407,
+	CELL_USBPSPCM_ERROR_CANCELED		= 0x80110408,
+	CELL_USBPSPCM_ERROR_RESETTING		= 0x80110409,
+	CELL_USBPSPCM_ERROR_RESET_END		= 0x8011040A,
+	CELL_USBPSPCM_ERROR_CLOSED			= 0x8011040B,
+	CELL_USBPSPCM_ERROR_NO_DATA			= 0x8011040C,
+};
+
+int cellUsbPspcmInit()
+{
+	UNIMPLEMENTED_FUNC(cellUsbpspcm);
+	return CELL_OK;
+}
+
+int cellUsbPspcmEnd()
+{
+	UNIMPLEMENTED_FUNC(cellUsbpspcm);
+	return CELL_OK;
+}
+
+int cellUsbPspcmCalcPoolSize()
+{
+	UNIMPLEMENTED_FUNC(cellUsbpspcm);
+	return CELL_OK;
+}
+
+int cellUsbPspcmRegister()
+{
+	UNIMPLEMENTED_FUNC(cellUsbpspcm);
+	return CELL_OK;
+}
+
+int cellUsbPspcmUnregister()
+{
+	UNIMPLEMENTED_FUNC(cellUsbpspcm);
+	return CELL_OK;
+}
+
+int cellUsbPspcmGetAddr()
+{
+	UNIMPLEMENTED_FUNC(cellUsbpspcm);
+	return CELL_OK;
+}
+
+int cellUsbPspcmBind()
+{
+	UNIMPLEMENTED_FUNC(cellUsbpspcm);
+	return CELL_OK;
+}
+
+int cellUsbPspcmBindAsync()
+{
+	UNIMPLEMENTED_FUNC(cellUsbpspcm);
+	return CELL_OK;
+}
+
+int cellUsbPspcmWaitBindAsync()
+{
+	UNIMPLEMENTED_FUNC(cellUsbpspcm);
+	return CELL_OK;
+}
+
+int cellUsbPspcmPollBindAsync()
+{
+	UNIMPLEMENTED_FUNC(cellUsbpspcm);
+	return CELL_OK;
+}
+
+int cellUsbPspcmCancelBind()
+{
+	UNIMPLEMENTED_FUNC(cellUsbpspcm);
+	return CELL_OK;
+}
+
+int cellUsbPspcmClose()
+{
+	UNIMPLEMENTED_FUNC(cellUsbpspcm);
+	return CELL_OK;
+}
+
+int cellUsbPspcmSend()
+{
+	UNIMPLEMENTED_FUNC(cellUsbpspcm);
+	return CELL_OK;
+}
+
+int cellUsbPspcmSendAsync()
+{
+	UNIMPLEMENTED_FUNC(cellUsbpspcm);
+	return CELL_OK;
+}
+
+int cellUsbPspcmWaitSendAsync()
+{
+	UNIMPLEMENTED_FUNC(cellUsbpspcm);
+	return CELL_OK;
+}
+
+int cellUsbPspcmPollSendAsync()
+{
+	UNIMPLEMENTED_FUNC(cellUsbpspcm);
+	return CELL_OK;
+}
+
+int cellUsbPspcmRecv()
+{
+	UNIMPLEMENTED_FUNC(cellUsbpspcm);
+	return CELL_OK;
+}
+
+int cellUsbPspcmRecvAsync()
+{
+	UNIMPLEMENTED_FUNC(cellUsbpspcm);
+	return CELL_OK;
+}
+
+int cellUsbPspcmWaitRecvAsync()
+{
+	UNIMPLEMENTED_FUNC(cellUsbpspcm);
+	return CELL_OK;
+}
+
+int cellUsbPspcmPollRecvAsync()
+{
+	UNIMPLEMENTED_FUNC(cellUsbpspcm);
+	return CELL_OK;
+}
+
+int cellUsbPspcmReset()
+{
+	UNIMPLEMENTED_FUNC(cellUsbpspcm);
+	return CELL_OK;
+}
+
+int cellUsbPspcmResetAsync()
+{
+	UNIMPLEMENTED_FUNC(cellUsbpspcm);
+	return CELL_OK;
+}
+
+int cellUsbPspcmWaitResetAsync()
+{
+	UNIMPLEMENTED_FUNC(cellUsbpspcm);
+	return CELL_OK;
+}
+
+int cellUsbPspcmPollResetAsync()
+{
+	UNIMPLEMENTED_FUNC(cellUsbpspcm);
+	return CELL_OK;
+}
+
+int cellUsbPspcmWaitData()
+{
+	UNIMPLEMENTED_FUNC(cellUsbpspcm);
+	return CELL_OK;
+}
+
+int cellUsbPspcmPollData()
+{
+	UNIMPLEMENTED_FUNC(cellUsbpspcm);
+	return CELL_OK;
+}
+
+int cellUsbPspcmCancelWaitData()
+{
+	UNIMPLEMENTED_FUNC(cellUsbpspcm);
+	return CELL_OK;
+}
+
+void cellUsbpspcm_init()
+{
+	cellUsbpspcm.AddFunc(0x657fcd36, cellUsbPspcmInit);
+	cellUsbpspcm.AddFunc(0x0f7b3b6d, cellUsbPspcmEnd);
+	cellUsbpspcm.AddFunc(0xf20df7fc, cellUsbPspcmCalcPoolSize);
+	cellUsbpspcm.AddFunc(0xe3fbf64d, cellUsbPspcmRegister);
+	cellUsbpspcm.AddFunc(0x7ff72b42, cellUsbPspcmUnregister);
+	cellUsbpspcm.AddFunc(0x97670a90, cellUsbPspcmGetAddr);
+	cellUsbpspcm.AddFunc(0xabe090e3, cellUsbPspcmBind);
+	cellUsbpspcm.AddFunc(0x17f42197, cellUsbPspcmBindAsync);
+	cellUsbpspcm.AddFunc(0x4abe830e, cellUsbPspcmWaitBindAsync);
+	cellUsbpspcm.AddFunc(0x01a4cde0, cellUsbPspcmPollBindAsync);
+	cellUsbpspcm.AddFunc(0xa4a5ddb4, cellUsbPspcmCancelBind);
+	cellUsbpspcm.AddFunc(0xfa07d320, cellUsbPspcmClose);
+	cellUsbpspcm.AddFunc(0x7277d7c3, cellUsbPspcmSend);
+	cellUsbpspcm.AddFunc(0x4af23efa, cellUsbPspcmSendAsync);
+	cellUsbpspcm.AddFunc(0x3caddf6c, cellUsbPspcmWaitSendAsync);
+	cellUsbpspcm.AddFunc(0x7f0a3eaf, cellUsbPspcmPollSendAsync);
+	cellUsbpspcm.AddFunc(0xf9883d3b, cellUsbPspcmRecv);
+	cellUsbpspcm.AddFunc(0x02955295, cellUsbPspcmRecvAsync);
+	cellUsbpspcm.AddFunc(0x461dc8cc, cellUsbPspcmWaitRecvAsync);
+	cellUsbpspcm.AddFunc(0x7b249315, cellUsbPspcmPollRecvAsync);
+	cellUsbpspcm.AddFunc(0xe68a65ac, cellUsbPspcmReset);
+	cellUsbpspcm.AddFunc(0x4ef182dd, cellUsbPspcmResetAsync);
+	cellUsbpspcm.AddFunc(0xe840f449, cellUsbPspcmWaitResetAsync);
+	cellUsbpspcm.AddFunc(0x3f22403e, cellUsbPspcmPollResetAsync);
+	cellUsbpspcm.AddFunc(0xdb864d11, cellUsbPspcmWaitData);
+	cellUsbpspcm.AddFunc(0x816799dd, cellUsbPspcmPollData);
+	cellUsbpspcm.AddFunc(0xe76e79ab, cellUsbPspcmCancelWaitData);
+}

rpcs3/Emu/SysCalls/Modules/cellVdec.cpp

@@ -0,0 +1,97 @@
+#include "stdafx.h"
+#include "Emu/SysCalls/SysCalls.h"
+#include "Emu/SysCalls/SC_FUNC.h"
+
+void cellVdec_init();
+Module cellVdec(0x0005, cellVdec_init);
+
+// Error Codes
+enum
+{
+	CELL_VDEC_ERROR_ARG		= 0x80610101,
+	CELL_VDEC_ERROR_SEQ		= 0x80610102,
+	CELL_VDEC_ERROR_BUSY	= 0x80610103,
+	CELL_VDEC_ERROR_EMPTY	= 0x80610104,
+	CELL_VDEC_ERROR_FATAL	= 0x80610180,
+};
+
+int cellVdecQueryAttr()
+{
+	UNIMPLEMENTED_FUNC(cellVdec);
+	return CELL_OK;
+}
+
+int cellVdecQueryAttrEx()
+{
+	UNIMPLEMENTED_FUNC(cellVdec);
+	return CELL_OK;
+}
+
+int cellVdecOpen()
+{
+	UNIMPLEMENTED_FUNC(cellVdec);
+	return CELL_OK;
+}
+
+int cellVdecOpenEx()
+{
+	UNIMPLEMENTED_FUNC(cellVdec);
+	return CELL_OK;
+}
+
+int cellVdecClose()
+{
+	UNIMPLEMENTED_FUNC(cellVdec);
+	return CELL_OK;
+}
+
+int cellVdecStartSeq()
+{
+	UNIMPLEMENTED_FUNC(cellVdec);
+	return CELL_OK;
+}
+
+int cellVdecEndSeq()
+{
+	UNIMPLEMENTED_FUNC(cellVdec);
+	return CELL_OK;
+}
+
+int cellVdecDecodeAu()
+{
+	UNIMPLEMENTED_FUNC(cellVdec);
+	return CELL_OK;
+}
+
+int cellVdecGetPicture()
+{
+	UNIMPLEMENTED_FUNC(cellVdec);
+	return CELL_OK;
+}
+
+int cellVdecGetPicItem()
+{
+	UNIMPLEMENTED_FUNC(cellVdec);
+	return CELL_OK;
+}
+
+int cellVdecSetFrameRate()
+{
+	UNIMPLEMENTED_FUNC(cellVdec);
+	return CELL_OK;
+}
+
+void cellVdec_init()
+{
+	cellVdec.AddFunc(0xff6f6ebe, cellVdecQueryAttr);
+	cellVdec.AddFunc(0xc982a84a, cellVdecQueryAttrEx);
+	cellVdec.AddFunc(0xb6bbcd5d, cellVdecOpen);
+	cellVdec.AddFunc(0x0053e2d8, cellVdecOpenEx);
+	cellVdec.AddFunc(0x16698e83, cellVdecClose);
+	cellVdec.AddFunc(0xc757c2aa, cellVdecStartSeq);
+	cellVdec.AddFunc(0x824433f0, cellVdecEndSeq);
+	cellVdec.AddFunc(0x2bf4ddd2, cellVdecDecodeAu);
+	cellVdec.AddFunc(0x807c861a, cellVdecGetPicture);
+	cellVdec.AddFunc(0x17c702b9, cellVdecGetPicItem);
+	cellVdec.AddFunc(0xe13ef6fc, cellVdecSetFrameRate);
+}

rpcs3/Emu/SysCalls/Modules/cellVoice.cpp

@@ -0,0 +1,271 @@
+#include "stdafx.h"
+#include "Emu/SysCalls/SysCalls.h"
+#include "Emu/SysCalls/SC_FUNC.h"
+
+void cellVoice_init();
+Module cellVoice(0x0046, cellVoice_init);
+
+// Error Codes
+enum
+{
+	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,
+};
+
+int cellVoiceConnectIPortToOPort()
+{
+	UNIMPLEMENTED_FUNC(cellVoice);
+	return CELL_OK;
+}
+
+int cellVoiceCreateNotifyEventQueue()
+{
+	UNIMPLEMENTED_FUNC(cellVoice);
+	return CELL_OK;
+}
+
+int cellVoiceCreatePort()
+{
+	UNIMPLEMENTED_FUNC(cellVoice);
+	return CELL_OK;
+}
+
+int cellVoiceDeletePort()
+{
+	UNIMPLEMENTED_FUNC(cellVoice);
+	return CELL_OK;
+}
+
+int cellVoiceDisconnectIPortFromOPort()
+{
+	UNIMPLEMENTED_FUNC(cellVoice);
+	return CELL_OK;
+}
+
+int cellVoiceEnd()
+{
+	UNIMPLEMENTED_FUNC(cellVoice);
+	return CELL_OK;
+}
+
+int cellVoiceGetBitRate()
+{
+	UNIMPLEMENTED_FUNC(cellVoice);
+	return CELL_OK;
+}
+
+int cellVoiceGetMuteFlag()
+{
+	UNIMPLEMENTED_FUNC(cellVoice);
+	return CELL_OK;
+}
+
+int cellVoiceGetPortAttr()
+{
+	UNIMPLEMENTED_FUNC(cellVoice);
+	return CELL_OK;
+}
+
+int cellVoiceGetPortInfo()
+{
+	UNIMPLEMENTED_FUNC(cellVoice);
+	return CELL_OK;
+}
+
+int cellVoiceGetSignalState()
+{
+	UNIMPLEMENTED_FUNC(cellVoice);
+	return CELL_OK;
+}
+
+int cellVoiceGetVolume()
+{
+	UNIMPLEMENTED_FUNC(cellVoice);
+	return CELL_OK;
+}
+
+int cellVoiceInit()
+{
+	UNIMPLEMENTED_FUNC(cellVoice);
+	return CELL_OK;
+}
+
+int cellVoiceInitEx()
+{
+	UNIMPLEMENTED_FUNC(cellVoice);
+	return CELL_OK;
+}
+
+int cellVoicePausePort()
+{
+	UNIMPLEMENTED_FUNC(cellVoice);
+	return CELL_OK;
+}
+
+int cellVoicePausePortAll()
+{
+	UNIMPLEMENTED_FUNC(cellVoice);
+	return CELL_OK;
+}
+
+int cellVoiceRemoveNotifyEventQueue()
+{
+	UNIMPLEMENTED_FUNC(cellVoice);
+	return CELL_OK;
+}
+
+int cellVoiceResetPort()
+{
+	UNIMPLEMENTED_FUNC(cellVoice);
+	return CELL_OK;
+}
+
+int cellVoiceResumePort()
+{
+	UNIMPLEMENTED_FUNC(cellVoice);
+	return CELL_OK;
+}
+
+int cellVoiceResumePortAll()
+{
+	UNIMPLEMENTED_FUNC(cellVoice);
+	return CELL_OK;
+}
+
+int cellVoiceSetBitRate()
+{
+	UNIMPLEMENTED_FUNC(cellVoice);
+	return CELL_OK;
+}
+
+int cellVoiceSetMuteFlag()
+{
+	UNIMPLEMENTED_FUNC(cellVoice);
+	return CELL_OK;
+}
+
+int cellVoiceSetMuteFlagAll()
+{
+	UNIMPLEMENTED_FUNC(cellVoice);
+	return CELL_OK;
+}
+
+int cellVoiceSetNotifyEventQueue()
+{
+	UNIMPLEMENTED_FUNC(cellVoice);
+	return CELL_OK;
+}
+
+int cellVoiceSetPortAttr()
+{
+	UNIMPLEMENTED_FUNC(cellVoice);
+	return CELL_OK;
+}
+
+int cellVoiceSetVolume()
+{
+	UNIMPLEMENTED_FUNC(cellVoice);
+	return CELL_OK;
+}
+
+int cellVoiceStart()
+{
+	UNIMPLEMENTED_FUNC(cellVoice);
+	return CELL_OK;
+}
+
+int cellVoiceStartEx()
+{
+	UNIMPLEMENTED_FUNC(cellVoice);
+	return CELL_OK;
+}
+
+int cellVoiceStop()
+{
+	UNIMPLEMENTED_FUNC(cellVoice);
+	return CELL_OK;
+}
+
+int cellVoiceUpdatePort()
+{
+	UNIMPLEMENTED_FUNC(cellVoice);
+	return CELL_OK;
+}
+
+int cellVoiceWriteToIPort()
+{
+	UNIMPLEMENTED_FUNC(cellVoice);
+	return CELL_OK;
+}
+
+int cellVoiceWriteToIPortEx()
+{
+	UNIMPLEMENTED_FUNC(cellVoice);
+	return CELL_OK;
+}
+
+int cellVoiceReadFromOPort()
+{
+	UNIMPLEMENTED_FUNC(cellVoice);
+	return CELL_OK;
+}
+
+int cellVoiceDebugTopology()
+{
+	UNIMPLEMENTED_FUNC(cellVoice);
+	return CELL_OK;
+}
+
+void cellVoice_init()
+{
+	cellVoice.AddFunc(0xae6a21d5, cellVoiceConnectIPortToOPort);
+	cellVoice.AddFunc(0x2a01013e, cellVoiceCreateNotifyEventQueue);
+	cellVoice.AddFunc(0x2de54871, cellVoiceCreatePort);
+	cellVoice.AddFunc(0x9f70c475, cellVoiceDeletePort);
+	cellVoice.AddFunc(0x18d3df30, cellVoiceDisconnectIPortFromOPort);
+	cellVoice.AddFunc(0xe0e1ae12, cellVoiceEnd);
+	cellVoice.AddFunc(0xbef53a2b, cellVoiceGetBitRate);
+	cellVoice.AddFunc(0x474609e2, cellVoiceGetMuteFlag);
+	cellVoice.AddFunc(0xf629ed67, cellVoiceGetPortAttr);
+	cellVoice.AddFunc(0x54ac3519, cellVoiceGetPortInfo);
+	cellVoice.AddFunc(0xd6811aa7, cellVoiceGetSignalState);
+	cellVoice.AddFunc(0x762dc193, cellVoiceGetVolume);
+	cellVoice.AddFunc(0xc7cf1182, cellVoiceInit);
+	cellVoice.AddFunc(0xb1a2c38f, cellVoiceInitEx);
+	cellVoice.AddFunc(0x87c71b06, cellVoicePausePort);
+	cellVoice.AddFunc(0xd14e784d, cellVoicePausePortAll);
+	cellVoice.AddFunc(0xdd000886, cellVoiceRemoveNotifyEventQueue);
+	cellVoice.AddFunc(0xff0fa43a, cellVoiceResetPort);
+	cellVoice.AddFunc(0x7bf17b15, cellVoiceResumePort);
+	cellVoice.AddFunc(0x7f3963f7, cellVoiceResumePortAll);
+	cellVoice.AddFunc(0x7e60adc6, cellVoiceSetBitRate);
+	cellVoice.AddFunc(0xdde35a0c, cellVoiceSetMuteFlag);
+	cellVoice.AddFunc(0xd4d80ea5, cellVoiceSetMuteFlagAll);
+	cellVoice.AddFunc(0x35d84910, cellVoiceSetNotifyEventQueue);
+	cellVoice.AddFunc(0x9d0f4af1, cellVoiceSetPortAttr);
+	cellVoice.AddFunc(0xd5ae37d8, cellVoiceSetVolume);
+	cellVoice.AddFunc(0x0a563878, cellVoiceStart);
+	cellVoice.AddFunc(0x94d51f92, cellVoiceStartEx);
+	cellVoice.AddFunc(0xd3a84be1, cellVoiceStop);
+	cellVoice.AddFunc(0x2f24fea3, cellVoiceUpdatePort);
+	cellVoice.AddFunc(0x3dad26e7, cellVoiceWriteToIPort);
+	cellVoice.AddFunc(0x30f0b5ab, cellVoiceWriteToIPortEx);
+	cellVoice.AddFunc(0x36472c57, cellVoiceReadFromOPort);
+	cellVoice.AddFunc(0x20bafe31, cellVoiceDebugTopology);
+}

rpcs3/Emu/SysCalls/Modules/cellVpost.cpp

@@ -0,0 +1,182 @@
+#include "stdafx.h"
+#include "Emu/SysCalls/SysCalls.h"
+#include "Emu/SysCalls/SC_FUNC.h"
+
+void cellVpost_init();
+Module cellVpost(0x0008, cellVpost_init);
+
+// Error Codes
+enum
+{
+	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,
+};
+
+int cellVpostQueryAttr()
+{
+	UNIMPLEMENTED_FUNC(cellVpost);
+	return CELL_OK;
+}
+
+int cellVpostOpen()
+{
+	UNIMPLEMENTED_FUNC(cellVpost);
+	return CELL_OK;
+}
+
+int cellVpostOpenEx()
+{
+	UNIMPLEMENTED_FUNC(cellVpost);
+	return CELL_OK;
+}
+
+int cellVpostClose()
+{
+	UNIMPLEMENTED_FUNC(cellVpost);
+	return CELL_OK;
+}
+
+int cellVpostExec()
+{
+	UNIMPLEMENTED_FUNC(cellVpost);
+	return CELL_OK;
+}
+
+void cellVpost_init()
+{
+	cellVpost.AddFunc(0x95e788c3, cellVpostQueryAttr);
+	cellVpost.AddFunc(0xcd33f3e2, cellVpostOpen);
+	cellVpost.AddFunc(0x40524325, cellVpostOpenEx);
+	cellVpost.AddFunc(0x10ef39f6, cellVpostClose);
+	cellVpost.AddFunc(0xabb8cc3d, cellVpostExec);
+}

rpcs3/rpcs3.vcxproj

@@ -250,18 +250,14 @@
     <ClCompile Include="Emu\SysCalls\Modules.cpp" />
     <ClCompile Include="Emu\SysCalls\Modules\cellGcmSys.cpp" />
     <ClCompile Include="Emu\SysCalls\Modules\cellGifDec.cpp" />
-    <ClCompile Include="Emu\SysCalls\Modules\cellHttpUtil.cpp" />
     <ClCompile Include="Emu\SysCalls\Modules\cellJpgDec.cpp" />
     <ClCompile Include="Emu\SysCalls\Modules\cellPngDec.cpp" />
     <ClCompile Include="Emu\SysCalls\Modules\cellResc.cpp" />
-    <ClCompile Include="Emu\SysCalls\Modules\cellSsl.cpp" />
     <ClCompile Include="Emu\SysCalls\Modules\cellSysmodule.cpp" />
     <ClCompile Include="Emu\SysCalls\Modules\cellSysutil.cpp" />
     <ClCompile Include="Emu\SysCalls\Modules\sysPrxForUser.cpp" />
     <ClCompile Include="Emu\SysCalls\Modules\sys_fs.cpp" />
-    <ClCompile Include="Emu\SysCalls\Modules\sys_http.cpp" />
     <ClCompile Include="Emu\SysCalls\Modules\sys_io.cpp" />
-    <ClCompile Include="Emu\SysCalls\Modules\sys_net.cpp" />
     <ClCompile Include="Emu\SysCalls\SysCalls.cpp" />
     <ClCompile Include="Emu\System.cpp" />
     <ClCompile Include="Gui\CompilerELF.cpp" />

rpcs3/rpcs3.vcxproj.filters

@@ -307,18 +307,6 @@
     <ClCompile Include="Emu\SysCalls\lv2\SC_Mouse.cpp">
       <Filter>Emu\SysCalls\lv2</Filter>
     </ClCompile>
-    <ClCompile Include="Emu\SysCalls\Modules\cellHttpUtil.cpp">
-      <Filter>Emu\SysCalls\Modules</Filter>
-    </ClCompile>
-    <ClCompile Include="Emu\SysCalls\Modules\cellSsl.cpp">
-      <Filter>Emu\SysCalls\Modules</Filter>
-    </ClCompile>
-    <ClCompile Include="Emu\SysCalls\Modules\sys_http.cpp">
-      <Filter>Emu\SysCalls\Modules</Filter>
-    </ClCompile>
-    <ClCompile Include="Emu\SysCalls\Modules\sys_net.cpp">
-      <Filter>Emu\SysCalls\Modules</Filter>
-    </ClCompile>
   </ItemGroup>
   <ItemGroup>
     <ResourceCompile Include="rpcs3.rc" />