archive/rpcs3
1
0
Fork 0
mirror of https://github.com/RPCS3/rpcs3.git synced 2025-07-09 16:31:28 +12:00
Code Issues Projects Releases Packages Wiki Activity Actions

PRX_DEBUG removed

Browse source
This commit is contained in:
Nekotekina 2015-02-19 01:54:31 +03:00
parent d177b1adea
commit e84fc6426c
8 changed files with 361 additions and 2015 deletions
Download patch file Download diff file Expand all files Collapse all files

144
rpcs3/Emu/SysCalls/Modules/cellAtrac.cpp
View file

@ -7,65 +7,44 @@ extern Module cellAtrac;
#include "cellAtrac.h" #include "cellAtrac.h"
#ifdef PRX_DEBUG s32 cellAtracSetDataAndGetMemSize(vm::ptr<CellAtracHandle> pHandle, u32 pucBufferAddr, u32 uiReadByte, u32 uiBufferByte, vm::ptr<u32> puiWorkMemByte)
#include "prx_libatrac3plus.h"
u32 libatrac3plus;
u32 libatrac3plus_rtoc;
#endif
s64 cellAtracSetDataAndGetMemSize(vm::ptr<CellAtracHandle> pHandle, u32 pucBufferAddr, u32 uiReadByte, u32 uiBufferByte, vm::ptr<u32> puiWorkMemByte)
{ {
cellAtrac.Warning("cellAtracSetDataAndGetMemSize(pHandle=0x%x, pucBufferAddr=0x%x, uiReadByte=0x%x, uiBufferByte=0x%x, puiWorkMemByte_addr=0x%x)", cellAtrac.Warning("cellAtracSetDataAndGetMemSize(pHandle=0x%x, pucBufferAddr=0x%x, uiReadByte=0x%x, uiBufferByte=0x%x, puiWorkMemByte_addr=0x%x)",
pHandle.addr(), pucBufferAddr, uiReadByte, uiBufferByte, puiWorkMemByte.addr()); pHandle.addr(), pucBufferAddr, uiReadByte, uiBufferByte, puiWorkMemByte.addr());
#ifdef PRX_DEBUG
return GetCurrentPPUThread().FastCall2(libatrac3plus + 0x11F4, libatrac3plus_rtoc);
#endif
*puiWorkMemByte = 0x1000; // unproved *puiWorkMemByte = 0x1000; // unproved
return CELL_OK; return CELL_OK;
} }
s64 cellAtracCreateDecoder(vm::ptr<CellAtracHandle> pHandle, u32 pucWorkMem_addr, u32 uiPpuThreadPriority, u32 uiSpuThreadPriority) s32 cellAtracCreateDecoder(vm::ptr<CellAtracHandle> pHandle, u32 pucWorkMem_addr, u32 uiPpuThreadPriority, u32 uiSpuThreadPriority)
{ {
cellAtrac.Warning("cellAtracCreateDecoder(pHandle=0x%x, pucWorkMem_addr=0x%x, uiPpuThreadPriority=%d, uiSpuThreadPriority=%d)", cellAtrac.Warning("cellAtracCreateDecoder(pHandle=0x%x, pucWorkMem_addr=0x%x, uiPpuThreadPriority=%d, uiSpuThreadPriority=%d)",
pHandle.addr(), pucWorkMem_addr, uiPpuThreadPriority, uiSpuThreadPriority); pHandle.addr(), pucWorkMem_addr, uiPpuThreadPriority, uiSpuThreadPriority);
#ifdef PRX_DEBUG
return GetCurrentPPUThread().FastCall2(libatrac3plus + 0x0FF0, libatrac3plus_rtoc);
#endif
pHandle->data.pucWorkMem_addr = pucWorkMem_addr; pHandle->data.pucWorkMem_addr = pucWorkMem_addr;
return CELL_OK; return CELL_OK;
} }
s64 cellAtracCreateDecoderExt(vm::ptr<CellAtracHandle> pHandle, u32 pucWorkMem_addr, u32 uiPpuThreadPriority, vm::ptr<CellAtracExtRes> pExtRes) s32 cellAtracCreateDecoderExt(vm::ptr<CellAtracHandle> pHandle, u32 pucWorkMem_addr, u32 uiPpuThreadPriority, vm::ptr<CellAtracExtRes> pExtRes)
{ {
cellAtrac.Warning("cellAtracCreateDecoderExt(pHandle=0x%x, pucWorkMem_addr=0x%x, uiPpuThreadPriority=%d, pExtRes_addr=0x%x)", cellAtrac.Warning("cellAtracCreateDecoderExt(pHandle=0x%x, pucWorkMem_addr=0x%x, uiPpuThreadPriority=%d, pExtRes_addr=0x%x)",
pHandle.addr(), pucWorkMem_addr, uiPpuThreadPriority, pExtRes.addr()); pHandle.addr(), pucWorkMem_addr, uiPpuThreadPriority, pExtRes.addr());
#ifdef PRX_DEBUG
return GetCurrentPPUThread().FastCall2(libatrac3plus + 0x0DB0, libatrac3plus_rtoc);
#endif
pHandle->data.pucWorkMem_addr = pucWorkMem_addr; pHandle->data.pucWorkMem_addr = pucWorkMem_addr;
return CELL_OK; return CELL_OK;
} }
s64 cellAtracDeleteDecoder(vm::ptr<CellAtracHandle> pHandle) s32 cellAtracDeleteDecoder(vm::ptr<CellAtracHandle> pHandle)
{ {
cellAtrac.Warning("cellAtracDeleteDecoder(pHandle=0x%x)", pHandle.addr()); cellAtrac.Warning("cellAtracDeleteDecoder(pHandle=0x%x)", pHandle.addr());
#ifdef PRX_DEBUG
return GetCurrentPPUThread().FastCall2(libatrac3plus + 0x0D08, libatrac3plus_rtoc);
#endif
return CELL_OK; return CELL_OK;
} }
s64 cellAtracDecode(vm::ptr<CellAtracHandle> pHandle, u32 pfOutAddr, vm::ptr<u32> puiSamples, vm::ptr<u32> puiFinishflag, vm::ptr<u32> piRemainFrame) s32 cellAtracDecode(vm::ptr<CellAtracHandle> pHandle, u32 pfOutAddr, vm::ptr<u32> puiSamples, vm::ptr<u32> puiFinishflag, vm::ptr<u32> piRemainFrame)
{ {
cellAtrac.Warning("cellAtracDecode(pHandle=0x%x, pfOutAddr=0x%x, puiSamples_addr=0x%x, puiFinishFlag_addr=0x%x, piRemainFrame_addr=0x%x)", cellAtrac.Warning("cellAtracDecode(pHandle=0x%x, pfOutAddr=0x%x, puiSamples_addr=0x%x, puiFinishFlag_addr=0x%x, piRemainFrame_addr=0x%x)",
pHandle.addr(), pfOutAddr, puiSamples.addr(), puiFinishflag.addr(), piRemainFrame.addr()); pHandle.addr(), pfOutAddr, puiSamples.addr(), puiFinishflag.addr(), piRemainFrame.addr());
#ifdef PRX_DEBUG
return GetCurrentPPUThread().FastCall2(libatrac3plus + 0x09A8, libatrac3plus_rtoc);
#endif
*puiSamples = 0; *puiSamples = 0;
*puiFinishflag = 1; *puiFinishflag = 1;
@ -73,13 +52,10 @@ s64 cellAtracDecode(vm::ptr<CellAtracHandle> pHandle, u32 pfOutAddr, vm::ptr<u32
return CELL_OK; return CELL_OK;
} }
s64 cellAtracGetStreamDataInfo(vm::ptr<CellAtracHandle> pHandle, vm::ptr<u32> ppucWritePointer, vm::ptr<u32> puiWritableByte, vm::ptr<u32> puiReadPosition) s32 cellAtracGetStreamDataInfo(vm::ptr<CellAtracHandle> pHandle, vm::ptr<u32> ppucWritePointer, vm::ptr<u32> puiWritableByte, vm::ptr<u32> puiReadPosition)
{ {
cellAtrac.Warning("cellAtracGetStreamDataInfo(pHandle=0x%x, ppucWritePointer_addr=0x%x, puiWritableByte_addr=0x%x, puiReadPosition_addr=0x%x)", cellAtrac.Warning("cellAtracGetStreamDataInfo(pHandle=0x%x, ppucWritePointer_addr=0x%x, puiWritableByte_addr=0x%x, puiReadPosition_addr=0x%x)",
pHandle.addr(), ppucWritePointer.addr(), puiWritableByte.addr(), puiReadPosition.addr()); pHandle.addr(), ppucWritePointer.addr(), puiWritableByte.addr(), puiReadPosition.addr());
#ifdef PRX_DEBUG
return GetCurrentPPUThread().FastCall2(libatrac3plus + 0x0BE8, libatrac3plus_rtoc);
#endif
*ppucWritePointer = pHandle->data.pucWorkMem_addr; *ppucWritePointer = pHandle->data.pucWorkMem_addr;
*puiWritableByte = 0x1000; *puiWritableByte = 0x1000;
@ -87,112 +63,82 @@ s64 cellAtracGetStreamDataInfo(vm::ptr<CellAtracHandle> pHandle, vm::ptr<u32> pp
return CELL_OK; return CELL_OK;
} }
s64 cellAtracAddStreamData(vm::ptr<CellAtracHandle> pHandle, u32 uiAddByte) s32 cellAtracAddStreamData(vm::ptr<CellAtracHandle> pHandle, u32 uiAddByte)
{ {
cellAtrac.Warning("cellAtracAddStreamData(pHandle=0x%x, uiAddByte=0x%x)", pHandle.addr(), uiAddByte); cellAtrac.Warning("cellAtracAddStreamData(pHandle=0x%x, uiAddByte=0x%x)", pHandle.addr(), uiAddByte);
#ifdef PRX_DEBUG
return GetCurrentPPUThread().FastCall2(libatrac3plus + 0x0AFC, libatrac3plus_rtoc);
#endif
return CELL_OK; return CELL_OK;
} }
s64 cellAtracGetRemainFrame(vm::ptr<CellAtracHandle> pHandle, vm::ptr<u32> piRemainFrame) s32 cellAtracGetRemainFrame(vm::ptr<CellAtracHandle> pHandle, vm::ptr<u32> piRemainFrame)
{ {
cellAtrac.Warning("cellAtracGetRemainFrame(pHandle=0x%x, piRemainFrame_addr=0x%x)", pHandle.addr(), piRemainFrame.addr()); cellAtrac.Warning("cellAtracGetRemainFrame(pHandle=0x%x, piRemainFrame_addr=0x%x)", pHandle.addr(), piRemainFrame.addr());
#ifdef PRX_DEBUG
return GetCurrentPPUThread().FastCall2(libatrac3plus + 0x092C, libatrac3plus_rtoc);
#endif
*piRemainFrame = CELL_ATRAC_ALLDATA_IS_ON_MEMORY; *piRemainFrame = CELL_ATRAC_ALLDATA_IS_ON_MEMORY;
return CELL_OK; return CELL_OK;
} }
s64 cellAtracGetVacantSize(vm::ptr<CellAtracHandle> pHandle, vm::ptr<u32> puiVacantSize) s32 cellAtracGetVacantSize(vm::ptr<CellAtracHandle> pHandle, vm::ptr<u32> puiVacantSize)
{ {
cellAtrac.Warning("cellAtracGetVacantSize(pHandle=0x%x, puiVacantSize_addr=0x%x)", pHandle.addr(), puiVacantSize.addr()); cellAtrac.Warning("cellAtracGetVacantSize(pHandle=0x%x, puiVacantSize_addr=0x%x)", pHandle.addr(), puiVacantSize.addr());
#ifdef PRX_DEBUG
return GetCurrentPPUThread().FastCall2(libatrac3plus + 0x08B0, libatrac3plus_rtoc);
#endif
*puiVacantSize = 0x1000; *puiVacantSize = 0x1000;
return CELL_OK; return CELL_OK;
} }
s64 cellAtracIsSecondBufferNeeded(vm::ptr<CellAtracHandle> pHandle) s32 cellAtracIsSecondBufferNeeded(vm::ptr<CellAtracHandle> pHandle)
{ {
cellAtrac.Warning("cellAtracIsSecondBufferNeeded(pHandle=0x%x)", pHandle.addr()); cellAtrac.Warning("cellAtracIsSecondBufferNeeded(pHandle=0x%x)", pHandle.addr());
#ifdef PRX_DEBUG
return GetCurrentPPUThread().FastCall2(libatrac3plus + 0x0010, libatrac3plus_rtoc);
#endif
return CELL_OK; return CELL_OK;
} }
s64 cellAtracGetSecondBufferInfo(vm::ptr<CellAtracHandle> pHandle, vm::ptr<u32> puiReadPosition, vm::ptr<u32> puiDataByte) s32 cellAtracGetSecondBufferInfo(vm::ptr<CellAtracHandle> pHandle, vm::ptr<u32> puiReadPosition, vm::ptr<u32> puiDataByte)
{ {
cellAtrac.Warning("cellAtracGetSecondBufferInfo(pHandle=0x%x, puiReadPosition_addr=0x%x, puiDataByte_addr=0x%x)", cellAtrac.Warning("cellAtracGetSecondBufferInfo(pHandle=0x%x, puiReadPosition_addr=0x%x, puiDataByte_addr=0x%x)",
pHandle.addr(), puiReadPosition.addr(), puiDataByte.addr()); pHandle.addr(), puiReadPosition.addr(), puiDataByte.addr());
#ifdef PRX_DEBUG
return GetCurrentPPUThread().FastCall2(libatrac3plus + 0x07E8, libatrac3plus_rtoc);
#endif
*puiReadPosition = 0; *puiReadPosition = 0;
*puiDataByte = 0; // write to null block will occur *puiDataByte = 0; // write to null block will occur
return CELL_OK; return CELL_OK;
} }
s64 cellAtracSetSecondBuffer(vm::ptr<CellAtracHandle> pHandle, u32 pucSecondBufferAddr, u32 uiSecondBufferByte) s32 cellAtracSetSecondBuffer(vm::ptr<CellAtracHandle> pHandle, u32 pucSecondBufferAddr, u32 uiSecondBufferByte)
{ {
cellAtrac.Warning("cellAtracSetSecondBuffer(pHandle=0x%x, pucSecondBufferAddr=0x%x, uiSecondBufferByte=0x%x)", cellAtrac.Warning("cellAtracSetSecondBuffer(pHandle=0x%x, pucSecondBufferAddr=0x%x, uiSecondBufferByte=0x%x)",
pHandle.addr(), pucSecondBufferAddr, uiSecondBufferByte); pHandle.addr(), pucSecondBufferAddr, uiSecondBufferByte);
#ifdef PRX_DEBUG
return GetCurrentPPUThread().FastCall2(libatrac3plus + 0x0704, libatrac3plus_rtoc);
#endif
return CELL_OK; return CELL_OK;
} }
s64 cellAtracGetChannel(vm::ptr<CellAtracHandle> pHandle, vm::ptr<u32> puiChannel) s32 cellAtracGetChannel(vm::ptr<CellAtracHandle> pHandle, vm::ptr<u32> puiChannel)
{ {
cellAtrac.Warning("cellAtracGetChannel(pHandle=0x%x, puiChannel_addr=0x%x)", pHandle.addr(), puiChannel.addr()); cellAtrac.Warning("cellAtracGetChannel(pHandle=0x%x, puiChannel_addr=0x%x)", pHandle.addr(), puiChannel.addr());
#ifdef PRX_DEBUG
return GetCurrentPPUThread().FastCall2(libatrac3plus + 0x0060, libatrac3plus_rtoc);
#endif
*puiChannel = 2; *puiChannel = 2;
return CELL_OK; return CELL_OK;
} }
s64 cellAtracGetMaxSample(vm::ptr<CellAtracHandle> pHandle, vm::ptr<u32> puiMaxSample) s32 cellAtracGetMaxSample(vm::ptr<CellAtracHandle> pHandle, vm::ptr<u32> puiMaxSample)
{ {
cellAtrac.Warning("cellAtracGetMaxSample(pHandle=0x%x, puiMaxSample_addr=0x%x)", pHandle.addr(), puiMaxSample.addr()); cellAtrac.Warning("cellAtracGetMaxSample(pHandle=0x%x, puiMaxSample_addr=0x%x)", pHandle.addr(), puiMaxSample.addr());
#ifdef PRX_DEBUG
return GetCurrentPPUThread().FastCall2(libatrac3plus + 0x00AC, libatrac3plus_rtoc);
#endif
*puiMaxSample = 512; *puiMaxSample = 512;
return CELL_OK; return CELL_OK;
} }
s64 cellAtracGetNextSample(vm::ptr<CellAtracHandle> pHandle, vm::ptr<u32> puiNextSample) s32 cellAtracGetNextSample(vm::ptr<CellAtracHandle> pHandle, vm::ptr<u32> puiNextSample)
{ {
cellAtrac.Warning("cellAtracGetNextSample(pHandle=0x%x, puiNextSample_addr=0x%x)", pHandle.addr(), puiNextSample.addr()); cellAtrac.Warning("cellAtracGetNextSample(pHandle=0x%x, puiNextSample_addr=0x%x)", pHandle.addr(), puiNextSample.addr());
#ifdef PRX_DEBUG
return GetCurrentPPUThread().FastCall2(libatrac3plus + 0x0688, libatrac3plus_rtoc);
#endif
*puiNextSample = 0; *puiNextSample = 0;
return CELL_OK; return CELL_OK;
} }
s64 cellAtracGetSoundInfo(vm::ptr<CellAtracHandle> pHandle, vm::ptr<u32> piEndSample, vm::ptr<u32> piLoopStartSample, vm::ptr<u32> piLoopEndSample) s32 cellAtracGetSoundInfo(vm::ptr<CellAtracHandle> pHandle, vm::ptr<u32> piEndSample, vm::ptr<u32> piLoopStartSample, vm::ptr<u32> piLoopEndSample)
{ {
cellAtrac.Warning("cellAtracGetSoundInfo(pHandle=0x%x, piEndSample_addr=0x%x, piLoopStartSample_addr=0x%x, piLoopEndSample_addr=0x%x)", cellAtrac.Warning("cellAtracGetSoundInfo(pHandle=0x%x, piEndSample_addr=0x%x, piLoopStartSample_addr=0x%x, piLoopEndSample_addr=0x%x)",
pHandle.addr(), piEndSample.addr(), piLoopStartSample.addr(), piLoopEndSample.addr()); pHandle.addr(), piEndSample.addr(), piLoopStartSample.addr(), piLoopEndSample.addr());
#ifdef PRX_DEBUG
return GetCurrentPPUThread().FastCall2(libatrac3plus + 0x0104, libatrac3plus_rtoc);
#endif
*piEndSample = 0; *piEndSample = 0;
*piLoopStartSample = 0; *piLoopStartSample = 0;
@ -200,60 +146,45 @@ s64 cellAtracGetSoundInfo(vm::ptr<CellAtracHandle> pHandle, vm::ptr<u32> piEndSa
return CELL_OK; return CELL_OK;
} }
s64 cellAtracGetNextDecodePosition(vm::ptr<CellAtracHandle> pHandle, vm::ptr<u32> puiSamplePosition) s32 cellAtracGetNextDecodePosition(vm::ptr<CellAtracHandle> pHandle, vm::ptr<u32> puiSamplePosition)
{ {
cellAtrac.Warning("cellAtracGetNextDecodePosition(pHandle=0x%x, puiSamplePosition_addr=0x%x)", cellAtrac.Warning("cellAtracGetNextDecodePosition(pHandle=0x%x, puiSamplePosition_addr=0x%x)",
pHandle.addr(), puiSamplePosition.addr()); pHandle.addr(), puiSamplePosition.addr());
#ifdef PRX_DEBUG
return GetCurrentPPUThread().FastCall2(libatrac3plus + 0x0190, libatrac3plus_rtoc);
#endif
*puiSamplePosition = 0; *puiSamplePosition = 0;
return CELL_ATRAC_ERROR_ALLDATA_WAS_DECODED; return CELL_ATRAC_ERROR_ALLDATA_WAS_DECODED;
} }
s64 cellAtracGetBitrate(vm::ptr<CellAtracHandle> pHandle, vm::ptr<u32> puiBitrate) s32 cellAtracGetBitrate(vm::ptr<CellAtracHandle> pHandle, vm::ptr<u32> puiBitrate)
{ {
cellAtrac.Warning("cellAtracGetBitrate(pHandle=0x%x, puiBitrate_addr=0x%x)", cellAtrac.Warning("cellAtracGetBitrate(pHandle=0x%x, puiBitrate_addr=0x%x)",
pHandle.addr(), puiBitrate.addr()); pHandle.addr(), puiBitrate.addr());
#ifdef PRX_DEBUG
return GetCurrentPPUThread().FastCall2(libatrac3plus + 0x0374, libatrac3plus_rtoc);
#endif
*puiBitrate = 128; *puiBitrate = 128;
return CELL_OK; return CELL_OK;
} }
s64 cellAtracGetLoopInfo(vm::ptr<CellAtracHandle> pHandle, vm::ptr<u32> piLoopNum, vm::ptr<u32> puiLoopStatus) s32 cellAtracGetLoopInfo(vm::ptr<CellAtracHandle> pHandle, vm::ptr<u32> piLoopNum, vm::ptr<u32> puiLoopStatus)
{ {
cellAtrac.Warning("cellAtracGetLoopInfo(pHandle=0x%x, piLoopNum_addr=0x%x, puiLoopStatus_addr=0x%x)", cellAtrac.Warning("cellAtracGetLoopInfo(pHandle=0x%x, piLoopNum_addr=0x%x, puiLoopStatus_addr=0x%x)",
pHandle.addr(), piLoopNum.addr(), puiLoopStatus.addr()); pHandle.addr(), piLoopNum.addr(), puiLoopStatus.addr());
#ifdef PRX_DEBUG
return GetCurrentPPUThread().FastCall2(libatrac3plus + 0x025C, libatrac3plus_rtoc);
#endif
*piLoopNum = 0; *piLoopNum = 0;
*puiLoopStatus = 0; *puiLoopStatus = 0;
return CELL_OK; return CELL_OK;
} }
s64 cellAtracSetLoopNum(vm::ptr<CellAtracHandle> pHandle, int iLoopNum) s32 cellAtracSetLoopNum(vm::ptr<CellAtracHandle> pHandle, int iLoopNum)
{ {
cellAtrac.Warning("cellAtracSetLoopNum(pHandle=0x%x, iLoopNum=0x%x)", pHandle.addr(), iLoopNum); cellAtrac.Warning("cellAtracSetLoopNum(pHandle=0x%x, iLoopNum=0x%x)", pHandle.addr(), iLoopNum);
#ifdef PRX_DEBUG
return GetCurrentPPUThread().FastCall2(libatrac3plus + 0x1538, libatrac3plus_rtoc);
#endif
return CELL_OK; return CELL_OK;
} }
s64 cellAtracGetBufferInfoForResetting(vm::ptr<CellAtracHandle> pHandle, u32 uiSample, vm::ptr<CellAtracBufferInfo> pBufferInfo) s32 cellAtracGetBufferInfoForResetting(vm::ptr<CellAtracHandle> pHandle, u32 uiSample, vm::ptr<CellAtracBufferInfo> pBufferInfo)
{ {
cellAtrac.Warning("cellAtracGetBufferInfoForResetting(pHandle=0x%x, uiSample=0x%x, pBufferInfo_addr=0x%x)", cellAtrac.Warning("cellAtracGetBufferInfoForResetting(pHandle=0x%x, uiSample=0x%x, pBufferInfo_addr=0x%x)",
pHandle.addr(), uiSample, pBufferInfo.addr()); pHandle.addr(), uiSample, pBufferInfo.addr());
#ifdef PRX_DEBUG
return GetCurrentPPUThread().FastCall2(libatrac3plus + 0x05BC, libatrac3plus_rtoc);
#endif
pBufferInfo->pucWriteAddr = pHandle->data.pucWorkMem_addr; pBufferInfo->pucWriteAddr = pHandle->data.pucWorkMem_addr;
pBufferInfo->uiWritableByte = 0x1000; pBufferInfo->uiWritableByte = 0x1000;
@ -262,24 +193,18 @@ s64 cellAtracGetBufferInfoForResetting(vm::ptr<CellAtracHandle> pHandle, u32 uiS
return CELL_OK; return CELL_OK;
} }
s64 cellAtracResetPlayPosition(vm::ptr<CellAtracHandle> pHandle, u32 uiSample, u32 uiWriteByte) s32 cellAtracResetPlayPosition(vm::ptr<CellAtracHandle> pHandle, u32 uiSample, u32 uiWriteByte)
{ {
cellAtrac.Warning("cellAtracResetPlayPosition(pHandle=0x%x, uiSample=0x%x, uiWriteByte=0x%x)", cellAtrac.Warning("cellAtracResetPlayPosition(pHandle=0x%x, uiSample=0x%x, uiWriteByte=0x%x)",
pHandle.addr(), uiSample, uiWriteByte); pHandle.addr(), uiSample, uiWriteByte);
#ifdef PRX_DEBUG
return GetCurrentPPUThread().FastCall2(libatrac3plus + 0x04E4, libatrac3plus_rtoc);
#endif
return CELL_OK; return CELL_OK;
} }
s64 cellAtracGetInternalErrorInfo(vm::ptr<CellAtracHandle> pHandle, vm::ptr<u32> piResult) s32 cellAtracGetInternalErrorInfo(vm::ptr<CellAtracHandle> pHandle, vm::ptr<u32> piResult)
{ {
cellAtrac.Warning("cellAtracGetInternalErrorInfo(pHandle=0x%x, piResult_addr=0x%x)", cellAtrac.Warning("cellAtracGetInternalErrorInfo(pHandle=0x%x, piResult_addr=0x%x)",
pHandle.addr(), piResult.addr()); pHandle.addr(), piResult.addr());
#ifdef PRX_DEBUG
return GetCurrentPPUThread().FastCall2(libatrac3plus + 0x02E4, libatrac3plus_rtoc);
#endif
*piResult = 0; *piResult = 0;
return CELL_OK; return CELL_OK;
@ -317,27 +242,4 @@ Module cellAtrac("cellAtrac", []()
cellAtrac.AddFunc(0x7772eb2b, cellAtracResetPlayPosition); cellAtrac.AddFunc(0x7772eb2b, cellAtracResetPlayPosition);
cellAtrac.AddFunc(0xb5c11938, cellAtracGetInternalErrorInfo); cellAtrac.AddFunc(0xb5c11938, cellAtracGetInternalErrorInfo);
#ifdef PRX_DEBUG
CallAfter([]()
{
if (!Memory.MainMem.GetStartAddr()) return;
libatrac3plus = (u32)Memory.MainMem.AllocAlign(sizeof(libatrac3plus_data), 0x100000);
memcpy(vm::get_ptr<void>(libatrac3plus), libatrac3plus_data, sizeof(libatrac3plus_data));
libatrac3plus_rtoc = libatrac3plus + 0xBED0;
extern Module* cellAdec;
FIX_IMPORT(cellAdec, cellAdecDecodeAu, libatrac3plus + 0x399C);
FIX_IMPORT(cellAdec, cellAdecStartSeq, libatrac3plus + 0x39BC);
FIX_IMPORT(cellAdec, cellAdecQueryAttr, libatrac3plus + 0x39DC);
FIX_IMPORT(cellAdec, cellAdecClose, libatrac3plus + 0x39FC);
FIX_IMPORT(cellAdec, cellAdecGetPcm, libatrac3plus + 0x3A1C);
FIX_IMPORT(cellAdec, cellAdecOpen, libatrac3plus + 0x3A3C);
fix_import(cellAdec, 0xDF982D2C, libatrac3plus + 0x3A5C);
fix_relocs(cellAtrac, libatrac3plus, 0x3EF0, 0x5048, 0x3CE0);
});
#endif
}); });

273
rpcs3/Emu/SysCalls/Modules/cellPngDec.cpp
View file

@ -10,15 +10,7 @@
extern Module cellPngDec; extern Module cellPngDec;
#undef PRX_DEBUG s32 pngDecCreate(
#ifdef PRX_DEBUG
#include "prx_libpngdec.h"
u32 libpngdec;
u32 libpngdec_rtoc;
#endif
s64 pngDecCreate(
vm::ptr<u32> mainHandle, vm::ptr<u32> mainHandle,
vm::ptr<const CellPngDecThreadInParam> param, vm::ptr<const CellPngDecThreadInParam> param,
vm::ptr<const CellPngDecExtThreadInParam> ext = vm::ptr<const CellPngDecExtThreadInParam>::make(0)) vm::ptr<const CellPngDecExtThreadInParam> ext = vm::ptr<const CellPngDecExtThreadInParam>::make(0))
@ -47,7 +39,7 @@ s64 pngDecCreate(
return CELL_OK; return CELL_OK;
} }
s64 pngDecDestroy(CellPngDecMainHandle dec) s32 pngDecDestroy(CellPngDecMainHandle dec)
{ {
if (!Memory.Free(dec.addr())) if (!Memory.Free(dec.addr()))
{ {
@ -57,7 +49,7 @@ s64 pngDecDestroy(CellPngDecMainHandle dec)
return CELL_OK; return CELL_OK;
} }
s64 pngDecOpen( s32 pngDecOpen(
CellPngDecMainHandle dec, CellPngDecMainHandle dec,
vm::ptr<u32> subHandle, vm::ptr<u32> subHandle,
vm::ptr<const CellPngDecSrc> src, vm::ptr<const CellPngDecSrc> src,
@ -117,7 +109,7 @@ s64 pngDecOpen(
return CELL_OK; return CELL_OK;
} }
s64 pngDecClose(CellPngDecSubHandle stream) s32 pngDecClose(CellPngDecSubHandle stream)
{ {
cellFsClose(stream->fd); cellFsClose(stream->fd);
if (!Memory.Free(stream.addr())) if (!Memory.Free(stream.addr()))
@ -128,7 +120,7 @@ s64 pngDecClose(CellPngDecSubHandle stream)
return CELL_OK; return CELL_OK;
} }
s64 pngReadHeader( s32 pngReadHeader(
CellPngDecSubHandle stream, CellPngDecSubHandle stream,
vm::ptr<CellPngDecInfo> info, vm::ptr<CellPngDecInfo> info,
vm::ptr<CellPngDecExtInfo> extInfo = vm::ptr<CellPngDecExtInfo>::make(0)) vm::ptr<CellPngDecExtInfo> extInfo = vm::ptr<CellPngDecExtInfo>::make(0))
@ -191,7 +183,7 @@ s64 pngReadHeader(
return CELL_OK; return CELL_OK;
} }
s64 pngDecSetParameter( s32 pngDecSetParameter(
CellPngDecSubHandle stream, CellPngDecSubHandle stream,
vm::ptr<const CellPngDecInParam> inParam, vm::ptr<const CellPngDecInParam> inParam,
vm::ptr<CellPngDecOutParam> outParam, vm::ptr<CellPngDecOutParam> outParam,
@ -236,7 +228,7 @@ s64 pngDecSetParameter(
return CELL_OK; return CELL_OK;
} }
s64 pngDecodeData( s32 pngDecodeData(
CellPngDecSubHandle stream, CellPngDecSubHandle stream,
vm::ptr<u8> data, vm::ptr<u8> data,
vm::ptr<const CellPngDecDataCtrlParam> dataCtrlParam, vm::ptr<const CellPngDecDataCtrlParam> dataCtrlParam,
@ -365,13 +357,8 @@ s64 pngDecodeData(
return CELL_OK; return CELL_OK;
} }
s64 cellPngDecCreate(vm::ptr<u32> mainHandle, vm::ptr<const CellPngDecThreadInParam> threadInParam, vm::ptr<CellPngDecThreadOutParam> threadOutParam) s32 cellPngDecCreate(vm::ptr<u32> mainHandle, vm::ptr<const CellPngDecThreadInParam> threadInParam, vm::ptr<CellPngDecThreadOutParam> threadOutParam)
{ {
#ifdef PRX_DEBUG
cellPngDec.Warning("%s()", __FUNCTION__);
const_cast<CellPngDecThreadInParam&>(*threadInParam).spuThreadEnable = CELL_PNGDEC_SPU_THREAD_DISABLE; // hack
return GetCurrentPPUThread().FastCall2(libpngdec + 0x295C, libpngdec_rtoc);
#else
cellPngDec.Warning("cellPngDecCreate(mainHandle_addr=0x%x, threadInParam_addr=0x%x, threadOutParam_addr=0x%x)", cellPngDec.Warning("cellPngDecCreate(mainHandle_addr=0x%x, threadInParam_addr=0x%x, threadOutParam_addr=0x%x)",
mainHandle.addr(), threadInParam.addr(), threadOutParam.addr()); mainHandle.addr(), threadInParam.addr(), threadOutParam.addr());
@ -382,20 +369,15 @@ s64 cellPngDecCreate(vm::ptr<u32> mainHandle, vm::ptr<const CellPngDecThreadInPa
threadOutParam->pngCodecVersion = PNGDEC_CODEC_VERSION; threadOutParam->pngCodecVersion = PNGDEC_CODEC_VERSION;
return CELL_OK; return CELL_OK;
#endif
} }
s64 cellPngDecExtCreate( s32 cellPngDecExtCreate(
vm::ptr<u32> mainHandle, vm::ptr<u32> mainHandle,
vm::ptr<const CellPngDecThreadInParam> threadInParam, vm::ptr<const CellPngDecThreadInParam> threadInParam,
vm::ptr<CellPngDecThreadOutParam> threadOutParam, vm::ptr<CellPngDecThreadOutParam> threadOutParam,
vm::ptr<const CellPngDecExtThreadInParam> extThreadInParam, vm::ptr<const CellPngDecExtThreadInParam> extThreadInParam,
vm::ptr<CellPngDecExtThreadOutParam> extThreadOutParam) vm::ptr<CellPngDecExtThreadOutParam> extThreadOutParam)
{ {
#ifdef PRX_DEBUG
cellPngDec.Warning("%s()", __FUNCTION__);
return GetCurrentPPUThread().FastCall2(libpngdec + 0x296C, libpngdec_rtoc);
#else
cellPngDec.Warning("cellPngDecCreate(mainHandle_addr=0x%x, threadInParam_addr=0x%x, threadOutParam_addr=0x%x, extThreadInParam_addr=0x%x, extThreadOutParam_addr=0x%x)", cellPngDec.Warning("cellPngDecCreate(mainHandle_addr=0x%x, threadInParam_addr=0x%x, threadOutParam_addr=0x%x, extThreadInParam_addr=0x%x, extThreadOutParam_addr=0x%x)",
mainHandle.addr(), threadInParam.addr(), threadOutParam.addr(), extThreadInParam.addr(), extThreadOutParam.addr()); mainHandle.addr(), threadInParam.addr(), threadOutParam.addr(), extThreadInParam.addr(), extThreadOutParam.addr());
@ -408,41 +390,30 @@ s64 cellPngDecExtCreate(
extThreadOutParam->reserved = 0; extThreadOutParam->reserved = 0;
return CELL_OK; return CELL_OK;
#endif
} }
s64 cellPngDecDestroy(CellPngDecMainHandle mainHandle) s32 cellPngDecDestroy(CellPngDecMainHandle mainHandle)
{ {
#ifdef PRX_DEBUG
cellPngDec.Warning("%s()", __FUNCTION__);
return GetCurrentPPUThread().FastCall2(libpngdec + 0x1E6C, libpngdec_rtoc);
#else
cellPngDec.Warning("cellPngDecDestroy(mainHandle=0x%x)", mainHandle.addr()); cellPngDec.Warning("cellPngDecDestroy(mainHandle=0x%x)", mainHandle.addr());
// destroy decoder // destroy decoder
return pngDecDestroy(mainHandle); return pngDecDestroy(mainHandle);
#endif
} }
s64 cellPngDecOpen( s32 cellPngDecOpen(
CellPngDecMainHandle mainHandle, CellPngDecMainHandle mainHandle,
vm::ptr<u32> subHandle, vm::ptr<u32> subHandle,
vm::ptr<const CellPngDecSrc> src, vm::ptr<const CellPngDecSrc> src,
vm::ptr<CellPngDecOpnInfo> openInfo) vm::ptr<CellPngDecOpnInfo> openInfo)
{ {
#ifdef PRX_DEBUG
cellPngDec.Warning("%s()", __FUNCTION__);
return GetCurrentPPUThread().FastCall2(libpngdec + 0x3F3C, libpngdec_rtoc);
#else
cellPngDec.Warning("cellPngDecOpen(mainHandle=0x%x, subHandle_addr=0x%x, src_addr=0x%x, openInfo_addr=0x%x)", cellPngDec.Warning("cellPngDecOpen(mainHandle=0x%x, subHandle_addr=0x%x, src_addr=0x%x, openInfo_addr=0x%x)",
mainHandle.addr(), subHandle.addr(), src.addr(), openInfo.addr()); mainHandle.addr(), subHandle.addr(), src.addr(), openInfo.addr());
// create stream handle // create stream handle
return pngDecOpen(mainHandle, subHandle, src, openInfo); return pngDecOpen(mainHandle, subHandle, src, openInfo);
#endif
} }
s64 cellPngDecExtOpen( s32 cellPngDecExtOpen(
CellPngDecMainHandle mainHandle, CellPngDecMainHandle mainHandle,
vm::ptr<u32> subHandle, vm::ptr<u32> subHandle,
vm::ptr<const CellPngDecSrc> src, vm::ptr<const CellPngDecSrc> src,
@ -450,78 +421,53 @@ s64 cellPngDecExtOpen(
vm::ptr<const CellPngDecCbCtrlStrm> cbCtrlStrm, vm::ptr<const CellPngDecCbCtrlStrm> cbCtrlStrm,
vm::ptr<const CellPngDecOpnParam> opnParam) vm::ptr<const CellPngDecOpnParam> opnParam)
{ {
#ifdef PRX_DEBUG
cellPngDec.Warning("%s()", __FUNCTION__);
return GetCurrentPPUThread().FastCall2(libpngdec + 0x3F34, libpngdec_rtoc);
#else
cellPngDec.Warning("cellPngDecExtOpen(mainHandle=0x%x, subHandle_addr=0x%x, src_addr=0x%x, openInfo_addr=0x%x, cbCtrlStrm_addr=0x%x, opnParam_addr=0x%x)", cellPngDec.Warning("cellPngDecExtOpen(mainHandle=0x%x, subHandle_addr=0x%x, src_addr=0x%x, openInfo_addr=0x%x, cbCtrlStrm_addr=0x%x, opnParam_addr=0x%x)",
mainHandle.addr(), subHandle.addr(), src.addr(), openInfo.addr(), cbCtrlStrm.addr(), opnParam.addr()); mainHandle.addr(), subHandle.addr(), src.addr(), openInfo.addr(), cbCtrlStrm.addr(), opnParam.addr());
// create stream handle // create stream handle
return pngDecOpen(mainHandle, subHandle, src, openInfo, cbCtrlStrm, opnParam); return pngDecOpen(mainHandle, subHandle, src, openInfo, cbCtrlStrm, opnParam);
#endif
} }
s64 cellPngDecClose(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle) s32 cellPngDecClose(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle)
{ {
#ifdef PRX_DEBUG
cellPngDec.Warning("%s()", __FUNCTION__);
return GetCurrentPPUThread().FastCall2(libpngdec + 0x066C, libpngdec_rtoc);
#else
cellPngDec.Warning("cellPngDecClose(mainHandle=0x%x, subHandle=0x%x)", mainHandle.addr(), subHandle.addr()); cellPngDec.Warning("cellPngDecClose(mainHandle=0x%x, subHandle=0x%x)", mainHandle.addr(), subHandle.addr());
return pngDecClose(subHandle); return pngDecClose(subHandle);
#endif
} }
s64 cellPngDecReadHeader(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr<CellPngDecInfo> info) s32 cellPngDecReadHeader(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr<CellPngDecInfo> info)
{ {
#ifdef PRX_DEBUG
cellPngDec.Warning("%s()", __FUNCTION__);
return GetCurrentPPUThread().FastCall2(libpngdec + 0x3A3C, libpngdec_rtoc);
#else
cellPngDec.Warning("cellPngDecReadHeader(mainHandle=0x%x, subHandle=0x%x, info_addr=0x%x)", cellPngDec.Warning("cellPngDecReadHeader(mainHandle=0x%x, subHandle=0x%x, info_addr=0x%x)",
mainHandle.addr(), subHandle.addr(), info.addr()); mainHandle.addr(), subHandle.addr(), info.addr());
return pngReadHeader(subHandle, info); return pngReadHeader(subHandle, info);
#endif
} }
s64 cellPngDecExtReadHeader( s32 cellPngDecExtReadHeader(
CellPngDecMainHandle mainHandle, CellPngDecMainHandle mainHandle,
CellPngDecSubHandle subHandle, CellPngDecSubHandle subHandle,
vm::ptr<CellPngDecInfo> info, vm::ptr<CellPngDecInfo> info,
vm::ptr<CellPngDecExtInfo> extInfo) vm::ptr<CellPngDecExtInfo> extInfo)
{ {
#ifdef PRX_DEBUG
cellPngDec.Warning("%s()", __FUNCTION__);
return GetCurrentPPUThread().FastCall2(libpngdec + 0x3A34, libpngdec_rtoc);
#else
cellPngDec.Warning("cellPngDecExtReadHeader(mainHandle=0x%x, subHandle=0x%x, info_addr=0x%x, extInfo_addr=0x%x)", cellPngDec.Warning("cellPngDecExtReadHeader(mainHandle=0x%x, subHandle=0x%x, info_addr=0x%x, extInfo_addr=0x%x)",
mainHandle.addr(), subHandle.addr(), info.addr(), extInfo.addr()); mainHandle.addr(), subHandle.addr(), info.addr(), extInfo.addr());
return pngReadHeader(subHandle, info, extInfo); return pngReadHeader(subHandle, info, extInfo);
#endif
} }
s64 cellPngDecSetParameter( s32 cellPngDecSetParameter(
CellPngDecMainHandle mainHandle, CellPngDecMainHandle mainHandle,
CellPngDecSubHandle subHandle, CellPngDecSubHandle subHandle,
vm::ptr<const CellPngDecInParam> inParam, vm::ptr<const CellPngDecInParam> inParam,
vm::ptr<CellPngDecOutParam> outParam) vm::ptr<CellPngDecOutParam> outParam)
{ {
#ifdef PRX_DEBUG
cellPngDec.Warning("%s()", __FUNCTION__);
return GetCurrentPPUThread().FastCall2(libpngdec + 0x33F4, libpngdec_rtoc);
#else
cellPngDec.Warning("cellPngDecSetParameter(mainHandle=0x%x, subHandle=0x%x, inParam_addr=0x%x, outParam_addr=0x%x)", cellPngDec.Warning("cellPngDecSetParameter(mainHandle=0x%x, subHandle=0x%x, inParam_addr=0x%x, outParam_addr=0x%x)",
mainHandle.addr(), subHandle.addr(), inParam.addr(), outParam.addr()); mainHandle.addr(), subHandle.addr(), inParam.addr(), outParam.addr());
return pngDecSetParameter(subHandle, inParam, outParam); return pngDecSetParameter(subHandle, inParam, outParam);
#endif
} }
s64 cellPngDecExtSetParameter( s32 cellPngDecExtSetParameter(
CellPngDecMainHandle mainHandle, CellPngDecMainHandle mainHandle,
CellPngDecSubHandle subHandle, CellPngDecSubHandle subHandle,
vm::ptr<const CellPngDecInParam> inParam, vm::ptr<const CellPngDecInParam> inParam,
@ -529,36 +475,26 @@ s64 cellPngDecExtSetParameter(
vm::ptr<const CellPngDecExtInParam> extInParam, vm::ptr<const CellPngDecExtInParam> extInParam,
vm::ptr<CellPngDecExtOutParam> extOutParam) vm::ptr<CellPngDecExtOutParam> extOutParam)
{ {
#ifdef PRX_DEBUG
cellPngDec.Warning("%s()", __FUNCTION__);
return GetCurrentPPUThread().FastCall2(libpngdec + 0x33EC, libpngdec_rtoc);
#else
cellPngDec.Warning("cellPngDecExtSetParameter(mainHandle=0x%x, subHandle=0x%x, inParam_addr=0x%x, outParam_addr=0x%x, extInParam=0x%x, extOutParam=0x%x", cellPngDec.Warning("cellPngDecExtSetParameter(mainHandle=0x%x, subHandle=0x%x, inParam_addr=0x%x, outParam_addr=0x%x, extInParam=0x%x, extOutParam=0x%x",
mainHandle.addr(), subHandle.addr(), inParam.addr(), outParam.addr(), extInParam.addr(), extOutParam.addr()); mainHandle.addr(), subHandle.addr(), inParam.addr(), outParam.addr(), extInParam.addr(), extOutParam.addr());
return pngDecSetParameter(subHandle, inParam, outParam, extInParam, extOutParam); return pngDecSetParameter(subHandle, inParam, outParam, extInParam, extOutParam);
#endif
} }
s64 cellPngDecDecodeData( s32 cellPngDecDecodeData(
CellPngDecMainHandle mainHandle, CellPngDecMainHandle mainHandle,
CellPngDecSubHandle subHandle, CellPngDecSubHandle subHandle,
vm::ptr<u8> data, vm::ptr<u8> data,
vm::ptr<const CellPngDecDataCtrlParam> dataCtrlParam, vm::ptr<const CellPngDecDataCtrlParam> dataCtrlParam,
vm::ptr<CellPngDecDataOutInfo> dataOutInfo) vm::ptr<CellPngDecDataOutInfo> dataOutInfo)
{ {
#ifdef PRX_DEBUG
cellPngDec.Warning("%s()", __FUNCTION__);
return GetCurrentPPUThread().FastCall2(libpngdec + 0x5D40, libpngdec_rtoc);
#else
cellPngDec.Warning("cellPngDecDecodeData(mainHandle=0x%x, subHandle=0x%x, data_addr=0x%x, dataCtrlParam_addr=0x%x, dataOutInfo_addr=0x%x)", cellPngDec.Warning("cellPngDecDecodeData(mainHandle=0x%x, subHandle=0x%x, data_addr=0x%x, dataCtrlParam_addr=0x%x, dataOutInfo_addr=0x%x)",
mainHandle.addr(), subHandle.addr(), data.addr(), dataCtrlParam.addr(), dataOutInfo.addr()); mainHandle.addr(), subHandle.addr(), data.addr(), dataCtrlParam.addr(), dataOutInfo.addr());
return pngDecodeData(subHandle, data, dataCtrlParam, dataOutInfo); return pngDecodeData(subHandle, data, dataCtrlParam, dataOutInfo);
#endif
} }
s64 cellPngDecExtDecodeData( s32 cellPngDecExtDecodeData(
CellPngDecMainHandle mainHandle, CellPngDecMainHandle mainHandle,
CellPngDecSubHandle subHandle, CellPngDecSubHandle subHandle,
vm::ptr<u8> data, vm::ptr<u8> data,
@ -567,210 +503,120 @@ s64 cellPngDecExtDecodeData(
vm::ptr<const CellPngDecCbCtrlDisp> cbCtrlDisp, vm::ptr<const CellPngDecCbCtrlDisp> cbCtrlDisp,
vm::ptr<CellPngDecDispParam> dispParam) vm::ptr<CellPngDecDispParam> dispParam)
{ {
#ifdef PRX_DEBUG
cellPngDec.Warning("%s()", __FUNCTION__);
return GetCurrentPPUThread().FastCall2(libpngdec + 0x5D38, libpngdec_rtoc);
#else
cellPngDec.Warning("cellPngDecExtDecodeData(mainHandle=0x%x, subHandle=0x%x, data_addr=0x%x, dataCtrlParam_addr=0x%x, dataOutInfo_addr=0x%x, cbCtrlDisp_addr=0x%x, dispParam_addr=0x%x)", cellPngDec.Warning("cellPngDecExtDecodeData(mainHandle=0x%x, subHandle=0x%x, data_addr=0x%x, dataCtrlParam_addr=0x%x, dataOutInfo_addr=0x%x, cbCtrlDisp_addr=0x%x, dispParam_addr=0x%x)",
mainHandle.addr(), subHandle.addr(), data.addr(), dataCtrlParam.addr(), dataOutInfo.addr(), cbCtrlDisp.addr(), dispParam.addr()); mainHandle.addr(), subHandle.addr(), data.addr(), dataCtrlParam.addr(), dataOutInfo.addr(), cbCtrlDisp.addr(), dispParam.addr());
return pngDecodeData(subHandle, data, dataCtrlParam, dataOutInfo, cbCtrlDisp, dispParam); return pngDecodeData(subHandle, data, dataCtrlParam, dataOutInfo, cbCtrlDisp, dispParam);
#endif
} }
s64 cellPngDecGetUnknownChunks( s32 cellPngDecGetUnknownChunks(
CellPngDecMainHandle mainHandle, CellPngDecMainHandle mainHandle,
CellPngDecSubHandle subHandle, CellPngDecSubHandle subHandle,
vm::ptr<vm::bptr<CellPngUnknownChunk>> unknownChunk, vm::ptr<vm::bptr<CellPngUnknownChunk>> unknownChunk,
vm::ptr<u32> unknownChunkNumber) vm::ptr<u32> unknownChunkNumber)
{ {
#ifdef PRX_DEBUG
cellPngDec.Warning("%s()", __FUNCTION__);
return GetCurrentPPUThread().FastCall2(libpngdec + 0x03EC, libpngdec_rtoc);
#else
UNIMPLEMENTED_FUNC(cellPngDec); UNIMPLEMENTED_FUNC(cellPngDec);
return CELL_OK; return CELL_OK;
#endif
} }
s64 cellPngDecGetpCAL(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr<CellPngPCAL> pcal) s32 cellPngDecGetpCAL(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr<CellPngPCAL> pcal)
{ {
#ifdef PRX_DEBUG
cellPngDec.Warning("%s()", __FUNCTION__);
return GetCurrentPPUThread().FastCall2(libpngdec + 0x0730, libpngdec_rtoc);
#else
UNIMPLEMENTED_FUNC(cellPngDec); UNIMPLEMENTED_FUNC(cellPngDec);
return CELL_OK; return CELL_OK;
#endif
} }
s64 cellPngDecGetcHRM(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr<CellPngCHRM> chrm) s32 cellPngDecGetcHRM(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr<CellPngCHRM> chrm)
{ {
#ifdef PRX_DEBUG
cellPngDec.Warning("%s()", __FUNCTION__);
return GetCurrentPPUThread().FastCall2(libpngdec + 0x0894, libpngdec_rtoc);
#else
UNIMPLEMENTED_FUNC(cellPngDec); UNIMPLEMENTED_FUNC(cellPngDec);
return CELL_OK; return CELL_OK;
#endif
} }
s64 cellPngDecGetsCAL(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr<CellPngSCAL> scal) s32 cellPngDecGetsCAL(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr<CellPngSCAL> scal)
{ {
#ifdef PRX_DEBUG
cellPngDec.Warning("%s()", __FUNCTION__);
return GetCurrentPPUThread().FastCall2(libpngdec + 0x09EC, libpngdec_rtoc);
#else
UNIMPLEMENTED_FUNC(cellPngDec); UNIMPLEMENTED_FUNC(cellPngDec);
return CELL_OK; return CELL_OK;
#endif
} }
s64 cellPngDecGetpHYs(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr<CellPngPHYS> phys) s32 cellPngDecGetpHYs(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr<CellPngPHYS> phys)
{ {
#ifdef PRX_DEBUG
cellPngDec.Warning("%s()", __FUNCTION__);
return GetCurrentPPUThread().FastCall2(libpngdec + 0x0B14, libpngdec_rtoc);
#else
UNIMPLEMENTED_FUNC(cellPngDec); UNIMPLEMENTED_FUNC(cellPngDec);
return CELL_OK; return CELL_OK;
#endif
} }
s64 cellPngDecGetoFFs(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr<CellPngOFFS> offs) s32 cellPngDecGetoFFs(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr<CellPngOFFS> offs)
{ {
#ifdef PRX_DEBUG
cellPngDec.Warning("%s()", __FUNCTION__);
return GetCurrentPPUThread().FastCall2(libpngdec + 0x0C58, libpngdec_rtoc);
#else
UNIMPLEMENTED_FUNC(cellPngDec); UNIMPLEMENTED_FUNC(cellPngDec);
return CELL_OK; return CELL_OK;
#endif
} }
s64 cellPngDecGetsPLT(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr<CellPngSPLT> splt) s32 cellPngDecGetsPLT(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr<CellPngSPLT> splt)
{ {
#ifdef PRX_DEBUG
cellPngDec.Warning("%s()", __FUNCTION__);
return GetCurrentPPUThread().FastCall2(libpngdec + 0x0D9C, libpngdec_rtoc);
#else
UNIMPLEMENTED_FUNC(cellPngDec); UNIMPLEMENTED_FUNC(cellPngDec);
return CELL_OK; return CELL_OK;
#endif
} }
s64 cellPngDecGetbKGD(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr<CellPngBKGD> bkgd) s32 cellPngDecGetbKGD(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr<CellPngBKGD> bkgd)
{ {
#ifdef PRX_DEBUG
cellPngDec.Warning("%s()", __FUNCTION__);
return GetCurrentPPUThread().FastCall2(libpngdec + 0x0ED0, libpngdec_rtoc);
#else
UNIMPLEMENTED_FUNC(cellPngDec); UNIMPLEMENTED_FUNC(cellPngDec);
return CELL_OK; return CELL_OK;
#endif
} }
s64 cellPngDecGettIME(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr<CellPngTIME> time) s32 cellPngDecGettIME(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr<CellPngTIME> time)
{ {
#ifdef PRX_DEBUG
cellPngDec.Warning("%s()", __FUNCTION__);
return GetCurrentPPUThread().FastCall2(libpngdec + 0x1024, libpngdec_rtoc);
#else
UNIMPLEMENTED_FUNC(cellPngDec); UNIMPLEMENTED_FUNC(cellPngDec);
return CELL_OK; return CELL_OK;
#endif
} }
s64 cellPngDecGethIST(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr<CellPngHIST> hist) s32 cellPngDecGethIST(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr<CellPngHIST> hist)
{ {
#ifdef PRX_DEBUG
cellPngDec.Warning("%s()", __FUNCTION__);
return GetCurrentPPUThread().FastCall2(libpngdec + 0x116C, libpngdec_rtoc);
#else
UNIMPLEMENTED_FUNC(cellPngDec); UNIMPLEMENTED_FUNC(cellPngDec);
return CELL_OK; return CELL_OK;
#endif
} }
s64 cellPngDecGettRNS(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr<CellPngTRNS> trns) s32 cellPngDecGettRNS(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr<CellPngTRNS> trns)
{ {
#ifdef PRX_DEBUG
cellPngDec.Warning("%s()", __FUNCTION__);
return GetCurrentPPUThread().FastCall2(libpngdec + 0x12A4, libpngdec_rtoc);
#else
UNIMPLEMENTED_FUNC(cellPngDec); UNIMPLEMENTED_FUNC(cellPngDec);
return CELL_OK; return CELL_OK;
#endif
} }
s64 cellPngDecGetsBIT(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr<CellPngSBIT> sbit) s32 cellPngDecGetsBIT(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr<CellPngSBIT> sbit)
{ {
#ifdef PRX_DEBUG
cellPngDec.Warning("%s()", __FUNCTION__);
return GetCurrentPPUThread().FastCall2(libpngdec + 0x1420, libpngdec_rtoc);
#else
UNIMPLEMENTED_FUNC(cellPngDec); UNIMPLEMENTED_FUNC(cellPngDec);
return CELL_OK; return CELL_OK;
#endif
} }
s64 cellPngDecGetiCCP(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr<CellPngICCP> iccp) s32 cellPngDecGetiCCP(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr<CellPngICCP> iccp)
{ {
#ifdef PRX_DEBUG
cellPngDec.Warning("%s()", __FUNCTION__);
return GetCurrentPPUThread().FastCall2(libpngdec + 0x1574, libpngdec_rtoc);
#else
UNIMPLEMENTED_FUNC(cellPngDec); UNIMPLEMENTED_FUNC(cellPngDec);
return CELL_OK; return CELL_OK;
#endif
} }
s64 cellPngDecGetsRGB(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr<CellPngSRGB> srgb) s32 cellPngDecGetsRGB(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr<CellPngSRGB> srgb)
{ {
#ifdef PRX_DEBUG
cellPngDec.Warning("%s()", __FUNCTION__);
return GetCurrentPPUThread().FastCall2(libpngdec + 0x16B4, libpngdec_rtoc);
#else
UNIMPLEMENTED_FUNC(cellPngDec); UNIMPLEMENTED_FUNC(cellPngDec);
return CELL_OK; return CELL_OK;
#endif
} }
s64 cellPngDecGetgAMA(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr<CellPngGAMA> gama) s32 cellPngDecGetgAMA(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr<CellPngGAMA> gama)
{ {
#ifdef PRX_DEBUG
cellPngDec.Warning("%s()", __FUNCTION__);
return GetCurrentPPUThread().FastCall2(libpngdec + 0x17CC, libpngdec_rtoc);
#else
UNIMPLEMENTED_FUNC(cellPngDec); UNIMPLEMENTED_FUNC(cellPngDec);
return CELL_OK; return CELL_OK;
#endif
} }
s64 cellPngDecGetPLTE(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr<CellPngPLTE> plte) s32 cellPngDecGetPLTE(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr<CellPngPLTE> plte)
{ {
#ifdef PRX_DEBUG
cellPngDec.Warning("%s()", __FUNCTION__);
return GetCurrentPPUThread().FastCall2(libpngdec + 0x18E4, libpngdec_rtoc);
#else
UNIMPLEMENTED_FUNC(cellPngDec); UNIMPLEMENTED_FUNC(cellPngDec);
return CELL_OK; return CELL_OK;
#endif
} }
s64 cellPngDecGetTextChunk( s32 cellPngDecGetTextChunk(
CellPngDecMainHandle mainHandle, CellPngDecMainHandle mainHandle,
CellPngDecSubHandle subHandle, CellPngDecSubHandle subHandle,
vm::ptr<u32> textInfoNum, vm::ptr<u32> textInfoNum,
vm::ptr<vm::bptr<CellPngTextInfo>> textInfo) vm::ptr<vm::bptr<CellPngTextInfo>> textInfo)
{ {
#ifdef PRX_DEBUG
cellPngDec.Warning("%s()", __FUNCTION__);
return GetCurrentPPUThread().FastCall2(libpngdec + 0x19FC, libpngdec_rtoc);
#else
UNIMPLEMENTED_FUNC(cellPngDec); UNIMPLEMENTED_FUNC(cellPngDec);
return CELL_OK; return CELL_OK;
#endif
} }
Module cellPngDec("cellPngDec", []() Module cellPngDec("cellPngDec", []()
@ -804,51 +650,4 @@ Module cellPngDec("cellPngDec", []()
REG_FUNC(cellPngDec, cellPngDecOpen); REG_FUNC(cellPngDec, cellPngDecOpen);
REG_FUNC(cellPngDec, cellPngDecExtDecodeData); REG_FUNC(cellPngDec, cellPngDecExtDecodeData);
REG_FUNC(cellPngDec, cellPngDecDecodeData); REG_FUNC(cellPngDec, cellPngDecDecodeData);
#ifdef PRX_DEBUG
CallAfter([]()
{
if (!Memory.MainMem.GetStartAddr()) return;
libpngdec = (u32)Memory.MainMem.AllocAlign(sizeof(libpngdec_data), 0x100000);
memcpy(vm::get_ptr<void>(libpngdec), libpngdec_data, sizeof(libpngdec_data));
libpngdec_rtoc = libpngdec + 0x49710;
extern Module* sysPrxForUser;
extern Module* cellSpurs;
extern Module* sys_fs;
FIX_IMPORT(sysPrxForUser, _sys_snprintf , libpngdec + 0x1E6D0);
FIX_IMPORT(sysPrxForUser, _sys_strlen , libpngdec + 0x1E6F0);
fix_import(sysPrxForUser, 0x3EF17F8C , libpngdec + 0x1E710);
FIX_IMPORT(sysPrxForUser, _sys_memset , libpngdec + 0x1E730);
FIX_IMPORT(sysPrxForUser, _sys_memcpy , libpngdec + 0x1E750);
FIX_IMPORT(sysPrxForUser, _sys_strcpy , libpngdec + 0x1E770);
FIX_IMPORT(sysPrxForUser, _sys_strncpy , libpngdec + 0x1E790);
FIX_IMPORT(sysPrxForUser, _sys_memcmp , libpngdec + 0x1E7B0);
FIX_IMPORT(cellSpurs, cellSpursQueueDetachLv2EventQueue , libpngdec + 0x1E7D0);
FIX_IMPORT(cellSpurs, cellSpursAttributeSetNamePrefix , libpngdec + 0x1E7F0);
FIX_IMPORT(cellSpurs, _cellSpursQueueInitialize , libpngdec + 0x1E810);
FIX_IMPORT(cellSpurs, _cellSpursTasksetAttributeInitialize, libpngdec + 0x1E830);
FIX_IMPORT(cellSpurs, cellSpursTasksetAttributeSetName , libpngdec + 0x1E850);
FIX_IMPORT(cellSpurs, cellSpursTaskGetReadOnlyAreaPattern , libpngdec + 0x1E870);
FIX_IMPORT(cellSpurs, cellSpursTaskGetContextSaveAreaSize , libpngdec + 0x1E890);
FIX_IMPORT(cellSpurs, cellSpursQueuePopBody , libpngdec + 0x1E8B0);
FIX_IMPORT(cellSpurs, cellSpursQueuePushBody , libpngdec + 0x1E8D0);
FIX_IMPORT(cellSpurs, _cellSpursAttributeInitialize , libpngdec + 0x1E8F0);
FIX_IMPORT(cellSpurs, cellSpursJoinTaskset , libpngdec + 0x1E910);
FIX_IMPORT(cellSpurs, cellSpursShutdownTaskset , libpngdec + 0x1E930);
FIX_IMPORT(cellSpurs, cellSpursInitializeWithAttribute , libpngdec + 0x1E950);
FIX_IMPORT(cellSpurs, cellSpursCreateTask , libpngdec + 0x1E970);
FIX_IMPORT(cellSpurs, cellSpursCreateTasksetWithAttribute , libpngdec + 0x1E990);
FIX_IMPORT(cellSpurs, cellSpursFinalize , libpngdec + 0x1E9B0);
FIX_IMPORT(cellSpurs, cellSpursQueueAttachLv2EventQueue , libpngdec + 0x1E9D0);
FIX_IMPORT(sys_fs, cellFsClose , libpngdec + 0x1E9F0);
FIX_IMPORT(sys_fs, cellFsRead , libpngdec + 0x1EA10);
FIX_IMPORT(sys_fs, cellFsOpen , libpngdec + 0x1EA30);
FIX_IMPORT(sys_fs, cellFsLseek , libpngdec + 0x1EA50);
fix_relocs(cellPngDec, libpngdec, 0x41C30, 0x47AB0, 0x40A00);
});
#endif
}); });

58
rpcs3/Emu/SysCalls/Modules/cellPngDec.h
View file

@ -183,77 +183,77 @@ struct CellPngDecDataOutInfo
}; };
// Functions // Functions
s64 cellPngDecCreate(vm::ptr<u32> mainHandle, vm::ptr<const CellPngDecThreadInParam> threadInParam, vm::ptr<CellPngDecThreadOutParam> threadOutParam); s32 cellPngDecCreate(vm::ptr<u32> mainHandle, vm::ptr<const CellPngDecThreadInParam> threadInParam, vm::ptr<CellPngDecThreadOutParam> threadOutParam);
s64 cellPngDecExtCreate( s32 cellPngDecExtCreate(
vm::ptr<u32> mainHandle, vm::ptr<u32> mainHandle,
vm::ptr<const CellPngDecThreadInParam> threadInParam, vm::ptr<const CellPngDecThreadInParam> threadInParam,
vm::ptr<CellPngDecThreadOutParam> threadOutParam, vm::ptr<CellPngDecThreadOutParam> threadOutParam,
vm::ptr<const CellPngDecExtThreadInParam> extThreadInParam, vm::ptr<const CellPngDecExtThreadInParam> extThreadInParam,
vm::ptr<CellPngDecExtThreadOutParam> extThreadOutParam); vm::ptr<CellPngDecExtThreadOutParam> extThreadOutParam);
s64 cellPngDecOpen( s32 cellPngDecOpen(
CellPngDecMainHandle mainHandle, CellPngDecMainHandle mainHandle,
vm::ptr<u32> subHandle, vm::ptr<u32> subHandle,
vm::ptr<const CellPngDecSrc> src, vm::ptr<const CellPngDecSrc> src,
vm::ptr<CellPngDecOpnInfo> openInfo); vm::ptr<CellPngDecOpnInfo> openInfo);
s64 cellPngDecReadHeader(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr<CellPngDecInfo> info); s32 cellPngDecReadHeader(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr<CellPngDecInfo> info);
s64 cellPngDecSetParameter( s32 cellPngDecSetParameter(
CellPngDecMainHandle mainHandle, CellPngDecMainHandle mainHandle,
CellPngDecSubHandle subHandle, CellPngDecSubHandle subHandle,
vm::ptr<const CellPngDecInParam> inParam, vm::ptr<const CellPngDecInParam> inParam,
vm::ptr<CellPngDecOutParam> outParam); vm::ptr<CellPngDecOutParam> outParam);
s64 cellPngDecDecodeData( s32 cellPngDecDecodeData(
CellPngDecMainHandle mainHandle, CellPngDecMainHandle mainHandle,
CellPngDecSubHandle subHandle, CellPngDecSubHandle subHandle,
vm::ptr<u8> data, vm::ptr<u8> data,
vm::ptr<const CellPngDecDataCtrlParam> dataCtrlParam, vm::ptr<const CellPngDecDataCtrlParam> dataCtrlParam,
vm::ptr<CellPngDecDataOutInfo> dataOutInfo); vm::ptr<CellPngDecDataOutInfo> dataOutInfo);
s64 cellPngDecClose(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle); s32 cellPngDecClose(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle);
s64 cellPngDecDestroy(CellPngDecMainHandle mainHandle); s32 cellPngDecDestroy(CellPngDecMainHandle mainHandle);
s64 cellPngDecGetTextChunk( s32 cellPngDecGetTextChunk(
CellPngDecMainHandle mainHandle, CellPngDecMainHandle mainHandle,
CellPngDecSubHandle subHandle, CellPngDecSubHandle subHandle,
vm::ptr<u32> textInfoNum, vm::ptr<u32> textInfoNum,
vm::ptr<vm::bptr<CellPngTextInfo>> textInfo); vm::ptr<vm::bptr<CellPngTextInfo>> textInfo);
s64 cellPngDecGetPLTE(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr<CellPngPLTE> plte); s32 cellPngDecGetPLTE(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr<CellPngPLTE> plte);
s64 cellPngDecGetgAMA(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr<CellPngGAMA> gama); s32 cellPngDecGetgAMA(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr<CellPngGAMA> gama);
s64 cellPngDecGetsRGB(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr<CellPngSRGB> srgb); s32 cellPngDecGetsRGB(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr<CellPngSRGB> srgb);
s64 cellPngDecGetiCCP(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr<CellPngICCP> iccp); s32 cellPngDecGetiCCP(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr<CellPngICCP> iccp);
s64 cellPngDecGetsBIT(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr<CellPngSBIT> sbit); s32 cellPngDecGetsBIT(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr<CellPngSBIT> sbit);
s64 cellPngDecGettRNS(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr<CellPngTRNS> trns); s32 cellPngDecGettRNS(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr<CellPngTRNS> trns);
s64 cellPngDecGethIST(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr<CellPngHIST> hist); s32 cellPngDecGethIST(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr<CellPngHIST> hist);
s64 cellPngDecGettIME(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr<CellPngTIME> time); s32 cellPngDecGettIME(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr<CellPngTIME> time);
s64 cellPngDecGetbKGD(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr<CellPngBKGD> bkgd); s32 cellPngDecGetbKGD(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr<CellPngBKGD> bkgd);
s64 cellPngDecGetsPLT(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr<CellPngSPLT> splt); s32 cellPngDecGetsPLT(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr<CellPngSPLT> splt);
s64 cellPngDecGetoFFs(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr<CellPngOFFS> offs); s32 cellPngDecGetoFFs(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr<CellPngOFFS> offs);
s64 cellPngDecGetpHYs(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr<CellPngPHYS> phys); s32 cellPngDecGetpHYs(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr<CellPngPHYS> phys);
s64 cellPngDecGetsCAL(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr<CellPngSCAL> scal); s32 cellPngDecGetsCAL(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr<CellPngSCAL> scal);
s64 cellPngDecGetcHRM(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr<CellPngCHRM> chrm); s32 cellPngDecGetcHRM(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr<CellPngCHRM> chrm);
s64 cellPngDecGetpCAL(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr<CellPngPCAL> pcal); s32 cellPngDecGetpCAL(CellPngDecMainHandle mainHandle, CellPngDecSubHandle subHandle, vm::ptr<CellPngPCAL> pcal);
s64 cellPngDecGetUnknownChunks( s32 cellPngDecGetUnknownChunks(
CellPngDecMainHandle mainHandle, CellPngDecMainHandle mainHandle,
CellPngDecSubHandle subHandle, CellPngDecSubHandle subHandle,
vm::ptr<vm::bptr<CellPngUnknownChunk>> unknownChunk, vm::ptr<vm::bptr<CellPngUnknownChunk>> unknownChunk,
@ -345,7 +345,7 @@ struct CellPngDecCbCtrlDisp
}; };
// Functions // Functions
s64 cellPngDecExtOpen( s32 cellPngDecExtOpen(
CellPngDecMainHandle mainHandle, CellPngDecMainHandle mainHandle,
vm::ptr<u32> subHandle, vm::ptr<u32> subHandle,
vm::ptr<const CellPngDecSrc> src, vm::ptr<const CellPngDecSrc> src,
@ -353,13 +353,13 @@ s64 cellPngDecExtOpen(
vm::ptr<const CellPngDecCbCtrlStrm> cbCtrlStrm, vm::ptr<const CellPngDecCbCtrlStrm> cbCtrlStrm,
vm::ptr<const CellPngDecOpnParam> opnParam); vm::ptr<const CellPngDecOpnParam> opnParam);
s64 cellPngDecExtReadHeader( s32 cellPngDecExtReadHeader(
CellPngDecMainHandle mainHandle, CellPngDecMainHandle mainHandle,
CellPngDecSubHandle subHandle, CellPngDecSubHandle subHandle,
vm::ptr<CellPngDecInfo> info, vm::ptr<CellPngDecInfo> info,
vm::ptr<CellPngDecExtInfo> extInfo); vm::ptr<CellPngDecExtInfo> extInfo);
s64 cellPngDecExtSetParameter( s32 cellPngDecExtSetParameter(
CellPngDecMainHandle mainHandle, CellPngDecMainHandle mainHandle,
CellPngDecSubHandle subHandle, CellPngDecSubHandle subHandle,
vm::ptr<const CellPngDecInParam> inParam, vm::ptr<const CellPngDecInParam> inParam,
@ -367,7 +367,7 @@ s64 cellPngDecExtSetParameter(
vm::ptr<const CellPngDecExtInParam> extInParam, vm::ptr<const CellPngDecExtInParam> extInParam,
vm::ptr<CellPngDecExtOutParam> extOutParam); vm::ptr<CellPngDecExtOutParam> extOutParam);
s64 cellPngDecExtDecodeData( s32 cellPngDecExtDecodeData(
CellPngDecMainHandle mainHandle, CellPngDecMainHandle mainHandle,
CellPngDecSubHandle subHandle, CellPngDecSubHandle subHandle,
vm::ptr<u8> data, vm::ptr<u8> data,

1001
rpcs3/Emu/SysCalls/Modules/cellSpurs.cpp
View file

File diff suppressed because it is too large Load diff

4
rpcs3/Emu/SysCalls/Modules/cellSpurs.h
View file

@ -957,5 +957,5 @@ struct SpursTasksetContext
static_assert(sizeof(SpursTasksetContext) == 0x900, "Incorrect size for SpursTasksetContext"); static_assert(sizeof(SpursTasksetContext) == 0x900, "Incorrect size for SpursTasksetContext");
s64 spursAttachLv2EventQueue(vm::ptr<CellSpurs> spurs, u32 queue, vm::ptr<u8> port, s32 isDynamic, bool wasCreated); s32 spursAttachLv2EventQueue(vm::ptr<CellSpurs> spurs, u32 queue, vm::ptr<u8> port, s32 isDynamic, bool wasCreated);
s64 spursWakeUp(PPUThread& CPU, vm::ptr<CellSpurs> spurs); s32 spursWakeUp(PPUThread& CPU, vm::ptr<CellSpurs> spurs);

479
rpcs3/Emu/SysCalls/Modules/cellSpursJq.cpp
View file

@ -13,692 +13,376 @@
extern Module cellSpursJq; extern Module cellSpursJq;
#ifdef PRX_DEBUG s32 cellSpursJobQueueAttributeInitialize()
#include "prx_libspurs_jq.h"
u32 libspurs_jq;
u32 libspurs_jq_rtoc;
#endif
s64 cellSpursJobQueueAttributeInitialize()
{ {
#ifdef PRX_DEBUG
cellSpursJq.Warning("%s()", __FUNCTION__);
return GetCurrentPPUThread().FastCall2(libspurs_jq + 0x000010, libspurs_jq_rtoc);
#else
UNIMPLEMENTED_FUNC(cellSpursJq); UNIMPLEMENTED_FUNC(cellSpursJq);
return CELL_OK; return CELL_OK;
#endif
} }
s64 cellSpursJobQueueAttributeSetMaxGrab() s32 cellSpursJobQueueAttributeSetMaxGrab()
{ {
#ifdef PRX_DEBUG
cellSpursJq.Warning("%s()", __FUNCTION__);
return GetCurrentPPUThread().FastCall2(libspurs_jq + 0x000058, libspurs_jq_rtoc);
#else
UNIMPLEMENTED_FUNC(cellSpursJq); UNIMPLEMENTED_FUNC(cellSpursJq);
return CELL_OK; return CELL_OK;
#endif
} }
s64 cellSpursJobQueueAttributeSetSubmitWithEntryLock() s32 cellSpursJobQueueAttributeSetSubmitWithEntryLock()
{ {
#ifdef PRX_DEBUG
cellSpursJq.Warning("%s()", __FUNCTION__);
return GetCurrentPPUThread().FastCall2(libspurs_jq + 0x000098, libspurs_jq_rtoc);
#else
UNIMPLEMENTED_FUNC(cellSpursJq); UNIMPLEMENTED_FUNC(cellSpursJq);
return CELL_OK; return CELL_OK;
#endif
} }
s64 cellSpursJobQueueAttributeSetDoBusyWaiting() s32 cellSpursJobQueueAttributeSetDoBusyWaiting()
{ {
#ifdef PRX_DEBUG
cellSpursJq.Warning("%s()", __FUNCTION__);
return GetCurrentPPUThread().FastCall2(libspurs_jq + 0x0000BC, libspurs_jq_rtoc);
#else
UNIMPLEMENTED_FUNC(cellSpursJq); UNIMPLEMENTED_FUNC(cellSpursJq);
return CELL_OK; return CELL_OK;
#endif
} }
s64 cellSpursJobQueueAttributeSetIsHaltOnError() s32 cellSpursJobQueueAttributeSetIsHaltOnError()
{ {
#ifdef PRX_DEBUG
cellSpursJq.Warning("%s()", __FUNCTION__);
return GetCurrentPPUThread().FastCall2(libspurs_jq + 0x0000E0, libspurs_jq_rtoc);
#else
UNIMPLEMENTED_FUNC(cellSpursJq); UNIMPLEMENTED_FUNC(cellSpursJq);
return CELL_OK; return CELL_OK;
#endif
} }
s64 cellSpursJobQueueAttributeSetIsJobTypeMemoryCheck() s32 cellSpursJobQueueAttributeSetIsJobTypeMemoryCheck()
{ {
#ifdef PRX_DEBUG
cellSpursJq.Warning("%s()", __FUNCTION__);
return GetCurrentPPUThread().FastCall2(libspurs_jq + 0x000104, libspurs_jq_rtoc);
#else
UNIMPLEMENTED_FUNC(cellSpursJq); UNIMPLEMENTED_FUNC(cellSpursJq);
return CELL_OK; return CELL_OK;
#endif
} }
s64 cellSpursJobQueueAttributeSetMaxSizeJobDescriptor() s32 cellSpursJobQueueAttributeSetMaxSizeJobDescriptor()
{ {
#ifdef PRX_DEBUG
cellSpursJq.Warning("%s()", __FUNCTION__);
return GetCurrentPPUThread().FastCall2(libspurs_jq + 0x000128, libspurs_jq_rtoc);
#else
UNIMPLEMENTED_FUNC(cellSpursJq); UNIMPLEMENTED_FUNC(cellSpursJq);
return CELL_OK; return CELL_OK;
#endif
} }
s64 cellSpursJobQueueAttributeSetGrabParameters() s32 cellSpursJobQueueAttributeSetGrabParameters()
{ {
#ifdef PRX_DEBUG
cellSpursJq.Warning("%s()", __FUNCTION__);
return GetCurrentPPUThread().FastCall2(libspurs_jq + 0x000178, libspurs_jq_rtoc);
#else
UNIMPLEMENTED_FUNC(cellSpursJq); UNIMPLEMENTED_FUNC(cellSpursJq);
return CELL_OK; return CELL_OK;
#endif
} }
s64 cellSpursJobQueueSetWaitingMode() s32 cellSpursJobQueueSetWaitingMode()
{ {
#ifdef PRX_DEBUG
cellSpursJq.Warning("%s()", __FUNCTION__);
return GetCurrentPPUThread().FastCall2(libspurs_jq + 0x0001C8, libspurs_jq_rtoc);
#else
UNIMPLEMENTED_FUNC(cellSpursJq); UNIMPLEMENTED_FUNC(cellSpursJq);
return CELL_OK; return CELL_OK;
#endif
} }
s64 cellSpursShutdownJobQueue() s32 cellSpursShutdownJobQueue()
{ {
#ifdef PRX_DEBUG
cellSpursJq.Warning("%s()", __FUNCTION__);
return GetCurrentPPUThread().FastCall2(libspurs_jq + 0x0002F0, libspurs_jq_rtoc);
#else
UNIMPLEMENTED_FUNC(cellSpursJq); UNIMPLEMENTED_FUNC(cellSpursJq);
return CELL_OK; return CELL_OK;
#endif
} }
s64 _cellSpursCreateJobQueueWithJobDescriptorPool() s32 _cellSpursCreateJobQueueWithJobDescriptorPool()
{ {
#ifdef PRX_DEBUG
cellSpursJq.Warning("%s()", __FUNCTION__);
return GetCurrentPPUThread().FastCall2(libspurs_jq + 0x0003CC, libspurs_jq_rtoc);
#else
UNIMPLEMENTED_FUNC(cellSpursJq); UNIMPLEMENTED_FUNC(cellSpursJq);
return CELL_OK; return CELL_OK;
#endif
} }
s64 _cellSpursCreateJobQueue() s32 _cellSpursCreateJobQueue()
{ {
#ifdef PRX_DEBUG
cellSpursJq.Warning("%s()", __FUNCTION__);
return GetCurrentPPUThread().FastCall2(libspurs_jq + 0x000CA8, libspurs_jq_rtoc);
#else
UNIMPLEMENTED_FUNC(cellSpursJq); UNIMPLEMENTED_FUNC(cellSpursJq);
return CELL_OK; return CELL_OK;
#endif
} }
s64 cellSpursJoinJobQueue() s32 cellSpursJoinJobQueue()
{ {
#ifdef PRX_DEBUG
cellSpursJq.Warning("%s()", __FUNCTION__);
return GetCurrentPPUThread().FastCall2(libspurs_jq + 0x000CF0, libspurs_jq_rtoc);
#else
UNIMPLEMENTED_FUNC(cellSpursJq); UNIMPLEMENTED_FUNC(cellSpursJq);
return CELL_OK; return CELL_OK;
#endif
} }
s64 _cellSpursJobQueuePushJobListBody() s32 _cellSpursJobQueuePushJobListBody()
{ {
#ifdef PRX_DEBUG
cellSpursJq.Warning("%s()", __FUNCTION__);
return GetCurrentPPUThread().FastCall2(libspurs_jq + 0x001B24, libspurs_jq_rtoc);
#else
UNIMPLEMENTED_FUNC(cellSpursJq); UNIMPLEMENTED_FUNC(cellSpursJq);
return CELL_OK; return CELL_OK;
#endif
} }
s64 _cellSpursJobQueuePushJobBody2() s32 _cellSpursJobQueuePushJobBody2()
{ {
#ifdef PRX_DEBUG
cellSpursJq.Warning("%s()", __FUNCTION__);
return GetCurrentPPUThread().FastCall2(libspurs_jq + 0x001BF0, libspurs_jq_rtoc);
#else
UNIMPLEMENTED_FUNC(cellSpursJq); UNIMPLEMENTED_FUNC(cellSpursJq);
return CELL_OK; return CELL_OK;
#endif
} }
s64 _cellSpursJobQueuePushJob2Body() s32 _cellSpursJobQueuePushJob2Body()
{ {
#ifdef PRX_DEBUG
cellSpursJq.Warning("%s()", __FUNCTION__);
return GetCurrentPPUThread().FastCall2(libspurs_jq + 0x001CD0, libspurs_jq_rtoc);
#else
UNIMPLEMENTED_FUNC(cellSpursJq); UNIMPLEMENTED_FUNC(cellSpursJq);
return CELL_OK; return CELL_OK;
#endif
} }
s64 _cellSpursJobQueuePushAndReleaseJobBody() s32 _cellSpursJobQueuePushAndReleaseJobBody()
{ {
#ifdef PRX_DEBUG
cellSpursJq.Warning("%s()", __FUNCTION__);
return GetCurrentPPUThread().FastCall2(libspurs_jq + 0x001DC8, libspurs_jq_rtoc);
#else
UNIMPLEMENTED_FUNC(cellSpursJq); UNIMPLEMENTED_FUNC(cellSpursJq);
return CELL_OK; return CELL_OK;
#endif
} }
s64 _cellSpursJobQueuePushJobBody() s32 _cellSpursJobQueuePushJobBody()
{ {
#ifdef PRX_DEBUG
cellSpursJq.Warning("%s()", __FUNCTION__);
return GetCurrentPPUThread().FastCall2(libspurs_jq + 0x001EC8, libspurs_jq_rtoc);
#else
UNIMPLEMENTED_FUNC(cellSpursJq); UNIMPLEMENTED_FUNC(cellSpursJq);
return CELL_OK; return CELL_OK;
#endif
} }
s64 _cellSpursJobQueuePushBody() s32 _cellSpursJobQueuePushBody()
{ {
#ifdef PRX_DEBUG
cellSpursJq.Warning("%s()", __FUNCTION__);
return GetCurrentPPUThread().FastCall2(libspurs_jq + 0x001F90, libspurs_jq_rtoc);
#else
UNIMPLEMENTED_FUNC(cellSpursJq); UNIMPLEMENTED_FUNC(cellSpursJq);
return CELL_OK; return CELL_OK;
#endif
} }
s64 _cellSpursJobQueueAllocateJobDescriptorBody() s32 _cellSpursJobQueueAllocateJobDescriptorBody()
{ {
#ifdef PRX_DEBUG
cellSpursJq.Warning("%s()", __FUNCTION__);
return GetCurrentPPUThread().FastCall2(libspurs_jq + 0x002434, libspurs_jq_rtoc);
#else
UNIMPLEMENTED_FUNC(cellSpursJq); UNIMPLEMENTED_FUNC(cellSpursJq);
return CELL_OK; return CELL_OK;
#endif
} }
s64 _cellSpursJobQueuePushSync() s32 _cellSpursJobQueuePushSync()
{ {
#ifdef PRX_DEBUG
cellSpursJq.Warning("%s()", __FUNCTION__);
return GetCurrentPPUThread().FastCall2(libspurs_jq + 0x002498, libspurs_jq_rtoc);
#else
UNIMPLEMENTED_FUNC(cellSpursJq); UNIMPLEMENTED_FUNC(cellSpursJq);
return CELL_OK; return CELL_OK;
#endif
} }
s64 _cellSpursJobQueuePushFlush() s32 _cellSpursJobQueuePushFlush()
{ {
#ifdef PRX_DEBUG
cellSpursJq.Warning("%s()", __FUNCTION__);
return GetCurrentPPUThread().FastCall2(libspurs_jq + 0x002528, libspurs_jq_rtoc);
#else
UNIMPLEMENTED_FUNC(cellSpursJq); UNIMPLEMENTED_FUNC(cellSpursJq);
return CELL_OK; return CELL_OK;
#endif
} }
s64 cellSpursJobQueueGetSpurs() s32 cellSpursJobQueueGetSpurs()
{ {
#ifdef PRX_DEBUG
cellSpursJq.Warning("%s()", __FUNCTION__);
return GetCurrentPPUThread().FastCall2(libspurs_jq + 0x002598, libspurs_jq_rtoc);
#else
UNIMPLEMENTED_FUNC(cellSpursJq); UNIMPLEMENTED_FUNC(cellSpursJq);
return CELL_OK; return CELL_OK;
#endif
} }
s64 cellSpursJobQueueGetHandleCount() s32 cellSpursJobQueueGetHandleCount()
{ {
#ifdef PRX_DEBUG
cellSpursJq.Warning("%s()", __FUNCTION__);
return GetCurrentPPUThread().FastCall2(libspurs_jq + 0x0025C4, libspurs_jq_rtoc);
#else
UNIMPLEMENTED_FUNC(cellSpursJq); UNIMPLEMENTED_FUNC(cellSpursJq);
return CELL_OK; return CELL_OK;
#endif
} }
s64 cellSpursJobQueueGetError() s32 cellSpursJobQueueGetError()
{ {
#ifdef PRX_DEBUG
cellSpursJq.Warning("%s()", __FUNCTION__);
return GetCurrentPPUThread().FastCall2(libspurs_jq + 0x002600, libspurs_jq_rtoc);
#else
UNIMPLEMENTED_FUNC(cellSpursJq); UNIMPLEMENTED_FUNC(cellSpursJq);
return CELL_OK; return CELL_OK;
#endif
} }
s64 cellSpursJobQueueGetMaxSizeJobDescriptor() s32 cellSpursJobQueueGetMaxSizeJobDescriptor()
{ {
#ifdef PRX_DEBUG
cellSpursJq.Warning("%s()", __FUNCTION__);
return GetCurrentPPUThread().FastCall2(libspurs_jq + 0x002668, libspurs_jq_rtoc);
#else
UNIMPLEMENTED_FUNC(cellSpursJq); UNIMPLEMENTED_FUNC(cellSpursJq);
return CELL_OK; return CELL_OK;
#endif
} }
s64 cellSpursGetJobQueueId() s32 cellSpursGetJobQueueId()
{ {
#ifdef PRX_DEBUG
cellSpursJq.Warning("%s()", __FUNCTION__);
return GetCurrentPPUThread().FastCall2(libspurs_jq + 0x0026A4, libspurs_jq_rtoc);
#else
UNIMPLEMENTED_FUNC(cellSpursJq); UNIMPLEMENTED_FUNC(cellSpursJq);
return CELL_OK; return CELL_OK;
#endif
} }
s64 cellSpursJobQueueGetSuspendedJobSize() s32 cellSpursJobQueueGetSuspendedJobSize()
{ {
#ifdef PRX_DEBUG
cellSpursJq.Warning("%s()", __FUNCTION__);
return GetCurrentPPUThread().FastCall2(libspurs_jq + 0x002700, libspurs_jq_rtoc);
#else
UNIMPLEMENTED_FUNC(cellSpursJq); UNIMPLEMENTED_FUNC(cellSpursJq);
return CELL_OK; return CELL_OK;
#endif
} }
s64 cellSpursJobQueueClose() s32 cellSpursJobQueueClose()
{ {
#ifdef PRX_DEBUG
cellSpursJq.Warning("%s()", __FUNCTION__);
return GetCurrentPPUThread().FastCall2(libspurs_jq + 0x002D70, libspurs_jq_rtoc);
#else
UNIMPLEMENTED_FUNC(cellSpursJq); UNIMPLEMENTED_FUNC(cellSpursJq);
return CELL_OK; return CELL_OK;
#endif
} }
s64 cellSpursJobQueueOpen() s32 cellSpursJobQueueOpen()
{ {
#ifdef PRX_DEBUG
cellSpursJq.Warning("%s()", __FUNCTION__);
return GetCurrentPPUThread().FastCall2(libspurs_jq + 0x002E50, libspurs_jq_rtoc);
#else
UNIMPLEMENTED_FUNC(cellSpursJq); UNIMPLEMENTED_FUNC(cellSpursJq);
return CELL_OK; return CELL_OK;
#endif
} }
s64 cellSpursJobQueueSemaphoreTryAcquire() s32 cellSpursJobQueueSemaphoreTryAcquire()
{ {
#ifdef PRX_DEBUG
cellSpursJq.Warning("%s()", __FUNCTION__);
return GetCurrentPPUThread().FastCall2(libspurs_jq + 0x003370, libspurs_jq_rtoc);
#else
UNIMPLEMENTED_FUNC(cellSpursJq); UNIMPLEMENTED_FUNC(cellSpursJq);
return CELL_OK; return CELL_OK;
#endif
} }
s64 cellSpursJobQueueSemaphoreAcquire() s32 cellSpursJobQueueSemaphoreAcquire()
{ {
#ifdef PRX_DEBUG
cellSpursJq.Warning("%s()", __FUNCTION__);
return GetCurrentPPUThread().FastCall2(libspurs_jq + 0x003378, libspurs_jq_rtoc);
#else
UNIMPLEMENTED_FUNC(cellSpursJq); UNIMPLEMENTED_FUNC(cellSpursJq);
return CELL_OK; return CELL_OK;
#endif
} }
s64 cellSpursJobQueueSemaphoreInitialize() s32 cellSpursJobQueueSemaphoreInitialize()
{ {
#ifdef PRX_DEBUG
cellSpursJq.Warning("%s()", __FUNCTION__);
return GetCurrentPPUThread().FastCall2(libspurs_jq + 0x003380, libspurs_jq_rtoc);
#else
UNIMPLEMENTED_FUNC(cellSpursJq); UNIMPLEMENTED_FUNC(cellSpursJq);
return CELL_OK; return CELL_OK;
#endif
} }
s64 cellSpursJobQueueSendSignal() s32 cellSpursJobQueueSendSignal()
{ {
#ifdef PRX_DEBUG
cellSpursJq.Warning("%s()", __FUNCTION__);
return GetCurrentPPUThread().FastCall2(libspurs_jq + 0x0033E0, libspurs_jq_rtoc);
#else
UNIMPLEMENTED_FUNC(cellSpursJq); UNIMPLEMENTED_FUNC(cellSpursJq);
return CELL_OK; return CELL_OK;
#endif
} }
s64 cellSpursJobQueuePortGetJobQueue() s32 cellSpursJobQueuePortGetJobQueue()
{ {
#ifdef PRX_DEBUG
cellSpursJq.Warning("%s()", __FUNCTION__);
return GetCurrentPPUThread().FastCall2(libspurs_jq + 0x00354C, libspurs_jq_rtoc);
#else
UNIMPLEMENTED_FUNC(cellSpursJq); UNIMPLEMENTED_FUNC(cellSpursJq);
return CELL_OK; return CELL_OK;
#endif
} }
s64 _cellSpursJobQueuePortPushSync() s32 _cellSpursJobQueuePortPushSync()
{ {
#ifdef PRX_DEBUG
cellSpursJq.Warning("%s()", __FUNCTION__);
return GetCurrentPPUThread().FastCall2(libspurs_jq + 0x003554, libspurs_jq_rtoc);
#else
UNIMPLEMENTED_FUNC(cellSpursJq); UNIMPLEMENTED_FUNC(cellSpursJq);
return CELL_OK; return CELL_OK;
#endif
} }
s64 _cellSpursJobQueuePortPushFlush() s32 _cellSpursJobQueuePortPushFlush()
{ {
#ifdef PRX_DEBUG
cellSpursJq.Warning("%s()", __FUNCTION__);
return GetCurrentPPUThread().FastCall2(libspurs_jq + 0x0035C0, libspurs_jq_rtoc);
#else
UNIMPLEMENTED_FUNC(cellSpursJq); UNIMPLEMENTED_FUNC(cellSpursJq);
return CELL_OK; return CELL_OK;
#endif
} }
s64 _cellSpursJobQueuePortPushJobListBody() s32 _cellSpursJobQueuePortPushJobListBody()
{ {
#ifdef PRX_DEBUG
cellSpursJq.Warning("%s()", __FUNCTION__);
return GetCurrentPPUThread().FastCall2(libspurs_jq + 0x003624, libspurs_jq_rtoc);
#else
UNIMPLEMENTED_FUNC(cellSpursJq); UNIMPLEMENTED_FUNC(cellSpursJq);
return CELL_OK; return CELL_OK;
#endif
} }
s64 _cellSpursJobQueuePortPushJobBody() s32 _cellSpursJobQueuePortPushJobBody()
{ {
#ifdef PRX_DEBUG
cellSpursJq.Warning("%s()", __FUNCTION__);
return GetCurrentPPUThread().FastCall2(libspurs_jq + 0x003A88, libspurs_jq_rtoc);
#else
UNIMPLEMENTED_FUNC(cellSpursJq); UNIMPLEMENTED_FUNC(cellSpursJq);
return CELL_OK; return CELL_OK;
#endif
} }
s64 _cellSpursJobQueuePortPushJobBody2() s32 _cellSpursJobQueuePortPushJobBody2()
{ {
#ifdef PRX_DEBUG
cellSpursJq.Warning("%s()", __FUNCTION__);
return GetCurrentPPUThread().FastCall2(libspurs_jq + 0x003A94, libspurs_jq_rtoc);
#else
UNIMPLEMENTED_FUNC(cellSpursJq); UNIMPLEMENTED_FUNC(cellSpursJq);
return CELL_OK; return CELL_OK;
#endif
} }
s64 _cellSpursJobQueuePortPushBody() s32 _cellSpursJobQueuePortPushBody()
{ {
#ifdef PRX_DEBUG
cellSpursJq.Warning("%s()", __FUNCTION__);
return GetCurrentPPUThread().FastCall2(libspurs_jq + 0x003A98, libspurs_jq_rtoc);
#else
UNIMPLEMENTED_FUNC(cellSpursJq); UNIMPLEMENTED_FUNC(cellSpursJq);
return CELL_OK; return CELL_OK;
#endif
} }
s64 cellSpursJobQueuePortTrySync() s32 cellSpursJobQueuePortTrySync()
{ {
#ifdef PRX_DEBUG
cellSpursJq.Warning("%s()", __FUNCTION__);
return GetCurrentPPUThread().FastCall2(libspurs_jq + 0x003C38, libspurs_jq_rtoc);
#else
UNIMPLEMENTED_FUNC(cellSpursJq); UNIMPLEMENTED_FUNC(cellSpursJq);
return CELL_OK; return CELL_OK;
#endif
} }
s64 cellSpursJobQueuePortSync() s32 cellSpursJobQueuePortSync()
{ {
#ifdef PRX_DEBUG
cellSpursJq.Warning("%s()", __FUNCTION__);
return GetCurrentPPUThread().FastCall2(libspurs_jq + 0x003C40, libspurs_jq_rtoc);
#else
UNIMPLEMENTED_FUNC(cellSpursJq); UNIMPLEMENTED_FUNC(cellSpursJq);
return CELL_OK; return CELL_OK;
#endif
} }
s64 cellSpursJobQueuePortInitialize() s32 cellSpursJobQueuePortInitialize()
{ {
#ifdef PRX_DEBUG
cellSpursJq.Warning("%s()", __FUNCTION__);
return GetCurrentPPUThread().FastCall2(libspurs_jq + 0x003C48, libspurs_jq_rtoc);
#else
UNIMPLEMENTED_FUNC(cellSpursJq); UNIMPLEMENTED_FUNC(cellSpursJq);
return CELL_OK; return CELL_OK;
#endif
} }
s64 cellSpursJobQueuePortInitializeWithDescriptorBuffer() s32 cellSpursJobQueuePortInitializeWithDescriptorBuffer()
{ {
#ifdef PRX_DEBUG
cellSpursJq.Warning("%s()", __FUNCTION__);
return GetCurrentPPUThread().FastCall2(libspurs_jq + 0x003D78, libspurs_jq_rtoc);
#else
UNIMPLEMENTED_FUNC(cellSpursJq); UNIMPLEMENTED_FUNC(cellSpursJq);
return CELL_OK; return CELL_OK;
#endif
} }
s64 cellSpursJobQueuePortFinalize() s32 cellSpursJobQueuePortFinalize()
{ {
#ifdef PRX_DEBUG
cellSpursJq.Warning("%s()", __FUNCTION__);
return GetCurrentPPUThread().FastCall2(libspurs_jq + 0x003E40, libspurs_jq_rtoc);
#else
UNIMPLEMENTED_FUNC(cellSpursJq); UNIMPLEMENTED_FUNC(cellSpursJq);
return CELL_OK; return CELL_OK;
#endif
} }
s64 _cellSpursJobQueuePortCopyPushJobBody() s32 _cellSpursJobQueuePortCopyPushJobBody()
{ {
#ifdef PRX_DEBUG
cellSpursJq.Warning("%s()", __FUNCTION__);
return GetCurrentPPUThread().FastCall2(libspurs_jq + 0x004280, libspurs_jq_rtoc);
#else
UNIMPLEMENTED_FUNC(cellSpursJq); UNIMPLEMENTED_FUNC(cellSpursJq);
return CELL_OK; return CELL_OK;
#endif
} }
s64 _cellSpursJobQueuePortCopyPushJobBody2() s32 _cellSpursJobQueuePortCopyPushJobBody2()
{ {
#ifdef PRX_DEBUG
cellSpursJq.Warning("%s()", __FUNCTION__);
return GetCurrentPPUThread().FastCall2(libspurs_jq + 0x00428C, libspurs_jq_rtoc);
#else
UNIMPLEMENTED_FUNC(cellSpursJq); UNIMPLEMENTED_FUNC(cellSpursJq);
return CELL_OK; return CELL_OK;
#endif
} }
s64 _cellSpursJobQueuePortCopyPushBody() s32 _cellSpursJobQueuePortCopyPushBody()
{ {
#ifdef PRX_DEBUG
cellSpursJq.Warning("%s()", __FUNCTION__);
return GetCurrentPPUThread().FastCall2(libspurs_jq + 0x004290, libspurs_jq_rtoc);
#else
UNIMPLEMENTED_FUNC(cellSpursJq); UNIMPLEMENTED_FUNC(cellSpursJq);
return CELL_OK; return CELL_OK;
#endif
} }
s64 cellSpursJobQueuePort2GetJobQueue() s32 cellSpursJobQueuePort2GetJobQueue()
{ {
#ifdef PRX_DEBUG
cellSpursJq.Warning("%s()", __FUNCTION__);
return GetCurrentPPUThread().FastCall2(libspurs_jq + 0x0042A4, libspurs_jq_rtoc);
#else
UNIMPLEMENTED_FUNC(cellSpursJq); UNIMPLEMENTED_FUNC(cellSpursJq);
return CELL_OK; return CELL_OK;
#endif
} }
s64 cellSpursJobQueuePort2PushSync() s32 cellSpursJobQueuePort2PushSync()
{ {
#ifdef PRX_DEBUG
cellSpursJq.Warning("%s()", __FUNCTION__);
return GetCurrentPPUThread().FastCall2(libspurs_jq + 0x0042AC, libspurs_jq_rtoc);
#else
UNIMPLEMENTED_FUNC(cellSpursJq); UNIMPLEMENTED_FUNC(cellSpursJq);
return CELL_OK; return CELL_OK;
#endif
} }
s64 cellSpursJobQueuePort2PushFlush() s32 cellSpursJobQueuePort2PushFlush()
{ {
#ifdef PRX_DEBUG
cellSpursJq.Warning("%s()", __FUNCTION__);
return GetCurrentPPUThread().FastCall2(libspurs_jq + 0x004330, libspurs_jq_rtoc);
#else
UNIMPLEMENTED_FUNC(cellSpursJq); UNIMPLEMENTED_FUNC(cellSpursJq);
return CELL_OK; return CELL_OK;
#endif
} }
s64 _cellSpursJobQueuePort2PushJobListBody() s32 _cellSpursJobQueuePort2PushJobListBody()
{ {
#ifdef PRX_DEBUG
cellSpursJq.Warning("%s()", __FUNCTION__);
return GetCurrentPPUThread().FastCall2(libspurs_jq + 0x0043B0, libspurs_jq_rtoc);
#else
UNIMPLEMENTED_FUNC(cellSpursJq); UNIMPLEMENTED_FUNC(cellSpursJq);
return CELL_OK; return CELL_OK;
#endif
} }
s64 cellSpursJobQueuePort2Sync() s32 cellSpursJobQueuePort2Sync()
{ {
#ifdef PRX_DEBUG
cellSpursJq.Warning("%s()", __FUNCTION__);
return GetCurrentPPUThread().FastCall2(libspurs_jq + 0x0045AC, libspurs_jq_rtoc);
#else
UNIMPLEMENTED_FUNC(cellSpursJq); UNIMPLEMENTED_FUNC(cellSpursJq);
return CELL_OK; return CELL_OK;
#endif
} }
s64 cellSpursJobQueuePort2Create() s32 cellSpursJobQueuePort2Create()
{ {
#ifdef PRX_DEBUG
cellSpursJq.Warning("%s()", __FUNCTION__);
return GetCurrentPPUThread().FastCall2(libspurs_jq + 0x0046C4, libspurs_jq_rtoc);
#else
UNIMPLEMENTED_FUNC(cellSpursJq); UNIMPLEMENTED_FUNC(cellSpursJq);
return CELL_OK; return CELL_OK;
#endif
} }
s64 cellSpursJobQueuePort2Destroy() s32 cellSpursJobQueuePort2Destroy()
{ {
#ifdef PRX_DEBUG
cellSpursJq.Warning("%s()", __FUNCTION__);
return GetCurrentPPUThread().FastCall2(libspurs_jq + 0x0047E4, libspurs_jq_rtoc);
#else
UNIMPLEMENTED_FUNC(cellSpursJq); UNIMPLEMENTED_FUNC(cellSpursJq);
return CELL_OK; return CELL_OK;
#endif
} }
s64 cellSpursJobQueuePort2AllocateJobDescriptor() s32 cellSpursJobQueuePort2AllocateJobDescriptor()
{ {
#ifdef PRX_DEBUG
cellSpursJq.Warning("%s()", __FUNCTION__);
return GetCurrentPPUThread().FastCall2(libspurs_jq + 0x004928, libspurs_jq_rtoc);
#else
UNIMPLEMENTED_FUNC(cellSpursJq); UNIMPLEMENTED_FUNC(cellSpursJq);
return CELL_OK; return CELL_OK;
#endif
} }
s64 _cellSpursJobQueuePort2PushAndReleaseJobBody() s32 _cellSpursJobQueuePort2PushAndReleaseJobBody()
{ {
#ifdef PRX_DEBUG
cellSpursJq.Warning("%s()", __FUNCTION__);
return GetCurrentPPUThread().FastCall2(libspurs_jq + 0x004D94, libspurs_jq_rtoc);
#else
UNIMPLEMENTED_FUNC(cellSpursJq); UNIMPLEMENTED_FUNC(cellSpursJq);
return CELL_OK; return CELL_OK;
#endif
} }
s64 _cellSpursJobQueuePort2CopyPushJobBody() s32 _cellSpursJobQueuePort2CopyPushJobBody()
{ {
#ifdef PRX_DEBUG
cellSpursJq.Warning("%s()", __FUNCTION__);
return GetCurrentPPUThread().FastCall2(libspurs_jq + 0x004DD0, libspurs_jq_rtoc);
#else
UNIMPLEMENTED_FUNC(cellSpursJq); UNIMPLEMENTED_FUNC(cellSpursJq);
return CELL_OK; return CELL_OK;
#endif
} }
s64 _cellSpursJobQueuePort2PushJobBody() s32 _cellSpursJobQueuePort2PushJobBody()
{ {
#ifdef PRX_DEBUG
cellSpursJq.Warning("%s()", __FUNCTION__);
return GetCurrentPPUThread().FastCall2(libspurs_jq + 0x004E0C, libspurs_jq_rtoc);
#else
UNIMPLEMENTED_FUNC(cellSpursJq); UNIMPLEMENTED_FUNC(cellSpursJq);
return CELL_OK; return CELL_OK;
#endif
} }
s64 cellSpursJobQueueSetExceptionEventHandler() s32 cellSpursJobQueueSetExceptionEventHandler()
{ {
#ifdef PRX_DEBUG
cellSpursJq.Warning("%s()", __FUNCTION__);
return GetCurrentPPUThread().FastCall2(libspurs_jq + 0x004E48, libspurs_jq_rtoc);
#else
UNIMPLEMENTED_FUNC(cellSpursJq); UNIMPLEMENTED_FUNC(cellSpursJq);
return CELL_OK; return CELL_OK;
#endif
} }
s64 cellSpursJobQueueUnsetExceptionEventHandler() s32 cellSpursJobQueueUnsetExceptionEventHandler()
{ {
#ifdef PRX_DEBUG
cellSpursJq.Warning("%s()", __FUNCTION__);
return GetCurrentPPUThread().FastCall2(libspurs_jq + 0x004EC0, libspurs_jq_rtoc);
#else
UNIMPLEMENTED_FUNC(cellSpursJq); UNIMPLEMENTED_FUNC(cellSpursJq);
return CELL_OK; return CELL_OK;
#endif
} }
Module cellSpursJq("cellSpursJq", []() Module cellSpursJq("cellSpursJq", []()
@ -765,43 +449,4 @@ Module cellSpursJq("cellSpursJq", []()
REG_FUNC(cellSpursJq, _cellSpursJobQueuePort2PushJobBody); REG_FUNC(cellSpursJq, _cellSpursJobQueuePort2PushJobBody);
REG_FUNC(cellSpursJq, cellSpursJobQueueSetExceptionEventHandler); REG_FUNC(cellSpursJq, cellSpursJobQueueSetExceptionEventHandler);
REG_FUNC(cellSpursJq, cellSpursJobQueueUnsetExceptionEventHandler); REG_FUNC(cellSpursJq, cellSpursJobQueueUnsetExceptionEventHandler);
#ifdef PRX_DEBUG
CallAfter([]()
{
if (!Memory.MainMem.GetStartAddr()) return;
libspurs_jq = (u32)Memory.MainMem.AllocAlign(sizeof(libspurs_jq_data), 0x100000);
memcpy(vm::get_ptr<void>(libspurs_jq), libspurs_jq_data, sizeof(libspurs_jq_data));
libspurs_jq_rtoc = libspurs_jq + 0x17E80;
extern Module* sysPrxForUser;
extern Module* cellSpurs;
extern Module* cellFiber;
FIX_IMPORT(cellSpurs, cellSpursSendWorkloadSignal , libspurs_jq + 0x6728);
FIX_IMPORT(cellSpurs, cellSpursWorkloadAttributeSetName , libspurs_jq + 0x6748);
FIX_IMPORT(cellSpurs, cellSpursRemoveWorkload , libspurs_jq + 0x6768);
FIX_IMPORT(cellSpurs, cellSpursWaitForWorkloadShutdown , libspurs_jq + 0x6788);
FIX_IMPORT(cellSpurs, cellSpursWakeUp , libspurs_jq + 0x67A8);
FIX_IMPORT(cellSpurs, cellSpursShutdownWorkload , libspurs_jq + 0x67C8);
FIX_IMPORT(cellSpurs, cellSpursAddWorkloadWithAttribute , libspurs_jq + 0x67E8);
FIX_IMPORT(cellSpurs, cellSpursSetExceptionEventHandler , libspurs_jq + 0x6808);
FIX_IMPORT(cellSpurs, _cellSpursWorkloadAttributeInitialize , libspurs_jq + 0x6828);
FIX_IMPORT(cellFiber, cellFiberPpuSelf , libspurs_jq + 0x6848);
FIX_IMPORT(cellFiber, cellFiberPpuWaitSignal , libspurs_jq + 0x6868);
FIX_IMPORT(sysPrxForUser, _sys_strncmp , libspurs_jq + 0x6888);
FIX_IMPORT(sysPrxForUser, _sys_snprintf , libspurs_jq + 0x68A8);
FIX_IMPORT(sysPrxForUser, sys_lwcond_destroy , libspurs_jq + 0x68C8);
FIX_IMPORT(sysPrxForUser, sys_lwmutex_create , libspurs_jq + 0x68E8);
FIX_IMPORT(sysPrxForUser, _sys_memset , libspurs_jq + 0x6908);
FIX_IMPORT(sysPrxForUser, _sys_printf , libspurs_jq + 0x6928);
fix_import(sysPrxForUser, 0x9FB6228E , libspurs_jq + 0x6948);
FIX_IMPORT(sysPrxForUser, sys_lwmutex_destroy , libspurs_jq + 0x6968);
FIX_IMPORT(sysPrxForUser, sys_lwcond_create , libspurs_jq + 0x6988);
fix_import(sysPrxForUser, 0xE75C40F2 , libspurs_jq + 0x69A8);
fix_relocs(cellSpursJq, libspurs_jq, 0xFF70, 0x12370, 0xED00);
});
#endif
}); });

152
rpcs3/Emu/SysCalls/Modules/cellSync.cpp
View file

@ -13,12 +13,6 @@
extern Module cellSync; extern Module cellSync;
#ifdef PRX_DEBUG
#include "prx_libsre.h"
u32 libsre;
u32 libsre_rtoc;
#endif
waiter_map_t g_sync_mutex_wm("sync_mutex_wm"); waiter_map_t g_sync_mutex_wm("sync_mutex_wm");
waiter_map_t g_sync_barrier_wait_wm("sync_barrier_wait_wm"); waiter_map_t g_sync_barrier_wait_wm("sync_barrier_wait_wm");
waiter_map_t g_sync_barrier_notify_wm("sync_barrier_notify_wm"); waiter_map_t g_sync_barrier_notify_wm("sync_barrier_notify_wm");
@ -886,11 +880,6 @@ void syncLFQueueInit(vm::ptr<CellSyncLFQueue> queue, vm::ptr<u8> buffer, u32 siz
s32 syncLFQueueInitialize(vm::ptr<CellSyncLFQueue> queue, vm::ptr<u8> buffer, u32 size, u32 depth, CellSyncQueueDirection direction, vm::ptr<void> eaSignal) s32 syncLFQueueInitialize(vm::ptr<CellSyncLFQueue> queue, vm::ptr<u8> buffer, u32 size, u32 depth, CellSyncQueueDirection direction, vm::ptr<void> eaSignal)
{ {
#ifdef PRX_DEBUG_XXX
return cb_caller<s32, vm::ptr<CellSyncLFQueue>, vm::ptr<u8>, u32, u32, CellSyncQueueDirection, vm::ptr<void>>::call(GetCurrentPPUThread(), libsre + 0x205C, libsre_rtoc,
queue, buffer, size, depth, direction, eaSignal);
#endif
if (!queue) if (!queue)
{ {
return CELL_SYNC_ERROR_NULL_POINTER; return CELL_SYNC_ERROR_NULL_POINTER;
@ -1112,10 +1101,7 @@ s32 _cellSyncLFQueueGetPushPointer(vm::ptr<CellSyncLFQueue> queue, vm::ptr<u32>
s32 syncLFQueueGetPushPointer2(vm::ptr<CellSyncLFQueue> queue, s32& pointer, u32 isBlocking, u32 useEventQueue) s32 syncLFQueueGetPushPointer2(vm::ptr<CellSyncLFQueue> queue, s32& pointer, u32 isBlocking, u32 useEventQueue)
{ {
// TODO throw __FUNCTION__;
//pointer = 0;
assert(!"syncLFQueueGetPushPointer2()");
return CELL_OK;
} }
s32 _cellSyncLFQueueGetPushPointer2(vm::ptr<CellSyncLFQueue> queue, vm::ptr<u32> pointer, u32 isBlocking, u32 useEventQueue) s32 _cellSyncLFQueueGetPushPointer2(vm::ptr<CellSyncLFQueue> queue, vm::ptr<u32> pointer, u32 isBlocking, u32 useEventQueue)
@ -1274,10 +1260,7 @@ s32 _cellSyncLFQueueCompletePushPointer(vm::ptr<CellSyncLFQueue> queue, s32 poin
s32 syncLFQueueCompletePushPointer2(vm::ptr<CellSyncLFQueue> queue, s32 pointer, const std::function<s32(u32 addr, u32 arg)> fpSendSignal) s32 syncLFQueueCompletePushPointer2(vm::ptr<CellSyncLFQueue> queue, s32 pointer, const std::function<s32(u32 addr, u32 arg)> fpSendSignal)
{ {
// TODO throw __FUNCTION__;
//if (fpSendSignal) return fpSendSignal(0, 0);
assert(!"syncLFQueueCompletePushPointer2()");
return CELL_OK;
} }
s32 _cellSyncLFQueueCompletePushPointer2(vm::ptr<CellSyncLFQueue> queue, s32 pointer, vm::ptr<s32(u32 addr, u32 arg)> fpSendSignal) s32 _cellSyncLFQueueCompletePushPointer2(vm::ptr<CellSyncLFQueue> queue, s32 pointer, vm::ptr<s32(u32 addr, u32 arg)> fpSendSignal)
@ -1304,32 +1287,18 @@ s32 _cellSyncLFQueuePushBody(PPUThread& CPU, vm::ptr<CellSyncLFQueue> queue, vm:
} }
s32 position; s32 position;
#ifdef PRX_DEBUG
vm::stackvar<be_t<s32>> position_v(CPU);
#endif
while (true) while (true)
{ {
s32 res; s32 res;
if (queue->m_direction != CELL_SYNC_QUEUE_ANY2ANY) if (queue->m_direction != CELL_SYNC_QUEUE_ANY2ANY)
{ {
#ifdef PRX_DEBUG_XXX
res = cb_call<s32, vm::ptr<CellSyncLFQueue>, u32, u32, u64>(CPU, libsre + 0x24B0, libsre_rtoc,
queue, position_v.addr(), isBlocking, 0);
position = position_v.value();
#else
res = syncLFQueueGetPushPointer(queue, position, isBlocking, 0); res = syncLFQueueGetPushPointer(queue, position, isBlocking, 0);
#endif
} }
else else
{ {
#ifdef PRX_DEBUG
res = cb_call<s32, vm::ptr<CellSyncLFQueue>, u32, u32, u64>(CPU, libsre + 0x3050, libsre_rtoc,
queue, position_v.addr(), isBlocking, 0);
position = position_v.value();
#else
res = syncLFQueueGetPushPointer2(queue, position, isBlocking, 0); res = syncLFQueueGetPushPointer2(queue, position, isBlocking, 0);
#endif
} }
if (!isBlocking || res != CELL_SYNC_ERROR_AGAIN) if (!isBlocking || res != CELL_SYNC_ERROR_AGAIN)
@ -1342,6 +1311,7 @@ s32 _cellSyncLFQueuePushBody(PPUThread& CPU, vm::ptr<CellSyncLFQueue> queue, vm:
} }
std::this_thread::sleep_for(std::chrono::milliseconds(1)); // hack std::this_thread::sleep_for(std::chrono::milliseconds(1)); // hack
if (Emu.IsStopped()) if (Emu.IsStopped())
{ {
cellSync.Warning("_cellSyncLFQueuePushBody(queue_addr=0x%x) aborted", queue.addr()); cellSync.Warning("_cellSyncLFQueuePushBody(queue_addr=0x%x) aborted", queue.addr());
@ -1355,23 +1325,14 @@ s32 _cellSyncLFQueuePushBody(PPUThread& CPU, vm::ptr<CellSyncLFQueue> queue, vm:
memcpy(vm::get_ptr<void>(addr), buffer.get_ptr(), size); memcpy(vm::get_ptr<void>(addr), buffer.get_ptr(), size);
s32 res; s32 res;
if (queue->m_direction != CELL_SYNC_QUEUE_ANY2ANY) if (queue->m_direction != CELL_SYNC_QUEUE_ANY2ANY)
{ {
#ifdef PRX_DEBUG_XXX
res = cb_call<s32, vm::ptr<CellSyncLFQueue>, s32, u64>(CPU, libsre + 0x26C0, libsre_rtoc,
queue, position, 0);
#else
res = syncLFQueueCompletePushPointer(queue, position, nullptr); res = syncLFQueueCompletePushPointer(queue, position, nullptr);
#endif
} }
else else
{ {
#ifdef PRX_DEBUG
res = cb_call<s32, vm::ptr<CellSyncLFQueue>, s32, u64>(CPU, libsre + 0x355C, libsre_rtoc,
queue, position, 0);
#else
res = syncLFQueueCompletePushPointer2(queue, position, nullptr); res = syncLFQueueCompletePushPointer2(queue, position, nullptr);
#endif
} }
return res; return res;
@ -1491,10 +1452,7 @@ s32 _cellSyncLFQueueGetPopPointer(vm::ptr<CellSyncLFQueue> queue, vm::ptr<u32> p
s32 syncLFQueueGetPopPointer2(vm::ptr<CellSyncLFQueue> queue, s32& pointer, u32 isBlocking, u32 useEventQueue) s32 syncLFQueueGetPopPointer2(vm::ptr<CellSyncLFQueue> queue, s32& pointer, u32 isBlocking, u32 useEventQueue)
{ {
// TODO throw __FUNCTION__;
//pointer = 0;
assert(!"syncLFQueueGetPopPointer2()");
return CELL_OK;
} }
s32 _cellSyncLFQueueGetPopPointer2(vm::ptr<CellSyncLFQueue> queue, vm::ptr<u32> pointer, u32 isBlocking, u32 useEventQueue) s32 _cellSyncLFQueueGetPopPointer2(vm::ptr<CellSyncLFQueue> queue, vm::ptr<u32> pointer, u32 isBlocking, u32 useEventQueue)
@ -1653,10 +1611,7 @@ s32 _cellSyncLFQueueCompletePopPointer(vm::ptr<CellSyncLFQueue> queue, s32 point
s32 syncLFQueueCompletePopPointer2(vm::ptr<CellSyncLFQueue> queue, s32 pointer, const std::function<s32(u32 addr, u32 arg)> fpSendSignal, u32 noQueueFull) s32 syncLFQueueCompletePopPointer2(vm::ptr<CellSyncLFQueue> queue, s32 pointer, const std::function<s32(u32 addr, u32 arg)> fpSendSignal, u32 noQueueFull)
{ {
// TODO throw __FUNCTION__;
//if (fpSendSignal) fpSendSignal(0, 0);
assert(!"syncLFQueueCompletePopPointer2()");
return CELL_OK;
} }
s32 _cellSyncLFQueueCompletePopPointer2(vm::ptr<CellSyncLFQueue> queue, s32 pointer, vm::ptr<s32(u32 addr, u32 arg)> fpSendSignal, u32 noQueueFull) s32 _cellSyncLFQueueCompletePopPointer2(vm::ptr<CellSyncLFQueue> queue, s32 pointer, vm::ptr<s32(u32 addr, u32 arg)> fpSendSignal, u32 noQueueFull)
@ -1683,31 +1638,17 @@ s32 _cellSyncLFQueuePopBody(PPUThread& CPU, vm::ptr<CellSyncLFQueue> queue, vm::
} }
s32 position; s32 position;
#ifdef PRX_DEBUG
vm::stackvar<be_t<s32>> position_v(CPU);
#endif
while (true) while (true)
{ {
s32 res; s32 res;
if (queue->m_direction != CELL_SYNC_QUEUE_ANY2ANY) if (queue->m_direction != CELL_SYNC_QUEUE_ANY2ANY)
{ {
#ifdef PRX_DEBUG_XXX
res = cb_call<s32, vm::ptr<CellSyncLFQueue>, u32, u32, u64, u64>(CPU, libsre + 0x2A90, libsre_rtoc,
queue, position_v.addr(), isBlocking, 0, 0);
position = position_v.value();
#else
res = syncLFQueueGetPopPointer(queue, position, isBlocking, 0, 0); res = syncLFQueueGetPopPointer(queue, position, isBlocking, 0, 0);
#endif
} }
else else
{ {
#ifdef PRX_DEBUG
res = cb_call<s32, vm::ptr<CellSyncLFQueue>, u32, u32, u64>(CPU, libsre + 0x39AC, libsre_rtoc,
queue, position_v.addr(), isBlocking, 0);
position = position_v.value();
#else
res = syncLFQueueGetPopPointer2(queue, position, isBlocking, 0); res = syncLFQueueGetPopPointer2(queue, position, isBlocking, 0);
#endif
} }
if (!isBlocking || res != CELL_SYNC_ERROR_AGAIN) if (!isBlocking || res != CELL_SYNC_ERROR_AGAIN)
@ -1720,6 +1661,7 @@ s32 _cellSyncLFQueuePopBody(PPUThread& CPU, vm::ptr<CellSyncLFQueue> queue, vm::
} }
std::this_thread::sleep_for(std::chrono::milliseconds(1)); // hack std::this_thread::sleep_for(std::chrono::milliseconds(1)); // hack
if (Emu.IsStopped()) if (Emu.IsStopped())
{ {
cellSync.Warning("_cellSyncLFQueuePopBody(queue_addr=0x%x) aborted", queue.addr()); cellSync.Warning("_cellSyncLFQueuePopBody(queue_addr=0x%x) aborted", queue.addr());
@ -1733,23 +1675,14 @@ s32 _cellSyncLFQueuePopBody(PPUThread& CPU, vm::ptr<CellSyncLFQueue> queue, vm::
memcpy(buffer.get_ptr(), vm::get_ptr<void>(addr), size); memcpy(buffer.get_ptr(), vm::get_ptr<void>(addr), size);
s32 res; s32 res;
if (queue->m_direction != CELL_SYNC_QUEUE_ANY2ANY) if (queue->m_direction != CELL_SYNC_QUEUE_ANY2ANY)
{ {
#ifdef PRX_DEBUG_XXX
res = cb_call<s32, vm::ptr<CellSyncLFQueue>, s32, u64, u64>(CPU, libsre + 0x2CA8, libsre_rtoc,
queue, position, 0, 0);
#else
res = syncLFQueueCompletePopPointer(queue, position, nullptr, 0); res = syncLFQueueCompletePopPointer(queue, position, nullptr, 0);
#endif
} }
else else
{ {
#ifdef PRX_DEBUG
res = cb_call<s32, vm::ptr<CellSyncLFQueue>, s32, u64, u64>(CPU, libsre + 0x3EB8, libsre_rtoc,
queue, position, 0, 0);
#else
res = syncLFQueueCompletePopPointer2(queue, position, nullptr, 0); res = syncLFQueueCompletePopPointer2(queue, position, nullptr, 0);
#endif
} }
return res; return res;
@ -1910,13 +1843,7 @@ s32 cellSyncLFQueueGetEntrySize(vm::ptr<const CellSyncLFQueue> queue, vm::ptr<u3
s32 syncLFQueueAttachLv2EventQueue(vm::ptr<u32> spus, u32 num, vm::ptr<CellSyncLFQueue> queue) s32 syncLFQueueAttachLv2EventQueue(vm::ptr<u32> spus, u32 num, vm::ptr<CellSyncLFQueue> queue)
{ {
#ifdef PRX_DEBUG throw __FUNCTION__;
return cb_call<s32, vm::ptr<u32>, u32, vm::ptr<CellSyncLFQueue>>(GetCurrentPPUThread(), libsre + 0x19A8, libsre_rtoc,
spus, num, queue);
#endif
assert(!"syncLFQueueAttachLv2EventQueue()");
return CELL_OK;
} }
s32 _cellSyncLFQueueAttachLv2EventQueue(vm::ptr<u32> spus, u32 num, vm::ptr<CellSyncLFQueue> queue) s32 _cellSyncLFQueueAttachLv2EventQueue(vm::ptr<u32> spus, u32 num, vm::ptr<CellSyncLFQueue> queue)
@ -1928,13 +1855,7 @@ s32 _cellSyncLFQueueAttachLv2EventQueue(vm::ptr<u32> spus, u32 num, vm::ptr<Cell
s32 syncLFQueueDetachLv2EventQueue(vm::ptr<u32> spus, u32 num, vm::ptr<CellSyncLFQueue> queue) s32 syncLFQueueDetachLv2EventQueue(vm::ptr<u32> spus, u32 num, vm::ptr<CellSyncLFQueue> queue)
{ {
#ifdef PRX_DEBUG throw __FUNCTION__;
return cb_call<s32, vm::ptr<u32>, u32, vm::ptr<CellSyncLFQueue>>(GetCurrentPPUThread(), libsre + 0x1DA0, libsre_rtoc,
spus, num, queue);
#endif
assert(!"syncLFQueueDetachLv2EventQueue()");
return CELL_OK;
} }
s32 _cellSyncLFQueueDetachLv2EventQueue(vm::ptr<u32> spus, u32 num, vm::ptr<CellSyncLFQueue> queue) s32 _cellSyncLFQueueDetachLv2EventQueue(vm::ptr<u32> spus, u32 num, vm::ptr<CellSyncLFQueue> queue)
@ -1992,53 +1913,4 @@ Module cellSync("cellSync", []()
cellSync.AddFunc(0xe1bc7add, _cellSyncLFQueuePopBody); cellSync.AddFunc(0xe1bc7add, _cellSyncLFQueuePopBody);
cellSync.AddFunc(0xe9bf2110, _cellSyncLFQueueGetPushPointer); cellSync.AddFunc(0xe9bf2110, _cellSyncLFQueueGetPushPointer);
cellSync.AddFunc(0xfe74e8e7, _cellSyncLFQueueCompletePopPointer); cellSync.AddFunc(0xfe74e8e7, _cellSyncLFQueueCompletePopPointer);
#ifdef PRX_DEBUG
CallAfter([]()
{
if (!Memory.MainMem.GetStartAddr()) return;
libsre = (u32)Memory.MainMem.AllocAlign(sizeof(libsre_data), 0x100000);
memcpy(vm::get_ptr<void>(libsre), libsre_data, sizeof(libsre_data));
libsre_rtoc = libsre + 0x399B0;
extern Module* sysPrxForUser;
FIX_IMPORT(sysPrxForUser, cellUserTraceRegister , libsre + 0x1D5BC); // ???
FIX_IMPORT(sysPrxForUser, cellUserTraceUnregister , libsre + 0x1D5DC); // ???
FIX_IMPORT(sysPrxForUser, _sys_strncmp , libsre + 0x1D5FC);
FIX_IMPORT(sysPrxForUser, _sys_strcat , libsre + 0x1D61C);
FIX_IMPORT(sysPrxForUser, _sys_vsnprintf , libsre + 0x1D63C);
FIX_IMPORT(sysPrxForUser, _sys_snprintf , libsre + 0x1D65C);
FIX_IMPORT(sysPrxForUser, sys_lwmutex_lock , libsre + 0x1D67C);
FIX_IMPORT(sysPrxForUser, sys_lwmutex_unlock , libsre + 0x1D69C);
FIX_IMPORT(sysPrxForUser, sys_lwcond_destroy , libsre + 0x1D6BC);
FIX_IMPORT(sysPrxForUser, sys_ppu_thread_create , libsre + 0x1D6DC);
FIX_IMPORT(sysPrxForUser, sys_lwcond_wait , libsre + 0x1D6FC);
FIX_IMPORT(sysPrxForUser, _sys_strlen , libsre + 0x1D71C);
FIX_IMPORT(sysPrxForUser, sys_lwmutex_create , libsre + 0x1D73C);
FIX_IMPORT(sysPrxForUser, _sys_spu_printf_detach_group , libsre + 0x1D75C);
FIX_IMPORT(sysPrxForUser, _sys_memset , libsre + 0x1D77C);
FIX_IMPORT(sysPrxForUser, _sys_memcpy , libsre + 0x1D79C);
FIX_IMPORT(sysPrxForUser, _sys_strncat , libsre + 0x1D7BC);
FIX_IMPORT(sysPrxForUser, _sys_strcpy , libsre + 0x1D7DC);
FIX_IMPORT(sysPrxForUser, _sys_printf , libsre + 0x1D7FC);
fix_import(sysPrxForUser, 0x9FB6228E , libsre + 0x1D81C);
FIX_IMPORT(sysPrxForUser, sys_ppu_thread_exit , libsre + 0x1D83C);
FIX_IMPORT(sysPrxForUser, sys_lwmutex_destroy , libsre + 0x1D85C);
FIX_IMPORT(sysPrxForUser, _sys_strncpy , libsre + 0x1D87C);
FIX_IMPORT(sysPrxForUser, sys_lwcond_create , libsre + 0x1D89C);
FIX_IMPORT(sysPrxForUser, _sys_spu_printf_attach_group , libsre + 0x1D8BC);
FIX_IMPORT(sysPrxForUser, sys_prx_get_module_id_by_name , libsre + 0x1D8DC);
FIX_IMPORT(sysPrxForUser, sys_spu_image_close , libsre + 0x1D8FC);
fix_import(sysPrxForUser, 0xE75C40F2 , libsre + 0x1D91C);
FIX_IMPORT(sysPrxForUser, sys_spu_image_import , libsre + 0x1D93C);
FIX_IMPORT(sysPrxForUser, sys_lwcond_signal , libsre + 0x1D95C);
FIX_IMPORT(sysPrxForUser, _sys_vprintf , libsre + 0x1D97C);
FIX_IMPORT(sysPrxForUser, _sys_memcmp , libsre + 0x1D99C);
fix_relocs(cellSync, libsre, 0x31EE0, 0x3A4F0, 0x2DF00);
});
#endif
}); });

263
rpcs3/Emu/SysCalls/Modules/cellSync2.cpp
View file

@ -7,18 +7,8 @@
extern Module cellSync2; extern Module cellSync2;
#ifdef PRX_DEBUG s32 _cellSync2MutexAttributeInitialize(vm::ptr<CellSync2MutexAttribute> attr, u32 sdkVersion)
#include "prx_libsync2.h"
u32 libsync2;
u32 libsync2_rtoc;
#endif
s64 _cellSync2MutexAttributeInitialize(vm::ptr<CellSync2MutexAttribute> attr, u32 sdkVersion)
{ {
#ifdef PRX_DEBUG
cellSync2.Warning("%s()", __FUNCTION__);
return GetCurrentPPUThread().FastCall2(libsync2 + 0x16A0, libsync2_rtoc);
#else
cellSync2.Warning("_cellSync2MutexAttributeInitialize(attr_addr=0x%x, sdkVersion=0x%x)", attr.addr(), sdkVersion); cellSync2.Warning("_cellSync2MutexAttributeInitialize(attr_addr=0x%x, sdkVersion=0x%x)", attr.addr(), sdkVersion);
attr->sdkVersion = sdkVersion; attr->sdkVersion = sdkVersion;
@ -30,85 +20,50 @@ s64 _cellSync2MutexAttributeInitialize(vm::ptr<CellSync2MutexAttribute> attr, u3
strcpy_trunc(attr->name, "CellSync2Mutex"); strcpy_trunc(attr->name, "CellSync2Mutex");
return CELL_OK; return CELL_OK;
#endif
} }
s64 cellSync2MutexEstimateBufferSize(vm::ptr<const CellSync2MutexAttribute> attr, vm::ptr<u32> bufferSize) s32 cellSync2MutexEstimateBufferSize(vm::ptr<const CellSync2MutexAttribute> attr, vm::ptr<u32> bufferSize)
{ {
#ifdef PRX_DEBUG
cellSync2.Warning("%s()", __FUNCTION__);
return GetCurrentPPUThread().FastCall2(libsync2 + 0xC3C, libsync2_rtoc);
#else
cellSync2.Todo("cellSync2MutexEstimateBufferSize(attr_addr=0x%x, bufferSize_addr=0x%x)", attr.addr(), bufferSize.addr()); cellSync2.Todo("cellSync2MutexEstimateBufferSize(attr_addr=0x%x, bufferSize_addr=0x%x)", attr.addr(), bufferSize.addr());
if (attr->maxWaiters > 32768) if (attr->maxWaiters > 32768)
return CELL_SYNC2_ERROR_INVAL; return CELL_SYNC2_ERROR_INVAL;
return CELL_OK; return CELL_OK;
#endif
} }
s64 cellSync2MutexInitialize() s32 cellSync2MutexInitialize()
{ {
#ifdef PRX_DEBUG
cellSync2.Warning("%s()", __FUNCTION__);
return GetCurrentPPUThread().FastCall2(libsync2 + 0x1584, libsync2_rtoc);
#else
UNIMPLEMENTED_FUNC(cellSync2); UNIMPLEMENTED_FUNC(cellSync2);
return CELL_OK; return CELL_OK;
#endif
} }
s64 cellSync2MutexFinalize() s32 cellSync2MutexFinalize()
{ {
#ifdef PRX_DEBUG
cellSync2.Warning("%s()", __FUNCTION__);
return GetCurrentPPUThread().FastCall2(libsync2 + 0x142C, libsync2_rtoc);
#else
UNIMPLEMENTED_FUNC(cellSync2); UNIMPLEMENTED_FUNC(cellSync2);
return CELL_OK; return CELL_OK;
#endif
} }
s64 cellSync2MutexLock() s32 cellSync2MutexLock()
{ {
#ifdef PRX_DEBUG
cellSync2.Warning("%s()", __FUNCTION__);
return GetCurrentPPUThread().FastCall2(libsync2 + 0x1734, libsync2_rtoc);
#else
UNIMPLEMENTED_FUNC(cellSync2); UNIMPLEMENTED_FUNC(cellSync2);
return CELL_OK; return CELL_OK;
#endif
} }
s64 cellSync2MutexTryLock() s32 cellSync2MutexTryLock()
{ {
#ifdef PRX_DEBUG
cellSync2.Warning("%s()", __FUNCTION__);
return GetCurrentPPUThread().FastCall2(libsync2 + 0x1A2C, libsync2_rtoc);
#else
UNIMPLEMENTED_FUNC(cellSync2); UNIMPLEMENTED_FUNC(cellSync2);
return CELL_OK; return CELL_OK;
#endif
} }
s64 cellSync2MutexUnlock() s32 cellSync2MutexUnlock()
{ {
#ifdef PRX_DEBUG
cellSync2.Warning("%s()", __FUNCTION__);
return GetCurrentPPUThread().FastCall2(libsync2 + 0x186C, libsync2_rtoc);
#else
UNIMPLEMENTED_FUNC(cellSync2); UNIMPLEMENTED_FUNC(cellSync2);
return CELL_OK; return CELL_OK;
#endif
} }
s64 _cellSync2CondAttributeInitialize(vm::ptr<CellSync2CondAttribute> attr, u32 sdkVersion) s32 _cellSync2CondAttributeInitialize(vm::ptr<CellSync2CondAttribute> attr, u32 sdkVersion)
{ {
#ifdef PRX_DEBUG
cellSync2.Warning("%s()", __FUNCTION__);
return GetCurrentPPUThread().FastCall2(libsync2 + 0x26DC, libsync2_rtoc);
#else
cellSync2.Warning("_cellSync2CondAttributeInitialize(attr_addr=0x%x, sdkVersion=0x%x)", attr.addr(), sdkVersion); cellSync2.Warning("_cellSync2CondAttributeInitialize(attr_addr=0x%x, sdkVersion=0x%x)", attr.addr(), sdkVersion);
attr->sdkVersion = sdkVersion; attr->sdkVersion = sdkVersion;
@ -116,85 +71,50 @@ s64 _cellSync2CondAttributeInitialize(vm::ptr<CellSync2CondAttribute> attr, u32
strcpy_trunc(attr->name, "CellSync2Cond"); strcpy_trunc(attr->name, "CellSync2Cond");
return CELL_OK; return CELL_OK;
#endif
} }
s64 cellSync2CondEstimateBufferSize(vm::ptr<const CellSync2CondAttribute> attr, vm::ptr<u32> bufferSize) s32 cellSync2CondEstimateBufferSize(vm::ptr<const CellSync2CondAttribute> attr, vm::ptr<u32> bufferSize)
{ {
#ifdef PRX_DEBUG
cellSync2.Warning("%s()", __FUNCTION__);
return GetCurrentPPUThread().FastCall2(libsync2 + 0x1B90, libsync2_rtoc);
#else
cellSync2.Todo("cellSync2CondEstimateBufferSize(attr_addr=0x%x, bufferSize_addr=0x%x)", attr.addr(), bufferSize.addr()); cellSync2.Todo("cellSync2CondEstimateBufferSize(attr_addr=0x%x, bufferSize_addr=0x%x)", attr.addr(), bufferSize.addr());
if (attr->maxWaiters == 0 || attr->maxWaiters > 32768) if (attr->maxWaiters == 0 || attr->maxWaiters > 32768)
return CELL_SYNC2_ERROR_INVAL; return CELL_SYNC2_ERROR_INVAL;
return CELL_OK; return CELL_OK;
#endif
} }
s64 cellSync2CondInitialize() s32 cellSync2CondInitialize()
{ {
#ifdef PRX_DEBUG
cellSync2.Warning("%s()", __FUNCTION__);
return GetCurrentPPUThread().FastCall2(libsync2 + 0x25DC, libsync2_rtoc);
#else
UNIMPLEMENTED_FUNC(cellSync2); UNIMPLEMENTED_FUNC(cellSync2);
return CELL_OK; return CELL_OK;
#endif
} }
s64 cellSync2CondFinalize() s32 cellSync2CondFinalize()
{ {
#ifdef PRX_DEBUG
cellSync2.Warning("%s()", __FUNCTION__);
return GetCurrentPPUThread().FastCall2(libsync2 + 0x23E0, libsync2_rtoc);
#else
UNIMPLEMENTED_FUNC(cellSync2); UNIMPLEMENTED_FUNC(cellSync2);
return CELL_OK; return CELL_OK;
#endif
} }
s64 cellSync2CondWait() s32 cellSync2CondWait()
{ {
#ifdef PRX_DEBUG
cellSync2.Warning("%s()", __FUNCTION__);
return GetCurrentPPUThread().FastCall2(libsync2 + 0x283C, libsync2_rtoc);
#else
UNIMPLEMENTED_FUNC(cellSync2); UNIMPLEMENTED_FUNC(cellSync2);
return CELL_OK; return CELL_OK;
#endif
} }
s64 cellSync2CondSignal() s32 cellSync2CondSignal()
{ {
#ifdef PRX_DEBUG
cellSync2.Warning("%s()", __FUNCTION__);
return GetCurrentPPUThread().FastCall2(libsync2 + 0x2768, libsync2_rtoc);
#else
UNIMPLEMENTED_FUNC(cellSync2); UNIMPLEMENTED_FUNC(cellSync2);
return CELL_OK; return CELL_OK;
#endif
} }
s64 cellSync2CondSignalAll() s32 cellSync2CondSignalAll()
{ {
#ifdef PRX_DEBUG
cellSync2.Warning("%s()", __FUNCTION__);
return GetCurrentPPUThread().FastCall2(libsync2 + 0x2910, libsync2_rtoc);
#else
UNIMPLEMENTED_FUNC(cellSync2); UNIMPLEMENTED_FUNC(cellSync2);
return CELL_OK; return CELL_OK;
#endif
} }
s64 _cellSync2SemaphoreAttributeInitialize(vm::ptr<CellSync2SemaphoreAttribute> attr, u32 sdkVersion) s32 _cellSync2SemaphoreAttributeInitialize(vm::ptr<CellSync2SemaphoreAttribute> attr, u32 sdkVersion)
{ {
#ifdef PRX_DEBUG
cellSync2.Warning("%s()", __FUNCTION__);
return GetCurrentPPUThread().FastCall2(libsync2 + 0x5644, libsync2_rtoc);
#else
cellSync2.Warning("_cellSync2SemaphoreAttributeInitialize(attr_addr=0x%x, sdkVersion=0x%x)", attr.addr(), sdkVersion); cellSync2.Warning("_cellSync2SemaphoreAttributeInitialize(attr_addr=0x%x, sdkVersion=0x%x)", attr.addr(), sdkVersion);
attr->sdkVersion = sdkVersion; attr->sdkVersion = sdkVersion;
@ -205,96 +125,56 @@ s64 _cellSync2SemaphoreAttributeInitialize(vm::ptr<CellSync2SemaphoreAttribute>
strcpy_trunc(attr->name, "CellSync2Semaphore"); strcpy_trunc(attr->name, "CellSync2Semaphore");
return CELL_OK; return CELL_OK;
#endif
} }
s64 cellSync2SemaphoreEstimateBufferSize(vm::ptr<const CellSync2SemaphoreAttribute> attr, vm::ptr<u32> bufferSize) s32 cellSync2SemaphoreEstimateBufferSize(vm::ptr<const CellSync2SemaphoreAttribute> attr, vm::ptr<u32> bufferSize)
{ {
#ifdef PRX_DEBUG
cellSync2.Warning("%s()", __FUNCTION__);
return GetCurrentPPUThread().FastCall2(libsync2 + 0x4AC4, libsync2_rtoc);
#else
cellSync2.Todo("cellSync2SemaphoreEstimateBufferSize(attr_addr=0x%x, bufferSize_addr=0x%x)", attr.addr(), bufferSize.addr()); cellSync2.Todo("cellSync2SemaphoreEstimateBufferSize(attr_addr=0x%x, bufferSize_addr=0x%x)", attr.addr(), bufferSize.addr());
if (attr->maxWaiters == 0 || attr->maxWaiters > 32768) if (attr->maxWaiters == 0 || attr->maxWaiters > 32768)
return CELL_SYNC2_ERROR_INVAL; return CELL_SYNC2_ERROR_INVAL;
return CELL_OK; return CELL_OK;
#endif
} }
s64 cellSync2SemaphoreInitialize() s32 cellSync2SemaphoreInitialize()
{ {
#ifdef PRX_DEBUG
cellSync2.Warning("%s()", __FUNCTION__);
return GetCurrentPPUThread().FastCall2(libsync2 + 0x54E0, libsync2_rtoc);
#else
UNIMPLEMENTED_FUNC(cellSync2); UNIMPLEMENTED_FUNC(cellSync2);
return CELL_OK; return CELL_OK;
#endif
} }
s64 cellSync2SemaphoreFinalize() s32 cellSync2SemaphoreFinalize()
{ {
#ifdef PRX_DEBUG
cellSync2.Warning("%s()", __FUNCTION__);
return GetCurrentPPUThread().FastCall2(libsync2 + 0x52F0, libsync2_rtoc);
#else
UNIMPLEMENTED_FUNC(cellSync2); UNIMPLEMENTED_FUNC(cellSync2);
return CELL_OK; return CELL_OK;
#endif
} }
s64 cellSync2SemaphoreAcquire() s32 cellSync2SemaphoreAcquire()
{ {
#ifdef PRX_DEBUG
cellSync2.Warning("%s()", __FUNCTION__);
return GetCurrentPPUThread().FastCall2(libsync2 + 0x57A4, libsync2_rtoc);
#else
UNIMPLEMENTED_FUNC(cellSync2); UNIMPLEMENTED_FUNC(cellSync2);
return CELL_OK; return CELL_OK;
#endif
} }
s64 cellSync2SemaphoreTryAcquire() s32 cellSync2SemaphoreTryAcquire()
{ {
#ifdef PRX_DEBUG
cellSync2.Warning("%s()", __FUNCTION__);
return GetCurrentPPUThread().FastCall2(libsync2 + 0x56D8, libsync2_rtoc);
#else
UNIMPLEMENTED_FUNC(cellSync2); UNIMPLEMENTED_FUNC(cellSync2);
return CELL_OK; return CELL_OK;
#endif
} }
s64 cellSync2SemaphoreRelease() s32 cellSync2SemaphoreRelease()
{ {
#ifdef PRX_DEBUG
cellSync2.Warning("%s()", __FUNCTION__);
return GetCurrentPPUThread().FastCall2(libsync2 + 0x5870, libsync2_rtoc);
#else
UNIMPLEMENTED_FUNC(cellSync2); UNIMPLEMENTED_FUNC(cellSync2);
return CELL_OK; return CELL_OK;
#endif
} }
s64 cellSync2SemaphoreGetCount() s32 cellSync2SemaphoreGetCount()
{ {
#ifdef PRX_DEBUG
cellSync2.Warning("%s()", __FUNCTION__);
return GetCurrentPPUThread().FastCall2(libsync2 + 0x4B4C, libsync2_rtoc);
#else
UNIMPLEMENTED_FUNC(cellSync2); UNIMPLEMENTED_FUNC(cellSync2);
return CELL_OK; return CELL_OK;
#endif
} }
s64 _cellSync2QueueAttributeInitialize(vm::ptr<CellSync2QueueAttribute> attr, u32 sdkVersion) s32 _cellSync2QueueAttributeInitialize(vm::ptr<CellSync2QueueAttribute> attr, u32 sdkVersion)
{ {
#ifdef PRX_DEBUG
cellSync2.Warning("%s()", __FUNCTION__);
return GetCurrentPPUThread().FastCall2(libsync2 + 0x3C5C, libsync2_rtoc);
#else
cellSync2.Warning("_cellSync2QueueAttributeInitialize(attr_addr=0x%x, sdkVersion=0x%x)", attr.addr(), sdkVersion); cellSync2.Warning("_cellSync2QueueAttributeInitialize(attr_addr=0x%x, sdkVersion=0x%x)", attr.addr(), sdkVersion);
attr->sdkVersion = sdkVersion; attr->sdkVersion = sdkVersion;
@ -308,15 +188,10 @@ s64 _cellSync2QueueAttributeInitialize(vm::ptr<CellSync2QueueAttribute> attr, u3
strcpy_trunc(attr->name, "CellSync2Queue"); strcpy_trunc(attr->name, "CellSync2Queue");
return CELL_OK; return CELL_OK;
#endif
} }
s64 cellSync2QueueEstimateBufferSize(vm::ptr<const CellSync2QueueAttribute> attr, vm::ptr<u32> bufferSize) s32 cellSync2QueueEstimateBufferSize(vm::ptr<const CellSync2QueueAttribute> attr, vm::ptr<u32> bufferSize)
{ {
#ifdef PRX_DEBUG
cellSync2.Warning("%s()", __FUNCTION__);
return GetCurrentPPUThread().FastCall2(libsync2 + 0x2A98, libsync2_rtoc);
#else
cellSync2.Todo("cellSync2QueueEstimateBufferSize(attr_addr=0x%x, bufferSize_addr=0x%x)", attr.addr(), bufferSize.addr()); cellSync2.Todo("cellSync2QueueEstimateBufferSize(attr_addr=0x%x, bufferSize_addr=0x%x)", attr.addr(), bufferSize.addr());
if (attr->elementSize == 0 || attr->elementSize > 16384 || attr->elementSize % 16 || attr->depth == 0 || attr->depth > 4294967292 || if (attr->elementSize == 0 || attr->elementSize > 16384 || attr->elementSize % 16 || attr->depth == 0 || attr->depth > 4294967292 ||
@ -324,95 +199,54 @@ s64 cellSync2QueueEstimateBufferSize(vm::ptr<const CellSync2QueueAttribute> attr
return CELL_SYNC2_ERROR_INVAL; return CELL_SYNC2_ERROR_INVAL;
return CELL_OK; return CELL_OK;
#endif
} }
s64 cellSync2QueueInitialize() s32 cellSync2QueueInitialize()
{ {
#ifdef PRX_DEBUG
cellSync2.Warning("%s()", __FUNCTION__);
return GetCurrentPPUThread().FastCall2(libsync2 + 0x3F98, libsync2_rtoc);
#else
UNIMPLEMENTED_FUNC(cellSync2); UNIMPLEMENTED_FUNC(cellSync2);
return CELL_OK; return CELL_OK;
#endif
} }
s64 cellSync2QueueFinalize() s32 cellSync2QueueFinalize()
{ {
#ifdef PRX_DEBUG
cellSync2.Warning("%s()", __FUNCTION__);
return GetCurrentPPUThread().FastCall2(libsync2 + 0x3C28, libsync2_rtoc);
#else
UNIMPLEMENTED_FUNC(cellSync2); UNIMPLEMENTED_FUNC(cellSync2);
return CELL_OK; return CELL_OK;
#endif
} }
s64 cellSync2QueuePush() s32 cellSync2QueuePush()
{ {
#ifdef PRX_DEBUG
cellSync2.Warning("%s()", __FUNCTION__);
return GetCurrentPPUThread().FastCall2(libsync2 + 0x478C, libsync2_rtoc);
#else
UNIMPLEMENTED_FUNC(cellSync2); UNIMPLEMENTED_FUNC(cellSync2);
return CELL_OK; return CELL_OK;
#endif
} }
s64 cellSync2QueueTryPush() s32 cellSync2QueueTryPush()
{ {
#ifdef PRX_DEBUG
cellSync2.Warning("%s()", __FUNCTION__);
return GetCurrentPPUThread().FastCall2(libsync2 + 0x4680, libsync2_rtoc);
#else
UNIMPLEMENTED_FUNC(cellSync2); UNIMPLEMENTED_FUNC(cellSync2);
return CELL_OK; return CELL_OK;
#endif
} }
s64 cellSync2QueuePop() s32 cellSync2QueuePop()
{ {
#ifdef PRX_DEBUG
cellSync2.Warning("%s()", __FUNCTION__);
return GetCurrentPPUThread().FastCall2(libsync2 + 0x4974, libsync2_rtoc);
#else
UNIMPLEMENTED_FUNC(cellSync2); UNIMPLEMENTED_FUNC(cellSync2);
return CELL_OK; return CELL_OK;
#endif
} }
s64 cellSync2QueueTryPop() s32 cellSync2QueueTryPop()
{ {
#ifdef PRX_DEBUG
cellSync2.Warning("%s()", __FUNCTION__);
return GetCurrentPPUThread().FastCall2(libsync2 + 0x4880, libsync2_rtoc);
#else
UNIMPLEMENTED_FUNC(cellSync2); UNIMPLEMENTED_FUNC(cellSync2);
return CELL_OK; return CELL_OK;
#endif
} }
s64 cellSync2QueueGetSize() s32 cellSync2QueueGetSize()
{ {
#ifdef PRX_DEBUG
cellSync2.Warning("%s()", __FUNCTION__);
return GetCurrentPPUThread().FastCall2(libsync2 + 0x2C00, libsync2_rtoc);
#else
UNIMPLEMENTED_FUNC(cellSync2); UNIMPLEMENTED_FUNC(cellSync2);
return CELL_OK; return CELL_OK;
#endif
} }
s64 cellSync2QueueGetDepth() s32 cellSync2QueueGetDepth()
{ {
#ifdef PRX_DEBUG
cellSync2.Warning("%s()", __FUNCTION__);
return GetCurrentPPUThread().FastCall2(libsync2 + 0x2B90, libsync2_rtoc);
#else
UNIMPLEMENTED_FUNC(cellSync2); UNIMPLEMENTED_FUNC(cellSync2);
return CELL_OK; return CELL_OK;
#endif
} }
Module cellSync2("cellSync2", []() Module cellSync2("cellSync2", []()
@ -452,37 +286,4 @@ Module cellSync2("cellSync2", []()
cellSync2.AddFunc(0x0c9a0ea9, cellSync2QueueTryPop); cellSync2.AddFunc(0x0c9a0ea9, cellSync2QueueTryPop);
cellSync2.AddFunc(0x12f0a27d, cellSync2QueueGetSize); cellSync2.AddFunc(0x12f0a27d, cellSync2QueueGetSize);
cellSync2.AddFunc(0xf0e1471c, cellSync2QueueGetDepth); cellSync2.AddFunc(0xf0e1471c, cellSync2QueueGetDepth);
#ifdef PRX_DEBUG
CallAfter([]()
{
if (!Memory.MainMem.GetStartAddr()) return;
libsync2 = (u32)Memory.MainMem.AllocAlign(sizeof(libsync2_data), 0x100000);
memcpy(vm::get_ptr<void>(libsync2), libsync2_data, sizeof(libsync2_data));
libsync2_rtoc = libsync2 + 0xF280;
extern Module* sysPrxForUser;
extern Module* cellSpurs;
extern Module* cellSpursJq;
extern Module* cellFiber;
FIX_IMPORT(cellSpurs, _cellSpursSendSignal , libsync2 + 0x61F0);
FIX_IMPORT(cellSpursJq, cellSpursJobQueueSendSignal , libsync2 + 0x6210);
FIX_IMPORT(cellFiber, cellFiberPpuUtilWorkerControlSendSignal , libsync2 + 0x6230);
FIX_IMPORT(cellFiber, cellFiberPpuSelf , libsync2 + 0x6250);
FIX_IMPORT(cellFiber, cellFiberPpuWaitSignal , libsync2 + 0x6270);
FIX_IMPORT(sysPrxForUser, sys_lwmutex_lock , libsync2 + 0x6290);
FIX_IMPORT(sysPrxForUser, sys_lwmutex_unlock , libsync2 + 0x62B0);
FIX_IMPORT(sysPrxForUser, sys_lwmutex_create , libsync2 + 0x62D0);
FIX_IMPORT(sysPrxForUser, sys_ppu_thread_get_id , libsync2 + 0x62F0);
FIX_IMPORT(sysPrxForUser, _sys_memset , libsync2 + 0x6310);
FIX_IMPORT(sysPrxForUser, _sys_printf , libsync2 + 0x6330);
fix_import(sysPrxForUser, 0x9FB6228E , libsync2 + 0x6350);
FIX_IMPORT(sysPrxForUser, sys_lwmutex_destroy , libsync2 + 0x6370);
FIX_IMPORT(sysPrxForUser, _sys_strncpy , libsync2 + 0x6390);
fix_relocs(cellSync2, libsync2, 0x73A0, 0x95A0, 0x6B90);
});
#endif
}); });