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);
}
}
private int _sceKernelWaitSemaCB(SemaphoreId SemaphoreId, int Signal, uint *Timeout, bool HandleCallbacks)
{
var CurrentThread = ThreadManager.Current;
var Semaphore = GetSemaphoreById(SemaphoreId);
bool TimedOut = false;
CurrentThread.SetWaitAndPrepareWakeUp(HleThread.WaitType.Semaphore,
$"sceKernelWaitSema('{Semaphore.Name}')", Semaphore, WakeUpCallback =>
{
PspRtc.RegisterTimeout(Timeout, () =>
{
TimedOut = true;
WakeUpCallback();
});
Semaphore.WaitThread(CurrentThread, () =>
{
WakeUpCallback();
//ThreadManager.ScheduleNext(CurrentThread);
}, Signal);
}, HandleCallbacks: HandleCallbacks);
if (TimedOut)
{
throw new SceKernelException(SceKernelErrors.ERROR_KERNEL_WAIT_TIMEOUT);
}
return(0);
}
private int _sceDisplayWaitVblankStartCB(CpuThreadState CpuThreadState, bool HandleCallbacks)
{
if (PspConfig.VerticalSynchronization && LastVblankCount != PspDisplay.VblankCount)
{
var SleepThread = ThreadManager.Current;
SleepThread.SetWaitAndPrepareWakeUp(HleThread.WaitType.Display, "sceDisplayWaitVblankStart", (WakeUpCallbackDelegate) =>
{
PspRtc.RegisterTimerAtOnce(LastWaitVblankStart + TimeSpan.FromMilliseconds(1000 / 60), () =>
{
WakeUpCallbackDelegate();
});
LastWaitVblankStart = PspRtc.UpdatedCurrentDateTime;
}, HandleCallbacks: HandleCallbacks);
/*
* SleepThread.SetWaitAndPrepareWakeUp(HleThread.WaitType.Display, "sceDisplayWaitVblankStart", (WakeUpCallbackDelegate) =>
* {
* //PspDisplay.VBlankEvent
* HleState.PspDisplay.VBlankEvent.CallbackOnStateOnce(() =>
* {
* LastVblankCount = HleState.PspDisplay.VblankCount;
* WakeUpCallbackDelegate();
* });
* });
*/
}
return(0);
}
public override void InitializeComponent()
{
this.IsRunning = true;
this.CpuProcessor = PspEmulatorContext.GetInstance <CpuProcessor>();
this.GpuProcessor = PspEmulatorContext.GetInstance <GpuProcessor>();
this.PspAudio = PspEmulatorContext.GetInstance <PspAudio>();
this.PspConfig = PspEmulatorContext.PspConfig;
this.PspRtc = PspEmulatorContext.GetInstance <PspRtc>();
this.PspDisplay = PspEmulatorContext.GetInstance <PspDisplay>();
this.PspController = PspEmulatorContext.GetInstance <PspController>();
this.MipsEmiter = new MipsEmiter();
this.Kirk = new Kirk();
this.Kirk.kirk_init();
this.HleOutputHandler = PspEmulatorContext.GetInstance <HleOutputHandler>();
// @TODO FIX! New Instances!?
this.ThreadManager = PspEmulatorContext.GetInstance <HleThreadManager>();
this.SemaphoreManager = PspEmulatorContext.GetInstance <HleSemaphoreManager>();
this.EventFlagManager = PspEmulatorContext.GetInstance <HleEventFlagManager>();
this.MemoryManager = new HleMemoryManager(this.CpuProcessor.Memory);
this.ModuleManager = PspEmulatorContext.GetInstance <HleModuleManager>();
this.CallbackManager = PspEmulatorContext.GetInstance <HleCallbackManager>();
this.HleIoManager = PspEmulatorContext.GetInstance <HleIoManager>();
this.HleRegistryManager = PspEmulatorContext.GetInstance <HleRegistryManager>();
this.HleInterruptManager = PspEmulatorContext.GetInstance <HleInterruptManager>();
}
public override void InitializeComponent()
{
CpuProcessor = PspEmulatorContext.GetInstance <CpuProcessor>();
PspRtc = PspEmulatorContext.GetInstance <PspRtc>();
ThreadManager = PspEmulatorContext.GetInstance <HleThreadManager>();
HleState = PspEmulatorContext.GetInstance <HleState>();
PspMemory = PspEmulatorContext.GetInstance <PspMemory>();
RegisterDevices();
}
/// <summary>
/// Wait for an event flag for a given bit pattern with callback.
/// </summary>
/// <param name="EventId">The event ID returned by <see cref="sceKernelCreateEventFlag"/>.</param>
/// <param name="Bits">The bit pattern to poll for.</param>
/// <param name="Wait">Wait type, one or more of PspEventFlagWaitTypes or'ed together</param>
/// <param name="OutBits">The bit pattern that was matched.</param>
/// <param name="Timeout">Timeout in microseconds</param>
/// <param name="HandleCallbacks"></param>
/// <returns>
/// ERROR_KERNEL_NOT_FOUND_EVENT_FLAG - If can't find the eventFlag
/// ERROR_KERNEL_WAIT_TIMEOUT - If there was a timeout
/// 0 - On success
/// </returns>
public int _sceKernelWaitEventFlagCB(HleEventFlag EventFlag, uint Bits, EventFlagWaitTypeSet Wait,
uint *OutBits, uint *Timeout, bool HandleCallbacks)
{
if ((Wait & ~EventFlagWaitTypeSet.MaskValidBits) != 0)
{
throw new SceKernelException(SceKernelErrors.ERROR_KERNEL_ILLEGAL_MODE);
}
if (Bits == 0)
{
throw new SceKernelException(SceKernelErrors.ERROR_KERNEL_EVENT_FLAG_ILLEGAL_WAIT_PATTERN);
}
bool TimedOut = false;
var PreviousPattern = EventFlag.Info.CurrentPattern;
ThreadManager.Current.SetWaitAndPrepareWakeUp(
HleThread.WaitType.Semaphore,
$"_sceKernelWaitEventFlagCB(EventId={EventFlag.GetUidIndex(InjectContext)}, Bits={Bits:X}, Wait={Wait})",
EventFlag,
WakeUpCallback =>
{
if (Timeout != null)
{
PspRtc.RegisterTimerInOnce(TimeSpanUtils.FromMicroseconds(*Timeout), () =>
{
TimedOut = true;
*Timeout = 0;
WakeUpCallback();
});
}
EventFlag.AddWaitingThread(new HleEventFlag.WaitThread()
{
HleThread = ThreadManager.Current,
BitsToMatch = Bits,
WaitType = Wait,
WakeUpCallback = () => { WakeUpCallback(); },
OutBits = OutBits,
});
}, HandleCallbacks: HandleCallbacks);
if (OutBits != null)
{
*OutBits = PreviousPattern;
}
if (TimedOut)
{
throw new SceKernelException(SceKernelErrors.ERROR_KERNEL_WAIT_TIMEOUT);
}
//throw(new NotImplementedException());
return(0);
}
/// <summary>
///
/// </summary>
/// <param name="ThreadId"></param>
/// <param name="Timeout"></param>
/// <param name="HandleCallbacks"></param>
/// <returns></returns>
private int _sceKernelWaitThreadEndCB(int ThreadId, uint *Timeout, bool HandleCallbacks)
{
var ThreadToWaitEnd = GetThreadById(ThreadId);
if (ThreadToWaitEnd.HasAnyStatus(HleThread.Status.Stopped))
{
return(0);
}
if (ThreadToWaitEnd.HasAnyStatus(HleThread.Status.Killed))
{
return(0);
}
bool TimedOut = false;
ThreadManager.Current.SetWaitAndPrepareWakeUp(HleThread.WaitType.None,
$"sceKernelWaitThreadEnd('{ThreadToWaitEnd.Name}')", ThreadToWaitEnd, WakeUpCallback =>
{
if (Timeout != null)
{
PspRtc.RegisterTimerInOnce(TimeSpanUtils.FromMicroseconds(*Timeout), () =>
{
TimedOut = true;
WakeUpCallback();
});
}
Console.WriteLine("Wait End!");
Action OnTerminate = null;
OnTerminate = () =>
{
ThreadToWaitEnd.OnTerminate -= OnTerminate;
Console.WriteLine("Ended!");
//throw(new Exception("aaaaaaaaaaaa"));
WakeUpCallback();
};
ThreadToWaitEnd.OnTerminate += OnTerminate;
}, HandleCallbacks: HandleCallbacks);
if (TimedOut)
{
return((int)SceKernelErrors.ERROR_KERNEL_WAIT_TIMEOUT);
}
else
{
return(0);
}
}
private int _sceKernelDelayThreadCB(uint DelayInMicroseconds, bool HandleCallbacks)
{
var CurrentThread = ThreadManager.Current;
CurrentThread.SetWaitAndPrepareWakeUp(HleThread.WaitType.Timer,
$"sceKernelDelayThread({DelayInMicroseconds}, {HandleCallbacks})", null,
WakeUpCallback =>
{
PspRtc.RegisterTimerInOnce(TimeSpanUtils.FromMicroseconds(DelayInMicroseconds),
() => { WakeUpCallback(); });
}, HandleCallbacks: HandleCallbacks);
return(0);
}
public SimplifiedPspEmulator(bool test = false, Action <InjectContext>?configure = null)
{
injector = PspInjectContext.CreateInjectContext(PspStoredConfig.Load(), test, configure);
Emulator = injector.GetInstance <PspEmulator>();
//Emulator.PspRunner = null;
//Emulator.CpuConfig.DebugSyscalls = true;
//Emulator.CpuConfig.TrackCallStack = true;
Rtc = injector.GetInstance <PspRtc>();
Display = injector.GetInstance <PspDisplay>();
DisplayComponent = injector.GetInstance <DisplayComponentThread>();
Memory = injector.GetInstance <PspMemory>();
Controller = injector.GetInstance <PspController>();
DisplayComponent.triggerStuff = true;
}
public override void InitializeComponent()
{
this.HlePspRtc = PspEmulatorContext.GetInstance <PspRtc>();
}
