private static IntPtr _signalHandlerPtr;

private static IntPtr _signalHandlerHandle;

private static bool _initialized;

static NativeSignalHandler()

private static readonly List<CacheEntry> _cacheEntries = new List<CacheEntry>();

private static bool _initialized;

[SupportedOSPlatform("windows")]

private Queue<OpenALAudioBuffer> _queuedBuffers;

private ulong _playedSampleCount;

public OpenALHardwareDeviceSession(OpenALHardwareDeviceDriver driver, IVirtualMemoryManager memoryManager, SampleFormat requestedSampleFormat, uint requestedSampleRate, uint requestedChannelCount, float requestedVolume) : base(memoryManager, requestedSampleFormat, requestedSampleRate, requestedChannelCount)

{

/// <summary>

/// Lock used to control the waiters registration.

/// </summary>

/// <summary>

/// Events signaled when the driver played audio buffers.

{

private const int RingBufferAlignment = 2048;

private byte[] _buffer;

private int _size;

/// </summary>

public class AudioInputManager : IDisposable

{

/// <summary>

/// Lock used for session allocation.

/// </summary>

/// <summary>

/// The session ids allocation table.

/// <summary>

/// The lock of the parent.

/// </summary>

/// <summary>

/// The dispose state.

/// </summary>

public class AudioOutputManager : IDisposable

{

/// <summary>

/// Lock used for session allocation.

/// </summary>

/// <summary>

/// The session ids allocation table.

/// <summary>

/// THe lock of the parent.

/// </summary>

/// <summary>

/// The dispose state.

{

public class AudioRenderSystem : IDisposable

{

private AudioRendererRenderingDevice _renderingDevice;

private AudioRendererExecutionMode _executionMode;

/// <summary>

/// Lock used for session allocation.

/// </summary>

/// <summary>

/// Lock used to control the <see cref="AudioProcessor"/> running state.

/// </summary>

/// <summary>

/// The session ids allocation table.

/// <summary>

/// Global lock of the object.

/// </summary>

/// <summary>

/// The upsamplers instances.

private int _refConsumerPtr;

private Action _interruptAction;

public event EventHandler<ScreenCaptureImageInfo> ScreenCaptured;

private List<BufferMigration> _sources;

private BufferMigration _migrationTarget;

/// <summary>

/// Whether the modified range list has any entries or not.

for (int i = 0; i < count; i++)

{

BufferModifiedRange overlap = overlaps[i];

if (overlap.Address > address)

{

// The start of the remaining region is uncovered by this overlap. Call the action for it.

private ulong _accumulatedCounter;

private int _waiterCount;

private Queue<BufferedQuery> _queryPool;

private AutoResetEvent _queuedEvent = new AutoResetEvent(false);

private bool _hostAccessReserved = false;

private int _refCount = 1; // Starts with a reference from the counter queue.

private ulong _result = ulong.MaxValue;

private double _divisor = 1f;

{

private const int DisposedLiveFrames = 2;

private readonly Dictionary<TextureCreateInfo, List<DisposedTexture>> _textures = new Dictionary<TextureCreateInfo, List<DisposedTexture>>();

/// <summary>

private ulong _accumulatedCounter;

private int _waiterCount;

private Queue<BufferedQuery> _queryPool;

private AutoResetEvent _queuedEvent = new AutoResetEvent(false);

private bool _hostAccessReserved = false;

private int _refCount = 1; // Starts with a reference from the counter queue.

private ulong _result = ulong.MaxValue;

private double _divisor = 1f;

private bool _canAcceptController = false;

private KeyboardInputMode _inputMode = KeyboardInputMode.ControllerAndKeyboard;

public event EventHandler AppletStateChanged;

private const int TextBoxBlinkSleepMilliseconds = 100;

private const int RendererWaitTimeoutMilliseconds = 100;

private SoftwareKeyboardUiState _state = new SoftwareKeyboardUiState();

private SoftwareKeyboardRendererBase _renderer;

const string CancelText = "Cancel";

const string ControllerToggleText = "Toggle input";

private RenderingSurfaceInfo _surfaceInfo = null;

private Image<Argb32> _surface = null;

private static RectangleF MeasureString(ReadOnlySpan<char> text, Font font)

{

RendererOptions options = new RendererOptions(font);

if (text == "")

{

FontRectangle emptyRectangle = TextMeasurer.Measure(" ", options);

}

private TRef<bool> _cancelled = null;

public bool IsRunning

{

public ProcessState State { get; private set; }

public KAddressArbiter AddressArbiter { get; private set; }

public KProcess(KernelContext context, bool allowCodeMemoryForJit = false) : base(context)

{

AddressArbiter = new KAddressArbiter(context);

_fullTlsPages = new SortedDictionary<ulong, KTlsPageInfo>();

public bool WaitingInArbitration { get; set; }

public KThread(KernelContext context) : base(context)

{

_mutexWaiters = new LinkedList<KThread>();

_pinnedWaiters = new LinkedList<KThread>();

}

public Result Initialize(

private KEvent _accumulatedSuspendedTickChangedEvent;

private int _accumulatedSuspendedTickChangedEventHandle;

// TODO: Set this when the game goes in suspension (go back to home menu ect), we currently don't support that so we can keep it set to 0.

private ulong _accumulatedSuspendedTickValue = 0;

return ResultCode.Success;

}

}

private readonly UserId _userId;

private readonly FriendServicePermissionLevel _permissionLevel;

private KEvent _notificationEvent;

private int _notificationEventHandle = 0;

private NvFence _previousFailingFence;

private uint _failingCount;

/// <summary>

/// Max failing count until waiting on CPU.

private Switch _device;

public NvHostSyncpt(Switch device)

{

{

private static ConcurrentDictionary<ulong, BsdContext> _registry = new ConcurrentDictionary<ulong, BsdContext>();

private List<IFileDescriptor> _fds;

private ulong _value;

private readonly EventFdFlags _flags;

public bool Blocking { get => !_flags.HasFlag(EventFdFlags.NonBlocking); set => throw new NotSupportedException(); }

{

private RandomNumberGenerator _rng;

public IRandomInterface(ServiceCtx context)

{

}

}

private IntegrityCheckLevel _fsIntegrityCheckLevel;

private Dictionary<CaCertificateId, CertStoreEntry> _certificates;

private struct CertStoreFileHeader

{

public bool EnableExternalEvent;

public int MaxBufferCountCached;

private KEvent _waitBufferFreeEvent;

private KEvent _frameAvailableEvent;

private uint _currentCallbackTicket;

private uint _callbackTicket;

public BufferQueueProducer(BufferQueueCore core, ITickSource tickSource)

{

protected BufferQueueConsumer Consumer;

private IConsumerListener _listener;

Slot slot = Slots[slotIndex];

return !slot.GraphicBuffer.IsNull && slot.GraphicBuffer.Object.Buffer.Surfaces[0].NvMapHandle == graphicBuffer.Object.Buffer.Surfaces[0].NvMapHandle;

}

}

private int _swapInterval;

private int _swapIntervalDelay;

public long RenderLayerId { get; private set; }

private UInt128 _timeZoneRuleVersion;

private uint _totalLocationNameCount;

private SteadyClockTimePoint _timeZoneUpdateTimePoint;

public TimeZoneManager()

{

_isInitialized = false;

_deviceLocationName = "UTC";

_timeZoneRuleVersion = new UInt128();

_myRules = new Box<TimeZoneRule>();

_timeZoneUpdateTimePoint = SteadyClockTimePoint.GetRandom();

private readonly List<MultiWaitHolderBase> _multiWaits;

private int _waitingThreadHandle;

public MultiWaitImpl()

{

_multiWaits = new List<MultiWaitHolderBase>();

}

public void LinkMultiWaitHolder(MultiWaitHolderBase multiWaitHolder)

SDL_GameControllerButton.SDL_CONTROLLER_BUTTON_PADDLE2,

SDL_GameControllerButton.SDL_CONTROLLER_BUTTON_PADDLE3,

SDL_GameControllerButton.SDL_CONTROLLER_BUTTON_PADDLE4,

// Virtual buttons are invalid, ignored.

SDL_GameControllerButton.SDL_CONTROLLER_BUTTON_INVALID,

SDL_GameControllerButton.SDL_CONTROLLER_BUTTON_INVALID,

};

private List<ButtonMappingEntry> _buttonsUserMapping;

}

}

private readonly SDL2KeyboardDriver _driver;

private StandardKeyboardInputConfig _configuration;

{

private CemuHookClient _cemuHookClient;

private bool _blockInputUpdates;

_device.Hid.Mouse.Update((int)position.X, (int)position.Y, buttons, (int)mouseInput.Scroll.X, (int)mouseInput.Scroll.Y, true);

}

{

_device.Hid.Mouse.Update(0, 0);

}

private event Action _onDirty;

private RegionSignal _preAction; // Action to perform before a read or write. This will block the memory access.

private PreciseRegionSignal _preciseAction; // Action to perform on a precise read or write.

private readonly List<VirtualRegion> _regions;

private ConcurrentDictionary<uint, Action<SDL_Event>> _registeredWindowHandlers;

private SDL2Driver() {}

}

}

private readonly GTK3KeyboardDriver _driver;

private StandardKeyboardInputConfig _configuration;