diff --git a/rpcs3/Emu/SysCalls/Modules/cellAdec.cpp b/rpcs3/Emu/SysCalls/Modules/cellAdec.cpp new file mode 100644 index 0000000000..e24f361c62 --- /dev/null +++ b/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); +} \ No newline at end of file diff --git a/rpcs3/Emu/SysCalls/Modules/cellAtrac.cpp b/rpcs3/Emu/SysCalls/Modules/cellAtrac.cpp new file mode 100644 index 0000000000..c29f7b1038 --- /dev/null +++ b/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); +} \ No newline at end of file diff --git a/rpcs3/Emu/SysCalls/Modules/cellBgdl.cpp b/rpcs3/Emu/SysCalls/Modules/cellBgdl.cpp new file mode 100644 index 0000000000..4738bc2e25 --- /dev/null +++ b/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); +} \ No newline at end of file diff --git a/rpcs3/Emu/SysCalls/Modules/cellCamera.cpp b/rpcs3/Emu/SysCalls/Modules/cellCamera.cpp new file mode 100644 index 0000000000..691f74e691 --- /dev/null +++ b/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); +} \ No newline at end of file diff --git a/rpcs3/Emu/SysCalls/Modules/cellCelp8Enc.cpp b/rpcs3/Emu/SysCalls/Modules/cellCelp8Enc.cpp new file mode 100644 index 0000000000..c6cf243dc2 --- /dev/null +++ b/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); +} \ No newline at end of file diff --git a/rpcs3/Emu/SysCalls/Modules/cellCelpEnc.cpp b/rpcs3/Emu/SysCalls/Modules/cellCelpEnc.cpp new file mode 100644 index 0000000000..ed476c84ba --- /dev/null +++ b/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); +} \ No newline at end of file diff --git a/rpcs3/Emu/SysCalls/Modules/cellDmux.cpp b/rpcs3/Emu/SysCalls/Modules/cellDmux.cpp new file mode 100644 index 0000000000..fa523aa9f2 --- /dev/null +++ b/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); +} \ No newline at end of file diff --git a/rpcs3/Emu/SysCalls/Modules/cellFiber.cpp b/rpcs3/Emu/SysCalls/Modules/cellFiber.cpp new file mode 100644 index 0000000000..efe6327166 --- /dev/null +++ b/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); +} \ No newline at end of file diff --git a/rpcs3/Emu/SysCalls/Modules/cellGame.cpp b/rpcs3/Emu/SysCalls/Modules/cellGame.cpp new file mode 100644 index 0000000000..1f1d800dab --- /dev/null +++ b/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); +} \ No newline at end of file diff --git a/rpcs3/Emu/SysCalls/Modules/cellGem.cpp b/rpcs3/Emu/SysCalls/Modules/cellGem.cpp new file mode 100644 index 0000000000..af3bf7c259 --- /dev/null +++ b/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); + +} \ No newline at end of file diff --git a/rpcs3/Emu/SysCalls/Modules/cellImejp.cpp b/rpcs3/Emu/SysCalls/Modules/cellImejp.cpp new file mode 100644 index 0000000000..150c97db13 --- /dev/null +++ b/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); +} \ No newline at end of file diff --git a/rpcs3/Emu/SysCalls/Modules/cellJpgEnc.cpp b/rpcs3/Emu/SysCalls/Modules/cellJpgEnc.cpp new file mode 100644 index 0000000000..f6d9fd980f --- /dev/null +++ b/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); +} \ No newline at end of file diff --git a/rpcs3/Emu/SysCalls/Modules/cellKey2char.cpp b/rpcs3/Emu/SysCalls/Modules/cellKey2char.cpp new file mode 100644 index 0000000000..bb85fcdb7a --- /dev/null +++ b/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); +} \ No newline at end of file diff --git a/rpcs3/Emu/SysCalls/Modules/cellL10n.cpp b/rpcs3/Emu/SysCalls/Modules/cellL10n.cpp new file mode 100644 index 0000000000..6989f8b8b5 --- /dev/null +++ b/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) +} \ No newline at end of file diff --git a/rpcs3/Emu/SysCalls/Modules/cellLv2dbg.cpp b/rpcs3/Emu/SysCalls/Modules/cellLv2dbg.cpp new file mode 100644 index 0000000000..e644dc1e5f --- /dev/null +++ b/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); +} \ No newline at end of file diff --git a/rpcs3/Emu/SysCalls/Modules/cellMic.cpp b/rpcs3/Emu/SysCalls/Modules/cellMic.cpp new file mode 100644 index 0000000000..195371e493 --- /dev/null +++ b/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); +} \ No newline at end of file diff --git a/rpcs3/Emu/SysCalls/Modules/cellMusicDecode.cpp b/rpcs3/Emu/SysCalls/Modules/cellMusicDecode.cpp new file mode 100644 index 0000000000..82b97f07ce --- /dev/null +++ b/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); +} \ No newline at end of file diff --git a/rpcs3/Emu/SysCalls/Modules/cellMusicExport.cpp b/rpcs3/Emu/SysCalls/Modules/cellMusicExport.cpp new file mode 100644 index 0000000000..d047287b3a --- /dev/null +++ b/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); +} \ No newline at end of file diff --git a/rpcs3/Emu/SysCalls/Modules/cellNetCtl.cpp b/rpcs3/Emu/SysCalls/Modules/cellNetCtl.cpp new file mode 100644 index 0000000000..9dc8a2364b --- /dev/null +++ b/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); +} \ No newline at end of file diff --git a/rpcs3/Emu/SysCalls/Modules/cellOvis.cpp b/rpcs3/Emu/SysCalls/Modules/cellOvis.cpp new file mode 100644 index 0000000000..a747c07951 --- /dev/null +++ b/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); +} \ No newline at end of file diff --git a/rpcs3/Emu/SysCalls/Modules/cellPamf.cpp b/rpcs3/Emu/SysCalls/Modules/cellPamf.cpp new file mode 100644 index 0000000000..0988d8a439 --- /dev/null +++ b/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); +} \ No newline at end of file diff --git a/rpcs3/Emu/SysCalls/Modules/cellPhotoDecode.cpp b/rpcs3/Emu/SysCalls/Modules/cellPhotoDecode.cpp new file mode 100644 index 0000000000..b0973a3e55 --- /dev/null +++ b/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); +} \ No newline at end of file diff --git a/rpcs3/Emu/SysCalls/Modules/cellPhotoExport.cpp b/rpcs3/Emu/SysCalls/Modules/cellPhotoExport.cpp new file mode 100644 index 0000000000..fb4d4d8d61 --- /dev/null +++ b/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); +} \ No newline at end of file diff --git a/rpcs3/Emu/SysCalls/Modules/cellPhotoImport.cpp b/rpcs3/Emu/SysCalls/Modules/cellPhotoImport.cpp new file mode 100644 index 0000000000..f4f25ff488 --- /dev/null +++ b/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); +} \ No newline at end of file diff --git a/rpcs3/Emu/SysCalls/Modules/cellPngEnc.cpp b/rpcs3/Emu/SysCalls/Modules/cellPngEnc.cpp new file mode 100644 index 0000000000..730f193559 --- /dev/null +++ b/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); +} \ No newline at end of file diff --git a/rpcs3/Emu/SysCalls/Modules/cellPrint.cpp b/rpcs3/Emu/SysCalls/Modules/cellPrint.cpp new file mode 100644 index 0000000000..bc8ac442dc --- /dev/null +++ b/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); +} \ No newline at end of file diff --git a/rpcs3/Emu/SysCalls/Modules/cellRtc.cpp b/rpcs3/Emu/SysCalls/Modules/cellRtc.cpp new file mode 100644 index 0000000000..018287e977 --- /dev/null +++ b/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); +} \ No newline at end of file diff --git a/rpcs3/Emu/SysCalls/Modules/cellRudp.cpp b/rpcs3/Emu/SysCalls/Modules/cellRudp.cpp new file mode 100644 index 0000000000..323229921c --- /dev/null +++ b/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); +} \ No newline at end of file diff --git a/rpcs3/Emu/SysCalls/Modules/cellSail.cpp b/rpcs3/Emu/SysCalls/Modules/cellSail.cpp new file mode 100644 index 0000000000..08c005ee3e --- /dev/null +++ b/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); +} \ No newline at end of file diff --git a/rpcs3/Emu/SysCalls/Modules/cellSailRec.cpp b/rpcs3/Emu/SysCalls/Modules/cellSailRec.cpp new file mode 100644 index 0000000000..759008f903 --- /dev/null +++ b/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); +} \ No newline at end of file diff --git a/rpcs3/Emu/SysCalls/Modules/cellScreenshot.cpp b/rpcs3/Emu/SysCalls/Modules/cellScreenshot.cpp new file mode 100644 index 0000000000..f7e3f3f503 --- /dev/null +++ b/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); +} \ No newline at end of file diff --git a/rpcs3/Emu/SysCalls/Modules/cellSearch.cpp b/rpcs3/Emu/SysCalls/Modules/cellSearch.cpp new file mode 100644 index 0000000000..a258f7eac7 --- /dev/null +++ b/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); +} \ No newline at end of file diff --git a/rpcs3/Emu/SysCalls/Modules/cellSheap.cpp b/rpcs3/Emu/SysCalls/Modules/cellSheap.cpp new file mode 100644 index 0000000000..7b86225d4e --- /dev/null +++ b/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); +} \ No newline at end of file diff --git a/rpcs3/Emu/SysCalls/Modules/cellSubdisplay.cpp b/rpcs3/Emu/SysCalls/Modules/cellSubdisplay.cpp new file mode 100644 index 0000000000..3d6ac0b2f9 --- /dev/null +++ b/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); +} \ No newline at end of file diff --git a/rpcs3/Emu/SysCalls/Modules/cellSync2.cpp b/rpcs3/Emu/SysCalls/Modules/cellSync2.cpp new file mode 100644 index 0000000000..ad4d219277 --- /dev/null +++ b/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); +} \ No newline at end of file diff --git a/rpcs3/Emu/SysCalls/Modules/cellSysutilAp.cpp b/rpcs3/Emu/SysCalls/Modules/cellSysutilAp.cpp new file mode 100644 index 0000000000..1aafba7138 --- /dev/null +++ b/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); +} \ No newline at end of file diff --git a/rpcs3/Emu/SysCalls/Modules/cellUsbd.cpp b/rpcs3/Emu/SysCalls/Modules/cellUsbd.cpp new file mode 100644 index 0000000000..2fb0b67e70 --- /dev/null +++ b/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); +} \ No newline at end of file diff --git a/rpcs3/Emu/SysCalls/Modules/cellUsbpspcm.cpp b/rpcs3/Emu/SysCalls/Modules/cellUsbpspcm.cpp new file mode 100644 index 0000000000..0d8195cac3 --- /dev/null +++ b/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); +} \ No newline at end of file diff --git a/rpcs3/Emu/SysCalls/Modules/cellVdec.cpp b/rpcs3/Emu/SysCalls/Modules/cellVdec.cpp new file mode 100644 index 0000000000..794d962251 --- /dev/null +++ b/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); +} \ No newline at end of file diff --git a/rpcs3/Emu/SysCalls/Modules/cellVoice.cpp b/rpcs3/Emu/SysCalls/Modules/cellVoice.cpp new file mode 100644 index 0000000000..a6ee0abd85 --- /dev/null +++ b/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); +} \ No newline at end of file diff --git a/rpcs3/Emu/SysCalls/Modules/cellVpost.cpp b/rpcs3/Emu/SysCalls/Modules/cellVpost.cpp new file mode 100644 index 0000000000..27113ad092 --- /dev/null +++ b/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); +} \ No newline at end of file diff --git a/rpcs3/rpcs3.vcxproj b/rpcs3/rpcs3.vcxproj index 5e0366b69d..893c671409 100644 --- a/rpcs3/rpcs3.vcxproj +++ b/rpcs3/rpcs3.vcxproj @@ -250,18 +250,14 @@ - - - - diff --git a/rpcs3/rpcs3.vcxproj.filters b/rpcs3/rpcs3.vcxproj.filters index ffab6ca23c..1606f87a8a 100644 --- a/rpcs3/rpcs3.vcxproj.filters +++ b/rpcs3/rpcs3.vcxproj.filters @@ -307,18 +307,6 @@ Emu\SysCalls\lv2 - - Emu\SysCalls\Modules - - - Emu\SysCalls\Modules - - - Emu\SysCalls\Modules - - - Emu\SysCalls\Modules -