From 1a85ccbbf423ea062ae7fc41c7444bb65b945d91 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Alexandro=20S=C3=A1nchez=20Bach?= Date: Wed, 25 Sep 2013 15:43:55 +0200 Subject: [PATCH 1/4] Improved image dec. modules & New dummy modules * Improved image decoding modules: - Fixed error that appeared after last commit (eebe859f83). - Changed some functions to use the mem*_t classes. - Implemented cell*DecSetParameter. * Created new dummy modules for sys_net (0x0000), sys_http (0x0001), cellHttpUtil (0x0002) and cellSsl (0x0003). --- rpcs3/Emu/SysCalls/Modules/cellGifDec.cpp | 105 +-- rpcs3/Emu/SysCalls/Modules/cellHttpUtil.cpp | 153 +++++ rpcs3/Emu/SysCalls/Modules/cellJpgDec.cpp | 109 +-- rpcs3/Emu/SysCalls/Modules/cellPngDec.cpp | 116 ++-- rpcs3/Emu/SysCalls/Modules/cellSsl.cpp | 110 +++ rpcs3/Emu/SysCalls/Modules/sys_http.cpp | 704 ++++++++++++++++++++ rpcs3/Emu/SysCalls/Modules/sys_net.cpp | 400 +++++++++++ rpcs3/rpcs3.vcxproj | 4 + rpcs3/rpcs3.vcxproj.filters | 12 + 9 files changed, 1589 insertions(+), 124 deletions(-) create mode 100644 rpcs3/Emu/SysCalls/Modules/cellHttpUtil.cpp create mode 100644 rpcs3/Emu/SysCalls/Modules/cellSsl.cpp create mode 100644 rpcs3/Emu/SysCalls/Modules/sys_http.cpp create mode 100644 rpcs3/Emu/SysCalls/Modules/sys_net.cpp diff --git a/rpcs3/Emu/SysCalls/Modules/cellGifDec.cpp b/rpcs3/Emu/SysCalls/Modules/cellGifDec.cpp index b8175f944c..0f0b8da426 100644 --- a/rpcs3/Emu/SysCalls/Modules/cellGifDec.cpp +++ b/rpcs3/Emu/SysCalls/Modules/cellGifDec.cpp @@ -74,12 +74,10 @@ struct CellGifDecSubHandle //Custom struct { u32 fd; u64 fileSize; - CellGifDecInParam inParam; + CellGifDecInfo info; + CellGifDecOutParam outParam; }; -CellGifDecInfo current_info; -CellGifDecSrc current_src; - int cellGifDecCreate(u32 mainHandle, u32 threadInParam, u32 threadOutParam) { @@ -93,47 +91,50 @@ int cellGifDecExtCreate(u32 mainHandle, u32 threadInParam, u32 threadOutParam, u return CELL_OK; } -int cellGifDecOpen(u32 mainHandle, u32 subHandle_addr, u32 src_addr, u32 openInfo) +int cellGifDecOpen(u32 mainHandle, mem32_t subHandle, u32 src_addr, u32 openInfo) { - //current_src.srcSelect = Memory.Read32(src_addr); - current_src.fileName = Memory.Read32(src_addr+4); - //current_src.fileOffset = Memory.Read32(src_addr+8); - //current_src.fileSize = Memory.Read32(src_addr+12); - //current_src.streamPtr = Memory.Read32(src_addr+16); - //current_src.streamSize = Memory.Read32(src_addr+20); - //current_src.spuThreadEnable = Memory.Read32(src_addr+24); + //u32 srcSelect = Memory.Read32(src_addr); + u32 fileName = Memory.Read32(src_addr+4); + //u64 fileOffset = Memory.Read32(src_addr+8); + //u32 fileSize = Memory.Read32(src_addr+12); + //u32 streamPtr = Memory.Read32(src_addr+16); + //u32 streamSize = Memory.Read32(src_addr+20); + //u32 spuThreadEnable = Memory.Read32(src_addr+24); - CellGifDecSubHandle *subHandle = new CellGifDecSubHandle; + CellGifDecSubHandle *current_subHandle = new CellGifDecSubHandle; // Get file descriptor u32 fd_addr = Memory.Alloc(sizeof(u32), 1); - int ret = cellFsOpen(current_src.fileName, 0, fd_addr, NULL, 0); - subHandle->fd = Memory.Read32(fd_addr); + int ret = cellFsOpen(fileName, 0, fd_addr, NULL, 0); + current_subHandle->fd = Memory.Read32(fd_addr); Memory.Free(fd_addr); if(ret != 0) return CELL_GIFDEC_ERROR_OPEN_FILE; // Get size of file u32 sb_addr = Memory.Alloc(52,1); // Alloc a CellFsStat struct - cellFsFstat(subHandle->fd, sb_addr); - subHandle->fileSize = Memory.Read64(sb_addr+36); // Get CellFsStat.st_size + cellFsFstat(current_subHandle->fd, sb_addr); + current_subHandle->fileSize = Memory.Read64(sb_addr+36); // Get CellFsStat.st_size Memory.Free(sb_addr); // From now, every u32 subHandle argument is a pointer to a CellPngDecSubHandle struct. - Memory.Write32(subHandle_addr, (u32)subHandle); + subHandle += (u32)current_subHandle; return CELL_OK; } -int cellGifDecReadHeader(u32 mainHandle, u32 subHandle, u32 info_addr) +int cellGifDecReadHeader(u32 mainHandle, u32 subHandle, mem_class_t info) { const u32& fd = ((CellGifDecSubHandle*)subHandle)->fd; const u64& fileSize = ((CellGifDecSubHandle*)subHandle)->fileSize; + CellGifDecInfo& current_info = ((CellGifDecSubHandle*)subHandle)->info; //Write the header to buffer u32 buffer = Memory.Alloc(13,1); // Alloc buffer for GIF header + u32 nread = Memory.Alloc(8,1); u32 pos_addr = Memory.Alloc(8,1); cellFsLseek(fd, 0, 0, pos_addr); - cellFsRead(fd, buffer, 13, NULL); + cellFsRead(fd, buffer, 13, nread); + Memory.Free(nread); Memory.Free(pos_addr); if (Memory.Read32(buffer) != 0x47494638 || @@ -154,7 +155,6 @@ int cellGifDecReadHeader(u32 mainHandle, u32 subHandle, u32 info_addr) current_info.SBackGroundColor = Memory.Read8(buffer+11); current_info.SPixelAspectRatio = Memory.Read8(buffer+12); - mem_class_t info(info_addr); info += current_info.SWidth; info += current_info.SHeight; info += current_info.SGlobalColorTableFlag; @@ -168,27 +168,48 @@ int cellGifDecReadHeader(u32 mainHandle, u32 subHandle, u32 info_addr) return CELL_OK; } -int cellGifDecSetParameter(u32 mainHandle, u32 subHandle, u32 inParam_addr, u32 outParam_addr) +int cellGifDecSetParameter(u32 mainHandle, u32 subHandle, u32 inParam_addr, mem_class_t outParam) { - CellGifDecInParam& inParam = ((CellGifDecSubHandle*)subHandle)->inParam; - inParam.colorSpace = Memory.Read32(inParam_addr+4); + CellGifDecInfo& current_info = ((CellGifDecSubHandle*)subHandle)->info; + CellGifDecOutParam& current_outParam = ((CellGifDecSubHandle*)subHandle)->outParam; + + current_outParam.outputWidthByte = (current_info.SWidth * current_info.SColorResolution * 3)/8; + current_outParam.outputWidth = current_info.SWidth; + current_outParam.outputHeight = current_info.SHeight; + current_outParam.outputColorSpace = Memory.Read32(inParam_addr+4); + switch (current_outParam.outputColorSpace) + { + case CELL_GIFDEC_RGBA: current_outParam.outputComponents = 4; break; + case CELL_GIFDEC_ARGB: current_outParam.outputComponents = 4; break; + default: return CELL_GIFDEC_ERROR_ARG; // Not supported color space + } + current_outParam.outputBitDepth = 0; // Unimplemented + current_outParam.useMemorySpace = 0; // Unimplemented - // (TODO) + outParam += current_outParam.outputWidthByte; + outParam += current_outParam.outputWidth; + outParam += current_outParam.outputHeight; + outParam += current_outParam.outputComponents; + outParam += current_outParam.outputBitDepth; + outParam += current_outParam.outputColorSpace; + outParam += current_outParam.useMemorySpace; return CELL_OK; } -int cellGifDecDecodeData(u32 mainHandle, u32 subHandle, u32 data_addr, u32 dataCtrlParam_addr, u32 dataOutInfo_addr) +int cellGifDecDecodeData(u32 mainHandle, u32 subHandle, mem8_ptr_t data, u32 dataCtrlParam_addr, mem_class_t dataOutInfo) { const u32& fd = ((CellGifDecSubHandle*)subHandle)->fd; const u64& fileSize = ((CellGifDecSubHandle*)subHandle)->fileSize; - const CellGifDecInParam& inParam = ((CellGifDecSubHandle*)subHandle)->inParam; // (TODO: We should use the outParam) + const CellGifDecOutParam& current_outParam = ((CellGifDecSubHandle*)subHandle)->outParam; // (TODO: We should use the outParam) //Copy the GIF file to a buffer u32 buffer = Memory.Alloc(fileSize,1); + u32 nread = Memory.Alloc(8,1); u32 pos_addr = Memory.Alloc(8,1); cellFsLseek(fd, 0, 0, pos_addr); - cellFsRead(fd, buffer, fileSize, NULL); + cellFsRead(fd, buffer, fileSize, nread); + Memory.Free(nread); Memory.Free(pos_addr); //Decode GIF file. (TODO: Is there any faster alternative? Can we do it without external libraries?) @@ -199,29 +220,27 @@ int cellGifDecDecodeData(u32 mainHandle, u32 subHandle, u32 data_addr, u32 dataC if (!image) return CELL_GIFDEC_ERROR_STREAM_FORMAT; u32 image_size = width * height * 4; - if (inParam.colorSpace == CELL_GIFDEC_RGBA){ + if (current_outParam.outputColorSpace == CELL_GIFDEC_RGBA){ for(u32 i = 0; i < image_size; i+=4){ - Memory.Write8(data_addr+i+0, image[i+0]); - Memory.Write8(data_addr+i+1, image[i+1]); - Memory.Write8(data_addr+i+2, image[i+2]); - Memory.Write8(data_addr+i+3, image[i+3]); + data += image[i+0]; + data += image[i+1]; + data += image[i+2]; + data += image[i+3]; } } - if (inParam.colorSpace == CELL_GIFDEC_ARGB){ + if (current_outParam.outputColorSpace == CELL_GIFDEC_ARGB){ for(u32 i = 0; i < image_size; i+=4){ - Memory.Write8(data_addr+i+0, image[i+3]); - Memory.Write8(data_addr+i+1, image[i+0]); - Memory.Write8(data_addr+i+2, image[i+1]); - Memory.Write8(data_addr+i+3, image[i+2]); + data += image[i+3]; + data += image[i+0]; + data += image[i+1]; + data += image[i+2]; } } delete[] image; - //The output data is an image (dataOutInfo.recordType = 1) - Memory.Write32(dataOutInfo_addr, 1); - - u32 outExtensionData_addr = Memory.Alloc(20,1); // (TODO: Is this the best way to avoid exceptions when trying to access this data? Will this produce a memory leak?) - Memory.Write32(dataOutInfo_addr+8, outExtensionData_addr); + dataOutInfo += (u32)1; // The output data is an image (dataOutInfo.recordType = 1) + dataOutInfo += (u32)0; // outExtension.label = 0 + dataOutInfo += Memory.Alloc(20,1); // outExtension.data allocated (TODO: Is this the best way to avoid exceptions when trying to access this data? Will this produce a memory leak?) return CELL_OK; } diff --git a/rpcs3/Emu/SysCalls/Modules/cellHttpUtil.cpp b/rpcs3/Emu/SysCalls/Modules/cellHttpUtil.cpp new file mode 100644 index 0000000000..c5ddea4b0a --- /dev/null +++ b/rpcs3/Emu/SysCalls/Modules/cellHttpUtil.cpp @@ -0,0 +1,153 @@ +#include "stdafx.h" +#include "Emu/SysCalls/SysCalls.h" +#include "Emu/SysCalls/SC_FUNC.h" + +void cellHttpUtil_init(); +Module cellHttpUtil(0x0002, cellHttpUtil_init); + +int cellHttpUtilParseUri() +{ + UNIMPLEMENTED_FUNC(cellHttpUtil); + return CELL_OK; +} + +int cellHttpUtilParseUriPath() +{ + UNIMPLEMENTED_FUNC(cellHttpUtil); + return CELL_OK; +} + +int cellHttpUtilParseProxy() +{ + UNIMPLEMENTED_FUNC(cellHttpUtil); + return CELL_OK; +} + +int cellHttpUtilParseStatusLine() +{ + UNIMPLEMENTED_FUNC(cellHttpUtil); + return CELL_OK; +} + +int cellHttpUtilParseHeader() +{ + UNIMPLEMENTED_FUNC(cellHttpUtil); + return CELL_OK; +} + +int cellHttpUtilBuildRequestLine() +{ + UNIMPLEMENTED_FUNC(cellHttpUtil); + return CELL_OK; +} + +int cellHttpUtilBuildHeader() +{ + UNIMPLEMENTED_FUNC(cellHttpUtil); + return CELL_OK; +} + +int cellHttpUtilBuildUri() +{ + UNIMPLEMENTED_FUNC(cellHttpUtil); + return CELL_OK; +} + +int cellHttpUtilCopyUri() +{ + UNIMPLEMENTED_FUNC(cellHttpUtil); + return CELL_OK; +} + +int cellHttpUtilMergeUriPath() +{ + UNIMPLEMENTED_FUNC(cellHttpUtil); + return CELL_OK; +} + +int cellHttpUtilSweepPath() +{ + UNIMPLEMENTED_FUNC(cellHttpUtil); + return CELL_OK; +} + +int cellHttpUtilCopyStatusLine() +{ + UNIMPLEMENTED_FUNC(cellHttpUtil); + return CELL_OK; +} + +int cellHttpUtilCopyHeader() +{ + UNIMPLEMENTED_FUNC(cellHttpUtil); + return CELL_OK; +} + +int cellHttpUtilAppendHeaderValue() +{ + UNIMPLEMENTED_FUNC(cellHttpUtil); + return CELL_OK; +} + +int cellHttpUtilEscapeUri() +{ + UNIMPLEMENTED_FUNC(cellHttpUtil); + return CELL_OK; +} + +int cellHttpUtilUnescapeUri() +{ + UNIMPLEMENTED_FUNC(cellHttpUtil); + return CELL_OK; +} + +int cellHttpUtilFormUrlEncode() +{ + UNIMPLEMENTED_FUNC(cellHttpUtil); + return CELL_OK; +} + +int cellHttpUtilFormUrlDecode() +{ + UNIMPLEMENTED_FUNC(cellHttpUtil); + return CELL_OK; +} + +int cellHttpUtilBase64Encoder() +{ + UNIMPLEMENTED_FUNC(cellHttpUtil); + return CELL_OK; +} + +int cellHttpUtilBase64Decoder() +{ + UNIMPLEMENTED_FUNC(cellHttpUtil); + return CELL_OK; +} + +void cellHttpUtil_init() +{ + cellHttpUtil.AddFunc(0x32faaf58, cellHttpUtilParseUri); + cellHttpUtil.AddFunc(0x8bb608e4, cellHttpUtilParseUriPath); + cellHttpUtil.AddFunc(0xa3457869, cellHttpUtilParseProxy); + cellHttpUtil.AddFunc(0x2bcbced4, cellHttpUtilParseStatusLine); + cellHttpUtil.AddFunc(0xe1fb0ebd, cellHttpUtilParseHeader); + + cellHttpUtil.AddFunc(0x1c6e4dbb, cellHttpUtilBuildRequestLine); + cellHttpUtil.AddFunc(0x04accebf, cellHttpUtilBuildHeader); + cellHttpUtil.AddFunc(0x6f0f7667, cellHttpUtilBuildUri); + + cellHttpUtil.AddFunc(0xf05df789, cellHttpUtilCopyUri); + cellHttpUtil.AddFunc(0x8ea23deb, cellHttpUtilMergeUriPath); + cellHttpUtil.AddFunc(0xaabeb869, cellHttpUtilSweepPath); + cellHttpUtil.AddFunc(0x50ea75bc, cellHttpUtilCopyStatusLine); + cellHttpUtil.AddFunc(0x97f9fbe5, cellHttpUtilCopyHeader); + cellHttpUtil.AddFunc(0x37bb53a2, cellHttpUtilAppendHeaderValue); + + cellHttpUtil.AddFunc(0x9003b1f2, cellHttpUtilEscapeUri); + cellHttpUtil.AddFunc(0x2763fd66, cellHttpUtilUnescapeUri); + cellHttpUtil.AddFunc(0x44d756d6, cellHttpUtilFormUrlEncode); + cellHttpUtil.AddFunc(0x8e6c5bb9, cellHttpUtilFormUrlDecode); + cellHttpUtil.AddFunc(0x83faa354, cellHttpUtilBase64Encoder); + cellHttpUtil.AddFunc(0x8e52ee08, cellHttpUtilBase64Decoder); +} \ No newline at end of file diff --git a/rpcs3/Emu/SysCalls/Modules/cellJpgDec.cpp b/rpcs3/Emu/SysCalls/Modules/cellJpgDec.cpp index 8f0f82c40e..b637558370 100644 --- a/rpcs3/Emu/SysCalls/Modules/cellJpgDec.cpp +++ b/rpcs3/Emu/SysCalls/Modules/cellJpgDec.cpp @@ -80,12 +80,10 @@ struct CellJpgDecSubHandle //Custom struct { u32 fd; u64 fileSize; - CellJpgDecInParam inParam; + CellJpgDecInfo info; + CellJpgDecOutParam outParam; }; -CellJpgDecInfo current_info; -CellJpgDecSrc current_src; - int cellJpgDecCreate(u32 mainHandle, u32 threadInParam, u32 threadOutParam) { @@ -105,33 +103,33 @@ int cellJpgDecDestroy(u32 mainHandle) return CELL_OK; } -int cellJpgDecOpen(u32 mainHandle, u32 subHandle_addr, u32 src_addr, u32 openInfo) +int cellJpgDecOpen(u32 mainHandle, mem32_t subHandle, u32 src_addr, u32 openInfo) { - //current_src.srcSelect = Memory.Read32(src_addr); - current_src.fileName = Memory.Read32(src_addr+4); - //current_src.fileOffset = Memory.Read32(src_addr+8); - //current_src.fileSize = Memory.Read32(src_addr+12); - //current_src.streamPtr = Memory.Read32(src_addr+16); - //current_src.streamSize = Memory.Read32(src_addr+20); - //current_src.spuThreadEnable = Memory.Read32(src_addr+24); + //u32 srcSelect = Memory.Read32(src_addr); + u32 fileName = Memory.Read32(src_addr+4); + //u64 fileOffset = Memory.Read32(src_addr+8); + //u32 fileSize = Memory.Read32(src_addr+12); + //u32 streamPtr = Memory.Read32(src_addr+16); + //u32 streamSize = Memory.Read32(src_addr+20); + //u32 spuThreadEnable = Memory.Read32(src_addr+24); - CellJpgDecSubHandle *subHandle = new CellJpgDecSubHandle; + CellJpgDecSubHandle *current_subHandle = new CellJpgDecSubHandle; // Get file descriptor u32 fd_addr = Memory.Alloc(sizeof(u32), 1); - int ret = cellFsOpen(current_src.fileName, 0, fd_addr, NULL, 0); - subHandle->fd = Memory.Read32(fd_addr); + int ret = cellFsOpen(fileName, 0, fd_addr, NULL, 0); + current_subHandle->fd = Memory.Read32(fd_addr); Memory.Free(fd_addr); if(ret != 0) return CELL_JPGDEC_ERROR_OPEN_FILE; // Get size of file u32 sb_addr = Memory.Alloc(52,1); // Alloc a CellFsStat struct - cellFsFstat(subHandle->fd, sb_addr); - subHandle->fileSize = Memory.Read64(sb_addr+36); // Get CellFsStat.st_size + cellFsFstat(current_subHandle->fd, sb_addr); + current_subHandle->fileSize = Memory.Read64(sb_addr+36); // Get CellFsStat.st_size Memory.Free(sb_addr); // From now, every u32 subHandle argument is a pointer to a CellPngDecSubHandle struct. - Memory.Write32(subHandle_addr, (u32)subHandle); + subHandle += (u32)current_subHandle; return CELL_OK; } @@ -144,16 +142,19 @@ int cellJpgDecClose(u32 mainHandle, u32 subHandle) return CELL_OK; } -int cellJpgDecReadHeader(u32 mainHandle, u32 subHandle, u32 info_addr) +int cellJpgDecReadHeader(u32 mainHandle, u32 subHandle, mem_class_t info) { const u32& fd = ((CellJpgDecSubHandle*)subHandle)->fd; const u64& fileSize = ((CellJpgDecSubHandle*)subHandle)->fileSize; + CellJpgDecInfo& current_info = ((CellJpgDecSubHandle*)subHandle)->info; //Copy the JPG file to a buffer u32 buffer = Memory.Alloc(fileSize,1); + u32 nread = Memory.Alloc(8,1); u32 pos_addr = Memory.Alloc(8,1); cellFsLseek(fd, 0, 0, pos_addr); - cellFsRead(fd, buffer, fileSize, NULL); + cellFsRead(fd, buffer, fileSize, nread); + Memory.Free(nread); Memory.Free(pos_addr); if (Memory.Read32(buffer) != 0xFFD8FFE0 || // Error: Not a valid SOI header @@ -185,10 +186,9 @@ int cellJpgDecReadHeader(u32 mainHandle, u32 subHandle, u32 info_addr) current_info.imageWidth = Memory.Read8(buffer+i+7)*256 + Memory.Read8(buffer+i+8); current_info.imageHeight = Memory.Read8(buffer+i+5)*256 + Memory.Read8(buffer+i+6); - current_info.numComponents = 0; // Unimplemented - current_info.colorSpace = 3; // Unimplemented + current_info.numComponents = 3; // Unimplemented + current_info.colorSpace = CELL_JPG_RGB; // Unimplemented - mem_class_t info(info_addr); info += current_info.imageWidth; info += current_info.imageHeight; info += current_info.numComponents; @@ -198,17 +198,19 @@ int cellJpgDecReadHeader(u32 mainHandle, u32 subHandle, u32 info_addr) return CELL_OK; } -int cellJpgDecDecodeData(u32 mainHandle, u32 subHandle, u32 data_addr, u32 dataCtrlParam_addr, u32 dataOutInfo_addr) +int cellJpgDecDecodeData(u32 mainHandle, u32 subHandle, mem8_ptr_t data, u32 dataCtrlParam_addr, u32 dataOutInfo_addr) { const u32& fd = ((CellJpgDecSubHandle*)subHandle)->fd; const u64& fileSize = ((CellJpgDecSubHandle*)subHandle)->fileSize; - const CellJpgDecInParam& inParam = ((CellJpgDecSubHandle*)subHandle)->inParam; // (TODO: We should use the outParam) + const CellJpgDecOutParam& current_outParam = ((CellJpgDecSubHandle*)subHandle)->outParam; // (TODO: We should use the outParam) //Copy the JPG file to a buffer u32 buffer = Memory.Alloc(fileSize,1); + u32 nread = Memory.Alloc(8,1); u32 pos_addr = Memory.Alloc(8,1); cellFsLseek(fd, 0, 0, pos_addr); - cellFsRead(fd, buffer, fileSize, NULL); + cellFsRead(fd, buffer, fileSize, nread); + Memory.Free(nread); Memory.Free(pos_addr); //Decode JPG file. (TODO: Is there any faster alternative? Can we do it without external libraries?) @@ -219,20 +221,20 @@ int cellJpgDecDecodeData(u32 mainHandle, u32 subHandle, u32 data_addr, u32 dataC if (!image) return CELL_JPGDEC_ERROR_STREAM_FORMAT; u32 image_size = width * height * 4; - if (inParam.outputColorSpace == CELL_JPG_RGBA){ + if (current_outParam.outputColorSpace == CELL_JPG_RGBA){ for(u32 i = 0; i < image_size; i+=4){ - Memory.Write8(data_addr+i+0, image[i+0]); - Memory.Write8(data_addr+i+1, image[i+1]); - Memory.Write8(data_addr+i+2, image[i+2]); - Memory.Write8(data_addr+i+3, image[i+3]); + data += image[i+0]; + data += image[i+1]; + data += image[i+2]; + data += image[i+3]; } } - else if (inParam.outputColorSpace == CELL_JPG_ARGB){ + else if (current_outParam.outputColorSpace == CELL_JPG_ARGB){ for(u32 i = 0; i < image_size; i+=4){ - Memory.Write8(data_addr+i+0, image[i+3]); - Memory.Write8(data_addr+i+1, image[i+0]); - Memory.Write8(data_addr+i+2, image[i+1]); - Memory.Write8(data_addr+i+3, image[i+2]); + data += image[i+3]; + data += image[i+0]; + data += image[i+1]; + data += image[i+2]; } } delete[] image; @@ -240,12 +242,39 @@ int cellJpgDecDecodeData(u32 mainHandle, u32 subHandle, u32 data_addr, u32 dataC return CELL_OK; } -int cellJpgDecSetParameter(u32 mainHandle, u32 subHandle, u32 inParam_addr, u32 outParam_addr) +int cellJpgDecSetParameter(u32 mainHandle, u32 subHandle, u32 inParam_addr, mem_class_t outParam) { - CellJpgDecInParam& inParam = ((CellJpgDecSubHandle*)subHandle)->inParam; - inParam.outputColorSpace = Memory.Read32(inParam_addr+16); + CellJpgDecInfo& current_info = ((CellJpgDecSubHandle*)subHandle)->info; + CellJpgDecOutParam& current_outParam = ((CellJpgDecSubHandle*)subHandle)->outParam; - // (TODO) + current_outParam.outputWidthByte = (current_info.imageWidth * current_info.numComponents); + current_outParam.outputWidth = current_info.imageWidth; + current_outParam.outputHeight = current_info.imageHeight; + current_outParam.outputColorSpace = Memory.Read32(inParam_addr+16); + switch (current_outParam.outputColorSpace) + { + case CELL_JPG_GRAYSCALE: current_outParam.outputComponents = 1; break; + case CELL_JPG_RGB: current_outParam.outputComponents = 3; break; + case CELL_JPG_YCbCr: current_outParam.outputComponents = 3; break; + case CELL_JPG_RGBA: current_outParam.outputComponents = 4; break; + case CELL_JPG_UPSAMPLE_ONLY: current_outParam.outputComponents = current_info.numComponents; break; + case CELL_JPG_ARGB: current_outParam.outputComponents = 4; break; + case CELL_JPG_GRAYSCALE_TO_ALPHA_RGBA: current_outParam.outputComponents = 4; break; + case CELL_JPG_GRAYSCALE_TO_ALPHA_ARGB: current_outParam.outputComponents = 4; break; + default: return CELL_JPGDEC_ERROR_ARG; // Not supported color space + } + current_outParam.outputMode = Memory.Read32(inParam_addr+12); + current_outParam.downScale = Memory.Read32(inParam_addr+4); + current_outParam.useMemorySpace = 0; // Unimplemented + + outParam += current_outParam.outputWidthByte; + outParam += current_outParam.outputWidth; + outParam += current_outParam.outputHeight; + outParam += current_outParam.outputComponents; + outParam += current_outParam.outputMode; + outParam += current_outParam.outputColorSpace; + outParam += current_outParam.downScale; + outParam += current_outParam.useMemorySpace; return CELL_OK; } diff --git a/rpcs3/Emu/SysCalls/Modules/cellPngDec.cpp b/rpcs3/Emu/SysCalls/Modules/cellPngDec.cpp index 783ba3738e..5cb71d7714 100644 --- a/rpcs3/Emu/SysCalls/Modules/cellPngDec.cpp +++ b/rpcs3/Emu/SysCalls/Modules/cellPngDec.cpp @@ -81,12 +81,10 @@ struct CellPngDecSubHandle //Custom struct { u32 fd; u64 fileSize; - CellPngDecInParam inParam; + CellPngDecInfo info; + CellPngDecOutParam outParam; }; -CellPngDecInfo current_info; -CellPngDecSrc current_src; - int cellPngDecCreate(u32 mainHandle, u32 threadInParam, u32 threadOutParam) { @@ -100,33 +98,33 @@ int cellPngDecDestroy(u32 mainHandle) return CELL_OK; } -int cellPngDecOpen(u32 mainHandle, u32 subHandle_addr, u32 src_addr, u32 openInfo) +int cellPngDecOpen(u32 mainHandle, mem32_t subHandle, u32 src_addr, u32 openInfo) { - //current_src.srcSelect = Memory.Read32(src_addr); - current_src.fileName = Memory.Read32(src_addr+4); - //current_src.fileOffset = Memory.Read32(src_addr+8); - //current_src.fileSize = Memory.Read32(src_addr+12); - //current_src.streamPtr = Memory.Read32(src_addr+16); - //current_src.streamSize = Memory.Read32(src_addr+20); - //current_src.spuThreadEnable = Memory.Read32(src_addr+24); + //u32 srcSelect = Memory.Read32(src_addr); + u32 fileName = Memory.Read32(src_addr+4); + //u64 fileOffset = Memory.Read32(src_addr+8); + //u32 fileSize = Memory.Read32(src_addr+12); + //u32 streamPtr = Memory.Read32(src_addr+16); + //u32 streamSize = Memory.Read32(src_addr+20); + //u32 spuThreadEnable = Memory.Read32(src_addr+24); - CellPngDecSubHandle *subHandle = new CellPngDecSubHandle; + CellPngDecSubHandle *current_subHandle = new CellPngDecSubHandle; // Get file descriptor u32 fd_addr = Memory.Alloc(sizeof(u32), 1); - int ret = cellFsOpen(current_src.fileName, 0, fd_addr, NULL, 0); - subHandle->fd = Memory.Read32(fd_addr); + int ret = cellFsOpen(fileName, 0, fd_addr, NULL, 0); + current_subHandle->fd = Memory.Read32(fd_addr); Memory.Free(fd_addr); if(ret != 0) return CELL_PNGDEC_ERROR_OPEN_FILE; // Get size of file u32 sb_addr = Memory.Alloc(52,1); // Alloc a CellFsStat struct - cellFsFstat(subHandle->fd, sb_addr); - subHandle->fileSize = Memory.Read64(sb_addr+36); // Get CellFsStat.st_size + cellFsFstat(current_subHandle->fd, sb_addr); + current_subHandle->fileSize = Memory.Read64(sb_addr+36); // Get CellFsStat.st_size Memory.Free(sb_addr); // From now, every u32 subHandle argument is a pointer to a CellPngDecSubHandle struct. - Memory.Write32(subHandle_addr, (u32)subHandle); + subHandle += (u32)current_subHandle; return CELL_OK; } @@ -139,19 +137,22 @@ int cellPngDecClose(u32 mainHandle, u32 subHandle) return CELL_OK; } -int cellPngDecReadHeader(u32 mainHandle, u32 subHandle, u32 info_addr) +int cellPngDecReadHeader(u32 mainHandle, u32 subHandle, mem_class_t info) { const u32& fd = ((CellPngDecSubHandle*)subHandle)->fd; const u64& fileSize = ((CellPngDecSubHandle*)subHandle)->fileSize; + CellPngDecInfo& current_info = ((CellPngDecSubHandle*)subHandle)->info; //Check size of file if(fileSize < 29) return CELL_PNGDEC_ERROR_HEADER; // Error: The file is smaller than the length of a PNG header //Write the header to buffer u32 buffer = Memory.Alloc(34,1); // Alloc buffer for PNG header + u32 nread = Memory.Alloc(8,1); u32 pos_addr = Memory.Alloc(8,1); cellFsLseek(fd, 0, 0, pos_addr); - cellFsRead(fd, buffer, 34, NULL); + cellFsRead(fd, buffer, 34, nread); + Memory.Free(nread); Memory.Free(pos_addr); if (Memory.Read32(buffer) != 0x89504E47 || @@ -163,14 +164,20 @@ int cellPngDecReadHeader(u32 mainHandle, u32 subHandle, u32 info_addr) } current_info.imageWidth = Memory.Read32(buffer+16); - current_info.imageHeight = Memory.Read32(buffer+20); - current_info.numComponents = 0; // Unimplemented - current_info.colorSpace = Memory.Read8(buffer+25); + current_info.imageHeight = Memory.Read32(buffer+20); + switch (Memory.Read8(buffer+25)) + { + case 0: current_info.colorSpace = CELL_PNGDEC_GRAYSCALE; current_info.numComponents = 1; break; + case 2: current_info.colorSpace = CELL_PNGDEC_RGB; current_info.numComponents = 3; break; + case 3: current_info.colorSpace = CELL_PNGDEC_PALETTE; current_info.numComponents = 1; break; + case 4: current_info.colorSpace = CELL_PNGDEC_GRAYSCALE_ALPHA; current_info.numComponents = 2; break; + case 6: current_info.colorSpace = CELL_PNGDEC_RGBA; current_info.numComponents = 4; break; + default: return CELL_PNGDEC_ERROR_HEADER; // Not supported color type + } current_info.bitDepth = Memory.Read8(buffer+24); current_info.interlaceMethod = Memory.Read8(buffer+28); current_info.chunkInformation = 0; // Unimplemented - mem_class_t info(info_addr); info += current_info.imageWidth; info += current_info.imageHeight; info += current_info.numComponents; @@ -183,17 +190,19 @@ int cellPngDecReadHeader(u32 mainHandle, u32 subHandle, u32 info_addr) return CELL_OK; } -int cellPngDecDecodeData(u32 mainHandle, u32 subHandle, u32 data_addr, u32 dataCtrlParam_addr, u32 dataOutInfo_addr) +int cellPngDecDecodeData(u32 mainHandle, u32 subHandle, mem8_ptr_t data, u32 dataCtrlParam_addr, mem_class_t dataOutInfo) { const u32& fd = ((CellPngDecSubHandle*)subHandle)->fd; const u64& fileSize = ((CellPngDecSubHandle*)subHandle)->fileSize; - const CellPngDecInParam& inParam = ((CellPngDecSubHandle*)subHandle)->inParam; // (TODO: We should use the outParam) + const CellPngDecOutParam& current_outParam = ((CellPngDecSubHandle*)subHandle)->outParam; //Copy the PNG file to a buffer u32 buffer = Memory.Alloc(fileSize,1); + u32 nread = Memory.Alloc(8,1); u32 pos_addr = Memory.Alloc(sizeof(u64),1); cellFsLseek(fd, 0, 0, pos_addr); - cellFsRead(fd, buffer, fileSize, NULL); + cellFsRead(fd, buffer, fileSize, nread); + Memory.Free(nread); Memory.Free(pos_addr); //Decode PNG file. (TODO: Is there any faster alternative? Can we do it without external libraries?) @@ -204,20 +213,20 @@ int cellPngDecDecodeData(u32 mainHandle, u32 subHandle, u32 data_addr, u32 dataC if (!image) return CELL_PNGDEC_ERROR_STREAM_FORMAT; u32 image_size = width * height * 4; - if (inParam.outputColorSpace == CELL_PNGDEC_RGBA){ + if (current_outParam.outputColorSpace == CELL_PNGDEC_RGBA){ for(u32 i = 0; i < image_size; i+=4){ - Memory.Write8(data_addr+i+0, image[i+0]); - Memory.Write8(data_addr+i+1, image[i+1]); - Memory.Write8(data_addr+i+2, image[i+2]); - Memory.Write8(data_addr+i+3, image[i+3]); + data += image[i+0]; + data += image[i+1]; + data += image[i+2]; + data += image[i+3]; } } - else if (inParam.outputColorSpace == CELL_PNGDEC_ARGB){ + else if (current_outParam.outputColorSpace == CELL_PNGDEC_ARGB){ for(u32 i = 0; i < image_size; i+=4){ - Memory.Write8(data_addr+i+0, image[i+3]); - Memory.Write8(data_addr+i+1, image[i+0]); - Memory.Write8(data_addr+i+2, image[i+1]); - Memory.Write8(data_addr+i+3, image[i+2]); + data += image[i+3]; + data += image[i+0]; + data += image[i+1]; + data += image[i+2]; } } delete[] image; @@ -225,12 +234,37 @@ int cellPngDecDecodeData(u32 mainHandle, u32 subHandle, u32 data_addr, u32 dataC return CELL_OK; } -int cellPngDecSetParameter(u32 mainHandle, u32 subHandle, u32 inParam_addr, u32 outParam_addr) +int cellPngDecSetParameter(u32 mainHandle, u32 subHandle, u32 inParam_addr, mem_class_t outParam) { - CellPngDecInParam& inParam = ((CellPngDecSubHandle*)subHandle)->inParam; - inParam.outputColorSpace = Memory.Read32(inParam_addr+8); + CellPngDecInfo& current_info = ((CellPngDecSubHandle*)subHandle)->info; + CellPngDecOutParam& current_outParam = ((CellPngDecSubHandle*)subHandle)->outParam; - // (TODO) + current_outParam.outputWidthByte = (current_info.imageWidth * current_info.numComponents * current_info.bitDepth)/8; + current_outParam.outputWidth = current_info.imageWidth; + current_outParam.outputHeight = current_info.imageHeight; + current_outParam.outputColorSpace = Memory.Read32(inParam_addr+8); + switch (current_outParam.outputColorSpace) + { + case CELL_PNGDEC_GRAYSCALE: current_outParam.outputComponents = 1; break; + case CELL_PNGDEC_GRAYSCALE_ALPHA: current_outParam.outputComponents = 2; break; + case CELL_PNGDEC_PALETTE: current_outParam.outputComponents = 1; break; + case CELL_PNGDEC_RGB: current_outParam.outputComponents = 3; break; + case CELL_PNGDEC_RGBA: current_outParam.outputComponents = 4; break; + case CELL_PNGDEC_ARGB: current_outParam.outputComponents = 4; break; + default: return CELL_PNGDEC_ERROR_ARG; // Not supported color space + } + current_outParam.outputBitDepth = Memory.Read32(inParam_addr+12); + current_outParam.outputMode = Memory.Read32(inParam_addr+4); + current_outParam.useMemorySpace = 0; // Unimplemented + + outParam += current_outParam.outputWidthByte; + outParam += current_outParam.outputWidth; + outParam += current_outParam.outputHeight; + outParam += current_outParam.outputComponents; + outParam += current_outParam.outputBitDepth; + outParam += current_outParam.outputMode; + outParam += current_outParam.outputColorSpace; + outParam += current_outParam.useMemorySpace; return CELL_OK; } diff --git a/rpcs3/Emu/SysCalls/Modules/cellSsl.cpp b/rpcs3/Emu/SysCalls/Modules/cellSsl.cpp new file mode 100644 index 0000000000..47634069bc --- /dev/null +++ b/rpcs3/Emu/SysCalls/Modules/cellSsl.cpp @@ -0,0 +1,110 @@ +#include "stdafx.h" +#include "Emu/SysCalls/SysCalls.h" +#include "Emu/SysCalls/SC_FUNC.h" + +void cellSsl_init(); +Module cellSsl(0x0003, cellSsl_init); + +int cellSslInit() +{ + UNIMPLEMENTED_FUNC(cellSsl); + return CELL_OK; +} + +int cellSslEnd() +{ + UNIMPLEMENTED_FUNC(cellSsl); + return CELL_OK; +} + +int cellSslCertificateLoader() +{ + UNIMPLEMENTED_FUNC(cellSsl); + return CELL_OK; +} + +int cellSslCertGetSerialNumber() +{ + UNIMPLEMENTED_FUNC(cellSsl); + return CELL_OK; +} + +int cellSslCertGetPublicKey() +{ + UNIMPLEMENTED_FUNC(cellSsl); + return CELL_OK; +} + +int cellSslCertGetRsaPublicKeyModulus() +{ + UNIMPLEMENTED_FUNC(cellSsl); + return CELL_OK; +} + +int cellSslCertGetRsaPublicKeyExponent() +{ + UNIMPLEMENTED_FUNC(cellSsl); + return CELL_OK; +} + +int cellSslCertGetNotBefore() +{ + UNIMPLEMENTED_FUNC(cellSsl); + return CELL_OK; +} + +int cellSslCertGetNotAfter() +{ + UNIMPLEMENTED_FUNC(cellSsl); + return CELL_OK; +} + +int cellSslCertGetSubjectName() +{ + UNIMPLEMENTED_FUNC(cellSsl); + return CELL_OK; +} + +int cellSslCertGetIssuerName() +{ + UNIMPLEMENTED_FUNC(cellSsl); + return CELL_OK; +} + +int cellSslCertGetNameEntryCount() +{ + UNIMPLEMENTED_FUNC(cellSsl); + return CELL_OK; +} + +int cellSslCertGetNameEntryInfo() +{ + UNIMPLEMENTED_FUNC(cellSsl); + return CELL_OK; +} + +int cellSslCertGetMd5Fingerprint() +{ + UNIMPLEMENTED_FUNC(cellSsl); + return CELL_OK; +} + +void cellSsl_init() +{ + cellSsl.AddFunc(0xfb02c9d2, cellSslInit); + cellSsl.AddFunc(0x1650aea4, cellSslEnd); + + cellSsl.AddFunc(0x571afaca, cellSslCertificateLoader); + + cellSsl.AddFunc(0x7b689ebc, cellSslCertGetSerialNumber); + cellSsl.AddFunc(0xf8206492, cellSslCertGetPublicKey); + cellSsl.AddFunc(0x8e505175, cellSslCertGetRsaPublicKeyModulus); + cellSsl.AddFunc(0x033c4905, cellSslCertGetRsaPublicKeyExponent); + cellSsl.AddFunc(0x31d9ba8d, cellSslCertGetNotBefore); + cellSsl.AddFunc(0x218b64da, cellSslCertGetNotAfter); + cellSsl.AddFunc(0x32c61bdf, cellSslCertGetSubjectName); + cellSsl.AddFunc(0xae6eb491, cellSslCertGetIssuerName); + cellSsl.AddFunc(0x766d3ca1, cellSslCertGetNameEntryCount); + cellSsl.AddFunc(0x006c4900, cellSslCertGetNameEntryInfo); + cellSsl.AddFunc(0x5e9253ca, cellSslCertGetMd5Fingerprint); +} \ No newline at end of file diff --git a/rpcs3/Emu/SysCalls/Modules/sys_http.cpp b/rpcs3/Emu/SysCalls/Modules/sys_http.cpp new file mode 100644 index 0000000000..d4cf217398 --- /dev/null +++ b/rpcs3/Emu/SysCalls/Modules/sys_http.cpp @@ -0,0 +1,704 @@ +#include "stdafx.h" +#include "Emu/SysCalls/SysCalls.h" +#include "Emu/SysCalls/SC_FUNC.h" + +void sys_http_init(); +Module sys_http(0x0001, sys_http_init); + +int cellHttpInit() +{ + UNIMPLEMENTED_FUNC(sys_http); + return CELL_OK; +} + +int cellHttpEnd() +{ + UNIMPLEMENTED_FUNC(sys_http); + return CELL_OK; +} + +int cellHttpsInit() +{ + UNIMPLEMENTED_FUNC(sys_http); + return CELL_OK; +} + +int cellHttpsEnd() +{ + UNIMPLEMENTED_FUNC(sys_http); + return CELL_OK; +} + +int cellHttpSetProxy() +{ + UNIMPLEMENTED_FUNC(sys_http); + return CELL_OK; +} + +int cellHttpGetProxy() +{ + UNIMPLEMENTED_FUNC(sys_http); + return CELL_OK; +} + +int cellHttpInitCookie() +{ + UNIMPLEMENTED_FUNC(sys_http); + return CELL_OK; +} + +int cellHttpEndCookie() +{ + UNIMPLEMENTED_FUNC(sys_http); + return CELL_OK; +} + +int cellHttpAddCookieWithClientId() +{ + UNIMPLEMENTED_FUNC(sys_http); + return CELL_OK; +} + +int cellHttpSessionCookieFlush() +{ + UNIMPLEMENTED_FUNC(sys_http); + return CELL_OK; +} + +int cellHttpCookieExportWithClientId() +{ + UNIMPLEMENTED_FUNC(sys_http); + return CELL_OK; +} + +int cellHttpCookieImportWithClientId() +{ + UNIMPLEMENTED_FUNC(sys_http); + return CELL_OK; +} + +int cellHttpClientSetCookieSendCallback() +{ + UNIMPLEMENTED_FUNC(sys_http); + return CELL_OK; +} + +int cellHttpClientSetCookieRecvCallback() +{ + UNIMPLEMENTED_FUNC(sys_http); + return CELL_OK; +} + +int cellHttpCreateClient() +{ + UNIMPLEMENTED_FUNC(sys_http); + return CELL_OK; +} + +int cellHttpDestroyClient() +{ + UNIMPLEMENTED_FUNC(sys_http); + return CELL_OK; +} + +int cellHttpClientSetAuthenticationCallback() +{ + UNIMPLEMENTED_FUNC(sys_http); + return CELL_OK; +} + +int cellHttpClientSetTransactionStateCallback() +{ + UNIMPLEMENTED_FUNC(sys_http); + return CELL_OK; +} + +int cellHttpClientSetRedirectCallback() +{ + UNIMPLEMENTED_FUNC(sys_http); + return CELL_OK; +} + +int cellHttpClientSetProxy() +{ + UNIMPLEMENTED_FUNC(sys_http); + return CELL_OK; +} + +int cellHttpClientGetProxy() +{ + UNIMPLEMENTED_FUNC(sys_http); + return CELL_OK; +} + +int cellHttpClientSetVersion() +{ + UNIMPLEMENTED_FUNC(sys_http); + return CELL_OK; +} + +int cellHttpClientGetVersion() +{ + UNIMPLEMENTED_FUNC(sys_http); + return CELL_OK; +} + +int cellHttpClientSetPipeline() +{ + UNIMPLEMENTED_FUNC(sys_http); + return CELL_OK; +} + +int cellHttpClientGetPipeline() +{ + UNIMPLEMENTED_FUNC(sys_http); + return CELL_OK; +} + +int cellHttpClientSetKeepAlive() +{ + UNIMPLEMENTED_FUNC(sys_http); + return CELL_OK; +} + +int cellHttpClientGetKeepAlive() +{ + UNIMPLEMENTED_FUNC(sys_http); + return CELL_OK; +} + +int cellHttpClientSetAutoRedirect() +{ + UNIMPLEMENTED_FUNC(sys_http); + return CELL_OK; +} + +int cellHttpClientGetAutoRedirect() +{ + UNIMPLEMENTED_FUNC(sys_http); + return CELL_OK; +} + +int cellHttpClientSetAutoAuthentication() +{ + UNIMPLEMENTED_FUNC(sys_http); + return CELL_OK; +} + +int cellHttpClientGetAutoAuthentication() +{ + UNIMPLEMENTED_FUNC(sys_http); + return CELL_OK; +} + +int cellHttpClientSetAuthenticationCacheStatus() +{ + UNIMPLEMENTED_FUNC(sys_http); + return CELL_OK; +} + +int cellHttpClientGetAuthenticationCacheStatus() +{ + UNIMPLEMENTED_FUNC(sys_http); + return CELL_OK; +} + +int cellHttpClientSetCookieStatus() +{ + UNIMPLEMENTED_FUNC(sys_http); + return CELL_OK; +} + +int cellHttpClientGetCookieStatus() +{ + UNIMPLEMENTED_FUNC(sys_http); + return CELL_OK; +} + +int cellHttpClientSetUserAgent() +{ + UNIMPLEMENTED_FUNC(sys_http); + return CELL_OK; +} + +int cellHttpClientGetUserAgent() +{ + UNIMPLEMENTED_FUNC(sys_http); + return CELL_OK; +} + +int cellHttpClientSetResponseBufferMax() +{ + UNIMPLEMENTED_FUNC(sys_http); + return CELL_OK; +} + +int cellHttpClientGetResponseBufferMax() +{ + UNIMPLEMENTED_FUNC(sys_http); + return CELL_OK; +} + +int cellHttpClientCloseAllConnections() +{ + UNIMPLEMENTED_FUNC(sys_http); + return CELL_OK; +} + +int cellHttpClientCloseConnections() +{ + UNIMPLEMENTED_FUNC(sys_http); + return CELL_OK; +} + +int cellHttpClientPollConnections() +{ + UNIMPLEMENTED_FUNC(sys_http); + return CELL_OK; +} + +int cellHttpClientSetRecvTimeout() +{ + UNIMPLEMENTED_FUNC(sys_http); + return CELL_OK; +} + +int cellHttpClientGetRecvTimeout() +{ + UNIMPLEMENTED_FUNC(sys_http); + return CELL_OK; +} + +int cellHttpClientSetSendTimeout() +{ + UNIMPLEMENTED_FUNC(sys_http); + return CELL_OK; +} + +int cellHttpClientGetSendTimeout() +{ + UNIMPLEMENTED_FUNC(sys_http); + return CELL_OK; +} + +int cellHttpClientSetConnTimeout() +{ + UNIMPLEMENTED_FUNC(sys_http); + return CELL_OK; +} + +int cellHttpClientGetConnTimeout() +{ + UNIMPLEMENTED_FUNC(sys_http); + return CELL_OK; +} + +int cellHttpClientSetTotalPoolSize() +{ + UNIMPLEMENTED_FUNC(sys_http); + return CELL_OK; +} + +int cellHttpClientGetTotalPoolSize() +{ + UNIMPLEMENTED_FUNC(sys_http); + return CELL_OK; +} + +int cellHttpClientSetPerHostPoolSize() +{ + UNIMPLEMENTED_FUNC(sys_http); + return CELL_OK; +} + +int cellHttpClientGetPerHostPoolSize() +{ + UNIMPLEMENTED_FUNC(sys_http); + return CELL_OK; +} + +int cellHttpClientSetPerHostKeepAliveMax() +{ + UNIMPLEMENTED_FUNC(sys_http); + return CELL_OK; +} + +int cellHttpClientGetPerHostKeepAliveMax() +{ + UNIMPLEMENTED_FUNC(sys_http); + return CELL_OK; +} + +int cellHttpClientSetPerPipelineMax() +{ + UNIMPLEMENTED_FUNC(sys_http); + return CELL_OK; +} + +int cellHttpClientGetPerPipelineMax() +{ + UNIMPLEMENTED_FUNC(sys_http); + return CELL_OK; +} + +int cellHttpClientSetRecvBufferSize() +{ + UNIMPLEMENTED_FUNC(sys_http); + return CELL_OK; +} + +int cellHttpClientGetRecvBufferSize() +{ + UNIMPLEMENTED_FUNC(sys_http); + return CELL_OK; +} + +int cellHttpClientGetAllHeaders() +{ + UNIMPLEMENTED_FUNC(sys_http); + return CELL_OK; +} + +int cellHttpClientSetHeader() +{ + UNIMPLEMENTED_FUNC(sys_http); + return CELL_OK; +} + +int cellHttpClientGetHeader() +{ + UNIMPLEMENTED_FUNC(sys_http); + return CELL_OK; +} + +int cellHttpClientAddHeader() +{ + UNIMPLEMENTED_FUNC(sys_http); + return CELL_OK; +} + +int cellHttpClientDeleteHeader() +{ + UNIMPLEMENTED_FUNC(sys_http); + return CELL_OK; +} + +int cellHttpClientSetSslCallback() +{ + UNIMPLEMENTED_FUNC(sys_http); + return CELL_OK; +} + +int cellHttpClientSetSslClientCertificate() +{ + UNIMPLEMENTED_FUNC(sys_http); + return CELL_OK; +} + +int cellHttpCreateTransaction() +{ + UNIMPLEMENTED_FUNC(sys_http); + return CELL_OK; +} + +int cellHttpDestroyTransaction() +{ + UNIMPLEMENTED_FUNC(sys_http); + return CELL_OK; +} + +int cellHttpTransactionGetUri() +{ + UNIMPLEMENTED_FUNC(sys_http); + return CELL_OK; +} + +int cellHttpTransactionCloseConnection() +{ + UNIMPLEMENTED_FUNC(sys_http); + return CELL_OK; +} + +int cellHttpTransactionReleaseConnection() +{ + UNIMPLEMENTED_FUNC(sys_http); + return CELL_OK; +} + +int cellHttpTransactionAbortConnection() +{ + UNIMPLEMENTED_FUNC(sys_http); + return CELL_OK; +} + +int cellHttpSendRequest() +{ + UNIMPLEMENTED_FUNC(sys_http); + return CELL_OK; +} + +int cellHttpRequestSetContentLength() +{ + UNIMPLEMENTED_FUNC(sys_http); + return CELL_OK; +} + +int cellHttpRequestGetContentLength() +{ + UNIMPLEMENTED_FUNC(sys_http); + return CELL_OK; +} + +int cellHttpRequestSetChunkedTransferStatus() +{ + UNIMPLEMENTED_FUNC(sys_http); + return CELL_OK; +} + +int cellHttpRequestGetChunkedTransferStatus() +{ + UNIMPLEMENTED_FUNC(sys_http); + return CELL_OK; +} + +int cellHttpRequestGetAllHeaders() +{ + UNIMPLEMENTED_FUNC(sys_http); + return CELL_OK; +} + +int cellHttpRequestSetHeader() +{ + UNIMPLEMENTED_FUNC(sys_http); + return CELL_OK; +} + +int cellHttpRequestGetHeader() +{ + UNIMPLEMENTED_FUNC(sys_http); + return CELL_OK; +} + +int cellHttpRequestAddHeader() +{ + UNIMPLEMENTED_FUNC(sys_http); + return CELL_OK; +} + +int cellHttpRequestDeleteHeader() +{ + UNIMPLEMENTED_FUNC(sys_http); + return CELL_OK; +} + +int cellHttpRecvResponse() +{ + UNIMPLEMENTED_FUNC(sys_http); + return CELL_OK; +} + +int cellHttpResponseGetAllHeaders() +{ + UNIMPLEMENTED_FUNC(sys_http); + return CELL_OK; +} + +int cellHttpResponseGetHeader() +{ + UNIMPLEMENTED_FUNC(sys_http); + return CELL_OK; +} + +int cellHttpResponseGetContentLength() +{ + UNIMPLEMENTED_FUNC(sys_http); + return CELL_OK; +} + +int cellHttpResponseGetStatusCode() +{ + UNIMPLEMENTED_FUNC(sys_http); + return CELL_OK; +} + +int cellHttpResponseGetStatusLine() +{ + UNIMPLEMENTED_FUNC(sys_http); + return CELL_OK; +} + +int cellHttpTransactionGetSslCipherName() +{ + UNIMPLEMENTED_FUNC(sys_http); + return CELL_OK; +} + +int cellHttpTransactionGetSslCipherId() +{ + UNIMPLEMENTED_FUNC(sys_http); + return CELL_OK; +} + +int cellHttpTransactionGetSslCipherVersion() +{ + UNIMPLEMENTED_FUNC(sys_http); + return CELL_OK; +} + +int cellHttpTransactionGetSslCipherBits() +{ + UNIMPLEMENTED_FUNC(sys_http); + return CELL_OK; +} + +int cellHttpTransactionGetSslCipherString() +{ + UNIMPLEMENTED_FUNC(sys_http); + return CELL_OK; +} + +int cellHttpTransactionGetSslVersion() +{ + UNIMPLEMENTED_FUNC(sys_http); + return CELL_OK; +} + +int cellHttpTransactionGetSslId() +{ + UNIMPLEMENTED_FUNC(sys_http); + return CELL_OK; +} + +int cellHttpClientSetSslVersion() +{ + UNIMPLEMENTED_FUNC(sys_http); + return CELL_OK; +} + +int cellHttpClientGetSslVersion() +{ + UNIMPLEMENTED_FUNC(sys_http); + return CELL_OK; +} + +int cellHttpClientSetSslIdDestroyCallback() +{ + UNIMPLEMENTED_FUNC(sys_http); + return CELL_OK; +} + +void sys_http_init() +{ + // (TODO: Find addresses for cellHttpClientSetSendBufferSize and cellHttpClientGetSendBufferSize) + + sys_http.AddFunc(0x250c386c, cellHttpInit); + sys_http.AddFunc(0xd276ff1f, cellHttpEnd); + sys_http.AddFunc(0x522180bc, cellHttpsInit); + sys_http.AddFunc(0xe6d4202f, cellHttpsEnd); + sys_http.AddFunc(0x0d896b97, cellHttpSetProxy); + sys_http.AddFunc(0x2a87603a, cellHttpGetProxy); + + sys_http.AddFunc(0x9638f766, cellHttpInitCookie); + sys_http.AddFunc(0x61b2bade, cellHttpEndCookie); + sys_http.AddFunc(0x1b5bdcc6, cellHttpAddCookieWithClientId); + sys_http.AddFunc(0xad6a2e5b, cellHttpSessionCookieFlush); + sys_http.AddFunc(0xf972c733, cellHttpCookieExportWithClientId); + sys_http.AddFunc(0x0d846d63, cellHttpCookieImportWithClientId); + sys_http.AddFunc(0x4d915204, cellHttpClientSetCookieSendCallback); + sys_http.AddFunc(0x13fe767b, cellHttpClientSetCookieRecvCallback); + + sys_http.AddFunc(0x4e4ee53a, cellHttpCreateClient); + sys_http.AddFunc(0x980855ac, cellHttpDestroyClient); + sys_http.AddFunc(0x660d42a9, cellHttpClientSetAuthenticationCallback); + sys_http.AddFunc(0xb6feb84b, cellHttpClientSetTransactionStateCallback); + sys_http.AddFunc(0x473cd9f1, cellHttpClientSetRedirectCallback); + + sys_http.AddFunc(0xd7d3cd5d, cellHttpClientSetProxy); + sys_http.AddFunc(0x4d40cf98, cellHttpClientGetProxy); + sys_http.AddFunc(0x40547d8b, cellHttpClientSetVersion); + sys_http.AddFunc(0xdc405507, cellHttpClientGetVersion); + sys_http.AddFunc(0x296a46cf, cellHttpClientSetPipeline); + sys_http.AddFunc(0x2a1f28f6, cellHttpClientGetPipeline); + sys_http.AddFunc(0x5d473170, cellHttpClientSetKeepAlive); + sys_http.AddFunc(0x591c21a8, cellHttpClientGetKeepAlive); + sys_http.AddFunc(0x211d8ba3, cellHttpClientSetAutoRedirect); + sys_http.AddFunc(0x2960e309, cellHttpClientGetAutoRedirect); + sys_http.AddFunc(0x8eaf47a3, cellHttpClientSetAutoAuthentication); + sys_http.AddFunc(0x5980a293, cellHttpClientGetAutoAuthentication); + sys_http.AddFunc(0x6eed4999, cellHttpClientSetAuthenticationCacheStatus); + sys_http.AddFunc(0xfce39343, cellHttpClientGetAuthenticationCacheStatus); + sys_http.AddFunc(0x434419c8, cellHttpClientSetCookieStatus); + sys_http.AddFunc(0xeb9c1e5e, cellHttpClientGetCookieStatus); + sys_http.AddFunc(0xcac9fc34, cellHttpClientSetUserAgent); + sys_http.AddFunc(0xee05b0c1, cellHttpClientGetUserAgent); + sys_http.AddFunc(0xadd66b5c, cellHttpClientSetResponseBufferMax); + sys_http.AddFunc(0x6884cdb7, cellHttpClientGetResponseBufferMax); + + sys_http.AddFunc(0x2033b878, cellHttpClientCloseAllConnections); + sys_http.AddFunc(0x27f86d70, cellHttpClientCloseConnections); + sys_http.AddFunc(0xadc0a4b2, cellHttpClientPollConnections); + sys_http.AddFunc(0x224e1610, cellHttpClientSetRecvTimeout); + sys_http.AddFunc(0xba78e51f, cellHttpClientGetRecvTimeout); + sys_http.AddFunc(0x71714cdc, cellHttpClientSetSendTimeout); + sys_http.AddFunc(0x271a0b06, cellHttpClientGetSendTimeout); + sys_http.AddFunc(0xd7471088, cellHttpClientSetConnTimeout); + sys_http.AddFunc(0x14bfc765, cellHttpClientGetConnTimeout); + sys_http.AddFunc(0x8aa5fcd3, cellHttpClientSetTotalPoolSize); + sys_http.AddFunc(0x070f1020, cellHttpClientGetTotalPoolSize); + sys_http.AddFunc(0xab1c55ab, cellHttpClientSetPerHostPoolSize); + sys_http.AddFunc(0xffc74003, cellHttpClientGetPerHostPoolSize); + sys_http.AddFunc(0x595adee9, cellHttpClientSetPerHostKeepAliveMax); + sys_http.AddFunc(0x46bcc9ff, cellHttpClientGetPerHostKeepAliveMax); + sys_http.AddFunc(0xdc7ed599, cellHttpClientSetPerPipelineMax); + sys_http.AddFunc(0xd06c90a4, cellHttpClientGetPerPipelineMax); + sys_http.AddFunc(0xbf6e3659, cellHttpClientSetRecvBufferSize); + sys_http.AddFunc(0x130150ea, cellHttpClientGetRecvBufferSize); + //sys_http.AddFunc(, cellHttpClientSetSendBufferSize); + //sys_http.AddFunc(, cellHttpClientGetSendBufferSize); + + sys_http.AddFunc(0x0d9c65be, cellHttpClientGetAllHeaders); + sys_http.AddFunc(0xa34c4b6f, cellHttpClientSetHeader); + sys_http.AddFunc(0xd1ec0b25, cellHttpClientGetHeader); + sys_http.AddFunc(0x4b33942a, cellHttpClientAddHeader); + sys_http.AddFunc(0x617eec02, cellHttpClientDeleteHeader); + + sys_http.AddFunc(0x1395d8d1, cellHttpClientSetSslCallback); + sys_http.AddFunc(0xd8352a40, cellHttpClientSetSslClientCertificate); + + sys_http.AddFunc(0x052a80d9, cellHttpCreateTransaction); + sys_http.AddFunc(0x32f5cae2, cellHttpDestroyTransaction); + sys_http.AddFunc(0x0ef17399, cellHttpTransactionGetUri); + sys_http.AddFunc(0xa0d9223c, cellHttpTransactionCloseConnection); + sys_http.AddFunc(0xd47cc666, cellHttpTransactionReleaseConnection); + sys_http.AddFunc(0x2d52848b, cellHttpTransactionAbortConnection); + + sys_http.AddFunc(0xa755b005, cellHttpSendRequest); + sys_http.AddFunc(0xaf73a64e, cellHttpRequestSetContentLength); + sys_http.AddFunc(0x958323cf, cellHttpRequestGetContentLength); + sys_http.AddFunc(0x8e3f7ee1, cellHttpRequestSetChunkedTransferStatus); + sys_http.AddFunc(0x4137a1f6, cellHttpRequestGetChunkedTransferStatus); + sys_http.AddFunc(0x42205fe0, cellHttpRequestGetAllHeaders); + sys_http.AddFunc(0x54f2a4de, cellHttpRequestSetHeader); + sys_http.AddFunc(0x0b9fea5f, cellHttpRequestGetHeader); + sys_http.AddFunc(0xed993147, cellHttpRequestAddHeader); + sys_http.AddFunc(0x16214411, cellHttpRequestDeleteHeader); + + sys_http.AddFunc(0x61c90691, cellHttpRecvResponse); + sys_http.AddFunc(0xbea17389, cellHttpResponseGetAllHeaders); + sys_http.AddFunc(0x4f5d8d20, cellHttpResponseGetHeader); + sys_http.AddFunc(0x464ff889, cellHttpResponseGetContentLength); + sys_http.AddFunc(0x10d0d7fc, cellHttpResponseGetStatusCode); + sys_http.AddFunc(0x6a81b5e4, cellHttpResponseGetStatusLine); + + sys_http.AddFunc(0x895c604c, cellHttpTransactionGetSslCipherName); + sys_http.AddFunc(0x34061e49, cellHttpTransactionGetSslCipherId); + sys_http.AddFunc(0x93e938e5, cellHttpTransactionGetSslCipherVersion); + sys_http.AddFunc(0x38954133, cellHttpTransactionGetSslCipherBits); + sys_http.AddFunc(0xe3c424b3, cellHttpTransactionGetSslCipherString); + sys_http.AddFunc(0xad1c6f02, cellHttpTransactionGetSslVersion); + sys_http.AddFunc(0x2a78ff04, cellHttpTransactionGetSslId); + + sys_http.AddFunc(0x65691795, cellHttpClientSetSslVersion); + sys_http.AddFunc(0xccf57336, cellHttpClientGetSslVersion); + sys_http.AddFunc(0x7313c78d, cellHttpClientSetSslIdDestroyCallback); +} \ No newline at end of file diff --git a/rpcs3/Emu/SysCalls/Modules/sys_net.cpp b/rpcs3/Emu/SysCalls/Modules/sys_net.cpp new file mode 100644 index 0000000000..3b83186840 --- /dev/null +++ b/rpcs3/Emu/SysCalls/Modules/sys_net.cpp @@ -0,0 +1,400 @@ +#include "stdafx.h" +#include "Emu/SysCalls/SysCalls.h" +#include "Emu/SysCalls/SC_FUNC.h" + +void sys_net_init(); +Module sys_net((u16)0x0000, sys_net_init); + +int accept() +{ + UNIMPLEMENTED_FUNC(sys_net); + return CELL_OK; +} + +int bind() +{ + UNIMPLEMENTED_FUNC(sys_net); + return CELL_OK; +} + +int connect() +{ + UNIMPLEMENTED_FUNC(sys_net); + return CELL_OK; +} + +int gethostbyaddr() +{ + UNIMPLEMENTED_FUNC(sys_net); + return CELL_OK; +} + +int gethostbyname() +{ + UNIMPLEMENTED_FUNC(sys_net); + return CELL_OK; +} + +int getpeername() +{ + UNIMPLEMENTED_FUNC(sys_net); + return CELL_OK; +} + +int getsockname() +{ + UNIMPLEMENTED_FUNC(sys_net); + return CELL_OK; +} + +int getsockopt() +{ + UNIMPLEMENTED_FUNC(sys_net); + return CELL_OK; +} + +int inet_addr() +{ + UNIMPLEMENTED_FUNC(sys_net); + return CELL_OK; +} + +int inet_aton() +{ + UNIMPLEMENTED_FUNC(sys_net); + return CELL_OK; +} + +int inet_lnaof() +{ + UNIMPLEMENTED_FUNC(sys_net); + return CELL_OK; +} + +int inet_makeaddr() +{ + UNIMPLEMENTED_FUNC(sys_net); + return CELL_OK; +} + +int inet_netof() +{ + UNIMPLEMENTED_FUNC(sys_net); + return CELL_OK; +} + +int inet_network() +{ + UNIMPLEMENTED_FUNC(sys_net); + return CELL_OK; +} + +int inet_ntoa() +{ + UNIMPLEMENTED_FUNC(sys_net); + return CELL_OK; +} + +int inet_ntop() +{ + UNIMPLEMENTED_FUNC(sys_net); + return CELL_OK; +} + +int inet_pton() +{ + UNIMPLEMENTED_FUNC(sys_net); + return CELL_OK; +} + +int listen() +{ + UNIMPLEMENTED_FUNC(sys_net); + return CELL_OK; +} + +int recv() +{ + UNIMPLEMENTED_FUNC(sys_net); + return CELL_OK; +} + +int recvfrom() +{ + UNIMPLEMENTED_FUNC(sys_net); + return CELL_OK; +} + +int recvmsg() +{ + UNIMPLEMENTED_FUNC(sys_net); + return CELL_OK; +} + +int send() +{ + UNIMPLEMENTED_FUNC(sys_net); + return CELL_OK; +} + +int sendmsg() +{ + UNIMPLEMENTED_FUNC(sys_net); + return CELL_OK; +} + +int sendto() +{ + UNIMPLEMENTED_FUNC(sys_net); + return CELL_OK; +} + +int setsockopt() +{ + UNIMPLEMENTED_FUNC(sys_net); + return CELL_OK; +} + +int shutdown() +{ + UNIMPLEMENTED_FUNC(sys_net); + return CELL_OK; +} + +int socket() +{ + UNIMPLEMENTED_FUNC(sys_net); + return CELL_OK; +} + +int socketclose() +{ + UNIMPLEMENTED_FUNC(sys_net); + return CELL_OK; +} + +int socketpoll() +{ + UNIMPLEMENTED_FUNC(sys_net); + return CELL_OK; +} + +int socketselect() +{ + UNIMPLEMENTED_FUNC(sys_net); + return CELL_OK; +} + +int sys_net_initialize_network_ex() +{ + UNIMPLEMENTED_FUNC(sys_net); + return CELL_OK; +} + +int sys_net_get_udpp2p_test_param() +{ + UNIMPLEMENTED_FUNC(sys_net); + return CELL_OK; +} + +int sys_net_set_udpp2p_test_param() +{ + UNIMPLEMENTED_FUNC(sys_net); + return CELL_OK; +} + +int sys_net_get_lib_name_server() +{ + UNIMPLEMENTED_FUNC(sys_net); + return CELL_OK; +} + +int sys_net_if_ctl() +{ + UNIMPLEMENTED_FUNC(sys_net); + return CELL_OK; +} + +int sys_net_get_netemu_test_param() +{ + UNIMPLEMENTED_FUNC(sys_net); + return CELL_OK; +} + +int sys_net_get_sockinfo() +{ + UNIMPLEMENTED_FUNC(sys_net); + return CELL_OK; +} + +int sys_net_close_dump() +{ + UNIMPLEMENTED_FUNC(sys_net); + return CELL_OK; +} + +int sys_net_set_test_param() +{ + UNIMPLEMENTED_FUNC(sys_net); + return CELL_OK; +} + +int sys_net_show_nameserver() +{ + UNIMPLEMENTED_FUNC(sys_net); + return CELL_OK; +} + +int _sys_net_errno_loc() +{ + UNIMPLEMENTED_FUNC(sys_net); + return CELL_OK; +} + +int sys_net_set_resolver_configurations() +{ + UNIMPLEMENTED_FUNC(sys_net); + return CELL_OK; +} + +int sys_net_show_route() +{ + UNIMPLEMENTED_FUNC(sys_net); + return CELL_OK; +} + +int sys_net_read_dump() +{ + UNIMPLEMENTED_FUNC(sys_net); + return CELL_OK; +} + +int sys_net_abort_resolver() +{ + UNIMPLEMENTED_FUNC(sys_net); + return CELL_OK; +} + +int sys_net_abort_socket() +{ + UNIMPLEMENTED_FUNC(sys_net); + return CELL_OK; +} + +int sys_net_set_lib_name_server() +{ + UNIMPLEMENTED_FUNC(sys_net); + return CELL_OK; +} + +int sys_net_get_test_param() +{ + UNIMPLEMENTED_FUNC(sys_net); + return CELL_OK; +} + +int sys_net_get_sockinfo_ex() +{ + UNIMPLEMENTED_FUNC(sys_net); + return CELL_OK; +} + +int sys_net_open_dump() +{ + UNIMPLEMENTED_FUNC(sys_net); + return CELL_OK; +} + +int sys_net_show_ifconfig() +{ + UNIMPLEMENTED_FUNC(sys_net); + return CELL_OK; +} + +int sys_net_finalize_network() +{ + UNIMPLEMENTED_FUNC(sys_net); + return CELL_OK; +} + +int _sys_net_h_errno_loc() +{ + UNIMPLEMENTED_FUNC(sys_net); + return CELL_OK; +} + +int sys_net_set_netemu_test_param() +{ + UNIMPLEMENTED_FUNC(sys_net); + return CELL_OK; +} + +int sys_net_free_thread_context() +{ + UNIMPLEMENTED_FUNC(sys_net); + return CELL_OK; +} + +void sys_net_init() +{ + // (TODO: Fix function overloading problem due to winsock.h and find addresses for ntohl and ntohs) + + //sys_net.AddFunc(0xc94f6939, accept); + //sys_net.AddFunc(0xb0a59804, bind); + //sys_net.AddFunc(0x64f66d35, connect); + //sys_net.AddFunc(0xf7ac8941, gethostbyaddr); + //sys_net.AddFunc(0x71f4c717, gethostbyname); + //sys_net.AddFunc(0xf9ec2db6, getpeername); + //sys_net.AddFunc(0x13efe7f5, getsockname); + //sys_net.AddFunc(0x5a045bd1, getsockopt); + //sys_net.AddFunc(0xdabbc2c0, inet_addr); + sys_net.AddFunc(0xa9a079e0, inet_aton); + sys_net.AddFunc(0x566893ce, inet_lnaof); + sys_net.AddFunc(0xb4152c74, inet_makeaddr); + sys_net.AddFunc(0xe39a62a7, inet_netof); + sys_net.AddFunc(0x506ad863, inet_network); + //sys_net.AddFunc(0x858a930b, inet_ntoa); + sys_net.AddFunc(0xc98a3146, inet_ntop); + sys_net.AddFunc(0x8af3825e, inet_pton); + //sys_net.AddFunc(0x28e208bb, listen); + //sys_net.AddFunc(, ntohl); + //sys_net.AddFunc(, ntohs); + //sys_net.AddFunc(0xfba04f37, recv); + //sys_net.AddFunc(0x1f953b9f, recvfrom); + sys_net.AddFunc(0xc9d09c34, recvmsg); + //sys_net.AddFunc(0xdc751b40, send); + sys_net.AddFunc(0xad09481b, sendmsg); + //sys_net.AddFunc(0x9647570b, sendto); + //sys_net.AddFunc(0x88f03575, setsockopt); + //sys_net.AddFunc(0xa50777c6, shutdown); + //sys_net.AddFunc(0x9c056962, socket); + sys_net.AddFunc(0x6db6e8cd, socketclose); + sys_net.AddFunc(0x051ee3ee, socketpoll); + sys_net.AddFunc(0x3f09e20a, socketselect); + + sys_net.AddFunc(0x139a9e9b, sys_net_initialize_network_ex); + sys_net.AddFunc(0x05bd4438, sys_net_get_udpp2p_test_param); + sys_net.AddFunc(0x10b81ed6, sys_net_set_udpp2p_test_param); + sys_net.AddFunc(0x1d14d6e4, sys_net_get_lib_name_server); + sys_net.AddFunc(0x27fb339d, sys_net_if_ctl); + sys_net.AddFunc(0x368823c0, sys_net_get_netemu_test_param); + sys_net.AddFunc(0x3b27c780, sys_net_get_sockinfo); + sys_net.AddFunc(0x44328aa2, sys_net_close_dump); + sys_net.AddFunc(0x4ab0b9b9, sys_net_set_test_param); + sys_net.AddFunc(0x5420e419, sys_net_show_nameserver); + sys_net.AddFunc(0x6005cde1, _sys_net_errno_loc); + sys_net.AddFunc(0x7687d48c, sys_net_set_resolver_configurations); + sys_net.AddFunc(0x79b61646, sys_net_show_route); + sys_net.AddFunc(0x89c9917c, sys_net_read_dump); + sys_net.AddFunc(0x8ccf05ed, sys_net_abort_resolver); + sys_net.AddFunc(0x8d1b77fb, sys_net_abort_socket); + sys_net.AddFunc(0x9a318259, sys_net_set_lib_name_server); + sys_net.AddFunc(0xa5a86557, sys_net_get_test_param); + sys_net.AddFunc(0xa765d029, sys_net_get_sockinfo_ex); + sys_net.AddFunc(0xab447704, sys_net_open_dump); + sys_net.AddFunc(0xb48636c4, sys_net_show_ifconfig); + sys_net.AddFunc(0xb68d5625, sys_net_finalize_network); + sys_net.AddFunc(0xc9157d30, _sys_net_h_errno_loc); + sys_net.AddFunc(0xe2434507, sys_net_set_netemu_test_param); + sys_net.AddFunc(0xfdb8f926, sys_net_free_thread_context); +} \ No newline at end of file diff --git a/rpcs3/rpcs3.vcxproj b/rpcs3/rpcs3.vcxproj index 893c671409..5e0366b69d 100644 --- a/rpcs3/rpcs3.vcxproj +++ b/rpcs3/rpcs3.vcxproj @@ -250,14 +250,18 @@ + + + + diff --git a/rpcs3/rpcs3.vcxproj.filters b/rpcs3/rpcs3.vcxproj.filters index 1606f87a8a..ffab6ca23c 100644 --- a/rpcs3/rpcs3.vcxproj.filters +++ b/rpcs3/rpcs3.vcxproj.filters @@ -307,6 +307,18 @@ Emu\SysCalls\lv2 + + Emu\SysCalls\Modules + + + Emu\SysCalls\Modules + + + Emu\SysCalls\Modules + + + Emu\SysCalls\Modules + From afb9273823d7ef3c70219d44a9bd766983151683 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Alexandro=20S=C3=A1nchez=20Bach?= Date: Sat, 28 Sep 2013 04:36:57 +0200 Subject: [PATCH 2/4] More dummy modules * 41 new dummy modules created. NOTE: I have detached the previous 4 dummy modules of my last commit (1a85ccbbf4) from the project since they will consume space of the executable, and compilation time and don't provide anything useful yet, the same applies to this commit. The only reason to provide this dummy modules is to avoid that developers have to spend too much time on creating the template of the module before implementing functions. If you want to implement a function of any of these modules, add the corresponding file to the project first. --- rpcs3/Emu/SysCalls/Modules/cellAdec.cpp | 83 ++ rpcs3/Emu/SysCalls/Modules/cellAtrac.cpp | 205 ++++ rpcs3/Emu/SysCalls/Modules/cellBgdl.cpp | 49 + rpcs3/Emu/SysCalls/Modules/cellCamera.cpp | 242 +++++ rpcs3/Emu/SysCalls/Modules/cellCelp8Enc.cpp | 84 ++ rpcs3/Emu/SysCalls/Modules/cellCelpEnc.cpp | 84 ++ rpcs3/Emu/SysCalls/Modules/cellDmux.cpp | 160 +++ rpcs3/Emu/SysCalls/Modules/cellFiber.cpp | 361 +++++++ rpcs3/Emu/SysCalls/Modules/cellGame.cpp | 147 +++ rpcs3/Emu/SysCalls/Modules/cellGem.cpp | 284 ++++++ rpcs3/Emu/SysCalls/Modules/cellImejp.cpp | 306 ++++++ rpcs3/Emu/SysCalls/Modules/cellJpgEnc.cpp | 91 ++ rpcs3/Emu/SysCalls/Modules/cellKey2char.cpp | 57 ++ rpcs3/Emu/SysCalls/Modules/cellL10n.cpp | 11 + rpcs3/Emu/SysCalls/Modules/cellLv2dbg.cpp | 269 +++++ rpcs3/Emu/SysCalls/Modules/cellMic.cpp | 331 +++++++ .../Emu/SysCalls/Modules/cellMusicDecode.cpp | 100 ++ .../Emu/SysCalls/Modules/cellMusicExport.cpp | 62 ++ rpcs3/Emu/SysCalls/Modules/cellNetCtl.cpp | 124 +++ rpcs3/Emu/SysCalls/Modules/cellOvis.cpp | 46 + rpcs3/Emu/SysCalls/Modules/cellPamf.cpp | 183 ++++ .../Emu/SysCalls/Modules/cellPhotoDecode.cpp | 51 + .../Emu/SysCalls/Modules/cellPhotoExport.cpp | 63 ++ .../Emu/SysCalls/Modules/cellPhotoImport.cpp | 37 + rpcs3/Emu/SysCalls/Modules/cellPngEnc.cpp | 84 ++ rpcs3/Emu/SysCalls/Modules/cellPrint.cpp | 107 ++ rpcs3/Emu/SysCalls/Modules/cellRtc.cpp | 267 +++++ rpcs3/Emu/SysCalls/Modules/cellRudp.cpp | 257 +++++ rpcs3/Emu/SysCalls/Modules/cellSail.cpp | 920 ++++++++++++++++++ rpcs3/Emu/SysCalls/Modules/cellSailRec.cpp | 288 ++++++ rpcs3/Emu/SysCalls/Modules/cellScreenshot.cpp | 49 + rpcs3/Emu/SysCalls/Modules/cellSearch.cpp | 176 ++++ rpcs3/Emu/SysCalls/Modules/cellSheap.cpp | 148 +++ rpcs3/Emu/SysCalls/Modules/cellSubdisplay.cpp | 95 ++ rpcs3/Emu/SysCalls/Modules/cellSync2.cpp | 254 +++++ rpcs3/Emu/SysCalls/Modules/cellSysutilAp.cpp | 44 + rpcs3/Emu/SysCalls/Modules/cellUsbd.cpp | 208 ++++ rpcs3/Emu/SysCalls/Modules/cellUsbpspcm.cpp | 216 ++++ rpcs3/Emu/SysCalls/Modules/cellVdec.cpp | 97 ++ rpcs3/Emu/SysCalls/Modules/cellVoice.cpp | 271 ++++++ rpcs3/Emu/SysCalls/Modules/cellVpost.cpp | 182 ++++ rpcs3/rpcs3.vcxproj | 4 - rpcs3/rpcs3.vcxproj.filters | 12 - 43 files changed, 7093 insertions(+), 16 deletions(-) create mode 100644 rpcs3/Emu/SysCalls/Modules/cellAdec.cpp create mode 100644 rpcs3/Emu/SysCalls/Modules/cellAtrac.cpp create mode 100644 rpcs3/Emu/SysCalls/Modules/cellBgdl.cpp create mode 100644 rpcs3/Emu/SysCalls/Modules/cellCamera.cpp create mode 100644 rpcs3/Emu/SysCalls/Modules/cellCelp8Enc.cpp create mode 100644 rpcs3/Emu/SysCalls/Modules/cellCelpEnc.cpp create mode 100644 rpcs3/Emu/SysCalls/Modules/cellDmux.cpp create mode 100644 rpcs3/Emu/SysCalls/Modules/cellFiber.cpp create mode 100644 rpcs3/Emu/SysCalls/Modules/cellGame.cpp create mode 100644 rpcs3/Emu/SysCalls/Modules/cellGem.cpp create mode 100644 rpcs3/Emu/SysCalls/Modules/cellImejp.cpp create mode 100644 rpcs3/Emu/SysCalls/Modules/cellJpgEnc.cpp create mode 100644 rpcs3/Emu/SysCalls/Modules/cellKey2char.cpp create mode 100644 rpcs3/Emu/SysCalls/Modules/cellL10n.cpp create mode 100644 rpcs3/Emu/SysCalls/Modules/cellLv2dbg.cpp create mode 100644 rpcs3/Emu/SysCalls/Modules/cellMic.cpp create mode 100644 rpcs3/Emu/SysCalls/Modules/cellMusicDecode.cpp create mode 100644 rpcs3/Emu/SysCalls/Modules/cellMusicExport.cpp create mode 100644 rpcs3/Emu/SysCalls/Modules/cellNetCtl.cpp create mode 100644 rpcs3/Emu/SysCalls/Modules/cellOvis.cpp create mode 100644 rpcs3/Emu/SysCalls/Modules/cellPamf.cpp create mode 100644 rpcs3/Emu/SysCalls/Modules/cellPhotoDecode.cpp create mode 100644 rpcs3/Emu/SysCalls/Modules/cellPhotoExport.cpp create mode 100644 rpcs3/Emu/SysCalls/Modules/cellPhotoImport.cpp create mode 100644 rpcs3/Emu/SysCalls/Modules/cellPngEnc.cpp create mode 100644 rpcs3/Emu/SysCalls/Modules/cellPrint.cpp create mode 100644 rpcs3/Emu/SysCalls/Modules/cellRtc.cpp create mode 100644 rpcs3/Emu/SysCalls/Modules/cellRudp.cpp create mode 100644 rpcs3/Emu/SysCalls/Modules/cellSail.cpp create mode 100644 rpcs3/Emu/SysCalls/Modules/cellSailRec.cpp create mode 100644 rpcs3/Emu/SysCalls/Modules/cellScreenshot.cpp create mode 100644 rpcs3/Emu/SysCalls/Modules/cellSearch.cpp create mode 100644 rpcs3/Emu/SysCalls/Modules/cellSheap.cpp create mode 100644 rpcs3/Emu/SysCalls/Modules/cellSubdisplay.cpp create mode 100644 rpcs3/Emu/SysCalls/Modules/cellSync2.cpp create mode 100644 rpcs3/Emu/SysCalls/Modules/cellSysutilAp.cpp create mode 100644 rpcs3/Emu/SysCalls/Modules/cellUsbd.cpp create mode 100644 rpcs3/Emu/SysCalls/Modules/cellUsbpspcm.cpp create mode 100644 rpcs3/Emu/SysCalls/Modules/cellVdec.cpp create mode 100644 rpcs3/Emu/SysCalls/Modules/cellVoice.cpp create mode 100644 rpcs3/Emu/SysCalls/Modules/cellVpost.cpp 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 - From 9bb2d082e6ecf8a350d7e7b2ee6697eaf27a9766 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Alexandro=20S=C3=A1nchez=20Bach?= Date: Sat, 28 Sep 2013 16:30:04 +0200 Subject: [PATCH 3/4] Some Modules updated to use mem*_t class cellKb, cellMouse and cellSysutil now use the mem*_t instances instead of using "u32 *_addr" variables. --- rpcs3/Emu/SysCalls/Modules/cellSysutil.cpp | 36 +++++++++++----------- rpcs3/Emu/SysCalls/SysCalls.h | 18 +++++------ rpcs3/Emu/SysCalls/lv2/SC_Keyboard.cpp | 16 ++++------ rpcs3/Emu/SysCalls/lv2/SC_Mouse.cpp | 24 ++++++--------- 4 files changed, 43 insertions(+), 51 deletions(-) diff --git a/rpcs3/Emu/SysCalls/Modules/cellSysutil.cpp b/rpcs3/Emu/SysCalls/Modules/cellSysutil.cpp index 643879ccdd..7de4712186 100644 --- a/rpcs3/Emu/SysCalls/Modules/cellSysutil.cpp +++ b/rpcs3/Emu/SysCalls/Modules/cellSysutil.cpp @@ -107,11 +107,11 @@ void cellVideoOutGetDeviceInfo() UNIMPLEMENTED_FUNC(cellSysutil); } -int cellSysutilGetSystemParamInt(int id, u32 value_addr) +int cellSysutilGetSystemParamInt(int id, mem32_t value) { - cellSysutil.Log("cellSysutilGetSystemParamInt(id=0x%x, value_addr=0x%x)", id, value_addr); + cellSysutil.Log("cellSysutilGetSystemParamInt(id=0x%x, value_addr=0x%x)", id, value.GetAddr()); - if(!Memory.IsGoodAddr(value_addr)) + if(!Memory.IsGoodAddr(value.IsGood())) { return CELL_EFAULT; } @@ -120,77 +120,77 @@ int cellSysutilGetSystemParamInt(int id, u32 value_addr) { case CELL_SYSUTIL_SYSTEMPARAM_ID_LANG: cellSysutil.Warning("cellSysutilGetSystemParamInt: CELL_SYSUTIL_SYSTEMPARAM_ID_LANG"); - Memory.Write32(value_addr, CELL_SYSUTIL_LANG_ENGLISH_US); + value = CELL_SYSUTIL_LANG_ENGLISH_US; break; case CELL_SYSUTIL_SYSTEMPARAM_ID_ENTER_BUTTON_ASSIGN: cellSysutil.Warning("cellSysutilGetSystemParamInt: CELL_SYSUTIL_SYSTEMPARAM_ID_ENTER_BUTTON_ASSIGN"); - Memory.Write32(value_addr, CELL_SYSUTIL_ENTER_BUTTON_ASSIGN_CROSS); + value = CELL_SYSUTIL_ENTER_BUTTON_ASSIGN_CROSS; break; case CELL_SYSUTIL_SYSTEMPARAM_ID_DATE_FORMAT: cellSysutil.Warning("cellSysutilGetSystemParamInt: CELL_SYSUTIL_SYSTEMPARAM_ID_DATE_FORMAT"); - Memory.Write32(value_addr, CELL_SYSUTIL_DATE_FMT_DDMMYYYY); + value = CELL_SYSUTIL_DATE_FMT_DDMMYYYY; break; case CELL_SYSUTIL_SYSTEMPARAM_ID_TIME_FORMAT: cellSysutil.Warning("cellSysutilGetSystemParamInt: CELL_SYSUTIL_SYSTEMPARAM_ID_TIME_FORMAT"); - Memory.Write32(value_addr, CELL_SYSUTIL_TIME_FMT_CLOCK24); + value = CELL_SYSUTIL_TIME_FMT_CLOCK24; break; case CELL_SYSUTIL_SYSTEMPARAM_ID_TIMEZONE: cellSysutil.Warning("cellSysutilGetSystemParamInt: CELL_SYSUTIL_SYSTEMPARAM_ID_TIMEZONE"); - Memory.Write32(value_addr, 3); + value = 3; break; case CELL_SYSUTIL_SYSTEMPARAM_ID_SUMMERTIME: cellSysutil.Warning("cellSysutilGetSystemParamInt: CELL_SYSUTIL_SYSTEMPARAM_ID_SUMMERTIME"); - Memory.Write32(value_addr, 1); + value = 1; break; case CELL_SYSUTIL_SYSTEMPARAM_ID_GAME_PARENTAL_LEVEL: cellSysutil.Warning("cellSysutilGetSystemParamInt: CELL_SYSUTIL_SYSTEMPARAM_ID_GAME_PARENTAL_LEVEL"); - Memory.Write32(value_addr, CELL_SYSUTIL_GAME_PARENTAL_OFF); + value = CELL_SYSUTIL_GAME_PARENTAL_OFF; break; case CELL_SYSUTIL_SYSTEMPARAM_ID_GAME_PARENTAL_LEVEL0_RESTRICT: cellSysutil.Warning("cellSysutilGetSystemParamInt: CELL_SYSUTIL_SYSTEMPARAM_ID_GAME_PARENTAL_LEVEL0_RESTRICT"); - Memory.Write32(value_addr, CELL_SYSUTIL_GAME_PARENTAL_LEVEL0_RESTRICT_OFF); + value = CELL_SYSUTIL_GAME_PARENTAL_LEVEL0_RESTRICT_OFF; break; case CELL_SYSUTIL_SYSTEMPARAM_ID_CURRENT_USER_HAS_NP_ACCOUNT: cellSysutil.Warning("cellSysutilGetSystemParamInt: CELL_SYSUTIL_SYSTEMPARAM_ID_CURRENT_USER_HAS_NP_ACCOUNT"); - Memory.Write32(value_addr, 0); + value = 0; break; case CELL_SYSUTIL_SYSTEMPARAM_ID_CAMERA_PLFREQ: cellSysutil.Warning("cellSysutilGetSystemParamInt: CELL_SYSUTIL_SYSTEMPARAM_ID_CAMERA_PLFREQ"); - Memory.Write32(value_addr, CELL_SYSUTIL_CAMERA_PLFREQ_DISABLED); + value = CELL_SYSUTIL_CAMERA_PLFREQ_DISABLED; break; case CELL_SYSUTIL_SYSTEMPARAM_ID_PAD_RUMBLE: cellSysutil.Warning("cellSysutilGetSystemParamInt: CELL_SYSUTIL_SYSTEMPARAM_ID_PAD_RUMBLE"); - Memory.Write32(value_addr, CELL_SYSUTIL_PAD_RUMBLE_OFF); + value = CELL_SYSUTIL_PAD_RUMBLE_OFF; break; case CELL_SYSUTIL_SYSTEMPARAM_ID_KEYBOARD_TYPE: cellSysutil.Warning("cellSysutilGetSystemParamInt: CELL_SYSUTIL_SYSTEMPARAM_ID_KEYBOARD_TYPE"); - Memory.Write32(value_addr, 0); + value = 0; break; case CELL_SYSUTIL_SYSTEMPARAM_ID_JAPANESE_KEYBOARD_ENTRY_METHOD: cellSysutil.Warning("cellSysutilGetSystemParamInt: CELL_SYSUTIL_SYSTEMPARAM_ID_JAPANESE_KEYBOARD_ENTRY_METHOD"); - Memory.Write32(value_addr, 0); + value = 0; break; case CELL_SYSUTIL_SYSTEMPARAM_ID_CHINESE_KEYBOARD_ENTRY_METHOD: cellSysutil.Warning("cellSysutilGetSystemParamInt: CELL_SYSUTIL_SYSTEMPARAM_ID_CHINESE_KEYBOARD_ENTRY_METHOD"); - Memory.Write32(value_addr, 0); + value = 0; break; case CELL_SYSUTIL_SYSTEMPARAM_ID_PAD_AUTOOFF: cellSysutil.Warning("cellSysutilGetSystemParamInt: CELL_SYSUTIL_SYSTEMPARAM_ID_PAD_AUTOOFF"); - Memory.Write32(value_addr, 0); + value = 0; break; default: diff --git a/rpcs3/Emu/SysCalls/SysCalls.h b/rpcs3/Emu/SysCalls/SysCalls.h index f7ac186209..df23bcdf29 100644 --- a/rpcs3/Emu/SysCalls/SysCalls.h +++ b/rpcs3/Emu/SysCalls/SysCalls.h @@ -224,24 +224,24 @@ extern int cellKbInit(u32 max_connect); extern int cellKbEnd(); extern int cellKbClearBuf(u32 port_no); extern u16 cellKbCnvRawCode(u32 arrange, u32 mkey, u32 led, u16 rawcode); -extern int cellKbGetInfo(u32 info_addr); -extern int cellKbRead(u32 port_no, u32 data_addr); +extern int cellKbGetInfo(mem_class_t info); +extern int cellKbRead(u32 port_no, mem_class_t data); extern int cellKbSetCodeType(u32 port_no, u32 type); extern int cellKbSetLEDStatus(u32 port_no, u8 led); extern int cellKbSetReadMode(u32 port_no, u32 rmode); -extern int cellKbGetConfiguration(u32 port_no, u32 config_addr); +extern int cellKbGetConfiguration(u32 port_no, mem_class_t config); //cellMouse extern int cellMouseInit(u32 max_connect); extern int cellMouseClearBuf(u32 port_no); extern int cellMouseEnd(); -extern int cellMouseGetInfo(u32 info_addr); -extern int cellMouseInfoTabletMode(u32 port_no, u32 info_addr); -extern int cellMouseGetData(u32 port_no, u32 data_addr); -extern int cellMouseGetDataList(u32 port_no, u32 data_addr); +extern int cellMouseGetInfo(mem_class_t info); +extern int cellMouseInfoTabletMode(u32 port_no, mem_class_t info); +extern int cellMouseGetData(u32 port_no, mem_class_t data); +extern int cellMouseGetDataList(u32 port_no, mem_class_t data); extern int cellMouseSetTabletMode(u32 port_no, u32 mode); -extern int cellMouseGetTabletDataList(u32 port_no, u32 data_addr); -extern int cellMouseGetRawData(u32 port_no, u32 data_addr); +extern int cellMouseGetTabletDataList(u32 port_no, mem_class_t data); +extern int cellMouseGetRawData(u32 port_no, mem_class_t data); //cellGcm extern int cellGcmCallback(u32 context_addr, u32 count); diff --git a/rpcs3/Emu/SysCalls/lv2/SC_Keyboard.cpp b/rpcs3/Emu/SysCalls/lv2/SC_Keyboard.cpp index f01e368e91..ccd3b09acc 100644 --- a/rpcs3/Emu/SysCalls/lv2/SC_Keyboard.cpp +++ b/rpcs3/Emu/SysCalls/lv2/SC_Keyboard.cpp @@ -93,13 +93,12 @@ u16 cellKbCnvRawCode(u32 arrange, u32 mkey, u32 led, u16 rawcode) return 0x0000; } -int cellKbGetInfo(u32 info_addr) +int cellKbGetInfo(mem_class_t info) { - sys_io.Log("cellKbGetInfo(info_addr=0x%x)", info_addr); + sys_io.Log("cellKbGetInfo(info_addr=0x%x)", info.GetAddr()); if(!Emu.GetKeyboardManager().IsInited()) return CELL_KB_ERROR_UNINITIALIZED; const KbInfo& current_info = Emu.GetKeyboardManager().GetInfo(); - mem_class_t info(info_addr); info += current_info.max_connect; info += current_info.now_connect; info += current_info.info; @@ -111,17 +110,15 @@ int cellKbGetInfo(u32 info_addr) return CELL_OK; } -int cellKbRead(u32 port_no, u32 data_addr) +int cellKbRead(u32 port_no, mem_class_t data) { - sys_io.Log("cellKbRead(port_no=%d,info_addr=0x%x)", port_no, data_addr); + sys_io.Log("cellKbRead(port_no=%d,info_addr=0x%x)", port_no, data.GetAddr()); const Array& keyboards = Emu.GetKeyboardManager().GetKeyboards(); if(!Emu.GetKeyboardManager().IsInited()) return CELL_KB_ERROR_UNINITIALIZED; if(port_no >= keyboards.GetCount()) return CELL_KB_ERROR_INVALID_PARAMETER; CellKbData& current_data = Emu.GetKeyboardManager().GetData(port_no); - - mem_class_t data(data_addr); data += current_data.led; data += current_data.mkey; data += min((u32)current_data.len, CELL_KB_MAX_KEYCODES); @@ -162,13 +159,12 @@ int cellKbSetReadMode(u32 port_no, u32 rmode) return CELL_OK; } -int cellKbGetConfiguration(u32 port_no, u32 config_addr) +int cellKbGetConfiguration(u32 port_no, mem_class_t config) { - sys_io.Log("cellKbGetConfiguration(port_no=%d,config_addr=0x%x)", port_no, config_addr); + sys_io.Log("cellKbGetConfiguration(port_no=%d,config_addr=0x%x)", port_no, config.GetAddr()); if(!Emu.GetKeyboardManager().IsInited()) return CELL_KB_ERROR_UNINITIALIZED; const CellKbConfig& current_config = Emu.GetKeyboardManager().GetConfig(port_no); - mem_class_t config(config_addr); config += current_config.arrange; config += current_config.read_mode; config += current_config.code_type; diff --git a/rpcs3/Emu/SysCalls/lv2/SC_Mouse.cpp b/rpcs3/Emu/SysCalls/lv2/SC_Mouse.cpp index 9161fba651..4145989fb6 100644 --- a/rpcs3/Emu/SysCalls/lv2/SC_Mouse.cpp +++ b/rpcs3/Emu/SysCalls/lv2/SC_Mouse.cpp @@ -46,13 +46,12 @@ int cellMouseEnd() return CELL_OK; } -int cellMouseGetInfo(u32 info_addr) +int cellMouseGetInfo(mem_class_t info) { - sys_io.Log("cellMouseGetInfo(info_addr=0x%x)", info_addr); + sys_io.Log("cellMouseGetInfo(info_addr=0x%x)", info.GetAddr()); if(!Emu.GetMouseManager().IsInited()) return CELL_MOUSE_ERROR_UNINITIALIZED; const MouseInfo& current_info = Emu.GetMouseManager().GetInfo(); - mem_class_t info(info_addr); info += current_info.max_connect; info += current_info.now_connect; info += current_info.info; @@ -63,27 +62,25 @@ int cellMouseGetInfo(u32 info_addr) return CELL_OK; } -int cellMouseInfoTabletMode(u32 port_no, u32 info_addr) +int cellMouseInfoTabletMode(u32 port_no, mem_class_t info) { - sys_io.Log("cellMouseInfoTabletMode(port_no=%d,info_addr=0x%x)", port_no,info_addr); + sys_io.Log("cellMouseInfoTabletMode(port_no=%d,info_addr=0x%x)", port_no, info.GetAddr()); if(!Emu.GetMouseManager().IsInited()) return CELL_MOUSE_ERROR_UNINITIALIZED; if(port_no >= Emu.GetMouseManager().GetMice().GetCount()) return CELL_MOUSE_ERROR_INVALID_PARAMETER; - mem_class_t info(info_addr); info += 0; // Unimplemented: (0=Tablet mode is not supported) info += 1; // Unimplemented: (1=Mouse mode) return CELL_OK; } -int cellMouseGetData(u32 port_no, u32 data_addr) +int cellMouseGetData(u32 port_no, mem_class_t data) { - sys_io.Log("cellMouseGetData(port_no=%d,data_addr=0x%x)", port_no,data_addr); + sys_io.Log("cellMouseGetData(port_no=%d,data_addr=0x%x)", port_no, data.GetAddr()); if(!Emu.GetMouseManager().IsInited()) return CELL_MOUSE_ERROR_UNINITIALIZED; if(port_no >= Emu.GetMouseManager().GetMice().GetCount()) return CELL_MOUSE_ERROR_NO_DEVICE; CellMouseData& current_data = Emu.GetMouseManager().GetData(port_no); - mem_class_t data(data_addr); data += current_data.update; data += current_data.buttons; data += current_data.x_axis; @@ -99,7 +96,7 @@ int cellMouseGetData(u32 port_no, u32 data_addr) return CELL_OK; } -int cellMouseGetDataList(u32 port_no, u32 data_addr) +int cellMouseGetDataList(u32 port_no, mem_class_t data) { UNIMPLEMENTED_FUNC(sys_io); @@ -113,23 +110,22 @@ int cellMouseSetTabletMode(u32 port_no, u32 mode) return CELL_OK; } -int cellMouseGetTabletDataList(u32 port_no, u32 data_addr) +int cellMouseGetTabletDataList(u32 port_no, mem_class_t data) { UNIMPLEMENTED_FUNC(sys_io); return CELL_OK; } -int cellMouseGetRawData(u32 port_no, u32 data_addr) +int cellMouseGetRawData(u32 port_no, mem_class_t data) { UNIMPLEMENTED_FUNC(sys_io); - /*sys_io.Log("cellMouseGetRawData(port_no=%d,data_addr=0x%x)", port_no,data_addr); + /*sys_io.Log("cellMouseGetRawData(port_no=%d,data_addr=0x%x)", port_no, data.GetAddr()); if(!Emu.GetMouseManager().IsInited()) return CELL_MOUSE_ERROR_UNINITIALIZED; if(port_no >= Emu.GetMouseManager().GetMice().GetCount()) return CELL_MOUSE_ERROR_NO_DEVICE; CellMouseRawData& current_rawdata = Emu.GetMouseManager().GetRawData(port_no); - mem_class_t data(data_addr); data += current_rawdata.len; for(s32 i=0; i Date: Sat, 28 Sep 2013 23:05:56 +0200 Subject: [PATCH 4/4] Small issue fixed --- rpcs3/Emu/SysCalls/Modules/cellSysutil.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/rpcs3/Emu/SysCalls/Modules/cellSysutil.cpp b/rpcs3/Emu/SysCalls/Modules/cellSysutil.cpp index 7de4712186..e6f0090ee1 100644 --- a/rpcs3/Emu/SysCalls/Modules/cellSysutil.cpp +++ b/rpcs3/Emu/SysCalls/Modules/cellSysutil.cpp @@ -111,7 +111,7 @@ int cellSysutilGetSystemParamInt(int id, mem32_t value) { cellSysutil.Log("cellSysutilGetSystemParamInt(id=0x%x, value_addr=0x%x)", id, value.GetAddr()); - if(!Memory.IsGoodAddr(value.IsGood())) + if(!value.IsGood()) { return CELL_EFAULT; }