public int sceKernelReceiveMbx(MessageBox MessageBox, PspPointer *PointerToMessage, uint *Timeout)
{
var CurrentThread = ThreadManager.Current;
bool TimedOut = false;
CurrentThread.SetWaitAndPrepareWakeUp(HleThread.WaitType.None, "sceKernelReceiveMbx", MessageBox,
WakeUpCallback =>
{
if (Timeout != null)
{
PspRtc.RegisterTimerInOnce(TimeSpanUtils.FromMicroseconds(*Timeout), () =>
{
TimedOut = true;
WakeUpCallback();
});
}
MessageBox.Receive(PointerToMessage, WakeUpCallback);
}, HandleCallbacks: false);
if (TimedOut)
{
return((int)SceKernelErrors.ERROR_KERNEL_WAIT_TIMEOUT);
}
else
{
//if (Timeout)
//return MessageBox.Receive(Message);
return(0);
}
}
public int sceKernelAllocateFplCB(FixedPool FixedPool, PspPointer *DataPointer, uint *Timeout)
{
FixedPool.Allocate(DataPointer, Timeout, HandleCallbacks: true);
//Console.WriteLine("Allocated: Address: 0x{0:X}", DataPointer->Address);
return(0);
}
//[HlePspNotImplemented]
public int sceMpegAvcDecode(SceMpegPointer *SceMpegPointer, SceMpegAu *MpegAccessUnit, int FrameWidth,
PspPointer *OutputBufferPointer, PspPointer *Init)
{
//if (*Init == 1)
//{
// throw (new SceKernelException(SceKernelErrors.ERROR_MPEG_NO_DATA));
//}
var SceMpegData = GetSceMpegData(SceMpegPointer);
var Mpeg = GetMpeg(SceMpegPointer);
// Dummy
var VideoPacket = new VideoPacket();
//Console.Error.WriteLine("0x{0:X}", PspMemory.PointerToPspAddress(OutputBuffer));
//Console.WriteLine("{0:X8}", (*OutputBufferPointer).Address);
Mpeg.AvcDecode(
MpegAccessUnit,
FrameWidth,
SceMpegData->SceMpegAvcMode.PixelFormat,
*OutputBufferPointer
);
SceMpegData->AvcFrameStatus = 1;
//Init = SceMpegData->AvcFrameStatus;
//throw (new SceKernelException(SceKernelErrors.ERROR_MPEG_NO_DATA));
return(0);
}
public void Allocate(CpuThreadState CpuThreadState, int Size, PspPointer *AddressPointer, uint *Timeout,
bool HandleCallbacks)
{
if (!TryAllocate(CpuThreadState, Size, AddressPointer))
{
bool TimedOut = false;
ThreadManForUser.ThreadManager.Current.SetWaitAndPrepareWakeUp(HleThread.WaitType.Semaphore,
"_sceKernelAllocateVplCB", this, (WakeUp) =>
{
ThreadManForUser.PspRtc.RegisterTimeout(Timeout, () =>
{
TimedOut = true;
WakeUp();
});
WaitList.Add(new WaitVariablePoolItem()
{
RequiredSize = Size,
WakeUp = () =>
{
WakeUp();
Allocate(CpuThreadState, Size, AddressPointer, Timeout, HandleCallbacks);
},
});
}, HandleCallbacks: HandleCallbacks);
if (TimedOut)
{
throw new SceKernelException(SceKernelErrors.ERROR_KERNEL_WAIT_TIMEOUT);
}
}
}
public int sceKernelTryAllocateFpl(FixedPool FixedPool, PspPointer *DataPointer)
{
if (!FixedPool.TryAllocate(DataPointer))
{
throw new SceKernelException(SceKernelErrors.ERROR_KERNEL_NO_MEMORY);
}
return(0);
}
public int sceKernelPollMbx(MessageBox MessageBox, PspPointer *PointerToMessage)
{
if (!MessageBox.Poll(PointerToMessage))
{
throw new SceKernelException(SceKernelErrors.ERROR_KERNEL_MESSAGEBOX_NO_MESSAGE);
}
return(0);
}
public int sceKernelTryAllocateVpl(CpuThreadState CpuThreadState, VariablePool VariablePool, int Size,
PspPointer *AddressPointer)
{
if (VariablePool.TryAllocate(CpuThreadState, Size, AddressPointer))
{
return(0);
}
else
{
return((int)SceKernelErrors.ERROR_KERNEL_NO_MEMORY);
}
}
public void Receive(PspPointer *PointerToMessage, Action WakeUp)
{
lock (this)
{
Action Extract = () =>
{
*PointerToMessage = Messages.Last.Value;
Messages.RemoveLast();
WakeUp?.Invoke();
};
ExtractQueue.Enqueue(Extract);
CheckQueue();
}
}
public bool Poll(PspPointer *PointerToMessage)
{
lock (this)
{
if (Messages.Any())
{
Receive(PointerToMessage, null);
return(true);
}
else
{
return(false);
}
}
}
public bool TryAllocate(PspPointer *DataPointer)
{
if (FreeBlocks.Count > 0)
{
var AllocatedBlock = FreeBlocks.First();
FreeBlocks.Remove(AllocatedBlock);
UsedBlocks.Add(AllocatedBlock);
//Console.Error.WriteLine("TryAllocate(0x{0:X})", AllocatedBlock);
DataPointer->Address = AllocatedBlock;
return(true);
}
else
{
return(false);
}
}
public bool TryAllocate(CpuThreadState CpuThreadState, int Size, PspPointer *AddressPointer)
{
Size = (int)MathUtils.NextAligned(Size, 4);
if (Size > Info.PoolSize)
{
throw new SceKernelException((SceKernelErrors)(-1));
}
try
{
var AllocatedSegment = MemoryPartition.Allocate(Size, InternalMemoryAnchor);
AddressPointer->Address = AllocatedSegment.GetAnchoredAddress(InternalMemoryAnchorReturn);
return(true);
}
catch (MemoryPartitionNoMemoryException)
{
//AddressPointer->Address = 0;
return(false);
}
}
public void Allocate(PspPointer *DataPointer, uint *Timeout, bool HandleCallbacks)
{
if (!TryAllocate(DataPointer))
{
if (Timeout != null)
{
throw new NotImplementedException();
}
var CurrentThread = ThreadManForUser.ThreadManager.Current;
CurrentThread.SetWaitAndPrepareWakeUp(HleThread.WaitType.Semaphore, "_sceKernelAllocateVplCB", this,
(WakeUp) =>
{
WaitItemList.Add(new WaitItem()
{
Thread = CurrentThread,
WakeUp = () =>
{
WakeUp();
Allocate(DataPointer, Timeout, HandleCallbacks);
},
});
}, HandleCallbacks: HandleCallbacks);
}
}
public int sceKernelAllocateVplCB(CpuThreadState CpuThreadState, VariablePool VariablePool, int Size,
PspPointer *AddressPointer, uint *Timeout)
{
VariablePool.Allocate(CpuThreadState, Size, AddressPointer, Timeout, HandleCallbacks: true);
return(0);
}
