public SceKernelMppInfo(string name, int partitionid, int attr, int size, int memType)
{
this.name = name;
this.attr = attr;
bufSize = size;
freeSize = size;
if (size != 0)
{
sysMemInfo = Modules.SysMemUserForUserModule.malloc(partitionid, "ThreadMan-MsgPipe", memType, size, 0);
address = sysMemInfo.addr;
}
else
{
sysMemInfo = null;
address = 0;
}
uid = SceUidManager.getNewUid(uidPurpose);
sendThreadWaitingList = ThreadWaitingList.createThreadWaitingList(SceKernelThreadInfo.PSP_WAIT_MSGPIPE, uid, attr, MsgPipeManager.PSP_MPP_ATTR_SEND_PRIORITY);
receiveThreadWaitingList = ThreadWaitingList.createThreadWaitingList(SceKernelThreadInfo.PSP_WAIT_MSGPIPE, uid, attr, MsgPipeManager.PSP_MPP_ATTR_RECEIVE_PRIORITY);
this.partitionid = partitionid;
head = 0;
tail = 0;
}
public virtual void free()
{
Memory.Instance.memset(sysMemInfo.addr, (sbyte)0, sysMemInfo.allocatedSize);
Modules.SysMemUserForUserModule.free(sysMemInfo);
sysMemInfo = null;
SceUidManager.releaseUid(uid, uidPurpose);
uid = -1;
}
public virtual int CRYPTO_malloc(int size)
{
cryptoMalloc = Modules.SysMemUserForUserModule.malloc(SysMemUserForUser.USER_PARTITION_ID, "CRYPTO_malloc", SysMemUserForUser.PSP_SMEM_Low, size, 0);
if (cryptoMalloc == null)
{
return(0);
}
return(cryptoMalloc.addr);
}
public virtual int CRYPTO_free(int allocatedAddress)
{
if (cryptoMalloc != null && cryptoMalloc.addr == allocatedAddress)
{
Modules.SysMemUserForUserModule.free(cryptoMalloc);
cryptoMalloc = null;
}
return(0);
}
public virtual int sceAacTermResource()
{
if (resourceMem != null)
{
Modules.SysMemUserForUserModule.free(resourceMem);
resourceMem = null;
}
return(0);
}
public virtual int sceUmdManGetUmdDrive(int unknown)
{
if (dummyUmdDriveInfo == null)
{
const int size = 36;
dummyUmdDriveInfo = Modules.SysMemUserForUserModule.malloc(SysMemUserForUser.KERNEL_PARTITION_ID, "sceUmdManGetUmdDrive", SysMemUserForUser.PSP_SMEM_Low, size, 0);
if (dummyUmdDriveInfo == null)
{
return(-1);
}
dummyUmdDrive = new TPointer(Memory.Instance, dummyUmdDriveInfo.addr);
dummyUmdDrive.clear(size);
}
// This will be the value of the first parameter passed to sceUmdMan_E3716915()
return(dummyUmdDrive.Address);
}
public virtual int sceAacInitResource(int numberIds)
{
int memSize = numberIds * 0x19000;
resourceMem = Modules.SysMemUserForUserModule.malloc(SysMemUserForUser.USER_PARTITION_ID, "SceLibAacResource", SysMemUserForUser.PSP_SMEM_Low, memSize, 0);
if (resourceMem == null)
{
return(SceKernelErrors.ERROR_AAC_NOT_ENOUGH_MEMORY);
}
Memory.Instance.memset(resourceMem.addr, (sbyte)0, memSize);
hleAacInit(numberIds);
return(0);
}
public virtual int sceUmdMan_D1478023()
{
// Has no parameters
ISectorDevice sectorDevice = SectorDevice;
if (sectorDevice == null)
{
Console.WriteLine(string.Format("sceUmdMan_D1478023 no SectorDevice available"));
return(-1);
}
int numSectors;
try
{
numSectors = sectorDevice.NumSectors;
}
catch (IOException e)
{
Console.WriteLine(string.Format("sceUmdMan_D1478023 IO error {0}", e));
return(-1);
}
if (dummyAreaInfo == null)
{
dummyAreaInfo = Modules.SysMemUserForUserModule.malloc(SysMemUserForUser.KERNEL_PARTITION_ID, "sceUmdMan_D1478023", SysMemUserForUser.PSP_SMEM_Low, 120, 0);
if (dummyAreaInfo == null)
{
return(-1);
}
dummyArea = new TPointer(Memory.Instance, dummyAreaInfo.addr);
}
dummyArea.setValue8(100, (sbyte)0x12);
dummyArea.setValue8(101, (sbyte)0x34);
dummyArea.setValue8(102, (sbyte)0x56);
dummyArea.setValue8(103, (sbyte)0x78);
dummyArea.setValue32(108, 0x11111111);
dummyArea.setValue32(112, numSectors); // value returned by sceIoDevctl cmd=0x01F20003 (get total number of sectors)
dummyArea.setValue32(116, numSectors); // value returned by sceIoDevctl cmd=0x01F20002 (get current LBA)
return(dummyArea.Address);
}
public virtual int scePsmfPlayerDelete(int psmfPlayer)
{
VideoEngine.Instance.resetVideoTextures();
if (ringbufferMem != null)
{
Modules.SysMemUserForUserModule.free(ringbufferMem);
ringbufferMem = null;
}
if (mpegMem != null)
{
Modules.SysMemUserForUserModule.free(mpegMem);
mpegMem = null;
}
// Set to NONE.
psmfPlayerStatus = PSMF_PLAYER_STATUS_NONE;
return(0);
}
public virtual int scePsmfPlayerCreate(int psmfPlayer, TPointer32 psmfPlayerDataAddr)
{
// The psmfDataAddr contains three fields that are manually set before
// scePsmfPlayerCreate is called.
displayBuffer = psmfPlayerDataAddr.getValue(0) & Memory.addressMask; // The buffer allocated for scePsmf, which is ported into scePsmfPlayer.
displayBufferSize = psmfPlayerDataAddr.getValue(4); // The buffer's size.
playbackThreadPriority = psmfPlayerDataAddr.getValue(8); // Priority of the "START" thread.
if (log.InfoEnabled)
{
Console.WriteLine(string.Format("PSMF Player Data: displayBuffer=0x{0:X8}, displayBufferSize=0x{1:X}, playbackThreadPriority={2:D}", displayBuffer, displayBufferSize, playbackThreadPriority));
}
// Allocate memory for the MPEG structure
Memory mem = Memory.Instance;
mpegMem = Modules.SysMemUserForUserModule.malloc(KERNEL_PARTITION_ID, Name + "-Mpeg", PSP_SMEM_Low, MPEG_MEMSIZE, 0);
int result = Modules.sceMpegModule.hleMpegCreate(TPointer.NULL, new TPointer(mem, mpegMem.addr), MPEG_MEMSIZE, null, Screen.width, 0, 0);
if (result < 0)
{
Console.WriteLine(string.Format("scePsmfPlayerCreate: error 0x{0:X8} while calling hleMpegCreate", result));
}
// Allocate memory for the ringbuffer, scePsmfPlayer creates a ringbuffer with 581 packets
const int packets = 581;
ringbufferMem = Modules.SysMemUserForUserModule.malloc(KERNEL_PARTITION_ID, Name + "-Ringbuffer", PSP_SMEM_Low, packets * ringbufferPacketSize, 0);
Modules.sceMpegModule.hleCreateRingbuffer(packets, ringbufferMem.addr, ringbufferMem.size);
SceMpegRingbuffer ringbuffer = Modules.sceMpegModule.MpegRingbuffer;
// This ringbuffer is used both for audio and video
ringbuffer.HasAudio = true;
ringbuffer.HasVideo = true;
// Start with INIT.
psmfPlayerStatus = PSMF_PLAYER_STATUS_INIT;
return(0);
}
public SceKernelTls(string name, int partitionId, int attr, int blockSize, int alignedBlockSize, int numberBlocks, int alignment)
{
blockSize = alignUp(blockSize, 3);
this.name = name;
this.attr = attr;
this.blockSize = blockSize;
this.alignedBlockSize = alignedBlockSize;
this.numberBlocks = numberBlocks;
int type = alignment == 0 ? PSP_SMEM_Low : PSP_SMEM_LowAligned;
if ((attr & PSP_ATTR_ADDR_HIGH) != 0)
{
type = alignment == 0 ? PSP_SMEM_High : PSP_SMEM_HighAligned;
}
int size = alignedBlockSize * numberBlocks;
sysMemInfo = Modules.SysMemUserForUserModule.malloc(partitionId, name, type, size, alignment);
uid = SceUidManager.getNewUid(uidPurpose);
threadIds = new int[numberBlocks];
}
