Merge branch 'master' of https://github.com/DHrpcs3/rpcs3

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/cellGifDec.cpp

@@ -74,12 +74,10 @@ struct CellGifDecSubHandle //Custom struct
 {
 	u32 fd;
 	u64 fileSize;
-	CellGifDecInParam inParam;
+	CellGifDecInfo info;
+	CellGifDecOutParam outParam;
 };
 
-CellGifDecInfo	current_info;
-CellGifDecSrc	current_src;
-
 
 int cellGifDecCreate(u32 mainHandle, u32 threadInParam, u32 threadOutParam)
 {
@@ -93,47 +91,50 @@ int cellGifDecExtCreate(u32 mainHandle, u32 threadInParam, u32 threadOutParam, u
 	return CELL_OK;
 }
 
-int cellGifDecOpen(u32 mainHandle, u32 subHandle_addr, u32 src_addr, u32 openInfo)
+int cellGifDecOpen(u32 mainHandle, mem32_t subHandle, u32 src_addr, u32 openInfo)
 {
-	//current_src.srcSelect       = Memory.Read32(src_addr);
-	current_src.fileName		  = Memory.Read32(src_addr+4);
-	//current_src.fileOffset      = Memory.Read32(src_addr+8);
-	//current_src.fileSize        = Memory.Read32(src_addr+12);
-	//current_src.streamPtr       = Memory.Read32(src_addr+16);
-	//current_src.streamSize      = Memory.Read32(src_addr+20);
-	//current_src.spuThreadEnable = Memory.Read32(src_addr+24);
+	//u32 srcSelect       = Memory.Read32(src_addr);
+	u32 fileName		  = Memory.Read32(src_addr+4);
+	//u64 fileOffset      = Memory.Read32(src_addr+8);
+	//u32 fileSize        = Memory.Read32(src_addr+12);
+	//u32 streamPtr       = Memory.Read32(src_addr+16);
+	//u32 streamSize      = Memory.Read32(src_addr+20);
+	//u32 spuThreadEnable = Memory.Read32(src_addr+24);
 
-	CellGifDecSubHandle *subHandle = new CellGifDecSubHandle;
+	CellGifDecSubHandle *current_subHandle = new CellGifDecSubHandle;
 
 	// Get file descriptor
 	u32 fd_addr = Memory.Alloc(sizeof(u32), 1);
-	int ret = cellFsOpen(current_src.fileName, 0, fd_addr, NULL, 0);
-	subHandle->fd = Memory.Read32(fd_addr);
+	int ret = cellFsOpen(fileName, 0, fd_addr, NULL, 0);
+	current_subHandle->fd = Memory.Read32(fd_addr);
 	Memory.Free(fd_addr);
 	if(ret != 0) return CELL_GIFDEC_ERROR_OPEN_FILE;
 
 	// Get size of file
 	u32 sb_addr = Memory.Alloc(52,1);					// Alloc a CellFsStat struct
-	cellFsFstat(subHandle->fd, sb_addr);
-	subHandle->fileSize = Memory.Read64(sb_addr+36);	// Get CellFsStat.st_size
+	cellFsFstat(current_subHandle->fd, sb_addr);
+	current_subHandle->fileSize = Memory.Read64(sb_addr+36);	// Get CellFsStat.st_size
 	Memory.Free(sb_addr);
 
 	// From now, every u32 subHandle argument is a pointer to a CellPngDecSubHandle struct.
-	Memory.Write32(subHandle_addr, (u32)subHandle);
+	subHandle += (u32)current_subHandle;
 
 	return CELL_OK;
 }
 
-int cellGifDecReadHeader(u32 mainHandle, u32 subHandle, u32 info_addr)
+int cellGifDecReadHeader(u32 mainHandle, u32 subHandle, mem_class_t info)
 {
 	const u32& fd = ((CellGifDecSubHandle*)subHandle)->fd;
 	const u64& fileSize = ((CellGifDecSubHandle*)subHandle)->fileSize;
+	CellGifDecInfo& current_info = ((CellGifDecSubHandle*)subHandle)->info;
 	
 	//Write the header to buffer
 	u32 buffer = Memory.Alloc(13,1);					// Alloc buffer for GIF header
+	u32 nread = Memory.Alloc(8,1);
 	u32 pos_addr = Memory.Alloc(8,1);
 	cellFsLseek(fd, 0, 0, pos_addr);
-	cellFsRead(fd, buffer, 13, NULL);
+	cellFsRead(fd, buffer, 13, nread);
+	Memory.Free(nread);
 	Memory.Free(pos_addr);
 
 	if (Memory.Read32(buffer) != 0x47494638 ||
@@ -154,7 +155,6 @@ int cellGifDecReadHeader(u32 mainHandle, u32 subHandle, u32 info_addr)
 	current_info.SBackGroundColor			= Memory.Read8(buffer+11);
 	current_info.SPixelAspectRatio			= Memory.Read8(buffer+12);
 
-	mem_class_t info(info_addr);
 	info += current_info.SWidth;
 	info += current_info.SHeight;
 	info += current_info.SGlobalColorTableFlag;
@@ -168,27 +168,48 @@ int cellGifDecReadHeader(u32 mainHandle, u32 subHandle, u32 info_addr)
 	return CELL_OK;
 }
 
-int cellGifDecSetParameter(u32 mainHandle, u32 subHandle, u32 inParam_addr, u32 outParam_addr)
+int cellGifDecSetParameter(u32 mainHandle, u32 subHandle, u32 inParam_addr, mem_class_t outParam)
 {
-	CellGifDecInParam& inParam = ((CellGifDecSubHandle*)subHandle)->inParam;
-	inParam.colorSpace = Memory.Read32(inParam_addr+4);
+	CellGifDecInfo& current_info = ((CellGifDecSubHandle*)subHandle)->info;
+	CellGifDecOutParam& current_outParam = ((CellGifDecSubHandle*)subHandle)->outParam;
+	
+	current_outParam.outputWidthByte	= (current_info.SWidth * current_info.SColorResolution * 3)/8;
+	current_outParam.outputWidth		= current_info.SWidth;
+	current_outParam.outputHeight		= current_info.SHeight;
+	current_outParam.outputColorSpace	= Memory.Read32(inParam_addr+4);
+	switch (current_outParam.outputColorSpace)
+	{
+	case CELL_GIFDEC_RGBA:	current_outParam.outputComponents = 4; break;
+	case CELL_GIFDEC_ARGB:	current_outParam.outputComponents = 4; break;
+	default: return CELL_GIFDEC_ERROR_ARG;		// Not supported color space
+	}
+	current_outParam.outputBitDepth		= 0;	// Unimplemented
+	current_outParam.useMemorySpace		= 0;	// Unimplemented
 
-	// (TODO)
+	outParam += current_outParam.outputWidthByte;
+	outParam += current_outParam.outputWidth;
+	outParam += current_outParam.outputHeight;
+	outParam += current_outParam.outputComponents;
+	outParam += current_outParam.outputBitDepth;
+	outParam += current_outParam.outputColorSpace;
+	outParam += current_outParam.useMemorySpace;
 
 	return CELL_OK;
 }
 
-int cellGifDecDecodeData(u32 mainHandle, u32 subHandle, u32 data_addr, u32 dataCtrlParam_addr, u32 dataOutInfo_addr)
+int cellGifDecDecodeData(u32 mainHandle, u32 subHandle, mem8_ptr_t data, u32 dataCtrlParam_addr, mem_class_t dataOutInfo)
 {
 	const u32& fd = ((CellGifDecSubHandle*)subHandle)->fd;
 	const u64& fileSize = ((CellGifDecSubHandle*)subHandle)->fileSize;
-	const CellGifDecInParam& inParam = ((CellGifDecSubHandle*)subHandle)->inParam; // (TODO: We should use the outParam)
+	const CellGifDecOutParam& current_outParam = ((CellGifDecSubHandle*)subHandle)->outParam; // (TODO: We should use the outParam)
 
 	//Copy the GIF file to a buffer
 	u32 buffer = Memory.Alloc(fileSize,1);
+	u32 nread = Memory.Alloc(8,1);
 	u32 pos_addr = Memory.Alloc(8,1);
 	cellFsLseek(fd, 0, 0, pos_addr);
-	cellFsRead(fd, buffer, fileSize, NULL);
+	cellFsRead(fd, buffer, fileSize, nread);
+	Memory.Free(nread);
 	Memory.Free(pos_addr);
 
 	//Decode GIF file. (TODO: Is there any faster alternative? Can we do it without external libraries?)
@@ -199,29 +220,27 @@ int cellGifDecDecodeData(u32 mainHandle, u32 subHandle, u32 data_addr, u32 dataC
 	if (!image)	return CELL_GIFDEC_ERROR_STREAM_FORMAT;
 
 	u32 image_size = width * height * 4;
-	if (inParam.colorSpace == CELL_GIFDEC_RGBA){
+	if (current_outParam.outputColorSpace == CELL_GIFDEC_RGBA){
 		for(u32 i = 0; i < image_size; i+=4){
-			Memory.Write8(data_addr+i+0, image[i+0]);
-			Memory.Write8(data_addr+i+1, image[i+1]);
-			Memory.Write8(data_addr+i+2, image[i+2]);
-			Memory.Write8(data_addr+i+3, image[i+3]);
+			data += image[i+0];
+			data += image[i+1];
+			data += image[i+2];
+			data += image[i+3];
 		}
 	}
-	if (inParam.colorSpace == CELL_GIFDEC_ARGB){
+	if (current_outParam.outputColorSpace == CELL_GIFDEC_ARGB){
 		for(u32 i = 0; i < image_size; i+=4){
-			Memory.Write8(data_addr+i+0, image[i+3]);
-			Memory.Write8(data_addr+i+1, image[i+0]);
-			Memory.Write8(data_addr+i+2, image[i+1]);
-			Memory.Write8(data_addr+i+3, image[i+2]);
+			data += image[i+3];
+			data += image[i+0];
+			data += image[i+1];
+			data += image[i+2];
 		}
 	}
 	delete[] image;
 
-	//The output data is an image (dataOutInfo.recordType = 1)
-	Memory.Write32(dataOutInfo_addr, 1);
-
-	u32 outExtensionData_addr = Memory.Alloc(20,1); // (TODO: Is this the best way to avoid exceptions when trying to access this data? Will this produce a memory leak?)
-	Memory.Write32(dataOutInfo_addr+8, outExtensionData_addr);
+	dataOutInfo += (u32)1;				// The output data is an image (dataOutInfo.recordType = 1)
+	dataOutInfo += (u32)0;				// outExtension.label = 0
+	dataOutInfo += Memory.Alloc(20,1);	// outExtension.data allocated (TODO: Is this the best way to avoid exceptions when trying to access this data? Will this produce a memory leak?)
 
 	return CELL_OK;
 }

rpcs3/Emu/SysCalls/Modules/cellHttpUtil.cpp

@@ -0,0 +1,153 @@
+#include "stdafx.h"
+#include "Emu/SysCalls/SysCalls.h"
+#include "Emu/SysCalls/SC_FUNC.h"
+
+void cellHttpUtil_init();
+Module cellHttpUtil(0x0002, cellHttpUtil_init);
+
+int cellHttpUtilParseUri()
+{
+	UNIMPLEMENTED_FUNC(cellHttpUtil);
+	return CELL_OK;
+}
+
+int cellHttpUtilParseUriPath()
+{
+	UNIMPLEMENTED_FUNC(cellHttpUtil);
+	return CELL_OK;
+}
+
+int cellHttpUtilParseProxy()
+{
+	UNIMPLEMENTED_FUNC(cellHttpUtil);
+	return CELL_OK;
+}
+
+int cellHttpUtilParseStatusLine()
+{
+	UNIMPLEMENTED_FUNC(cellHttpUtil);
+	return CELL_OK;
+}
+
+int cellHttpUtilParseHeader()
+{
+	UNIMPLEMENTED_FUNC(cellHttpUtil);
+	return CELL_OK;
+}
+
+int cellHttpUtilBuildRequestLine()
+{
+	UNIMPLEMENTED_FUNC(cellHttpUtil);
+	return CELL_OK;
+}
+
+int cellHttpUtilBuildHeader()
+{
+	UNIMPLEMENTED_FUNC(cellHttpUtil);
+	return CELL_OK;
+}
+
+int cellHttpUtilBuildUri()
+{
+	UNIMPLEMENTED_FUNC(cellHttpUtil);
+	return CELL_OK;
+}
+
+int cellHttpUtilCopyUri()
+{
+	UNIMPLEMENTED_FUNC(cellHttpUtil);
+	return CELL_OK;
+}
+
+int cellHttpUtilMergeUriPath()
+{
+	UNIMPLEMENTED_FUNC(cellHttpUtil);
+	return CELL_OK;
+}
+
+int cellHttpUtilSweepPath()
+{
+	UNIMPLEMENTED_FUNC(cellHttpUtil);
+	return CELL_OK;
+}
+
+int cellHttpUtilCopyStatusLine()
+{
+	UNIMPLEMENTED_FUNC(cellHttpUtil);
+	return CELL_OK;
+}
+
+int cellHttpUtilCopyHeader()
+{
+	UNIMPLEMENTED_FUNC(cellHttpUtil);
+	return CELL_OK;
+}
+
+int cellHttpUtilAppendHeaderValue()
+{
+	UNIMPLEMENTED_FUNC(cellHttpUtil);
+	return CELL_OK;
+}
+
+int cellHttpUtilEscapeUri()
+{
+	UNIMPLEMENTED_FUNC(cellHttpUtil);
+	return CELL_OK;
+}
+
+int cellHttpUtilUnescapeUri()
+{
+	UNIMPLEMENTED_FUNC(cellHttpUtil);
+	return CELL_OK;
+}
+
+int cellHttpUtilFormUrlEncode()
+{
+	UNIMPLEMENTED_FUNC(cellHttpUtil);
+	return CELL_OK;
+}
+
+int cellHttpUtilFormUrlDecode()
+{
+	UNIMPLEMENTED_FUNC(cellHttpUtil);
+	return CELL_OK;
+}
+
+int cellHttpUtilBase64Encoder()
+{
+	UNIMPLEMENTED_FUNC(cellHttpUtil);
+	return CELL_OK;
+}
+
+int cellHttpUtilBase64Decoder()
+{
+	UNIMPLEMENTED_FUNC(cellHttpUtil);
+	return CELL_OK;
+}
+
+void cellHttpUtil_init()
+{
+	cellHttpUtil.AddFunc(0x32faaf58, cellHttpUtilParseUri);
+	cellHttpUtil.AddFunc(0x8bb608e4, cellHttpUtilParseUriPath);
+	cellHttpUtil.AddFunc(0xa3457869, cellHttpUtilParseProxy);
+	cellHttpUtil.AddFunc(0x2bcbced4, cellHttpUtilParseStatusLine);
+	cellHttpUtil.AddFunc(0xe1fb0ebd, cellHttpUtilParseHeader);
+
+	cellHttpUtil.AddFunc(0x1c6e4dbb, cellHttpUtilBuildRequestLine);
+	cellHttpUtil.AddFunc(0x04accebf, cellHttpUtilBuildHeader);
+	cellHttpUtil.AddFunc(0x6f0f7667, cellHttpUtilBuildUri);
+
+	cellHttpUtil.AddFunc(0xf05df789, cellHttpUtilCopyUri);
+	cellHttpUtil.AddFunc(0x8ea23deb, cellHttpUtilMergeUriPath);
+	cellHttpUtil.AddFunc(0xaabeb869, cellHttpUtilSweepPath);
+	cellHttpUtil.AddFunc(0x50ea75bc, cellHttpUtilCopyStatusLine);
+	cellHttpUtil.AddFunc(0x97f9fbe5, cellHttpUtilCopyHeader);
+	cellHttpUtil.AddFunc(0x37bb53a2, cellHttpUtilAppendHeaderValue);
+
+	cellHttpUtil.AddFunc(0x9003b1f2, cellHttpUtilEscapeUri);
+	cellHttpUtil.AddFunc(0x2763fd66, cellHttpUtilUnescapeUri);
+	cellHttpUtil.AddFunc(0x44d756d6, cellHttpUtilFormUrlEncode);
+	cellHttpUtil.AddFunc(0x8e6c5bb9, cellHttpUtilFormUrlDecode);
+	cellHttpUtil.AddFunc(0x83faa354, cellHttpUtilBase64Encoder);
+	cellHttpUtil.AddFunc(0x8e52ee08, cellHttpUtilBase64Decoder);
+}

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/cellJpgDec.cpp

@@ -80,12 +80,10 @@ struct CellJpgDecSubHandle	//Custom struct
 {
 	u32 fd;
 	u64 fileSize;
-	CellJpgDecInParam inParam;
+	CellJpgDecInfo info;
+	CellJpgDecOutParam outParam;
 };
 
-CellJpgDecInfo	current_info;
-CellJpgDecSrc	current_src;
-
 
 int cellJpgDecCreate(u32 mainHandle, u32 threadInParam, u32 threadOutParam)
 {
@@ -105,33 +103,33 @@ int cellJpgDecDestroy(u32 mainHandle)
 	return CELL_OK;
 }
 
-int cellJpgDecOpen(u32 mainHandle, u32 subHandle_addr, u32 src_addr, u32 openInfo)
+int cellJpgDecOpen(u32 mainHandle, mem32_t subHandle, u32 src_addr, u32 openInfo)
 {
-	//current_src.srcSelect       = Memory.Read32(src_addr);
-	current_src.fileName		  = Memory.Read32(src_addr+4);
-	//current_src.fileOffset      = Memory.Read32(src_addr+8);
-	//current_src.fileSize        = Memory.Read32(src_addr+12);
-	//current_src.streamPtr       = Memory.Read32(src_addr+16);
-	//current_src.streamSize      = Memory.Read32(src_addr+20);
-	//current_src.spuThreadEnable = Memory.Read32(src_addr+24);
+	//u32 srcSelect       = Memory.Read32(src_addr);
+	u32 fileName		  = Memory.Read32(src_addr+4);
+	//u64 fileOffset      = Memory.Read32(src_addr+8);
+	//u32 fileSize        = Memory.Read32(src_addr+12);
+	//u32 streamPtr       = Memory.Read32(src_addr+16);
+	//u32 streamSize      = Memory.Read32(src_addr+20);
+	//u32 spuThreadEnable = Memory.Read32(src_addr+24);
 
-	CellJpgDecSubHandle *subHandle = new CellJpgDecSubHandle;
+	CellJpgDecSubHandle *current_subHandle = new CellJpgDecSubHandle;
 
 	// Get file descriptor
 	u32 fd_addr = Memory.Alloc(sizeof(u32), 1);
-	int ret = cellFsOpen(current_src.fileName, 0, fd_addr, NULL, 0);
-	subHandle->fd = Memory.Read32(fd_addr);
+	int ret = cellFsOpen(fileName, 0, fd_addr, NULL, 0);
+	current_subHandle->fd = Memory.Read32(fd_addr);
 	Memory.Free(fd_addr);
 	if(ret != 0) return CELL_JPGDEC_ERROR_OPEN_FILE;
 
 	// Get size of file
 	u32 sb_addr = Memory.Alloc(52,1);					// Alloc a CellFsStat struct
-	cellFsFstat(subHandle->fd, sb_addr);
-	subHandle->fileSize = Memory.Read64(sb_addr+36);	// Get CellFsStat.st_size
+	cellFsFstat(current_subHandle->fd, sb_addr);
+	current_subHandle->fileSize = Memory.Read64(sb_addr+36);	// Get CellFsStat.st_size
 	Memory.Free(sb_addr);
 
 	// From now, every u32 subHandle argument is a pointer to a CellPngDecSubHandle struct.
-	Memory.Write32(subHandle_addr, (u32)subHandle);
+	subHandle += (u32)current_subHandle;
 
 	return CELL_OK;
 }
@@ -144,16 +142,19 @@ int cellJpgDecClose(u32 mainHandle, u32 subHandle)
 	return CELL_OK;
 }
 
-int cellJpgDecReadHeader(u32 mainHandle, u32 subHandle, u32 info_addr)
+int cellJpgDecReadHeader(u32 mainHandle, u32 subHandle, mem_class_t info)
 {
 	const u32& fd = ((CellJpgDecSubHandle*)subHandle)->fd;
 	const u64& fileSize = ((CellJpgDecSubHandle*)subHandle)->fileSize;
+	CellJpgDecInfo& current_info = ((CellJpgDecSubHandle*)subHandle)->info;
 
 	//Copy the JPG file to a buffer
 	u32 buffer = Memory.Alloc(fileSize,1);
+	u32 nread = Memory.Alloc(8,1);
 	u32 pos_addr = Memory.Alloc(8,1);
 	cellFsLseek(fd, 0, 0, pos_addr);
-	cellFsRead(fd, buffer, fileSize, NULL);
+	cellFsRead(fd, buffer, fileSize, nread);
+	Memory.Free(nread);
 	Memory.Free(pos_addr);
 
 	if (Memory.Read32(buffer) != 0xFFD8FFE0 ||			// Error: Not a valid SOI header
@@ -185,10 +186,9 @@ int cellJpgDecReadHeader(u32 mainHandle, u32 subHandle, u32 info_addr)
 
 	current_info.imageWidth       = Memory.Read8(buffer+i+7)*256 + Memory.Read8(buffer+i+8);
 	current_info.imageHeight      = Memory.Read8(buffer+i+5)*256 + Memory.Read8(buffer+i+6);
-	current_info.numComponents    = 0;							// Unimplemented
-	current_info.colorSpace       = 3;							// Unimplemented
+	current_info.numComponents    = 3;							// Unimplemented
+	current_info.colorSpace       = CELL_JPG_RGB;				// Unimplemented
 
-	mem_class_t info(info_addr);
 	info += current_info.imageWidth;
 	info += current_info.imageHeight;
 	info += current_info.numComponents;
@@ -198,17 +198,19 @@ int cellJpgDecReadHeader(u32 mainHandle, u32 subHandle, u32 info_addr)
 	return CELL_OK;
 }
 
-int cellJpgDecDecodeData(u32 mainHandle, u32 subHandle, u32 data_addr, u32 dataCtrlParam_addr, u32 dataOutInfo_addr)
+int cellJpgDecDecodeData(u32 mainHandle, u32 subHandle, mem8_ptr_t data, u32 dataCtrlParam_addr, u32 dataOutInfo_addr)
 {
 	const u32& fd = ((CellJpgDecSubHandle*)subHandle)->fd;
 	const u64& fileSize = ((CellJpgDecSubHandle*)subHandle)->fileSize;
-	const CellJpgDecInParam& inParam = ((CellJpgDecSubHandle*)subHandle)->inParam; // (TODO: We should use the outParam)
+	const CellJpgDecOutParam& current_outParam = ((CellJpgDecSubHandle*)subHandle)->outParam; // (TODO: We should use the outParam)
 
 	//Copy the JPG file to a buffer
 	u32 buffer = Memory.Alloc(fileSize,1);
+	u32 nread = Memory.Alloc(8,1);
 	u32 pos_addr = Memory.Alloc(8,1);
 	cellFsLseek(fd, 0, 0, pos_addr);
-	cellFsRead(fd, buffer, fileSize, NULL);
+	cellFsRead(fd, buffer, fileSize, nread);
+	Memory.Free(nread);
 	Memory.Free(pos_addr);
 
 	//Decode JPG file. (TODO: Is there any faster alternative? Can we do it without external libraries?)
@@ -219,20 +221,20 @@ int cellJpgDecDecodeData(u32 mainHandle, u32 subHandle, u32 data_addr, u32 dataC
 	if (!image) return CELL_JPGDEC_ERROR_STREAM_FORMAT;
 
 	u32 image_size = width * height * 4;
-	if (inParam.outputColorSpace == CELL_JPG_RGBA){
+	if (current_outParam.outputColorSpace == CELL_JPG_RGBA){
 		for(u32 i = 0; i < image_size; i+=4){
-			Memory.Write8(data_addr+i+0, image[i+0]);
-			Memory.Write8(data_addr+i+1, image[i+1]);
-			Memory.Write8(data_addr+i+2, image[i+2]);
-			Memory.Write8(data_addr+i+3, image[i+3]);
+			data += image[i+0];
+			data += image[i+1];
+			data += image[i+2];
+			data += image[i+3];
 		}
 	}
-	else if (inParam.outputColorSpace == CELL_JPG_ARGB){
+	else if (current_outParam.outputColorSpace == CELL_JPG_ARGB){
 		for(u32 i = 0; i < image_size; i+=4){
-			Memory.Write8(data_addr+i+0, image[i+3]);
-			Memory.Write8(data_addr+i+1, image[i+0]);
-			Memory.Write8(data_addr+i+2, image[i+1]);
-			Memory.Write8(data_addr+i+3, image[i+2]);
+			data += image[i+3];
+			data += image[i+0];
+			data += image[i+1];
+			data += image[i+2];
 		}
 	}
 	delete[] image;
@@ -240,12 +242,39 @@ int cellJpgDecDecodeData(u32 mainHandle, u32 subHandle, u32 data_addr, u32 dataC
 	return CELL_OK;
 }
 
-int cellJpgDecSetParameter(u32 mainHandle, u32 subHandle, u32 inParam_addr, u32 outParam_addr)
+int cellJpgDecSetParameter(u32 mainHandle, u32 subHandle, u32 inParam_addr, mem_class_t outParam)
 {
-	CellJpgDecInParam& inParam = ((CellJpgDecSubHandle*)subHandle)->inParam;
-	inParam.outputColorSpace = Memory.Read32(inParam_addr+16);
+	CellJpgDecInfo& current_info = ((CellJpgDecSubHandle*)subHandle)->info;
+	CellJpgDecOutParam& current_outParam = ((CellJpgDecSubHandle*)subHandle)->outParam;
 
-	// (TODO)
+	current_outParam.outputWidthByte	= (current_info.imageWidth * current_info.numComponents);
+	current_outParam.outputWidth		= current_info.imageWidth;
+	current_outParam.outputHeight		= current_info.imageHeight;
+	current_outParam.outputColorSpace	= Memory.Read32(inParam_addr+16);
+	switch (current_outParam.outputColorSpace)
+	{
+	case CELL_JPG_GRAYSCALE:				current_outParam.outputComponents = 1; break;
+	case CELL_JPG_RGB:						current_outParam.outputComponents = 3; break;
+	case CELL_JPG_YCbCr:					current_outParam.outputComponents = 3; break;
+	case CELL_JPG_RGBA:						current_outParam.outputComponents = 4; break;
+	case CELL_JPG_UPSAMPLE_ONLY:			current_outParam.outputComponents = current_info.numComponents; break;
+	case CELL_JPG_ARGB:						current_outParam.outputComponents = 4; break;
+	case CELL_JPG_GRAYSCALE_TO_ALPHA_RGBA:	current_outParam.outputComponents = 4; break;
+	case CELL_JPG_GRAYSCALE_TO_ALPHA_ARGB:	current_outParam.outputComponents = 4; break;
+	default: return CELL_JPGDEC_ERROR_ARG;		// Not supported color space
+	}
+	current_outParam.outputMode			= Memory.Read32(inParam_addr+12);
+	current_outParam.downScale			= Memory.Read32(inParam_addr+4);
+	current_outParam.useMemorySpace		= 0;	// Unimplemented
+
+	outParam += current_outParam.outputWidthByte;
+	outParam += current_outParam.outputWidth;
+	outParam += current_outParam.outputHeight;
+	outParam += current_outParam.outputComponents;
+	outParam += current_outParam.outputMode;
+	outParam += current_outParam.outputColorSpace;
+	outParam += current_outParam.downScale;
+	outParam += current_outParam.useMemorySpace;
 
 	return CELL_OK;
 }

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/cellPngDec.cpp

@@ -81,12 +81,10 @@ struct CellPngDecSubHandle //Custom struct
 {
 	u32 fd;
 	u64 fileSize;
-	CellPngDecInParam inParam;
+	CellPngDecInfo info;
+	CellPngDecOutParam outParam;
 };
 
-CellPngDecInfo	current_info;
-CellPngDecSrc	current_src;
-
 
 int cellPngDecCreate(u32 mainHandle, u32 threadInParam, u32 threadOutParam)
 {
@@ -100,33 +98,33 @@ int cellPngDecDestroy(u32 mainHandle)
 	return CELL_OK;
 }
 
-int cellPngDecOpen(u32 mainHandle, u32 subHandle_addr, u32 src_addr, u32 openInfo)
+int cellPngDecOpen(u32 mainHandle, mem32_t subHandle, u32 src_addr, u32 openInfo)
 {
-	//current_src.srcSelect       = Memory.Read32(src_addr);
-	current_src.fileName		  = Memory.Read32(src_addr+4);
-	//current_src.fileOffset      = Memory.Read32(src_addr+8);
-	//current_src.fileSize        = Memory.Read32(src_addr+12);
-	//current_src.streamPtr       = Memory.Read32(src_addr+16);
-	//current_src.streamSize      = Memory.Read32(src_addr+20);
-	//current_src.spuThreadEnable = Memory.Read32(src_addr+24);
+	//u32 srcSelect       = Memory.Read32(src_addr);
+	u32 fileName		  = Memory.Read32(src_addr+4);
+	//u64 fileOffset      = Memory.Read32(src_addr+8);
+	//u32 fileSize        = Memory.Read32(src_addr+12);
+	//u32 streamPtr       = Memory.Read32(src_addr+16);
+	//u32 streamSize      = Memory.Read32(src_addr+20);
+	//u32 spuThreadEnable = Memory.Read32(src_addr+24);
 
-	CellPngDecSubHandle *subHandle = new CellPngDecSubHandle;
+	CellPngDecSubHandle *current_subHandle = new CellPngDecSubHandle;
 
 	// Get file descriptor
 	u32 fd_addr = Memory.Alloc(sizeof(u32), 1);
-	int ret = cellFsOpen(current_src.fileName, 0, fd_addr, NULL, 0);
-	subHandle->fd = Memory.Read32(fd_addr);
+	int ret = cellFsOpen(fileName, 0, fd_addr, NULL, 0);
+	current_subHandle->fd = Memory.Read32(fd_addr);
 	Memory.Free(fd_addr);
 	if(ret != 0) return CELL_PNGDEC_ERROR_OPEN_FILE;
 
 	// Get size of file
 	u32 sb_addr = Memory.Alloc(52,1);					// Alloc a CellFsStat struct
-	cellFsFstat(subHandle->fd, sb_addr);
-	subHandle->fileSize = Memory.Read64(sb_addr+36);	// Get CellFsStat.st_size
+	cellFsFstat(current_subHandle->fd, sb_addr);
+	current_subHandle->fileSize = Memory.Read64(sb_addr+36);	// Get CellFsStat.st_size
 	Memory.Free(sb_addr);
 
 	// From now, every u32 subHandle argument is a pointer to a CellPngDecSubHandle struct.
-	Memory.Write32(subHandle_addr, (u32)subHandle);
+	subHandle += (u32)current_subHandle;
 
 	return CELL_OK;
 }
@@ -139,19 +137,22 @@ int cellPngDecClose(u32 mainHandle, u32 subHandle)
 	return CELL_OK;
 }
 
-int cellPngDecReadHeader(u32 mainHandle, u32 subHandle, u32 info_addr)
+int cellPngDecReadHeader(u32 mainHandle, u32 subHandle, mem_class_t info)
 {
 	const u32& fd = ((CellPngDecSubHandle*)subHandle)->fd;
 	const u64& fileSize = ((CellPngDecSubHandle*)subHandle)->fileSize;
+	CellPngDecInfo& current_info = ((CellPngDecSubHandle*)subHandle)->info;
 
 	//Check size of file
 	if(fileSize < 29) return CELL_PNGDEC_ERROR_HEADER;	// Error: The file is smaller than the length of a PNG header
 	
 	//Write the header to buffer
 	u32 buffer = Memory.Alloc(34,1);					// Alloc buffer for PNG header
+	u32 nread = Memory.Alloc(8,1);
 	u32 pos_addr = Memory.Alloc(8,1);
 	cellFsLseek(fd, 0, 0, pos_addr);
-	cellFsRead(fd, buffer, 34, NULL);
+	cellFsRead(fd, buffer, 34, nread);
+	Memory.Free(nread);
 	Memory.Free(pos_addr);
 
 	if (Memory.Read32(buffer) != 0x89504E47 ||
@@ -163,14 +164,20 @@ int cellPngDecReadHeader(u32 mainHandle, u32 subHandle, u32 info_addr)
 	}
 
 	current_info.imageWidth       = Memory.Read32(buffer+16);
-	current_info.imageHeight      = Memory.Read32(buffer+20);
-	current_info.numComponents    = 0;							// Unimplemented
-	current_info.colorSpace       = Memory.Read8(buffer+25);
+	current_info.imageHeight      = Memory.Read32(buffer+20);						
+	switch (Memory.Read8(buffer+25))
+	{
+	case 0:  current_info.colorSpace = CELL_PNGDEC_GRAYSCALE;		current_info.numComponents = 1; break;
+	case 2:  current_info.colorSpace = CELL_PNGDEC_RGB;				current_info.numComponents = 3; break;
+	case 3:  current_info.colorSpace = CELL_PNGDEC_PALETTE;			current_info.numComponents = 1; break;
+	case 4:  current_info.colorSpace = CELL_PNGDEC_GRAYSCALE_ALPHA; current_info.numComponents = 2; break;
+	case 6:	 current_info.colorSpace = CELL_PNGDEC_RGBA;			current_info.numComponents = 4; break;
+	default: return CELL_PNGDEC_ERROR_HEADER; // Not supported color type
+	}
 	current_info.bitDepth         = Memory.Read8(buffer+24);
 	current_info.interlaceMethod  = Memory.Read8(buffer+28);
 	current_info.chunkInformation = 0;							// Unimplemented
 
-	mem_class_t info(info_addr);
 	info += current_info.imageWidth;
 	info += current_info.imageHeight;
 	info += current_info.numComponents;
@@ -183,17 +190,19 @@ int cellPngDecReadHeader(u32 mainHandle, u32 subHandle, u32 info_addr)
 	return CELL_OK;
 }
 
-int cellPngDecDecodeData(u32 mainHandle, u32 subHandle, u32 data_addr, u32 dataCtrlParam_addr, u32 dataOutInfo_addr)
+int cellPngDecDecodeData(u32 mainHandle, u32 subHandle, mem8_ptr_t data, u32 dataCtrlParam_addr, mem_class_t dataOutInfo)
 {
 	const u32& fd = ((CellPngDecSubHandle*)subHandle)->fd;
 	const u64& fileSize = ((CellPngDecSubHandle*)subHandle)->fileSize;
-	const CellPngDecInParam& inParam = ((CellPngDecSubHandle*)subHandle)->inParam; // (TODO: We should use the outParam)
+	const CellPngDecOutParam& current_outParam = ((CellPngDecSubHandle*)subHandle)->outParam;
 
 	//Copy the PNG file to a buffer
 	u32 buffer = Memory.Alloc(fileSize,1);
+	u32 nread = Memory.Alloc(8,1);
 	u32 pos_addr = Memory.Alloc(sizeof(u64),1);
 	cellFsLseek(fd, 0, 0, pos_addr);
-	cellFsRead(fd, buffer, fileSize, NULL);
+	cellFsRead(fd, buffer, fileSize, nread);
+	Memory.Free(nread);
 	Memory.Free(pos_addr);
 
 	//Decode PNG file. (TODO: Is there any faster alternative? Can we do it without external libraries?)
@@ -204,20 +213,20 @@ int cellPngDecDecodeData(u32 mainHandle, u32 subHandle, u32 data_addr, u32 dataC
 	if (!image)	return CELL_PNGDEC_ERROR_STREAM_FORMAT;
 
 	u32 image_size = width * height * 4;
-	if (inParam.outputColorSpace == CELL_PNGDEC_RGBA){
+	if (current_outParam.outputColorSpace == CELL_PNGDEC_RGBA){
 		for(u32 i = 0; i < image_size; i+=4){
-			Memory.Write8(data_addr+i+0, image[i+0]);
-			Memory.Write8(data_addr+i+1, image[i+1]);
-			Memory.Write8(data_addr+i+2, image[i+2]);
-			Memory.Write8(data_addr+i+3, image[i+3]);
+			data += image[i+0];
+			data += image[i+1];
+			data += image[i+2];
+			data += image[i+3];
 		}
 	}
-	else if (inParam.outputColorSpace == CELL_PNGDEC_ARGB){
+	else if (current_outParam.outputColorSpace == CELL_PNGDEC_ARGB){
 		for(u32 i = 0; i < image_size; i+=4){
-			Memory.Write8(data_addr+i+0, image[i+3]);
-			Memory.Write8(data_addr+i+1, image[i+0]);
-			Memory.Write8(data_addr+i+2, image[i+1]);
-			Memory.Write8(data_addr+i+3, image[i+2]);
+			data += image[i+3];
+			data += image[i+0];
+			data += image[i+1];
+			data += image[i+2];
 		}
 	}
 	delete[] image;
@@ -225,12 +234,37 @@ int cellPngDecDecodeData(u32 mainHandle, u32 subHandle, u32 data_addr, u32 dataC
 	return CELL_OK;
 }
 
-int cellPngDecSetParameter(u32 mainHandle, u32 subHandle, u32 inParam_addr, u32 outParam_addr)
+int cellPngDecSetParameter(u32 mainHandle, u32 subHandle, u32 inParam_addr, mem_class_t outParam)
 {
-	CellPngDecInParam& inParam = ((CellPngDecSubHandle*)subHandle)->inParam;
-	inParam.outputColorSpace = Memory.Read32(inParam_addr+8);
+	CellPngDecInfo& current_info = ((CellPngDecSubHandle*)subHandle)->info;
+	CellPngDecOutParam& current_outParam = ((CellPngDecSubHandle*)subHandle)->outParam;
 
-	// (TODO)
+	current_outParam.outputWidthByte	= (current_info.imageWidth * current_info.numComponents * current_info.bitDepth)/8;
+	current_outParam.outputWidth		= current_info.imageWidth;
+	current_outParam.outputHeight		= current_info.imageHeight;
+	current_outParam.outputColorSpace	= Memory.Read32(inParam_addr+8);
+	switch (current_outParam.outputColorSpace)
+	{
+	case CELL_PNGDEC_GRAYSCALE:			current_outParam.outputComponents = 1; break;
+	case CELL_PNGDEC_GRAYSCALE_ALPHA:	current_outParam.outputComponents = 2; break;
+	case CELL_PNGDEC_PALETTE:			current_outParam.outputComponents = 1; break;
+	case CELL_PNGDEC_RGB:				current_outParam.outputComponents = 3; break;
+	case CELL_PNGDEC_RGBA:				current_outParam.outputComponents = 4; break;
+	case CELL_PNGDEC_ARGB:				current_outParam.outputComponents = 4; break;
+	default: return CELL_PNGDEC_ERROR_ARG;		// Not supported color space
+	}
+	current_outParam.outputBitDepth		= Memory.Read32(inParam_addr+12);
+	current_outParam.outputMode			= Memory.Read32(inParam_addr+4); 
+	current_outParam.useMemorySpace		= 0;	// Unimplemented
+
+	outParam += current_outParam.outputWidthByte;
+	outParam += current_outParam.outputWidth;
+	outParam += current_outParam.outputHeight;
+	outParam += current_outParam.outputComponents;
+	outParam += current_outParam.outputBitDepth;
+	outParam += current_outParam.outputMode;
+	outParam += current_outParam.outputColorSpace;
+	outParam += current_outParam.useMemorySpace;
 
 	return CELL_OK;
 }

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/cellSsl.cpp

@@ -0,0 +1,110 @@
+#include "stdafx.h"
+#include "Emu/SysCalls/SysCalls.h"
+#include "Emu/SysCalls/SC_FUNC.h"
+
+void cellSsl_init();
+Module cellSsl(0x0003, cellSsl_init);
+
+int cellSslInit()
+{
+	UNIMPLEMENTED_FUNC(cellSsl);
+	return CELL_OK;
+}
+
+int cellSslEnd()
+{
+	UNIMPLEMENTED_FUNC(cellSsl);
+	return CELL_OK;
+}
+
+int cellSslCertificateLoader()
+{
+	UNIMPLEMENTED_FUNC(cellSsl);
+	return CELL_OK;
+}
+
+int cellSslCertGetSerialNumber()
+{
+	UNIMPLEMENTED_FUNC(cellSsl);
+	return CELL_OK;
+}
+
+int cellSslCertGetPublicKey()
+{
+	UNIMPLEMENTED_FUNC(cellSsl);
+	return CELL_OK;
+}
+
+int cellSslCertGetRsaPublicKeyModulus()
+{
+	UNIMPLEMENTED_FUNC(cellSsl);
+	return CELL_OK;
+}
+
+int cellSslCertGetRsaPublicKeyExponent()
+{
+	UNIMPLEMENTED_FUNC(cellSsl);
+	return CELL_OK;
+}
+
+int cellSslCertGetNotBefore()
+{
+	UNIMPLEMENTED_FUNC(cellSsl);
+	return CELL_OK;
+}
+
+int cellSslCertGetNotAfter()
+{
+	UNIMPLEMENTED_FUNC(cellSsl);
+	return CELL_OK;
+}
+
+int cellSslCertGetSubjectName()
+{
+	UNIMPLEMENTED_FUNC(cellSsl);
+	return CELL_OK;
+}
+
+int cellSslCertGetIssuerName()
+{
+	UNIMPLEMENTED_FUNC(cellSsl);
+	return CELL_OK;
+}
+
+int cellSslCertGetNameEntryCount()
+{
+	UNIMPLEMENTED_FUNC(cellSsl);
+	return CELL_OK;
+}
+
+int cellSslCertGetNameEntryInfo()
+{
+	UNIMPLEMENTED_FUNC(cellSsl);
+	return CELL_OK;
+}
+
+int cellSslCertGetMd5Fingerprint()
+{
+	UNIMPLEMENTED_FUNC(cellSsl);
+	return CELL_OK;
+}
+
+void cellSsl_init()
+{
+	cellSsl.AddFunc(0xfb02c9d2, cellSslInit);
+	cellSsl.AddFunc(0x1650aea4, cellSslEnd);
+
+	cellSsl.AddFunc(0x571afaca, cellSslCertificateLoader);
+
+	cellSsl.AddFunc(0x7b689ebc, cellSslCertGetSerialNumber);
+	cellSsl.AddFunc(0xf8206492, cellSslCertGetPublicKey);
+	cellSsl.AddFunc(0x8e505175, cellSslCertGetRsaPublicKeyModulus);
+	cellSsl.AddFunc(0x033c4905, cellSslCertGetRsaPublicKeyExponent);
+	cellSsl.AddFunc(0x31d9ba8d, cellSslCertGetNotBefore);
+	cellSsl.AddFunc(0x218b64da, cellSslCertGetNotAfter);
+	cellSsl.AddFunc(0x32c61bdf, cellSslCertGetSubjectName);
+	cellSsl.AddFunc(0xae6eb491, cellSslCertGetIssuerName);
+	cellSsl.AddFunc(0x766d3ca1, cellSslCertGetNameEntryCount);
+	cellSsl.AddFunc(0x006c4900, cellSslCertGetNameEntryInfo);
+	cellSsl.AddFunc(0x5e9253ca, cellSslCertGetMd5Fingerprint);
+}

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/cellSysutil.cpp

@@ -107,11 +107,11 @@ void cellVideoOutGetDeviceInfo()
 	UNIMPLEMENTED_FUNC(cellSysutil);
 }
 
-int cellSysutilGetSystemParamInt(int id, u32 value_addr)
+int cellSysutilGetSystemParamInt(int id, mem32_t value)
 {
-	cellSysutil.Log("cellSysutilGetSystemParamInt(id=0x%x, value_addr=0x%x)", id, value_addr);
+	cellSysutil.Log("cellSysutilGetSystemParamInt(id=0x%x, value_addr=0x%x)", id, value.GetAddr());
 
-	if(!Memory.IsGoodAddr(value_addr))
+	if(!value.IsGood())
 	{
 		return CELL_EFAULT;
 	}
@@ -120,77 +120,77 @@ int cellSysutilGetSystemParamInt(int id, u32 value_addr)
 	{
 	case CELL_SYSUTIL_SYSTEMPARAM_ID_LANG:
 		cellSysutil.Warning("cellSysutilGetSystemParamInt: CELL_SYSUTIL_SYSTEMPARAM_ID_LANG");
-		Memory.Write32(value_addr, CELL_SYSUTIL_LANG_ENGLISH_US);
+		value = CELL_SYSUTIL_LANG_ENGLISH_US;
 	break;
 
 	case CELL_SYSUTIL_SYSTEMPARAM_ID_ENTER_BUTTON_ASSIGN:
 		cellSysutil.Warning("cellSysutilGetSystemParamInt: CELL_SYSUTIL_SYSTEMPARAM_ID_ENTER_BUTTON_ASSIGN");
-		Memory.Write32(value_addr, CELL_SYSUTIL_ENTER_BUTTON_ASSIGN_CROSS);
+		value = CELL_SYSUTIL_ENTER_BUTTON_ASSIGN_CROSS;
 	break;
 
 	case CELL_SYSUTIL_SYSTEMPARAM_ID_DATE_FORMAT:
 		cellSysutil.Warning("cellSysutilGetSystemParamInt: CELL_SYSUTIL_SYSTEMPARAM_ID_DATE_FORMAT");
-		Memory.Write32(value_addr, CELL_SYSUTIL_DATE_FMT_DDMMYYYY);
+		value = CELL_SYSUTIL_DATE_FMT_DDMMYYYY;
 	break;
 
 	case CELL_SYSUTIL_SYSTEMPARAM_ID_TIME_FORMAT:
 		cellSysutil.Warning("cellSysutilGetSystemParamInt: CELL_SYSUTIL_SYSTEMPARAM_ID_TIME_FORMAT");
-		Memory.Write32(value_addr, CELL_SYSUTIL_TIME_FMT_CLOCK24);
+		value = CELL_SYSUTIL_TIME_FMT_CLOCK24;
 	break;
 
 	case CELL_SYSUTIL_SYSTEMPARAM_ID_TIMEZONE:
 		cellSysutil.Warning("cellSysutilGetSystemParamInt: CELL_SYSUTIL_SYSTEMPARAM_ID_TIMEZONE");
-		Memory.Write32(value_addr, 3);
+		value = 3;
 	break;
 
 	case CELL_SYSUTIL_SYSTEMPARAM_ID_SUMMERTIME:
 		cellSysutil.Warning("cellSysutilGetSystemParamInt: CELL_SYSUTIL_SYSTEMPARAM_ID_SUMMERTIME");
-		Memory.Write32(value_addr, 1);
+		value = 1;
 	break;
 
 	case CELL_SYSUTIL_SYSTEMPARAM_ID_GAME_PARENTAL_LEVEL:
 		cellSysutil.Warning("cellSysutilGetSystemParamInt: CELL_SYSUTIL_SYSTEMPARAM_ID_GAME_PARENTAL_LEVEL");
-		Memory.Write32(value_addr, CELL_SYSUTIL_GAME_PARENTAL_OFF);
+		value = CELL_SYSUTIL_GAME_PARENTAL_OFF;
 	break;
 
 	case CELL_SYSUTIL_SYSTEMPARAM_ID_GAME_PARENTAL_LEVEL0_RESTRICT:
 		cellSysutil.Warning("cellSysutilGetSystemParamInt: CELL_SYSUTIL_SYSTEMPARAM_ID_GAME_PARENTAL_LEVEL0_RESTRICT");
-		Memory.Write32(value_addr, CELL_SYSUTIL_GAME_PARENTAL_LEVEL0_RESTRICT_OFF);
+		value = CELL_SYSUTIL_GAME_PARENTAL_LEVEL0_RESTRICT_OFF;
 	break;
 
 	case CELL_SYSUTIL_SYSTEMPARAM_ID_CURRENT_USER_HAS_NP_ACCOUNT:
 		cellSysutil.Warning("cellSysutilGetSystemParamInt: CELL_SYSUTIL_SYSTEMPARAM_ID_CURRENT_USER_HAS_NP_ACCOUNT");
-		Memory.Write32(value_addr, 0);
+		value = 0;
 	break;
 
 	case CELL_SYSUTIL_SYSTEMPARAM_ID_CAMERA_PLFREQ:
 		cellSysutil.Warning("cellSysutilGetSystemParamInt: CELL_SYSUTIL_SYSTEMPARAM_ID_CAMERA_PLFREQ");
-		Memory.Write32(value_addr, CELL_SYSUTIL_CAMERA_PLFREQ_DISABLED);
+		value = CELL_SYSUTIL_CAMERA_PLFREQ_DISABLED;
 	break;
 
 	case CELL_SYSUTIL_SYSTEMPARAM_ID_PAD_RUMBLE:
 		cellSysutil.Warning("cellSysutilGetSystemParamInt: CELL_SYSUTIL_SYSTEMPARAM_ID_PAD_RUMBLE");
-		Memory.Write32(value_addr, CELL_SYSUTIL_PAD_RUMBLE_OFF);
+		value = CELL_SYSUTIL_PAD_RUMBLE_OFF;
 	break;
 
 	case CELL_SYSUTIL_SYSTEMPARAM_ID_KEYBOARD_TYPE:
 		cellSysutil.Warning("cellSysutilGetSystemParamInt: CELL_SYSUTIL_SYSTEMPARAM_ID_KEYBOARD_TYPE");
-		Memory.Write32(value_addr, 0);
+		value = 0;
 	break;
 
 	case CELL_SYSUTIL_SYSTEMPARAM_ID_JAPANESE_KEYBOARD_ENTRY_METHOD:
 		cellSysutil.Warning("cellSysutilGetSystemParamInt: CELL_SYSUTIL_SYSTEMPARAM_ID_JAPANESE_KEYBOARD_ENTRY_METHOD");
-		Memory.Write32(value_addr, 0);
+		value = 0;
 	break;
 
 	case CELL_SYSUTIL_SYSTEMPARAM_ID_CHINESE_KEYBOARD_ENTRY_METHOD:
 		cellSysutil.Warning("cellSysutilGetSystemParamInt: CELL_SYSUTIL_SYSTEMPARAM_ID_CHINESE_KEYBOARD_ENTRY_METHOD");
-		Memory.Write32(value_addr, 0);
+		value = 0;
 	break;
 
 	case CELL_SYSUTIL_SYSTEMPARAM_ID_PAD_AUTOOFF:
 		cellSysutil.Warning("cellSysutilGetSystemParamInt: CELL_SYSUTIL_SYSTEMPARAM_ID_PAD_AUTOOFF");
-		Memory.Write32(value_addr, 0);
+		value = 0;
 	break;
 
 	default:

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/Emu/SysCalls/Modules/sys_http.cpp

@@ -0,0 +1,704 @@
+#include "stdafx.h"
+#include "Emu/SysCalls/SysCalls.h"
+#include "Emu/SysCalls/SC_FUNC.h"
+
+void sys_http_init();
+Module sys_http(0x0001, sys_http_init);
+
+int cellHttpInit()
+{
+	UNIMPLEMENTED_FUNC(sys_http);
+	return CELL_OK;
+}
+
+int cellHttpEnd()
+{
+	UNIMPLEMENTED_FUNC(sys_http);
+	return CELL_OK;
+}
+
+int cellHttpsInit()
+{
+	UNIMPLEMENTED_FUNC(sys_http);
+	return CELL_OK;
+}
+
+int cellHttpsEnd()
+{
+	UNIMPLEMENTED_FUNC(sys_http);
+	return CELL_OK;
+}
+
+int cellHttpSetProxy()
+{
+	UNIMPLEMENTED_FUNC(sys_http);
+	return CELL_OK;
+}
+
+int cellHttpGetProxy()
+{
+	UNIMPLEMENTED_FUNC(sys_http);
+	return CELL_OK;
+}
+
+int cellHttpInitCookie()
+{
+	UNIMPLEMENTED_FUNC(sys_http);
+	return CELL_OK;
+}
+
+int cellHttpEndCookie()
+{
+	UNIMPLEMENTED_FUNC(sys_http);
+	return CELL_OK;
+}
+
+int cellHttpAddCookieWithClientId()
+{
+	UNIMPLEMENTED_FUNC(sys_http);
+	return CELL_OK;
+}
+
+int cellHttpSessionCookieFlush()
+{
+	UNIMPLEMENTED_FUNC(sys_http);
+	return CELL_OK;
+}
+
+int cellHttpCookieExportWithClientId()
+{
+	UNIMPLEMENTED_FUNC(sys_http);
+	return CELL_OK;
+}
+
+int cellHttpCookieImportWithClientId()
+{
+	UNIMPLEMENTED_FUNC(sys_http);
+	return CELL_OK;
+}
+
+int cellHttpClientSetCookieSendCallback()
+{
+	UNIMPLEMENTED_FUNC(sys_http);
+	return CELL_OK;
+}
+
+int cellHttpClientSetCookieRecvCallback()
+{
+	UNIMPLEMENTED_FUNC(sys_http);
+	return CELL_OK;
+}
+
+int cellHttpCreateClient()
+{
+	UNIMPLEMENTED_FUNC(sys_http);
+	return CELL_OK;
+}
+
+int cellHttpDestroyClient()
+{
+	UNIMPLEMENTED_FUNC(sys_http);
+	return CELL_OK;
+}
+
+int cellHttpClientSetAuthenticationCallback()
+{
+	UNIMPLEMENTED_FUNC(sys_http);
+	return CELL_OK;
+}
+
+int cellHttpClientSetTransactionStateCallback()
+{
+	UNIMPLEMENTED_FUNC(sys_http);
+	return CELL_OK;
+}
+
+int cellHttpClientSetRedirectCallback()
+{
+	UNIMPLEMENTED_FUNC(sys_http);
+	return CELL_OK;
+}
+
+int cellHttpClientSetProxy()
+{
+	UNIMPLEMENTED_FUNC(sys_http);
+	return CELL_OK;
+}
+
+int cellHttpClientGetProxy()
+{
+	UNIMPLEMENTED_FUNC(sys_http);
+	return CELL_OK;
+}
+
+int cellHttpClientSetVersion()
+{
+	UNIMPLEMENTED_FUNC(sys_http);
+	return CELL_OK;
+}
+
+int cellHttpClientGetVersion()
+{
+	UNIMPLEMENTED_FUNC(sys_http);
+	return CELL_OK;
+}
+
+int cellHttpClientSetPipeline()
+{
+	UNIMPLEMENTED_FUNC(sys_http);
+	return CELL_OK;
+}
+
+int cellHttpClientGetPipeline()
+{
+	UNIMPLEMENTED_FUNC(sys_http);
+	return CELL_OK;
+}
+
+int cellHttpClientSetKeepAlive()
+{
+	UNIMPLEMENTED_FUNC(sys_http);
+	return CELL_OK;
+}
+
+int cellHttpClientGetKeepAlive()
+{
+	UNIMPLEMENTED_FUNC(sys_http);
+	return CELL_OK;
+}
+
+int cellHttpClientSetAutoRedirect()
+{
+	UNIMPLEMENTED_FUNC(sys_http);
+	return CELL_OK;
+}
+
+int cellHttpClientGetAutoRedirect()
+{
+	UNIMPLEMENTED_FUNC(sys_http);
+	return CELL_OK;
+}
+
+int cellHttpClientSetAutoAuthentication()
+{
+	UNIMPLEMENTED_FUNC(sys_http);
+	return CELL_OK;
+}
+
+int cellHttpClientGetAutoAuthentication()
+{
+	UNIMPLEMENTED_FUNC(sys_http);
+	return CELL_OK;
+}
+
+int cellHttpClientSetAuthenticationCacheStatus()
+{
+	UNIMPLEMENTED_FUNC(sys_http);
+	return CELL_OK;
+}
+
+int cellHttpClientGetAuthenticationCacheStatus()
+{
+	UNIMPLEMENTED_FUNC(sys_http);
+	return CELL_OK;
+}
+
+int cellHttpClientSetCookieStatus()
+{
+	UNIMPLEMENTED_FUNC(sys_http);
+	return CELL_OK;
+}
+
+int cellHttpClientGetCookieStatus()
+{
+	UNIMPLEMENTED_FUNC(sys_http);
+	return CELL_OK;
+}
+
+int cellHttpClientSetUserAgent()
+{
+	UNIMPLEMENTED_FUNC(sys_http);
+	return CELL_OK;
+}
+
+int cellHttpClientGetUserAgent()
+{
+	UNIMPLEMENTED_FUNC(sys_http);
+	return CELL_OK;
+}
+
+int cellHttpClientSetResponseBufferMax()
+{
+	UNIMPLEMENTED_FUNC(sys_http);
+	return CELL_OK;
+}
+
+int cellHttpClientGetResponseBufferMax()
+{
+	UNIMPLEMENTED_FUNC(sys_http);
+	return CELL_OK;
+}
+
+int cellHttpClientCloseAllConnections()
+{
+	UNIMPLEMENTED_FUNC(sys_http);
+	return CELL_OK;
+}
+
+int cellHttpClientCloseConnections()
+{
+	UNIMPLEMENTED_FUNC(sys_http);
+	return CELL_OK;
+}
+
+int cellHttpClientPollConnections()
+{
+	UNIMPLEMENTED_FUNC(sys_http);
+	return CELL_OK;
+}
+
+int cellHttpClientSetRecvTimeout()
+{
+	UNIMPLEMENTED_FUNC(sys_http);
+	return CELL_OK;
+}
+
+int cellHttpClientGetRecvTimeout()
+{
+	UNIMPLEMENTED_FUNC(sys_http);
+	return CELL_OK;
+}
+
+int cellHttpClientSetSendTimeout()
+{
+	UNIMPLEMENTED_FUNC(sys_http);
+	return CELL_OK;
+}
+
+int cellHttpClientGetSendTimeout()
+{
+	UNIMPLEMENTED_FUNC(sys_http);
+	return CELL_OK;
+}
+
+int cellHttpClientSetConnTimeout()
+{
+	UNIMPLEMENTED_FUNC(sys_http);
+	return CELL_OK;
+}
+
+int cellHttpClientGetConnTimeout()
+{
+	UNIMPLEMENTED_FUNC(sys_http);
+	return CELL_OK;
+}
+
+int cellHttpClientSetTotalPoolSize()
+{
+	UNIMPLEMENTED_FUNC(sys_http);
+	return CELL_OK;
+}
+
+int cellHttpClientGetTotalPoolSize()
+{
+	UNIMPLEMENTED_FUNC(sys_http);
+	return CELL_OK;
+}
+
+int cellHttpClientSetPerHostPoolSize()
+{
+	UNIMPLEMENTED_FUNC(sys_http);
+	return CELL_OK;
+}
+
+int cellHttpClientGetPerHostPoolSize()
+{
+	UNIMPLEMENTED_FUNC(sys_http);
+	return CELL_OK;
+}
+
+int cellHttpClientSetPerHostKeepAliveMax()
+{
+	UNIMPLEMENTED_FUNC(sys_http);
+	return CELL_OK;
+}
+
+int cellHttpClientGetPerHostKeepAliveMax()
+{
+	UNIMPLEMENTED_FUNC(sys_http);
+	return CELL_OK;
+}
+
+int cellHttpClientSetPerPipelineMax()
+{
+	UNIMPLEMENTED_FUNC(sys_http);
+	return CELL_OK;
+}
+
+int cellHttpClientGetPerPipelineMax()
+{
+	UNIMPLEMENTED_FUNC(sys_http);
+	return CELL_OK;
+}
+
+int cellHttpClientSetRecvBufferSize()
+{
+	UNIMPLEMENTED_FUNC(sys_http);
+	return CELL_OK;
+}
+
+int cellHttpClientGetRecvBufferSize()
+{
+	UNIMPLEMENTED_FUNC(sys_http);
+	return CELL_OK;
+}
+
+int cellHttpClientGetAllHeaders()
+{
+	UNIMPLEMENTED_FUNC(sys_http);
+	return CELL_OK;
+}
+
+int cellHttpClientSetHeader()
+{
+	UNIMPLEMENTED_FUNC(sys_http);
+	return CELL_OK;
+}
+
+int cellHttpClientGetHeader()
+{
+	UNIMPLEMENTED_FUNC(sys_http);
+	return CELL_OK;
+}
+
+int cellHttpClientAddHeader()
+{
+	UNIMPLEMENTED_FUNC(sys_http);
+	return CELL_OK;
+}
+
+int cellHttpClientDeleteHeader()
+{
+	UNIMPLEMENTED_FUNC(sys_http);
+	return CELL_OK;
+}
+
+int cellHttpClientSetSslCallback()
+{
+	UNIMPLEMENTED_FUNC(sys_http);
+	return CELL_OK;
+}
+
+int cellHttpClientSetSslClientCertificate()
+{
+	UNIMPLEMENTED_FUNC(sys_http);
+	return CELL_OK;
+}
+
+int cellHttpCreateTransaction()
+{
+	UNIMPLEMENTED_FUNC(sys_http);
+	return CELL_OK;
+}
+
+int cellHttpDestroyTransaction()
+{
+	UNIMPLEMENTED_FUNC(sys_http);
+	return CELL_OK;
+}
+
+int cellHttpTransactionGetUri()
+{
+	UNIMPLEMENTED_FUNC(sys_http);
+	return CELL_OK;
+}
+
+int cellHttpTransactionCloseConnection()
+{
+	UNIMPLEMENTED_FUNC(sys_http);
+	return CELL_OK;
+}
+
+int cellHttpTransactionReleaseConnection()
+{
+	UNIMPLEMENTED_FUNC(sys_http);
+	return CELL_OK;
+}
+
+int cellHttpTransactionAbortConnection()
+{
+	UNIMPLEMENTED_FUNC(sys_http);
+	return CELL_OK;
+}
+
+int cellHttpSendRequest()
+{
+	UNIMPLEMENTED_FUNC(sys_http);
+	return CELL_OK;
+}
+
+int cellHttpRequestSetContentLength()
+{
+	UNIMPLEMENTED_FUNC(sys_http);
+	return CELL_OK;
+}
+
+int cellHttpRequestGetContentLength()
+{
+	UNIMPLEMENTED_FUNC(sys_http);
+	return CELL_OK;
+}
+
+int cellHttpRequestSetChunkedTransferStatus()
+{
+	UNIMPLEMENTED_FUNC(sys_http);
+	return CELL_OK;
+}
+
+int cellHttpRequestGetChunkedTransferStatus()
+{
+	UNIMPLEMENTED_FUNC(sys_http);
+	return CELL_OK;
+}
+
+int cellHttpRequestGetAllHeaders()
+{
+	UNIMPLEMENTED_FUNC(sys_http);
+	return CELL_OK;
+}
+
+int cellHttpRequestSetHeader()
+{
+	UNIMPLEMENTED_FUNC(sys_http);
+	return CELL_OK;
+}
+
+int cellHttpRequestGetHeader()
+{
+	UNIMPLEMENTED_FUNC(sys_http);
+	return CELL_OK;
+}
+
+int cellHttpRequestAddHeader()
+{
+	UNIMPLEMENTED_FUNC(sys_http);
+	return CELL_OK;
+}
+
+int cellHttpRequestDeleteHeader()
+{
+	UNIMPLEMENTED_FUNC(sys_http);
+	return CELL_OK;
+}
+
+int cellHttpRecvResponse()
+{
+	UNIMPLEMENTED_FUNC(sys_http);
+	return CELL_OK;
+}
+
+int cellHttpResponseGetAllHeaders()
+{
+	UNIMPLEMENTED_FUNC(sys_http);
+	return CELL_OK;
+}
+
+int cellHttpResponseGetHeader()
+{
+	UNIMPLEMENTED_FUNC(sys_http);
+	return CELL_OK;
+}
+
+int cellHttpResponseGetContentLength()
+{
+	UNIMPLEMENTED_FUNC(sys_http);
+	return CELL_OK;
+}
+
+int cellHttpResponseGetStatusCode()
+{
+	UNIMPLEMENTED_FUNC(sys_http);
+	return CELL_OK;
+}
+
+int cellHttpResponseGetStatusLine()
+{
+	UNIMPLEMENTED_FUNC(sys_http);
+	return CELL_OK;
+}
+
+int cellHttpTransactionGetSslCipherName()
+{
+	UNIMPLEMENTED_FUNC(sys_http);
+	return CELL_OK;
+}
+
+int cellHttpTransactionGetSslCipherId()
+{
+	UNIMPLEMENTED_FUNC(sys_http);
+	return CELL_OK;
+}
+
+int cellHttpTransactionGetSslCipherVersion()
+{
+	UNIMPLEMENTED_FUNC(sys_http);
+	return CELL_OK;
+}
+
+int cellHttpTransactionGetSslCipherBits()
+{
+	UNIMPLEMENTED_FUNC(sys_http);
+	return CELL_OK;
+}
+
+int cellHttpTransactionGetSslCipherString()
+{
+	UNIMPLEMENTED_FUNC(sys_http);
+	return CELL_OK;
+}
+
+int cellHttpTransactionGetSslVersion()
+{
+	UNIMPLEMENTED_FUNC(sys_http);
+	return CELL_OK;
+}
+
+int cellHttpTransactionGetSslId()
+{
+	UNIMPLEMENTED_FUNC(sys_http);
+	return CELL_OK;
+}
+
+int cellHttpClientSetSslVersion()
+{
+	UNIMPLEMENTED_FUNC(sys_http);
+	return CELL_OK;
+}
+
+int cellHttpClientGetSslVersion()
+{
+	UNIMPLEMENTED_FUNC(sys_http);
+	return CELL_OK;
+}
+
+int cellHttpClientSetSslIdDestroyCallback()
+{
+	UNIMPLEMENTED_FUNC(sys_http);
+	return CELL_OK;
+}
+
+void sys_http_init()
+{
+	// (TODO: Find addresses for cellHttpClientSetSendBufferSize and cellHttpClientGetSendBufferSize)
+
+	sys_http.AddFunc(0x250c386c, cellHttpInit);
+	sys_http.AddFunc(0xd276ff1f, cellHttpEnd);
+	sys_http.AddFunc(0x522180bc, cellHttpsInit);
+	sys_http.AddFunc(0xe6d4202f, cellHttpsEnd);
+	sys_http.AddFunc(0x0d896b97, cellHttpSetProxy);
+	sys_http.AddFunc(0x2a87603a, cellHttpGetProxy);
+
+	sys_http.AddFunc(0x9638f766, cellHttpInitCookie);
+	sys_http.AddFunc(0x61b2bade, cellHttpEndCookie);
+	sys_http.AddFunc(0x1b5bdcc6, cellHttpAddCookieWithClientId);
+	sys_http.AddFunc(0xad6a2e5b, cellHttpSessionCookieFlush);
+	sys_http.AddFunc(0xf972c733, cellHttpCookieExportWithClientId);
+	sys_http.AddFunc(0x0d846d63, cellHttpCookieImportWithClientId);
+	sys_http.AddFunc(0x4d915204, cellHttpClientSetCookieSendCallback);
+	sys_http.AddFunc(0x13fe767b, cellHttpClientSetCookieRecvCallback);
+
+	sys_http.AddFunc(0x4e4ee53a, cellHttpCreateClient);
+	sys_http.AddFunc(0x980855ac, cellHttpDestroyClient);
+	sys_http.AddFunc(0x660d42a9, cellHttpClientSetAuthenticationCallback);
+	sys_http.AddFunc(0xb6feb84b, cellHttpClientSetTransactionStateCallback);
+	sys_http.AddFunc(0x473cd9f1, cellHttpClientSetRedirectCallback);
+
+	sys_http.AddFunc(0xd7d3cd5d, cellHttpClientSetProxy);
+	sys_http.AddFunc(0x4d40cf98, cellHttpClientGetProxy);
+	sys_http.AddFunc(0x40547d8b, cellHttpClientSetVersion);
+	sys_http.AddFunc(0xdc405507, cellHttpClientGetVersion);
+	sys_http.AddFunc(0x296a46cf, cellHttpClientSetPipeline);
+	sys_http.AddFunc(0x2a1f28f6, cellHttpClientGetPipeline);
+	sys_http.AddFunc(0x5d473170, cellHttpClientSetKeepAlive);
+	sys_http.AddFunc(0x591c21a8, cellHttpClientGetKeepAlive);
+	sys_http.AddFunc(0x211d8ba3, cellHttpClientSetAutoRedirect);
+	sys_http.AddFunc(0x2960e309, cellHttpClientGetAutoRedirect);
+	sys_http.AddFunc(0x8eaf47a3, cellHttpClientSetAutoAuthentication);
+	sys_http.AddFunc(0x5980a293, cellHttpClientGetAutoAuthentication);
+	sys_http.AddFunc(0x6eed4999, cellHttpClientSetAuthenticationCacheStatus);
+	sys_http.AddFunc(0xfce39343, cellHttpClientGetAuthenticationCacheStatus);
+	sys_http.AddFunc(0x434419c8, cellHttpClientSetCookieStatus);
+	sys_http.AddFunc(0xeb9c1e5e, cellHttpClientGetCookieStatus);
+	sys_http.AddFunc(0xcac9fc34, cellHttpClientSetUserAgent);
+	sys_http.AddFunc(0xee05b0c1, cellHttpClientGetUserAgent);
+	sys_http.AddFunc(0xadd66b5c, cellHttpClientSetResponseBufferMax);
+	sys_http.AddFunc(0x6884cdb7, cellHttpClientGetResponseBufferMax);
+
+	sys_http.AddFunc(0x2033b878, cellHttpClientCloseAllConnections);
+	sys_http.AddFunc(0x27f86d70, cellHttpClientCloseConnections);
+	sys_http.AddFunc(0xadc0a4b2, cellHttpClientPollConnections);
+	sys_http.AddFunc(0x224e1610, cellHttpClientSetRecvTimeout);
+	sys_http.AddFunc(0xba78e51f, cellHttpClientGetRecvTimeout);
+	sys_http.AddFunc(0x71714cdc, cellHttpClientSetSendTimeout);
+	sys_http.AddFunc(0x271a0b06, cellHttpClientGetSendTimeout);
+	sys_http.AddFunc(0xd7471088, cellHttpClientSetConnTimeout);
+	sys_http.AddFunc(0x14bfc765, cellHttpClientGetConnTimeout);
+	sys_http.AddFunc(0x8aa5fcd3, cellHttpClientSetTotalPoolSize);
+	sys_http.AddFunc(0x070f1020, cellHttpClientGetTotalPoolSize);
+	sys_http.AddFunc(0xab1c55ab, cellHttpClientSetPerHostPoolSize);
+	sys_http.AddFunc(0xffc74003, cellHttpClientGetPerHostPoolSize);
+	sys_http.AddFunc(0x595adee9, cellHttpClientSetPerHostKeepAliveMax);
+	sys_http.AddFunc(0x46bcc9ff, cellHttpClientGetPerHostKeepAliveMax);
+	sys_http.AddFunc(0xdc7ed599, cellHttpClientSetPerPipelineMax);
+	sys_http.AddFunc(0xd06c90a4, cellHttpClientGetPerPipelineMax);
+	sys_http.AddFunc(0xbf6e3659, cellHttpClientSetRecvBufferSize);
+	sys_http.AddFunc(0x130150ea, cellHttpClientGetRecvBufferSize);
+	//sys_http.AddFunc(, cellHttpClientSetSendBufferSize);
+	//sys_http.AddFunc(, cellHttpClientGetSendBufferSize);
+
+	sys_http.AddFunc(0x0d9c65be, cellHttpClientGetAllHeaders);
+	sys_http.AddFunc(0xa34c4b6f, cellHttpClientSetHeader);
+	sys_http.AddFunc(0xd1ec0b25, cellHttpClientGetHeader);
+	sys_http.AddFunc(0x4b33942a, cellHttpClientAddHeader);
+	sys_http.AddFunc(0x617eec02, cellHttpClientDeleteHeader);
+
+	sys_http.AddFunc(0x1395d8d1, cellHttpClientSetSslCallback);
+	sys_http.AddFunc(0xd8352a40, cellHttpClientSetSslClientCertificate);
+
+	sys_http.AddFunc(0x052a80d9, cellHttpCreateTransaction);
+	sys_http.AddFunc(0x32f5cae2, cellHttpDestroyTransaction);
+	sys_http.AddFunc(0x0ef17399, cellHttpTransactionGetUri);
+	sys_http.AddFunc(0xa0d9223c, cellHttpTransactionCloseConnection);
+	sys_http.AddFunc(0xd47cc666, cellHttpTransactionReleaseConnection);
+	sys_http.AddFunc(0x2d52848b, cellHttpTransactionAbortConnection);
+
+	sys_http.AddFunc(0xa755b005, cellHttpSendRequest);
+	sys_http.AddFunc(0xaf73a64e, cellHttpRequestSetContentLength);
+	sys_http.AddFunc(0x958323cf, cellHttpRequestGetContentLength);
+	sys_http.AddFunc(0x8e3f7ee1, cellHttpRequestSetChunkedTransferStatus);
+	sys_http.AddFunc(0x4137a1f6, cellHttpRequestGetChunkedTransferStatus);
+	sys_http.AddFunc(0x42205fe0, cellHttpRequestGetAllHeaders);
+	sys_http.AddFunc(0x54f2a4de, cellHttpRequestSetHeader);
+	sys_http.AddFunc(0x0b9fea5f, cellHttpRequestGetHeader);
+	sys_http.AddFunc(0xed993147, cellHttpRequestAddHeader);
+	sys_http.AddFunc(0x16214411, cellHttpRequestDeleteHeader);
+
+	sys_http.AddFunc(0x61c90691, cellHttpRecvResponse);
+	sys_http.AddFunc(0xbea17389, cellHttpResponseGetAllHeaders);
+	sys_http.AddFunc(0x4f5d8d20, cellHttpResponseGetHeader);
+	sys_http.AddFunc(0x464ff889, cellHttpResponseGetContentLength);
+	sys_http.AddFunc(0x10d0d7fc, cellHttpResponseGetStatusCode);
+	sys_http.AddFunc(0x6a81b5e4, cellHttpResponseGetStatusLine);
+
+	sys_http.AddFunc(0x895c604c, cellHttpTransactionGetSslCipherName);
+	sys_http.AddFunc(0x34061e49, cellHttpTransactionGetSslCipherId);
+	sys_http.AddFunc(0x93e938e5, cellHttpTransactionGetSslCipherVersion);
+	sys_http.AddFunc(0x38954133, cellHttpTransactionGetSslCipherBits);
+	sys_http.AddFunc(0xe3c424b3, cellHttpTransactionGetSslCipherString);
+	sys_http.AddFunc(0xad1c6f02, cellHttpTransactionGetSslVersion);
+	sys_http.AddFunc(0x2a78ff04, cellHttpTransactionGetSslId);
+
+	sys_http.AddFunc(0x65691795, cellHttpClientSetSslVersion);
+	sys_http.AddFunc(0xccf57336, cellHttpClientGetSslVersion);
+	sys_http.AddFunc(0x7313c78d, cellHttpClientSetSslIdDestroyCallback);
+}

rpcs3/Emu/SysCalls/Modules/sys_net.cpp

@@ -0,0 +1,400 @@
+#include "stdafx.h"
+#include "Emu/SysCalls/SysCalls.h"
+#include "Emu/SysCalls/SC_FUNC.h"
+
+void sys_net_init();
+Module sys_net((u16)0x0000, sys_net_init);
+
+int accept()
+{
+	UNIMPLEMENTED_FUNC(sys_net);
+	return CELL_OK;
+}
+
+int bind()
+{
+	UNIMPLEMENTED_FUNC(sys_net);
+	return CELL_OK;
+}
+
+int connect()
+{
+	UNIMPLEMENTED_FUNC(sys_net);
+	return CELL_OK;
+}
+
+int gethostbyaddr()
+{
+	UNIMPLEMENTED_FUNC(sys_net);
+	return CELL_OK;
+}
+
+int gethostbyname()
+{
+	UNIMPLEMENTED_FUNC(sys_net);
+	return CELL_OK;
+}
+
+int getpeername()
+{
+	UNIMPLEMENTED_FUNC(sys_net);
+	return CELL_OK;
+}
+
+int getsockname()
+{
+	UNIMPLEMENTED_FUNC(sys_net);
+	return CELL_OK;
+}
+
+int getsockopt()
+{
+	UNIMPLEMENTED_FUNC(sys_net);
+	return CELL_OK;
+}
+
+int inet_addr()
+{
+	UNIMPLEMENTED_FUNC(sys_net);
+	return CELL_OK;
+}
+
+int inet_aton()
+{
+	UNIMPLEMENTED_FUNC(sys_net);
+	return CELL_OK;
+}
+
+int inet_lnaof()
+{
+	UNIMPLEMENTED_FUNC(sys_net);
+	return CELL_OK;
+}
+
+int inet_makeaddr()
+{
+	UNIMPLEMENTED_FUNC(sys_net);
+	return CELL_OK;
+}
+
+int inet_netof()
+{
+	UNIMPLEMENTED_FUNC(sys_net);
+	return CELL_OK;
+}
+
+int inet_network()
+{
+	UNIMPLEMENTED_FUNC(sys_net);
+	return CELL_OK;
+}
+
+int inet_ntoa()
+{
+	UNIMPLEMENTED_FUNC(sys_net);
+	return CELL_OK;
+}
+
+int inet_ntop()
+{
+	UNIMPLEMENTED_FUNC(sys_net);
+	return CELL_OK;
+}
+
+int inet_pton()
+{
+	UNIMPLEMENTED_FUNC(sys_net);
+	return CELL_OK;
+}
+
+int listen()
+{
+	UNIMPLEMENTED_FUNC(sys_net);
+	return CELL_OK;
+}
+
+int recv()
+{
+	UNIMPLEMENTED_FUNC(sys_net);
+	return CELL_OK;
+}
+
+int recvfrom()
+{
+	UNIMPLEMENTED_FUNC(sys_net);
+	return CELL_OK;
+}
+
+int recvmsg()
+{
+	UNIMPLEMENTED_FUNC(sys_net);
+	return CELL_OK;
+}
+
+int send()
+{
+	UNIMPLEMENTED_FUNC(sys_net);
+	return CELL_OK;
+}
+
+int sendmsg()
+{
+	UNIMPLEMENTED_FUNC(sys_net);
+	return CELL_OK;
+}
+
+int sendto()
+{
+	UNIMPLEMENTED_FUNC(sys_net);
+	return CELL_OK;
+}
+
+int setsockopt()
+{
+	UNIMPLEMENTED_FUNC(sys_net);
+	return CELL_OK;
+}
+
+int shutdown()
+{
+	UNIMPLEMENTED_FUNC(sys_net);
+	return CELL_OK;
+}
+
+int socket()
+{
+	UNIMPLEMENTED_FUNC(sys_net);
+	return CELL_OK;
+}
+
+int socketclose()
+{
+	UNIMPLEMENTED_FUNC(sys_net);
+	return CELL_OK;
+}
+
+int socketpoll()
+{
+	UNIMPLEMENTED_FUNC(sys_net);
+	return CELL_OK;
+}
+
+int socketselect()
+{
+	UNIMPLEMENTED_FUNC(sys_net);
+	return CELL_OK;
+}
+
+int sys_net_initialize_network_ex()
+{
+	UNIMPLEMENTED_FUNC(sys_net);
+	return CELL_OK;
+}
+
+int sys_net_get_udpp2p_test_param()
+{
+	UNIMPLEMENTED_FUNC(sys_net);
+	return CELL_OK;
+}
+
+int sys_net_set_udpp2p_test_param()
+{
+	UNIMPLEMENTED_FUNC(sys_net);
+	return CELL_OK;
+}
+
+int sys_net_get_lib_name_server()
+{
+	UNIMPLEMENTED_FUNC(sys_net);
+	return CELL_OK;
+}
+
+int sys_net_if_ctl()
+{
+	UNIMPLEMENTED_FUNC(sys_net);
+	return CELL_OK;
+}
+
+int sys_net_get_netemu_test_param()
+{
+	UNIMPLEMENTED_FUNC(sys_net);
+	return CELL_OK;
+}
+
+int sys_net_get_sockinfo()
+{
+	UNIMPLEMENTED_FUNC(sys_net);
+	return CELL_OK;
+}
+
+int sys_net_close_dump()
+{
+	UNIMPLEMENTED_FUNC(sys_net);
+	return CELL_OK;
+}
+
+int sys_net_set_test_param()
+{
+	UNIMPLEMENTED_FUNC(sys_net);
+	return CELL_OK;
+}
+
+int sys_net_show_nameserver()
+{
+	UNIMPLEMENTED_FUNC(sys_net);
+	return CELL_OK;
+}
+
+int _sys_net_errno_loc()
+{
+	UNIMPLEMENTED_FUNC(sys_net);
+	return CELL_OK;
+}
+
+int sys_net_set_resolver_configurations()
+{
+	UNIMPLEMENTED_FUNC(sys_net);
+	return CELL_OK;
+}
+
+int sys_net_show_route()
+{
+	UNIMPLEMENTED_FUNC(sys_net);
+	return CELL_OK;
+}
+
+int sys_net_read_dump()
+{
+	UNIMPLEMENTED_FUNC(sys_net);
+	return CELL_OK;
+}
+
+int sys_net_abort_resolver()
+{
+	UNIMPLEMENTED_FUNC(sys_net);
+	return CELL_OK;
+}
+
+int sys_net_abort_socket()
+{
+	UNIMPLEMENTED_FUNC(sys_net);
+	return CELL_OK;
+}
+
+int sys_net_set_lib_name_server()
+{
+	UNIMPLEMENTED_FUNC(sys_net);
+	return CELL_OK;
+}
+
+int sys_net_get_test_param()
+{
+	UNIMPLEMENTED_FUNC(sys_net);
+	return CELL_OK;
+}
+
+int sys_net_get_sockinfo_ex()
+{
+	UNIMPLEMENTED_FUNC(sys_net);
+	return CELL_OK;
+}
+
+int sys_net_open_dump()
+{
+	UNIMPLEMENTED_FUNC(sys_net);
+	return CELL_OK;
+}
+
+int sys_net_show_ifconfig()
+{
+	UNIMPLEMENTED_FUNC(sys_net);
+	return CELL_OK;
+}
+
+int sys_net_finalize_network()
+{
+	UNIMPLEMENTED_FUNC(sys_net);
+	return CELL_OK;
+}
+
+int _sys_net_h_errno_loc()
+{
+	UNIMPLEMENTED_FUNC(sys_net);
+	return CELL_OK;
+}
+
+int sys_net_set_netemu_test_param()
+{
+	UNIMPLEMENTED_FUNC(sys_net);
+	return CELL_OK;
+}
+
+int sys_net_free_thread_context()
+{
+	UNIMPLEMENTED_FUNC(sys_net);
+	return CELL_OK;
+}
+
+void sys_net_init()
+{
+	// (TODO: Fix function overloading problem due to winsock.h and find addresses for ntohl and ntohs)
+
+	//sys_net.AddFunc(0xc94f6939, accept);
+	//sys_net.AddFunc(0xb0a59804, bind);
+	//sys_net.AddFunc(0x64f66d35, connect);
+	//sys_net.AddFunc(0xf7ac8941, gethostbyaddr);
+	//sys_net.AddFunc(0x71f4c717, gethostbyname);
+	//sys_net.AddFunc(0xf9ec2db6, getpeername);
+	//sys_net.AddFunc(0x13efe7f5, getsockname);
+	//sys_net.AddFunc(0x5a045bd1, getsockopt);
+	//sys_net.AddFunc(0xdabbc2c0, inet_addr);
+	sys_net.AddFunc(0xa9a079e0, inet_aton);
+	sys_net.AddFunc(0x566893ce, inet_lnaof);
+	sys_net.AddFunc(0xb4152c74, inet_makeaddr);
+	sys_net.AddFunc(0xe39a62a7, inet_netof);
+	sys_net.AddFunc(0x506ad863, inet_network);
+	//sys_net.AddFunc(0x858a930b, inet_ntoa);
+	sys_net.AddFunc(0xc98a3146, inet_ntop);
+	sys_net.AddFunc(0x8af3825e, inet_pton);
+	//sys_net.AddFunc(0x28e208bb, listen);
+	//sys_net.AddFunc(, ntohl);
+	//sys_net.AddFunc(, ntohs);
+	//sys_net.AddFunc(0xfba04f37, recv);
+	//sys_net.AddFunc(0x1f953b9f, recvfrom);
+	sys_net.AddFunc(0xc9d09c34, recvmsg);
+	//sys_net.AddFunc(0xdc751b40, send);
+	sys_net.AddFunc(0xad09481b, sendmsg);
+	//sys_net.AddFunc(0x9647570b, sendto);
+	//sys_net.AddFunc(0x88f03575, setsockopt);
+	//sys_net.AddFunc(0xa50777c6, shutdown);
+	//sys_net.AddFunc(0x9c056962, socket);
+	sys_net.AddFunc(0x6db6e8cd, socketclose);
+	sys_net.AddFunc(0x051ee3ee, socketpoll);
+	sys_net.AddFunc(0x3f09e20a, socketselect);
+
+	sys_net.AddFunc(0x139a9e9b, sys_net_initialize_network_ex);
+	sys_net.AddFunc(0x05bd4438, sys_net_get_udpp2p_test_param);
+	sys_net.AddFunc(0x10b81ed6, sys_net_set_udpp2p_test_param);
+	sys_net.AddFunc(0x1d14d6e4, sys_net_get_lib_name_server);
+	sys_net.AddFunc(0x27fb339d, sys_net_if_ctl);
+	sys_net.AddFunc(0x368823c0, sys_net_get_netemu_test_param);
+	sys_net.AddFunc(0x3b27c780, sys_net_get_sockinfo);
+	sys_net.AddFunc(0x44328aa2, sys_net_close_dump);
+	sys_net.AddFunc(0x4ab0b9b9, sys_net_set_test_param);
+	sys_net.AddFunc(0x5420e419, sys_net_show_nameserver);
+	sys_net.AddFunc(0x6005cde1, _sys_net_errno_loc);
+	sys_net.AddFunc(0x7687d48c, sys_net_set_resolver_configurations);
+	sys_net.AddFunc(0x79b61646, sys_net_show_route);
+	sys_net.AddFunc(0x89c9917c, sys_net_read_dump);
+	sys_net.AddFunc(0x8ccf05ed, sys_net_abort_resolver);
+	sys_net.AddFunc(0x8d1b77fb, sys_net_abort_socket);
+	sys_net.AddFunc(0x9a318259, sys_net_set_lib_name_server);
+	sys_net.AddFunc(0xa5a86557, sys_net_get_test_param);
+	sys_net.AddFunc(0xa765d029, sys_net_get_sockinfo_ex);
+	sys_net.AddFunc(0xab447704, sys_net_open_dump);
+	sys_net.AddFunc(0xb48636c4, sys_net_show_ifconfig);
+	sys_net.AddFunc(0xb68d5625, sys_net_finalize_network);
+	sys_net.AddFunc(0xc9157d30, _sys_net_h_errno_loc);
+	sys_net.AddFunc(0xe2434507, sys_net_set_netemu_test_param);
+	sys_net.AddFunc(0xfdb8f926, sys_net_free_thread_context);
+}

rpcs3/Emu/SysCalls/SysCalls.h

@@ -224,24 +224,24 @@ extern int cellKbInit(u32 max_connect);
 extern int cellKbEnd();
 extern int cellKbClearBuf(u32 port_no);
 extern u16 cellKbCnvRawCode(u32 arrange, u32 mkey, u32 led, u16 rawcode);
-extern int cellKbGetInfo(u32 info_addr);
-extern int cellKbRead(u32 port_no, u32 data_addr);
+extern int cellKbGetInfo(mem_class_t info);
+extern int cellKbRead(u32 port_no, mem_class_t data);
 extern int cellKbSetCodeType(u32 port_no, u32 type);
 extern int cellKbSetLEDStatus(u32 port_no, u8 led);
 extern int cellKbSetReadMode(u32 port_no, u32 rmode);
-extern int cellKbGetConfiguration(u32 port_no, u32 config_addr);
+extern int cellKbGetConfiguration(u32 port_no, mem_class_t config);
 
 //cellMouse
 extern int cellMouseInit(u32 max_connect);
 extern int cellMouseClearBuf(u32 port_no);
 extern int cellMouseEnd();
-extern int cellMouseGetInfo(u32 info_addr);
-extern int cellMouseInfoTabletMode(u32 port_no, u32 info_addr);
-extern int cellMouseGetData(u32 port_no, u32 data_addr);
-extern int cellMouseGetDataList(u32 port_no, u32 data_addr);
+extern int cellMouseGetInfo(mem_class_t info);
+extern int cellMouseInfoTabletMode(u32 port_no, mem_class_t info);
+extern int cellMouseGetData(u32 port_no, mem_class_t data);
+extern int cellMouseGetDataList(u32 port_no, mem_class_t data);
 extern int cellMouseSetTabletMode(u32 port_no, u32 mode);
-extern int cellMouseGetTabletDataList(u32 port_no, u32 data_addr);
-extern int cellMouseGetRawData(u32 port_no, u32 data_addr);
+extern int cellMouseGetTabletDataList(u32 port_no, mem_class_t data);
+extern int cellMouseGetRawData(u32 port_no, mem_class_t data);
 
 //cellGcm
 extern int cellGcmCallback(u32 context_addr, u32 count);

rpcs3/Emu/SysCalls/lv2/SC_Keyboard.cpp

@@ -93,13 +93,12 @@ u16 cellKbCnvRawCode(u32 arrange, u32 mkey, u32 led, u16 rawcode)
 	return 0x0000;
 }
 
-int cellKbGetInfo(u32 info_addr)
+int cellKbGetInfo(mem_class_t info)
 {
-	sys_io.Log("cellKbGetInfo(info_addr=0x%x)", info_addr);
+	sys_io.Log("cellKbGetInfo(info_addr=0x%x)", info.GetAddr());
 	if(!Emu.GetKeyboardManager().IsInited()) return CELL_KB_ERROR_UNINITIALIZED;
 
 	const KbInfo& current_info = Emu.GetKeyboardManager().GetInfo();
-	mem_class_t info(info_addr);
 	info += current_info.max_connect;
 	info += current_info.now_connect;
 	info += current_info.info;
@@ -111,17 +110,15 @@ int cellKbGetInfo(u32 info_addr)
 	return CELL_OK;
 }
 
-int cellKbRead(u32 port_no, u32 data_addr)
+int cellKbRead(u32 port_no, mem_class_t data)
 {
-	sys_io.Log("cellKbRead(port_no=%d,info_addr=0x%x)", port_no, data_addr);
+	sys_io.Log("cellKbRead(port_no=%d,info_addr=0x%x)", port_no, data.GetAddr());
 
 	const Array<Keyboard>& keyboards = Emu.GetKeyboardManager().GetKeyboards();
 	if(!Emu.GetKeyboardManager().IsInited()) return CELL_KB_ERROR_UNINITIALIZED;
 	if(port_no >= keyboards.GetCount()) return CELL_KB_ERROR_INVALID_PARAMETER;
 
 	CellKbData& current_data = Emu.GetKeyboardManager().GetData(port_no);
-		
-	mem_class_t data(data_addr);
 	data += current_data.led;
 	data += current_data.mkey;
 	data += min((u32)current_data.len, CELL_KB_MAX_KEYCODES);
@@ -162,13 +159,12 @@ int cellKbSetReadMode(u32 port_no, u32 rmode)
 	return CELL_OK;
 }
 
-int cellKbGetConfiguration(u32 port_no, u32 config_addr)
+int cellKbGetConfiguration(u32 port_no, mem_class_t config)
 {
-	sys_io.Log("cellKbGetConfiguration(port_no=%d,config_addr=0x%x)", port_no, config_addr);
+	sys_io.Log("cellKbGetConfiguration(port_no=%d,config_addr=0x%x)", port_no, config.GetAddr());
 	if(!Emu.GetKeyboardManager().IsInited()) return CELL_KB_ERROR_UNINITIALIZED;
 
 	const CellKbConfig& current_config = Emu.GetKeyboardManager().GetConfig(port_no);
-	mem_class_t config(config_addr);
 	config += current_config.arrange;
 	config += current_config.read_mode;
 	config += current_config.code_type;

rpcs3/Emu/SysCalls/lv2/SC_Mouse.cpp

@@ -46,13 +46,12 @@ int cellMouseEnd()
 	return CELL_OK;
 }
 
-int cellMouseGetInfo(u32 info_addr)
+int cellMouseGetInfo(mem_class_t info)
 {
-	sys_io.Log("cellMouseGetInfo(info_addr=0x%x)", info_addr);
+	sys_io.Log("cellMouseGetInfo(info_addr=0x%x)", info.GetAddr());
 	if(!Emu.GetMouseManager().IsInited()) return CELL_MOUSE_ERROR_UNINITIALIZED;
 
 	const MouseInfo& current_info = Emu.GetMouseManager().GetInfo();
-	mem_class_t info(info_addr);
 	info += current_info.max_connect;
 	info += current_info.now_connect;
 	info += current_info.info;
@@ -63,27 +62,25 @@ int cellMouseGetInfo(u32 info_addr)
 	return CELL_OK;
 }
 
-int cellMouseInfoTabletMode(u32 port_no, u32 info_addr)
+int cellMouseInfoTabletMode(u32 port_no, mem_class_t info)
 {
-	sys_io.Log("cellMouseInfoTabletMode(port_no=%d,info_addr=0x%x)", port_no,info_addr);
+	sys_io.Log("cellMouseInfoTabletMode(port_no=%d,info_addr=0x%x)", port_no, info.GetAddr());
 	if(!Emu.GetMouseManager().IsInited()) return CELL_MOUSE_ERROR_UNINITIALIZED;
 	if(port_no >= Emu.GetMouseManager().GetMice().GetCount()) return CELL_MOUSE_ERROR_INVALID_PARAMETER;
 
-	mem_class_t info(info_addr);
 	info += 0;		// Unimplemented: (0=Tablet mode is not supported)
 	info += 1;		// Unimplemented: (1=Mouse mode)
 	
 	return CELL_OK;
 }
 
-int cellMouseGetData(u32 port_no, u32 data_addr)
+int cellMouseGetData(u32 port_no, mem_class_t data)
 {
-	sys_io.Log("cellMouseGetData(port_no=%d,data_addr=0x%x)", port_no,data_addr);
+	sys_io.Log("cellMouseGetData(port_no=%d,data_addr=0x%x)", port_no, data.GetAddr());
 	if(!Emu.GetMouseManager().IsInited()) return CELL_MOUSE_ERROR_UNINITIALIZED;
 	if(port_no >= Emu.GetMouseManager().GetMice().GetCount()) return CELL_MOUSE_ERROR_NO_DEVICE;
 	
 	CellMouseData& current_data = Emu.GetMouseManager().GetData(port_no);
-	mem_class_t data(data_addr);
 	data += current_data.update;
 	data += current_data.buttons;
 	data += current_data.x_axis;
@@ -99,7 +96,7 @@ int cellMouseGetData(u32 port_no, u32 data_addr)
 	return CELL_OK;
 }
 
-int cellMouseGetDataList(u32 port_no, u32 data_addr)
+int cellMouseGetDataList(u32 port_no, mem_class_t data)
 {
 	UNIMPLEMENTED_FUNC(sys_io);
 	
@@ -113,23 +110,22 @@ int cellMouseSetTabletMode(u32 port_no, u32 mode)
 	return CELL_OK;
 }
 
-int cellMouseGetTabletDataList(u32 port_no, u32 data_addr)
+int cellMouseGetTabletDataList(u32 port_no, mem_class_t data)
 {
 	UNIMPLEMENTED_FUNC(sys_io);
 	
 	return CELL_OK;
 }
 
-int cellMouseGetRawData(u32 port_no, u32 data_addr)
+int cellMouseGetRawData(u32 port_no, mem_class_t data)
 {
 	UNIMPLEMENTED_FUNC(sys_io);
 
-	/*sys_io.Log("cellMouseGetRawData(port_no=%d,data_addr=0x%x)", port_no,data_addr);
+	/*sys_io.Log("cellMouseGetRawData(port_no=%d,data_addr=0x%x)", port_no, data.GetAddr());
 	if(!Emu.GetMouseManager().IsInited()) return CELL_MOUSE_ERROR_UNINITIALIZED;
 	if(port_no >= Emu.GetMouseManager().GetMice().GetCount()) return CELL_MOUSE_ERROR_NO_DEVICE;
 
 	CellMouseRawData& current_rawdata = Emu.GetMouseManager().GetRawData(port_no);
-	mem_class_t data(data_addr);
 	data += current_rawdata.len;
 	for(s32 i=0; i<current_rawdata.len; i++)
 	{