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>(); }