mirror of
https://github.com/ryujinx-mirror/ryujinx.git
synced 2024-10-20 08:21:40 +00:00
4d02a2d2c0
* Initial NVDEC and VIC implementation * Update FFmpeg.AutoGen to 4.3.0 * Add nvdec dependencies for Windows * Unify some VP9 structures * Rename VP9 structure fields * Improvements to Video API * XML docs for Common.Memory * Remove now unused or redundant overloads from MemoryAccessor * NVDEC UV surface read/write scalar paths * Add FIXME comments about hacky things/stuff that will need to be fixed in the future * Cleaned up VP9 memory allocation * Remove some debug logs * Rename some VP9 structs * Remove unused struct * No need to compile Ryujinx.Graphics.Host1x with unsafe anymore * Name AsyncWorkQueue threads to make debugging easier * Make Vp9PictureInfo a ref struct * LayoutConverter no longer needs the depth argument (broken by rebase) * Pooling of VP9 buffers, plus fix a memory leak on VP9 * Really wish VS could rename projects properly... * Address feedback * Remove using * Catch OperationCanceledException * Add licensing informations * Add THIRDPARTY.md to release too Co-authored-by: Thog <me@thog.eu>
199 lines
No EOL
5.4 KiB
C#
199 lines
No EOL
5.4 KiB
C#
using Ryujinx.Common.Logging;
|
|
using Ryujinx.Graphics.Gpu.Synchronization;
|
|
using System;
|
|
using System.Threading;
|
|
|
|
namespace Ryujinx.HLE.HOS.Services.Nv.NvDrvServices.NvHostCtrl
|
|
{
|
|
class NvHostSyncpt
|
|
{
|
|
public const int VBlank0SyncpointId = 26;
|
|
public const int VBlank1SyncpointId = 27;
|
|
|
|
private int[] _counterMin;
|
|
private int[] _counterMax;
|
|
private bool[] _clientManaged;
|
|
private bool[] _assigned;
|
|
|
|
private Switch _device;
|
|
|
|
private object _syncpointAllocatorLock = new object();
|
|
|
|
public NvHostSyncpt(Switch device)
|
|
{
|
|
_device = device;
|
|
_counterMin = new int[SynchronizationManager.MaxHardwareSyncpoints];
|
|
_counterMax = new int[SynchronizationManager.MaxHardwareSyncpoints];
|
|
_clientManaged = new bool[SynchronizationManager.MaxHardwareSyncpoints];
|
|
_assigned = new bool[SynchronizationManager.MaxHardwareSyncpoints];
|
|
|
|
// Reserve VBLANK syncpoints
|
|
ReserveSyncpointLocked(VBlank0SyncpointId, true);
|
|
ReserveSyncpointLocked(VBlank1SyncpointId, true);
|
|
}
|
|
|
|
private void ReserveSyncpointLocked(uint id, bool isClientManaged)
|
|
{
|
|
if (id >= SynchronizationManager.MaxHardwareSyncpoints || _assigned[id])
|
|
{
|
|
throw new ArgumentOutOfRangeException(nameof(id));
|
|
}
|
|
|
|
_assigned[id] = true;
|
|
_clientManaged[id] = isClientManaged;
|
|
}
|
|
|
|
public uint AllocateSyncpoint(bool isClientManaged)
|
|
{
|
|
lock (_syncpointAllocatorLock)
|
|
{
|
|
for (uint i = 1; i < SynchronizationManager.MaxHardwareSyncpoints; i++)
|
|
{
|
|
if (!_assigned[i])
|
|
{
|
|
ReserveSyncpointLocked(i, isClientManaged);
|
|
return i;
|
|
}
|
|
}
|
|
}
|
|
|
|
Logger.PrintError(LogClass.ServiceNv, "Cannot allocate a new syncpoint!");
|
|
|
|
return 0;
|
|
}
|
|
|
|
public void ReleaseSyncpoint(uint id)
|
|
{
|
|
if (id == 0)
|
|
{
|
|
return;
|
|
}
|
|
|
|
lock (_syncpointAllocatorLock)
|
|
{
|
|
if (id >= SynchronizationManager.MaxHardwareSyncpoints || !_assigned[id])
|
|
{
|
|
throw new ArgumentOutOfRangeException(nameof(id));
|
|
}
|
|
|
|
_assigned[id] = false;
|
|
_clientManaged[id] = false;
|
|
|
|
SetSyncpointMinEqualSyncpointMax(id);
|
|
}
|
|
}
|
|
|
|
public void SetSyncpointMinEqualSyncpointMax(uint id)
|
|
{
|
|
if (id >= SynchronizationManager.MaxHardwareSyncpoints)
|
|
{
|
|
throw new ArgumentOutOfRangeException(nameof(id));
|
|
}
|
|
|
|
int value = (int)ReadSyncpointValue(id);
|
|
|
|
Interlocked.Exchange(ref _counterMax[id], value);
|
|
}
|
|
|
|
public uint ReadSyncpointValue(uint id)
|
|
{
|
|
return UpdateMin(id);
|
|
}
|
|
|
|
public uint ReadSyncpointMinValue(uint id)
|
|
{
|
|
return (uint)_counterMin[id];
|
|
}
|
|
|
|
public uint ReadSyncpointMaxValue(uint id)
|
|
{
|
|
return (uint)_counterMax[id];
|
|
}
|
|
|
|
private bool IsClientManaged(uint id)
|
|
{
|
|
if (id >= SynchronizationManager.MaxHardwareSyncpoints)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
return _clientManaged[id];
|
|
}
|
|
|
|
public void Increment(uint id)
|
|
{
|
|
if (IsClientManaged(id))
|
|
{
|
|
IncrementSyncpointMax(id);
|
|
}
|
|
|
|
IncrementSyncpointGPU(id);
|
|
}
|
|
|
|
public uint UpdateMin(uint id)
|
|
{
|
|
uint newValue = _device.Gpu.Synchronization.GetSyncpointValue(id);
|
|
|
|
Interlocked.Exchange(ref _counterMin[id], (int)newValue);
|
|
|
|
return newValue;
|
|
}
|
|
|
|
private void IncrementSyncpointGPU(uint id)
|
|
{
|
|
_device.Gpu.Synchronization.IncrementSyncpoint(id);
|
|
}
|
|
|
|
public void IncrementSyncpointMin(uint id)
|
|
{
|
|
Interlocked.Increment(ref _counterMin[id]);
|
|
}
|
|
|
|
public uint IncrementSyncpointMaxExt(uint id, int count)
|
|
{
|
|
if (count == 0)
|
|
{
|
|
return ReadSyncpointMaxValue(id);
|
|
}
|
|
|
|
uint result = 0;
|
|
|
|
for (int i = 0; i < count; i++)
|
|
{
|
|
result = IncrementSyncpointMax(id);
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
private uint IncrementSyncpointMax(uint id)
|
|
{
|
|
return (uint)Interlocked.Increment(ref _counterMax[id]);
|
|
}
|
|
|
|
public uint IncrementSyncpointMax(uint id, uint incrs)
|
|
{
|
|
return (uint)Interlocked.Add(ref _counterMax[id], (int)incrs);
|
|
}
|
|
|
|
public bool IsSyncpointExpired(uint id, uint threshold)
|
|
{
|
|
return MinCompare(id, _counterMin[id], _counterMax[id], (int)threshold);
|
|
}
|
|
|
|
private bool MinCompare(uint id, int min, int max, int threshold)
|
|
{
|
|
int minDiff = min - threshold;
|
|
int maxDiff = max - threshold;
|
|
|
|
if (IsClientManaged(id))
|
|
{
|
|
return minDiff >= 0;
|
|
}
|
|
else
|
|
{
|
|
return (uint)maxDiff >= (uint)minDiff;
|
|
}
|
|
}
|
|
}
|
|
} |