private async void MainForm_Load(object sender, EventArgs e)
{
// Left Panel
UIHelpers.InitCombox(prevClipboardTypeCombox, 0);
UIHelpers.InitCombox(preResizeScale, 1);
UIHelpers.InitCombox(preResizeMode, 0);
UIHelpers.FillEnumComboBox(preResizeFilter, typeof(Upscale.Filter), 0);
// Right Panel
UIHelpers.InitCombox(prevOverwriteCombox, 0);
UIHelpers.InitCombox(prevOutputFormatCombox, 0);
UIHelpers.FillEnumComboBox(prevOutputFormatCombox, typeof(Upscale.ExportFormats));
UIHelpers.InitCombox(postResizeScale, 1);
UIHelpers.InitCombox(postResizeMode, 0);
UIHelpers.FillEnumComboBox(postResizeFilter, typeof(Upscale.Filter), 0);
// Batch Upscale
UIHelpers.InitCombox(batchOutMode, 0);
UIHelpers.InitCombox(preprocessMode, 0);
await CheckInstallation();
EmbeddedPython.Init();
EsrganData.CheckModelDir();
EsrganData.ReloadModelList();
NvApi.Init();
if (OSUtils.IsUserAdministrator())
{
Program.ShowMessage("Cupscale is running as administrator.\nThis will break Drag-n-Drop functionality.", "Warning");
}
}
private async void Form1_Load(object sender, EventArgs e)
{
CheckForIllegalCrossThreadCalls = false;
AutoScaleMode = AutoScaleMode.None;
StartupChecks.CheckOs();
// Main Tab
UiUtils.InitCombox(interpFactorCombox, 0);
UiUtils.InitCombox(outSpeedCombox, 0);
UiUtils.InitCombox(outModeCombox, 0);
UiUtils.InitCombox(aiModel, 2);
// Video Utils
UiUtils.InitCombox(trimCombox, 0);
Program.mainForm = this;
Logger.textbox = logBox;
NvApi.Init();
InitAis();
InterpolationProgress.preview = previewPicturebox;
RemovePreviewIfDisabled();
UpdateStepByStepControls();
Initialized();
HandleArgs();
Text = $"Flowframes";
if (Program.args.Contains("show-model-downloader"))
{
new ModelDownloadForm().ShowDialog();
}
}
private void SoftwareControlValueChanged(IControl control)
{
NvApi.NvGPUCoolerLevels coolerLevels = new() { Version = NvApi.GPU_COOLER_LEVELS_VER, Levels = new NvApi.NvLevel[NvApi.MAX_COOLER_PER_GPU] };
coolerLevels.Levels[0].Level = (int)control.SoftwareValue;
coolerLevels.Levels[0].Policy = 1;
NvApi.NvAPI_GPU_SetCoolerLevels(_handle, 0, ref coolerLevels);
}
private void Form1_Load(object sender, EventArgs e)
{
CheckForIllegalCrossThreadCalls = false;
AutoScaleMode = AutoScaleMode.None;
if (!File.Exists(Paths.GetVerPath()) && Paths.GetExeDir().ToLower().Contains("temp"))
{
MessageBox.Show("You seem to be running Flowframes out of an archive.\nPlease extract the whole archive first!", "Error");
IOUtils.TryDeleteIfExists(Paths.GetDataPath());
Application.Exit();
}
Text = $"Flowframes {Updater.GetInstalledVer()}";
// Main Tab
UIUtils.InitCombox(interpFactorCombox, 0);
UIUtils.InitCombox(outModeCombox, 0);
UIUtils.InitCombox(aiModel, 2);
// Video Utils
UIUtils.InitCombox(trimCombox, 0);
Program.mainForm = this;
Logger.textbox = logBox;
NvApi.Init();
InitAis();
InterpolateUtils.preview = previewPicturebox;
UpdateStepByStepControls();
Initialized();
Checks();
HandleArguments();
}
public override bool InitializeHardware()
{
Logger.Debug("Initializing hardware ...");
if (NvApi.NvApiEnumPhysicalGpUs == null || NvApi.NvApiGetPhysicalGpUsFromDisplay == null || NvApi.NvApiEnumNvidiaDisplayHandle == null)
{
Logger.Debug("Unable to init hardware, NvApiEnumPhysicalGpUs, NvApiEnumNvidiaDisplayHandle and NvApiGetPhysicalGpUsFromDisplay are null pointer");
return(false);
}
NvStatus status;
var handles = new NvPhysicalGpuHandle[NvApi.MaxPhysicalGpus];
if ((status = NvApi.NvApiEnumPhysicalGpUs(handles, out var gpuCount)) != NvStatus.Ok)
{
Logger.Error($"Unable to enumerate physical gpus, the API status is: {status}");
return(false);
}
for (var gpuIndex = 0; gpuIndex < gpuCount; gpuIndex++)
{
var ngpu = new NVidiaGpu(gpuIndex, handles[gpuIndex]);
Logger.Debug($"Adding GPU {ngpu}");
ngpu.InitializeSensors();
Hardware.Add(ngpu);
}
return(true);
}
private void SetDefaultFanSpeed()
{
NvApi.NvGPUCoolerLevels coolerLevels = new NvApi.NvGPUCoolerLevels {
Version = NvApi.GPU_COOLER_LEVELS_VER, Levels = new NvApi.NvLevel[NvApi.MAX_COOLER_PER_GPU]
};
coolerLevels.Levels[0].Policy = 0x20;
NvApi.NvAPI_GPU_SetCoolerLevels(_handle, 0, ref coolerLevels);
}
/// <summary>
///
/// </summary>
/// <param name="parameters"></param>
public GenericDisplay(Game game, GraphicsDevice device, GameParameters parameters) : base(game, device, parameters)
{
window = CreateTouchForm(parameters, null);
try {
NvApi.Initialize();
NvApi.Stereo_Disable();
}
catch (NVException nvex) {
Log.Debug(nvex.Message);
}
//var deviceFlags = DeviceCreationFlags.SingleThreaded;
var deviceFlags = DeviceCreationFlags.None;
deviceFlags |= parameters.UseDebugDevice ? DeviceCreationFlags.Debug : DeviceCreationFlags.None;
deviceFlags |= parameters.SupportVideo ? DeviceCreationFlags.BgraSupport | (DeviceCreationFlags)2048 : DeviceCreationFlags.None;
var driverType = DriverType.Hardware;
var featureLevel = HardwareProfileChecker.GetFeatureLevel(parameters.GraphicsProfile);
swapChainDesc = new SwapChainDescription()
{
BufferCount = 2,
ModeDescription = new ModeDescription(parameters.Width, parameters.Height, new Rational(60, 1), Format.R8G8B8A8_UNorm),
IsWindowed = true,
OutputHandle = window.Handle,
SampleDescription = new SampleDescription(parameters.MsaaLevel, 0),
SwapEffect = SwapEffect.Discard,
Usage = Usage.RenderTargetOutput,
Flags = SwapChainFlags.None,
};
D3D.Device.CreateWithSwapChain(driverType, deviceFlags, new[] { featureLevel }, swapChainDesc, out d3dDevice, out swapChain);
//Log.Message(" compute shaders : {0}", d3dDevice.CheckFeatureSupport(Feature.ComputeShaders) );
//Log.Message(" shader doubles : {0}", d3dDevice.CheckFeatureSupport(Feature.ShaderDoubles) );
//Log.Message(" threading : {0}", d3dDevice.CheckFeatureSupport(Feature.Threading) );
bool driverConcurrentCreates;
bool driverCommandLists;
d3dDevice.CheckThreadingSupport(out driverConcurrentCreates, out driverCommandLists);
d3dDevice.GetCounterCapabilities();
Log.Message(" Concurrent Creates : {0}", driverConcurrentCreates);
Log.Message(" Command Lists : {0}", driverCommandLists);
var factory = swapChain.GetParent <Factory>();
factory.MakeWindowAssociation(window.Handle, WindowAssociationFlags.IgnoreAll);
clientWidth = window.ClientSize.Width;
clientHeight = window.ClientSize.Height;
}
private async void MainForm_Load(object sender, EventArgs e)
{
if (!Directory.Exists(Path.Combine(Paths.GetExeDir(), "runtimes")) && Paths.GetExeDir().ToLower().Contains("temp"))
{
MessageBox.Show("You seem to be running Flowframes out of an archive.\nPlease extract the whole archive first!", "Error");
IOUtils.TryDeleteIfExists(Paths.GetDataPath());
Application.Exit();
}
// Left Panel
UIHelpers.InitCombox(prevClipboardTypeCombox, 0);
UIHelpers.InitCombox(preResizeScale, 1);
UIHelpers.InitCombox(preResizeMode, 0);
UIHelpers.FillEnumComboBox(preResizeFilter, typeof(Upscale.Filter), 0);
// Right Panel
UIHelpers.InitCombox(prevOverwriteCombox, 0);
UIHelpers.InitCombox(imageOutputFormat, 0);
UIHelpers.FillEnumComboBox(imageOutputFormat, typeof(Upscale.ImgExportMode));
UIHelpers.FillEnumComboBox(videoOutputFormat, typeof(Upscale.VidExportMode));
UIHelpers.InitCombox(postResizeScale, 1);
UIHelpers.InitCombox(postResizeMode, 0);
UIHelpers.FillEnumComboBox(postResizeFilter, typeof(Upscale.Filter), 0);
// Batch Upscale
UIHelpers.InitCombox(batchOutMode, 0);
UIHelpers.InitCombox(preprocessMode, 0);
UIHelpers.InitCombox(batchCacheSplitDepth, 0);
// Video Upscale
UIHelpers.InitCombox(videoPreprocessMode, 1);
await CheckInstallation();
await EmbeddedPython.Init();
EsrganData.CheckModelDir();
EsrganData.ReloadModelList();
NvApi.Init();
if (OSUtils.IsUserAdministrator())
{
Program.ShowMessage("Cupscale is running as administrator.\nThis will break Drag-n-Drop functionality.", "Warning");
}
LoadEsrganOptions();
flowPanelLeft.AutoScroll = false;
flowPanelLeft.HorizontalScroll.Maximum = 0;
flowPanelLeft.VerticalScroll.Visible = false;
flowPanelLeft.AutoScroll = true;
flowPanelRight.AutoScroll = false;
flowPanelRight.HorizontalScroll.Maximum = 0;
flowPanelRight.VerticalScroll.Visible = false;
flowPanelRight.AutoScroll = true;
initialized = true;
BusyCheckLoop();
}
private static string GetName(NvApi.NvPhysicalGpuHandle handle)
{
if (NvApi.NvAPI_GPU_GetFullName(handle, out string gpuName) == NvApi.NvStatus.OK)
{
return("NVIDIA " + gpuName.Trim());
}
return("NVIDIA");
}
private NvApi.NvGPUCoolerSettings GetCoolerSettings()
{
NvApi.NvGPUCoolerSettings settings = new() { Version = NvApi.GPU_COOLER_SETTINGS_VER, Cooler = new NvApi.NvCooler[NvApi.MAX_COOLER_PER_GPU] };
if (!(NvApi.NvAPI_GPU_GetCoolerSettings != null && NvApi.NvAPI_GPU_GetCoolerSettings(_handle, 0, ref settings) == NvApi.NvStatus.OK))
{
settings.Count = 0;
}
return(settings);
}
private uint[] GetClocks()
{
NvApi.NvClocks allClocks = new() { Version = NvApi.GPU_CLOCKS_VER, Clock = new uint[NvApi.MAX_CLOCKS_PER_GPU] };
if (NvApi.NvAPI_GPU_GetAllClocks != null && NvApi.NvAPI_GPU_GetAllClocks(_handle, ref allClocks) == NvApi.NvStatus.OK)
{
return(allClocks.Clock);
}
return(null);
}
public NvMemoryInfo?ObrainMemoryInfo()
{
var memoryInfo = new NvMemoryInfo {
Version = NvApi.GpuMemoryInfoVer
};
if (NvApi.GetMemoryInfo(Gpu.AdapterHandle, ref memoryInfo) == NvStatus.Ok)
{
return(memoryInfo);
}
return(null);
}
private NvApi.NvFanCoolersStatus GetFanCoolersStatus()
{
var coolers = new NvApi.NvFanCoolersStatus {
Version = NvApi.GPU_FAN_COOLERS_STATUS_VER, Items = new NvApi.NvFanCoolersStatusItem[NvApi.MAX_FAN_COOLERS_STATUS_ITEMS]
};
if (!(NvApi.NvAPI_GPU_ClientFanCoolersGetStatus != null && NvApi.NvAPI_GPU_ClientFanCoolersGetStatus(_handle, ref coolers) == NvApi.NvStatus.OK))
{
coolers.Count = 0;
}
return(coolers);
}
/// <summary>
///
/// </summary>
/// <param name="disposing"></param>
protected override void Dispose(bool disposing)
{
if (disposing)
{
NvApi.Stereo_Deactivate(stereoHandle);
NvApi.Stereo_DestroyHandle(stereoHandle);
SafeDispose(ref backbufferColor);
SafeDispose(ref backbufferDepth);
SafeDispose(ref swapChain);
}
base.Dispose(disposing);
}
private async void MainForm_Load(object sender, EventArgs e)
{
// Left Panel
UIHelpers.InitCombox(prevClipboardTypeCombox, 0);
UIHelpers.InitCombox(preResizeScale, 1);
UIHelpers.InitCombox(preResizeMode, 0);
UIHelpers.FillEnumComboBox(preResizeFilter, typeof(Upscale.Filter), 0);
// Right Panel
UIHelpers.InitCombox(prevOverwriteCombox, 0);
UIHelpers.InitCombox(imageOutputFormat, 0);
UIHelpers.FillEnumComboBox(imageOutputFormat, typeof(Upscale.ImgExportMode));
UIHelpers.FillEnumComboBox(videoOutputFormat, typeof(Upscale.VidExportMode));
UIHelpers.InitCombox(postResizeScale, 1);
UIHelpers.InitCombox(postResizeMode, 0);
UIHelpers.FillEnumComboBox(postResizeFilter, typeof(Upscale.Filter), 0);
// Batch Upscale
UIHelpers.InitCombox(batchOutMode, 0);
UIHelpers.InitCombox(preprocessMode, 0);
UIHelpers.InitCombox(batchCacheSplitDepth, 0);
// Video Upscale
UIHelpers.InitCombox(videoPreprocessMode, 1);
await CheckInstallation();
await EmbeddedPython.Init();
EsrganData.CheckModelDir();
EsrganData.ReloadModelList();
NvApi.Init();
if (OSUtils.IsUserAdministrator())
{
Program.ShowMessage("Cupscale is running as administrator.\nThis will break Drag-n-Drop functionality.", "Warning");
}
LoadEsrganOptions();
flowPanelLeft.AutoScroll = false;
flowPanelLeft.HorizontalScroll.Maximum = 0;
flowPanelLeft.VerticalScroll.Visible = false;
flowPanelLeft.AutoScroll = true;
flowPanelRight.AutoScroll = false;
flowPanelRight.HorizontalScroll.Maximum = 0;
flowPanelRight.VerticalScroll.Visible = false;
flowPanelRight.AutoScroll = true;
initialized = true;
BusyCheckLoop();
}
public NvPStates?ObtainPStates()
{
var states = new NvPStates {
Version = NvApi.GpuPstatesVer,
PStates = new NvPState[NvApi.MaxPstatesPerGpu]
};
if (NvApi.GetDynamicPStatesInfoEx == null || NvApi.GetDynamicPStatesInfoEx(Gpu.AdapterHandle, ref states) != NvStatus.Ok)
{
return(null);
}
return(states);
}
private NvApi.NvGPUThermalSettings GetThermalSettings()
{
NvApi.NvGPUThermalSettings settings = new NvApi.NvGPUThermalSettings
{
Version = NvApi.GPU_THERMAL_SETTINGS_VER, Count = NvApi.MAX_THERMAL_SENSORS_PER_GPU, Sensor = new NvApi.NvSensor[NvApi.MAX_THERMAL_SENSORS_PER_GPU]
};
if (!(NvApi.NvAPI_GPU_GetThermalSettings != null && NvApi.NvAPI_GPU_GetThermalSettings(_handle, (int)NvApi.NvThermalTarget.ALL, ref settings) == NvApi.NvStatus.OK))
{
settings.Count = 0;
}
return(settings);
}
private uint[] ObtainClocks()
{
if (NvApi.GetAllClocks == null)
{
return(null);
}
var allClocks = new NvClocks {
Version = NvApi.GpuClocksVer,
Clock = new uint[NvApi.MaxClocksPerGpu]
};
return(NvApi.GetAllClocks(Gpu.AdapterHandle, ref allClocks) == NvStatus.Ok ? allClocks.Clock : null);
}
private NvGpuThermalSettings ObtainThermalSettings()
{
var settings = new NvGpuThermalSettings {
Version = NvApi.GpuThermalSettingsVer,
Count = NvApi.MaxThermalSensorsPerGpu
};
settings.Sensor = new NvSensor[settings.Count];
if (NvApi.GetThermalSettings(Gpu.AdapterHandle, (int)NvThermalTarget.All, ref settings) != NvStatus.Ok)
{
settings.Count = 0;
}
return(settings);
}
private static string GetName(NvApi.NvPhysicalGpuHandle handle)
{
if (NvApi.NvAPI_GPU_GetFullName(handle, out string gpuName) == NvApi.NvStatus.OK)
{
gpuName = gpuName.Trim();
if (gpuName.StartsWith("NVIDIA", StringComparison.OrdinalIgnoreCase))
{
return(gpuName);
}
return("NVIDIA " + gpuName.Trim());
}
return("NVIDIA");
}
/// <summary>
///
/// </summary>
/// <param name="parameters"></param>
public StereoInterlacedDisplay(Game game, GraphicsDevice device, GraphicsParameters parameters) : base(game, device, parameters)
{
try {
NvApi.Initialize();
NvApi.Stereo_Disable();
}
catch (NVException nvex) {
Log.Debug(nvex.Message);
}
window = CreateForm(parameters, null, false);
var deviceFlags = DeviceCreationFlags.None;
deviceFlags |= parameters.UseDebugDevice ? DeviceCreationFlags.Debug : DeviceCreationFlags.None;
var driverType = DriverType.Hardware;
var featureLevel = HardwareProfileChecker.GetFeatureLevel(parameters.GraphicsProfile);
swapChainDesc = new SwapChainDescription()
{
BufferCount = 1,
ModeDescription = new ModeDescription(parameters.Width, parameters.Height, new Rational(60, 1), Format.R8G8B8A8_UNorm),
IsWindowed = true,
OutputHandle = window.Handle,
SampleDescription = new SampleDescription(1, 0),
SwapEffect = SwapEffect.Discard,
Usage = Usage.RenderTargetOutput,
Flags = SwapChainFlags.None,
};
D3D.Device.CreateWithSwapChain(driverType, deviceFlags, new[] { featureLevel }, swapChainDesc, out d3dDevice, out swapChain);
var factory = swapChain.GetParent <Factory>();
factory.MakeWindowAssociation(window.Handle, WindowAssociationFlags.IgnoreAll);
clientWidth = window.ClientSize.Width;
clientHeight = window.ClientSize.Height;
}
public override bool Open()
{
if (!NvApi.Initialize())
{
Logger.Error("NvAPI initialization failed");
return(false);
}
if (NvApi.ApiStatus == NvStatus.NvidiaDeviceNotFound)
{
Logger.Info("No nVidia devices present");
return(true);
}
if (NvApi.IsAvailable)
{
return(InitializeHardware());
}
return(false);
}
public NVidiaGpu(int adapterIndex, NvPhysicalGpuHandle handle)
{
AdapterHandle = handle;
_gpuIdentifer = new NVidiaGpuIdentifer(this);
GpuModelName = NvApi.NvApiGpuGetFullName(handle, out var gpuName) == NvStatus.Ok ? gpuName.Trim() : "Unknown";
if (NvApi.GetPciIdentifiers != null && NvApi.GetPciIdentifiers(AdapterHandle, out var deviceId, out var subSystemId, out var revisionId, out var extDeviceId) == NvStatus.Ok)
{
DeviceId = $"0x{deviceId:X}";
SubSystemId = $"0x{subSystemId:X}";
RevisionId = $"0x{revisionId:X}";
}
if (NvApi.GetBusSlotId != null && NvApi.GetBusId(AdapterHandle, out _busId) != NvStatus.Ok)
{
throw new Exception("Unable to obtain bus slot id");
}
GpuFullName = $"NVIDIA {GpuModelName}";
}
/// <summary>
/// Gets the tempature of the graphics card.
/// </summary>
/// <returns></returns>
public LuaResult GetGpuTemps()
{
switch (DebugSettings.GpuVendor)
{
case GpuVendor.Nvidia:
NvApi.ThermalSettings thermalSettings = new NvApi.ThermalSettings();
if (NvApi.GetThermalSettings(Renderer.Device.NativePointer, 0, ref thermalSettings) != 0)
{
throw new Exception("NvidiaControlPanel.GetThermalSettings() returned false.");
}
var sensor = thermalSettings.Sensors[0];
return(new LuaResult(sensor.CurrentTemp, sensor.DefaultMinTemp, sensor.DefaultMaxTemp));
case GpuVendor.AMD:
throw new NotImplementedException();
case GpuVendor.Intel:
throw new NotImplementedException();
default:
throw new NotSupportedException($"Tempature measurements are not supported for vendor {DebugSettings.GpuVendor}");
}
}
/// <summary>
///
/// </summary>
/// <param name="parameters"></param>
public NV3DVisionDisplay(Game game, GraphicsDevice device, GraphicsParameters parameters) : base(game, device, parameters)
{
Log.Message("Using NVidia 3D Vision");
//
// Init NV API and enable stereo :
//
NvApi.Initialize();
NvApi.Stereo_Enable();
NvApi.Stereo_SetDriverMode(NvStereoDriverMode.Direct);
//
// Create main window
//
window = CreateForm(parameters, null, false);
var deviceFlags = DeviceCreationFlags.None;
deviceFlags |= parameters.UseDebugDevice ? DeviceCreationFlags.Debug : DeviceCreationFlags.None;
var driverType = DriverType.Hardware;
var featureLevel = HardwareProfileChecker.GetFeatureLevel(parameters.GraphicsProfile);
swapChainDesc = new SwapChainDescription()
{
BufferCount = 1,
ModeDescription = new ModeDescription(parameters.Width, parameters.Height, new Rational(60, 1), Format.R8G8B8A8_UNorm),
IsWindowed = true,
OutputHandle = window.Handle,
SampleDescription = new SampleDescription(parameters.MsaaLevel, 0),
SwapEffect = SwapEffect.Discard,
Usage = Usage.RenderTargetOutput,
Flags = SwapChainFlags.None,
};
//
// Create device :
//
D3D.Device.CreateWithSwapChain(driverType, deviceFlags, new[] { featureLevel }, swapChainDesc, out d3dDevice, out swapChain);
var factory = swapChain.GetParent <Factory>();
factory.MakeWindowAssociation(window.Handle, WindowAssociationFlags.IgnoreAll);
clientWidth = window.ClientSize.Width;
clientHeight = window.ClientSize.Height;
//
// Setup 3DVision :
//
try {
stereoHandle = NvApi.Stereo_CreateHandleFromIUnknown(d3dDevice.NativePointer);
NvApi.Stereo_Activate(stereoHandle);
NvApi.Stereo_SetActiveEye(stereoHandle, NvStereoActiveEye.Mono);
} catch (NVException) {
SafeDispose(ref d3dDevice);
SafeDispose(ref swapChain);
throw;
}
}
public override string GetReport()
{
StringBuilder r = new StringBuilder();
r.AppendLine("Nvidia GPU");
r.AppendLine();
r.AppendFormat("Name: {0}{1}", _name, Environment.NewLine);
r.AppendFormat("Index: {0}{1}", _adapterIndex, Environment.NewLine);
if (_displayHandle.HasValue && NvApi.NvAPI_GetDisplayDriverVersion != null)
{
NvApi.NvDisplayDriverVersion driverVersion = new NvApi.NvDisplayDriverVersion {
Version = NvApi.DISPLAY_DRIVER_VERSION_VER
};
if (NvApi.NvAPI_GetDisplayDriverVersion(_displayHandle.Value, ref driverVersion) == NvApi.NvStatus.OK)
{
r.Append("Driver Version: ");
r.Append(driverVersion.DriverVersion / 100);
r.Append(".");
r.Append((driverVersion.DriverVersion % 100).ToString("00", CultureInfo.InvariantCulture));
r.AppendLine();
r.Append("Driver Branch: ");
r.AppendLine(driverVersion.BuildBranch);
}
}
r.AppendLine();
if (NvApi.NvAPI_GPU_GetPCIIdentifiers != null)
{
NvApi.NvStatus status = NvApi.NvAPI_GPU_GetPCIIdentifiers(_handle, out uint deviceId, out uint subSystemId, out uint revisionId, out uint extDeviceId);
if (status == NvApi.NvStatus.OK)
{
r.Append("DeviceID: 0x");
r.AppendLine(deviceId.ToString("X", CultureInfo.InvariantCulture));
r.Append("SubSystemID: 0x");
r.AppendLine(subSystemId.ToString("X", CultureInfo.InvariantCulture));
r.Append("RevisionID: 0x");
r.AppendLine(revisionId.ToString("X", CultureInfo.InvariantCulture));
r.Append("ExtDeviceID: 0x");
r.AppendLine(extDeviceId.ToString("X", CultureInfo.InvariantCulture));
r.AppendLine();
}
}
if (NvApi.NvAPI_GPU_GetThermalSettings != null)
{
NvApi.NvGPUThermalSettings settings = new NvApi.NvGPUThermalSettings
{
Version = NvApi.GPU_THERMAL_SETTINGS_VER, Count = NvApi.MAX_THERMAL_SENSORS_PER_GPU, Sensor = new NvApi.NvSensor[NvApi.MAX_THERMAL_SENSORS_PER_GPU]
};
NvApi.NvStatus status = NvApi.NvAPI_GPU_GetThermalSettings(_handle, (int)NvApi.NvThermalTarget.ALL, ref settings);
r.AppendLine("Thermal Settings");
r.AppendLine();
if (status == NvApi.NvStatus.OK)
{
for (int i = 0; i < settings.Count; i++)
{
r.AppendFormat(" Sensor[{0}].Controller: {1}{2}", i, settings.Sensor[i].Controller, Environment.NewLine);
r.AppendFormat(" Sensor[{0}].DefaultMinTemp: {1}{2}", i, settings.Sensor[i].DefaultMinTemp, Environment.NewLine);
r.AppendFormat(" Sensor[{0}].DefaultMaxTemp: {1}{2}", i, settings.Sensor[i].DefaultMaxTemp, Environment.NewLine);
r.AppendFormat(" Sensor[{0}].CurrentTemp: {1}{2}", i, settings.Sensor[i].CurrentTemp, Environment.NewLine);
r.AppendFormat(" Sensor[{0}].Target: {1}{2}", i, settings.Sensor[i].Target, Environment.NewLine);
}
}
else
{
r.Append(" Status: ");
r.AppendLine(status.ToString());
}
r.AppendLine();
}
if (NvApi.NvAPI_GPU_GetAllClocks != null)
{
NvApi.NvClocks allClocks = new NvApi.NvClocks {
Version = NvApi.GPU_CLOCKS_VER, Clock = new uint[NvApi.MAX_CLOCKS_PER_GPU]
};
NvApi.NvStatus status = NvApi.NvAPI_GPU_GetAllClocks(_handle, ref allClocks);
r.AppendLine("Clocks");
r.AppendLine();
if (status == NvApi.NvStatus.OK)
{
for (int i = 0; i < allClocks.Clock.Length; i++)
{
if (allClocks.Clock[i] > 0)
{
r.AppendFormat(" Clock[{0}]: {1}{2}", i, allClocks.Clock[i], Environment.NewLine);
}
}
}
else
{
r.Append(" Status: ");
r.AppendLine(status.ToString());
}
r.AppendLine();
}
if (NvApi.NvAPI_GPU_GetTachReading != null)
{
NvApi.NvStatus status = NvApi.NvAPI_GPU_GetTachReading(_handle, out int tachValue);
r.AppendLine("Tachometer");
r.AppendLine();
if (status == NvApi.NvStatus.OK)
{
r.AppendFormat(" Value: {0}{1}", tachValue, Environment.NewLine);
}
else
{
r.Append(" Status: ");
r.AppendLine(status.ToString());
}
r.AppendLine();
}
if (NvApi.NvAPI_GPU_GetPStates != null)
{
NvApi.NvPStates states = new NvApi.NvPStates {
Version = NvApi.GPU_PSTATES_VER, PStates = new NvApi.NvPState[NvApi.MAX_PSTATES_PER_GPU]
};
NvApi.NvStatus status = NvApi.NvAPI_GPU_GetPStates(_handle, ref states);
r.AppendLine("P-States");
r.AppendLine();
if (status == NvApi.NvStatus.OK)
{
for (int i = 0; i < states.PStates.Length; i++)
{
if (states.PStates[i].Present)
{
r.AppendFormat(" Percentage[{0}]: {1}{2}", i, states.PStates[i].Percentage, Environment.NewLine);
}
}
}
else
{
r.Append(" Status: ");
r.AppendLine(status.ToString());
}
r.AppendLine();
}
if (NvApi.NvAPI_GPU_GetUsages != null)
{
NvApi.NvUsages usages = new NvApi.NvUsages {
Version = NvApi.GPU_USAGES_VER, Usage = new uint[NvApi.MAX_USAGES_PER_GPU]
};
NvApi.NvStatus status = NvApi.NvAPI_GPU_GetUsages(_handle, ref usages);
r.AppendLine("Usages");
r.AppendLine();
if (status == NvApi.NvStatus.OK)
{
for (int i = 0; i < usages.Usage.Length; i++)
{
if (usages.Usage[i] > 0)
{
r.AppendFormat(" Usage[{0}]: {1}{2}", i, usages.Usage[i], Environment.NewLine);
}
}
}
else
{
r.Append(" Status: ");
r.AppendLine(status.ToString());
}
r.AppendLine();
}
if (NvApi.NvAPI_GPU_GetCoolerSettings != null)
{
NvApi.NvGPUCoolerSettings settings = new NvApi.NvGPUCoolerSettings {
Version = NvApi.GPU_COOLER_SETTINGS_VER, Cooler = new NvApi.NvCooler[NvApi.MAX_COOLER_PER_GPU]
};
NvApi.NvStatus status = NvApi.NvAPI_GPU_GetCoolerSettings(_handle, 0, ref settings);
r.AppendLine("Cooler Settings");
r.AppendLine();
if (status == NvApi.NvStatus.OK)
{
for (int i = 0; i < settings.Count; i++)
{
r.AppendFormat(" Cooler[{0}].Type: {1}{2}", i, settings.Cooler[i].Type, Environment.NewLine);
r.AppendFormat(" Cooler[{0}].Controller: {1}{2}", i, settings.Cooler[i].Controller, Environment.NewLine);
r.AppendFormat(" Cooler[{0}].DefaultMin: {1}{2}", i, settings.Cooler[i].DefaultMin, Environment.NewLine);
r.AppendFormat(" Cooler[{0}].DefaultMax: {1}{2}", i, settings.Cooler[i].DefaultMax, Environment.NewLine);
r.AppendFormat(" Cooler[{0}].CurrentMin: {1}{2}", i, settings.Cooler[i].CurrentMin, Environment.NewLine);
r.AppendFormat(" Cooler[{0}].CurrentMax: {1}{2}", i, settings.Cooler[i].CurrentMax, Environment.NewLine);
r.AppendFormat(" Cooler[{0}].CurrentLevel: {1}{2}", i, settings.Cooler[i].CurrentLevel, Environment.NewLine);
r.AppendFormat(" Cooler[{0}].DefaultPolicy: {1}{2}", i, settings.Cooler[i].DefaultPolicy, Environment.NewLine);
r.AppendFormat(" Cooler[{0}].CurrentPolicy: {1}{2}", i, settings.Cooler[i].CurrentPolicy, Environment.NewLine);
r.AppendFormat(" Cooler[{0}].Target: {1}{2}", i, settings.Cooler[i].Target, Environment.NewLine);
r.AppendFormat(" Cooler[{0}].ControlType: {1}{2}", i, settings.Cooler[i].ControlType, Environment.NewLine);
r.AppendFormat(" Cooler[{0}].Active: {1}{2}", i, settings.Cooler[i].Active, Environment.NewLine);
}
}
else
{
r.Append(" Status: ");
r.AppendLine(status.ToString());
}
r.AppendLine();
}
if (NvApi.NvAPI_GPU_ClientFanCoolersGetStatus != null)
{
var coolers = new NvApi.NvFanCoolersStatus
{
Version = NvApi.GPU_FAN_COOLERS_STATUS_VER,
Items = new NvApi.NvFanCoolersStatusItem[NvApi.MAX_FAN_COOLERS_STATUS_ITEMS]
};
NvApi.NvStatus status = NvApi.NvAPI_GPU_ClientFanCoolersGetStatus(_handle, ref coolers);
r.AppendLine("Fan Coolers Status");
r.AppendLine();
if (status == NvApi.NvStatus.OK)
{
for (int i = 0; i < coolers.Count; i++)
{
r.AppendFormat(" Items[{0}].Type: {1}{2}", i,
coolers.Items[i].Type, Environment.NewLine);
r.AppendFormat(" Items[{0}].CurrentRpm: {1}{2}", i,
coolers.Items[i].CurrentRpm, Environment.NewLine);
r.AppendFormat(" Items[{0}].CurrentMinLevel: {1}{2}", i,
coolers.Items[i].CurrentMinLevel, Environment.NewLine);
r.AppendFormat(" Items[{0}].CurrentMaxLevel: {1}{2}", i,
coolers.Items[i].CurrentMaxLevel, Environment.NewLine);
r.AppendFormat(" Items[{0}].CurrentLevel: {1}{2}", i,
coolers.Items[i].CurrentLevel, Environment.NewLine);
}
}
else
{
r.Append(" Status: ");
r.AppendLine(status.ToString());
}
r.AppendLine();
}
if (NvApi.NvAPI_GPU_GetMemoryInfo != null && _displayHandle.HasValue)
{
NvApi.NvMemoryInfo memoryInfo = new NvApi.NvMemoryInfo {
Version = NvApi.GPU_MEMORY_INFO_VER, Values = new uint[NvApi.MAX_MEMORY_VALUES_PER_GPU]
};
NvApi.NvStatus status = NvApi.NvAPI_GPU_GetMemoryInfo(_displayHandle.Value, ref memoryInfo);
r.AppendLine("Memory Info");
r.AppendLine();
if (status == NvApi.NvStatus.OK)
{
for (int i = 0; i < memoryInfo.Values.Length; i++)
{
r.AppendFormat(" Value[{0}]: {1}{2}", i, memoryInfo.Values[i], Environment.NewLine);
}
}
else
{
r.Append(" Status: ");
r.AppendLine(status.ToString());
}
r.AppendLine();
}
return(r.ToString());
}
public NvidiaGpu(int adapterIndex, NvApi.NvPhysicalGpuHandle handle, NvApi.NvDisplayHandle?displayHandle, ISettings settings)
: base(GetName(handle), new Identifier("gpu", adapterIndex.ToString(CultureInfo.InvariantCulture)), settings)
{
_adapterIndex = adapterIndex;
_handle = handle;
_displayHandle = displayHandle;
bool hasPciBusId = NvApi.NvAPI_GPU_GetBusId(handle, out uint busId) == NvApi.NvStatus.OK;
NvApi.NvGPUThermalSettings thermalSettings = GetThermalSettings();
_temperatures = new Sensor[thermalSettings.Count];
for (int i = 0; i < _temperatures.Length; i++)
{
NvApi.NvSensor sensor = thermalSettings.Sensor[i];
string name;
switch (sensor.Target)
{
case NvApi.NvThermalTarget.BOARD:
name = "GPU Board";
break;
case NvApi.NvThermalTarget.GPU:
name = "GPU Core";
break;
case NvApi.NvThermalTarget.MEMORY:
name = "GPU Memory";
break;
case NvApi.NvThermalTarget.POWER_SUPPLY:
name = "GPU Power Supply";
break;
case NvApi.NvThermalTarget.UNKNOWN:
name = "GPU Unknown";
break;
default:
name = "GPU";
break;
}
_temperatures[i] = new Sensor(name, i, SensorType.Temperature, this, new ParameterDescription[0], settings);
ActivateSensor(_temperatures[i]);
}
if (NvApi.NvAPI_GPU_GetTachReading != null && NvApi.NvAPI_GPU_GetTachReading(handle, out _) == NvApi.NvStatus.OK)
{
_fan = new Sensor("GPU", 0, SensorType.Fan, this, settings);
}
else if (NvApi.NvAPI_GPU_ClientFanCoolersGetStatus != null && GetCoolerSettings().Count > 0)
{
_fan = new Sensor("GPU", 0, SensorType.Fan, this, settings);
}
_clocks = new Sensor[3];
_clocks[0] = new Sensor("GPU Core", 0, SensorType.Clock, this, settings);
_clocks[1] = new Sensor("GPU Memory", 1, SensorType.Clock, this, settings);
_clocks[2] = new Sensor("GPU Shader", 2, SensorType.Clock, this, settings);
for (int i = 0; i < _clocks.Length; i++)
{
ActivateSensor(_clocks[i]);
}
_loads = new Sensor[4];
_loads[0] = new Sensor("GPU Core", 0, SensorType.Load, this, settings);
_loads[1] = new Sensor("GPU Memory Controller", 1, SensorType.Load, this, settings);
_loads[2] = new Sensor("GPU Video Engine", 2, SensorType.Load, this, settings);
_loads[3] = new Sensor("GPU Bus", 4, SensorType.Load, this, settings);
_memoryLoad = new Sensor("GPU Memory", 3, SensorType.Load, this, settings);
_memoryFree = new Sensor("GPU Memory Free", 1, SensorType.SmallData, this, settings);
_memoryUsed = new Sensor("GPU Memory Used", 2, SensorType.SmallData, this, settings);
_memoryAvail = new Sensor("GPU Memory Total", 3, SensorType.SmallData, this, settings);
_control = new Sensor("GPU Fan", 0, SensorType.Control, this, settings);
NvApi.NvGPUCoolerSettings coolerSettings = GetCoolerSettings();
if (coolerSettings.Count > 0)
{
_fanControl = new Control(_control, settings, coolerSettings.Cooler[0].DefaultMin, coolerSettings.Cooler[0].DefaultMax);
_fanControl.ControlModeChanged += ControlModeChanged;
_fanControl.SoftwareControlValueChanged += SoftwareControlValueChanged;
ControlModeChanged(_fanControl);
_control.Control = _fanControl;
}
if (NvidiaML.IsAvailable)
{
if (hasPciBusId)
{
_nvmlDevice = NvidiaML.NvmlDeviceGetHandleByPciBusId($" 0000:{busId:X2}:00.0") ?? NvidiaML.NvmlDeviceGetHandleByIndex(_adapterIndex);
}
else
{
_nvmlDevice = NvidiaML.NvmlDeviceGetHandleByIndex(_adapterIndex);
}
if (_nvmlDevice.HasValue)
{
_powerUsage = new Sensor("GPU Package", 0, SensorType.Power, this, settings);
_pcieThroughputRx = new Sensor("GPU PCIe Rx", 0, SensorType.Throughput, this, settings);
_pcieThroughputTx = new Sensor("GPU PCIe Tx", 1, SensorType.Throughput, this, settings);
}
}
Update();
}
public override void Update()
{
NvApi.NvGPUThermalSettings settings = GetThermalSettings();
foreach (Sensor sensor in _temperatures)
{
sensor.Value = settings.Sensor[sensor.Index].CurrentTemp;
}
bool readTach = false;
if (_fan != null)
{
if (NvApi.NvAPI_GPU_GetTachReading(_handle, out int value) == NvApi.NvStatus.OK)
{
_fan.Value = value;
ActivateSensor(_fan);
readTach = true;
}
}
uint[] values = GetClocks();
if (values != null)
{
_clocks[1].Value = 0.001f * values[8];
if (values[30] != 0)
{
_clocks[0].Value = 0.0005f * values[30];
_clocks[2].Value = 0.001f * values[30];
}
else
{
_clocks[0].Value = 0.001f * values[0];
_clocks[2].Value = 0.001f * values[14];
}
}
NvApi.NvPStates states = new NvApi.NvPStates {
Version = NvApi.GPU_PSTATES_VER, PStates = new NvApi.NvPState[NvApi.MAX_PSTATES_PER_GPU]
};
if (NvApi.NvAPI_GPU_GetPStates != null && NvApi.NvAPI_GPU_GetPStates(_handle, ref states) == NvApi.NvStatus.OK)
{
for (int i = 0; i < _loads.Length; i++)
{
if (states.PStates[i].Present)
{
_loads[i].Value = states.PStates[i].Percentage;
ActivateSensor(_loads[i]);
}
}
}
else
{
NvApi.NvUsages usages = new NvApi.NvUsages {
Version = NvApi.GPU_USAGES_VER, Usage = new uint[NvApi.MAX_USAGES_PER_GPU]
};
if (NvApi.NvAPI_GPU_GetUsages != null && NvApi.NvAPI_GPU_GetUsages(_handle, ref usages) == NvApi.NvStatus.OK)
{
_loads[0].Value = usages.Usage[2];
_loads[1].Value = usages.Usage[6];
_loads[2].Value = usages.Usage[10];
for (int i = 0; i < 3; i++)
{
ActivateSensor(_loads[i]);
}
}
}
bool readCoolerSettings = false;
NvApi.NvGPUCoolerSettings coolerSettings = GetCoolerSettings();
if (coolerSettings.Count > 0)
{
_control.Value = coolerSettings.Cooler[0].CurrentLevel;
ActivateSensor(_control);
readCoolerSettings = true;
}
if (!readTach || !readCoolerSettings)
{
NvApi.NvFanCoolersStatus coolersStatus = GetFanCoolersStatus();
if (coolersStatus.Count > 0)
{
if (!readCoolerSettings)
{
_control.Value = coolersStatus.Items[0].CurrentLevel;
ActivateSensor(_control);
}
if (!readTach && _fan != null)
{
_fan.Value = coolersStatus.Items[0].CurrentRpm;
ActivateSensor(_fan);
}
}
}
NvApi.NvMemoryInfo memoryInfo = new NvApi.NvMemoryInfo {
Version = NvApi.GPU_MEMORY_INFO_VER, Values = new uint[NvApi.MAX_MEMORY_VALUES_PER_GPU]
};
if (NvApi.NvAPI_GPU_GetMemoryInfo != null && _displayHandle.HasValue && NvApi.NvAPI_GPU_GetMemoryInfo(_displayHandle.Value, ref memoryInfo) == NvApi.NvStatus.OK)
{
uint totalMemory = memoryInfo.Values[0];
uint freeMemory = memoryInfo.Values[4];
float usedMemory = Math.Max(totalMemory - freeMemory, 0);
_memoryFree.Value = (float)freeMemory / 1024;
_memoryAvail.Value = (float)totalMemory / 1024;
_memoryUsed.Value = usedMemory / 1024;
_memoryLoad.Value = 100f * usedMemory / totalMemory;
ActivateSensor(_memoryAvail);
ActivateSensor(_memoryUsed);
ActivateSensor(_memoryFree);
ActivateSensor(_memoryLoad);
}
if (NvidiaML.IsAvailable && _nvmlDevice.HasValue)
{
int?result = NvidiaML.NvmlDeviceGetPowerUsage(_nvmlDevice.Value);
if (result.HasValue)
{
_powerUsage.Value = (float)result.Value / 1000;
ActivateSensor(_powerUsage);
}
// In MB/s, throughput sensors are passed as in KB/s.
uint?rx = NvidiaML.NvmlDeviceGetPcieThroughput(_nvmlDevice.Value, NvidiaML.NvmlPcieUtilCounter.RxBytes);
if (rx.HasValue)
{
_pcieThroughputRx.Value = rx * 1024;
ActivateSensor(_pcieThroughputRx);
}
uint?tx = NvidiaML.NvmlDeviceGetPcieThroughput(_nvmlDevice.Value, NvidiaML.NvmlPcieUtilCounter.TxBytes);
if (tx.HasValue)
{
_pcieThroughputTx.Value = tx * 1024;
ActivateSensor(_pcieThroughputTx);
}
}
}
public override void Update()
{
NvApi.NvGPUThermalSettings settings = GetThermalSettings();
foreach (Sensor sensor in _temperatures)
{
sensor.Value = settings.Sensor[sensor.Index].CurrentTemp;
}
if (_fan != null)
{
NvApi.NvAPI_GPU_GetTachReading(_handle, out int value);
_fan.Value = value;
}
uint[] values = GetClocks();
if (values != null)
{
_clocks[1].Value = 0.001f * values[8];
if (values[30] != 0)
{
_clocks[0].Value = 0.0005f * values[30];
_clocks[2].Value = 0.001f * values[30];
}
else
{
_clocks[0].Value = 0.001f * values[0];
_clocks[2].Value = 0.001f * values[14];
}
}
NvApi.NvPStates states = new NvApi.NvPStates {
Version = NvApi.GPU_PSTATES_VER, PStates = new NvApi.NvPState[NvApi.MAX_PSTATES_PER_GPU]
};
if (NvApi.NvAPI_GPU_GetPStates != null && NvApi.NvAPI_GPU_GetPStates(_handle, ref states) == NvApi.NvStatus.OK)
{
for (int i = 0; i < 3; i++)
{
if (states.PStates[i].Present)
{
_loads[i].Value = states.PStates[i].Percentage;
ActivateSensor(_loads[i]);
}
}
}
else
{
NvApi.NvUsages usages = new NvApi.NvUsages {
Version = NvApi.GPU_USAGES_VER, Usage = new uint[NvApi.MAX_USAGES_PER_GPU]
};
if (NvApi.NvAPI_GPU_GetUsages != null && NvApi.NvAPI_GPU_GetUsages(_handle, ref usages) == NvApi.NvStatus.OK)
{
_loads[0].Value = usages.Usage[2];
_loads[1].Value = usages.Usage[6];
_loads[2].Value = usages.Usage[10];
for (int i = 0; i < 3; i++)
{
ActivateSensor(_loads[i]);
}
}
}
NvApi.NvGPUCoolerSettings coolerSettings = GetCoolerSettings();
if (coolerSettings.Count > 0)
{
_control.Value = coolerSettings.Cooler[0].CurrentLevel;
ActivateSensor(_control);
}
NvApi.NvMemoryInfo memoryInfo = new NvApi.NvMemoryInfo {
Version = NvApi.GPU_MEMORY_INFO_VER, Values = new uint[NvApi.MAX_MEMORY_VALUES_PER_GPU]
};
if (NvApi.NvAPI_GPU_GetMemoryInfo != null && _displayHandle.HasValue && NvApi.NvAPI_GPU_GetMemoryInfo(_displayHandle.Value, ref memoryInfo) == NvApi.NvStatus.OK)
{
uint totalMemory = memoryInfo.Values[0];
uint freeMemory = memoryInfo.Values[4];
float usedMemory = Math.Max(totalMemory - freeMemory, 0);
_memoryFree.Value = (float)freeMemory / 1024;
_memoryAvail.Value = (float)totalMemory / 1024;
_memoryUsed.Value = usedMemory / 1024;
_memoryLoad.Value = 100f * usedMemory / totalMemory;
ActivateSensor(_memoryAvail);
ActivateSensor(_memoryUsed);
ActivateSensor(_memoryFree);
ActivateSensor(_memoryLoad);
}
if (NvidiaML.IsAvailable && _nvmlDevice.HasValue)
{
var result = NvidiaML.NvmlDeviceGetPowerUsage(_nvmlDevice.Value);
if (result.HasValue)
{
_powerUsage.Value = (float)result.Value / 1000;
ActivateSensor(_powerUsage);
}
}
}
public async Task Refresh()
{
if (sw.ElapsedMilliseconds < 1000 && sw.ElapsedMilliseconds != 0)
{
Logger.Log($"[DepCheck] Skipping refresh - Only {sw.ElapsedMilliseconds}ms have passed since last refresh!");
return;
}
sw.Restart();
Logger.Log("[DepCheck] Refreshing...");
gpuAvail = false;
nvGpuAvail = false;
sysPyAvail = false;
embedPyAvail = false;
torchAvail = false;
cv2Avail = false;
SetChecking(gpu);
if (HasGpu())
{
SetGreen(gpu, "Available");
gpuAvail = true;
}
else
{
SetRed(gpu);
}
await Task.Delay(10);
SetChecking(nvGpu);
string nvGpuName = NvApi.GetGpuName().Replace("GeForce ", "");
Logger.Log("[DepCheck] GPU Name: " + nvGpuName);
if (!string.IsNullOrWhiteSpace(nvGpuName))
{
SetGreen(nvGpu, nvGpuName);
nvGpuAvail = true;
}
else
{
SetRed(nvGpu);
}
await Task.Delay(10);
SetChecking(sysPython);
string sysPyVer = GetSysPyVersion();
if (!string.IsNullOrWhiteSpace(sysPyVer) && !sysPyVer.ToLower().Contains("not found") && sysPyVer.Length <= 35)
{
SetGreen(sysPython, sysPyVer);
sysPyAvail = true;
}
else
{
SetRed(sysPython);
}
await Task.Delay(10);
SetChecking(embedPython);
string embedPyVer = GetEmbedPyVersion();
if (!string.IsNullOrWhiteSpace(embedPyVer) && !embedPyVer.ToLower().Contains("not found") && embedPyVer.Length <= 35)
{
SetGreen(embedPython, embedPyVer);
embedPyAvail = true;
}
else
{
SetRed(embedPython);
}
await Task.Delay(10);
SetChecking(torch);
string torchVer = GetPytorchVer();
if (!string.IsNullOrWhiteSpace(torchVer) && torchVer.Length <= 35)
{
SetGreen(torch, torchVer);
torchAvail = true;
}
else
{
SetRed(torch);
}
await Task.Delay(10);
SetChecking(cv2);
string cv2Ver = GetOpenCvVer();
if (!string.IsNullOrWhiteSpace(cv2Ver) && !cv2Ver.ToLower().Contains("ModuleNotFoundError") && cv2Ver.Length <= 35)
{
SetGreen(cv2, cv2Ver);
cv2Avail = true;
}
else
{
SetRed(cv2);
}
RefreshAvailOptions();
}
