/// <summary> /// This function retrieves the available driver memory footprint for the GPU associated with a display. /// </summary> /// <param name="displayHandle">Handle of the display for which the memory information of its GPU is to be extracted.</param> /// <returns>The memory footprint available in the driver.</returns> /// <exception cref="NVIDIANotSupportedException">This operation is not supported.</exception> /// <exception cref="NVIDIAApiException">Status.NvidiaDeviceNotFound: No NVIDIA GPU driving a display was found.</exception> /// <exception cref="Exception">A delegate callback throws an exception.</exception> public static IDisplayDriverMemoryInfo GetDisplayDriverMemoryInfo(DisplayHandle displayHandle) { var getMemoryInfo = DelegateFactory.GetDelegate <Delegates.Display.NvAPI_GetDisplayDriverMemoryInfo>(); foreach (var acceptType in getMemoryInfo.Accepts()) { var instance = acceptType.Instantiate <IDisplayDriverMemoryInfo>(); using (var displayDriverMemoryInfo = ValueTypeReference.FromValueType(instance, acceptType)) { var status = getMemoryInfo(displayHandle, displayDriverMemoryInfo); if (status == Status.IncompatibleStructureVersion) { continue; } if (status != Status.Ok) { throw new NVIDIAApiException(status); } return(displayDriverMemoryInfo.ToValueType <IDisplayDriverMemoryInfo>(acceptType)); } } throw new NVIDIANotSupportedException("This operation is not supported."); }
/// <summary> /// This API lets caller enumerate all the supported NVIDIA display views - nView and Dualview modes. /// </summary> /// <param name="display"> /// NVIDIA Display selection. It can be DisplayHandle.DefaultHandle or a handle enumerated from /// DisplayApi.EnumNVidiaDisplayHandle(). /// </param> /// <returns>Array of supported views.</returns> /// <exception cref="NVIDIANotSupportedException">This operation is not supported.</exception> /// <exception cref="NVIDIAApiException">Status.Error: Miscellaneous error occurred</exception> /// <exception cref="NVIDIAApiException">Status.InvalidArgument: Invalid input parameter.</exception> public static TargetViewMode[] GetSupportedViews(DisplayHandle display) { var getSupportedViews = DelegateFactory.Get <Delegates.Display.NvAPI_GetSupportedViews>(); uint allAvailable = 0; var status = getSupportedViews(display, ValueTypeArray.Null, ref allAvailable); if (status != Status.Ok) { throw new NVIDIAApiException(status); } if (allAvailable == 0) { return(new TargetViewMode[0]); } if (!getSupportedViews.Accepts().Contains(typeof(TargetViewMode))) { throw new NVIDIANotSupportedException("This operation is not supported."); } using ( var viewModes = ValueTypeArray.FromArray(TargetViewMode.Standard.Repeat((int)allAvailable).Cast <object>(), typeof(TargetViewMode).GetEnumUnderlyingType())) { status = getSupportedViews(display, viewModes, ref allAvailable); if (status != Status.Ok) { throw new NVIDIAApiException(status); } return(viewModes.ToArray <TargetViewMode>((int)allAvailable, typeof(TargetViewMode).GetEnumUnderlyingType())); } }
/// <summary> /// This function returns the handle of the NVIDIA display specified by the enum index (thisEnum). The client should keep enumerating until it returns NVAPI_END_ENUMERATION. /// Note: Display handles can get invalidated on a modeset, so the calling applications need to renum the handles after every modeset. /// </summary> /// <param name="thisEnum">The index of the NVIDIA display.</param> /// <param name="displayHandle">Pointer to the NVIDIA display handle.</param> /// <returns></returns> public static Status EnumNvidiaDisplayHandle(int thisEnum, ref DisplayHandle displayHandle) { Status status; if (EnumNvidiaDisplayHandleInternal != null) { status = EnumNvidiaDisplayHandleInternal(thisEnum, ref displayHandle); } else { status = Status.NVAPI_FUNCTION_NOT_FOUND; } return status; }
/// <summary> /// This function returns the logical GPU handle associated with the specified display. /// At least one GPU must be present in the system and running an NVIDIA display driver. /// display can be DisplayHandle.DefaultHandle or a handle enumerated from EnumNVidiaDisplayHandle(). /// </summary> /// <param name="display">Display handle to get information about</param> /// <returns>Logical GPU handle associated with the specified display</returns> /// <exception cref="NVIDIAApiException">Status.InvalidArgument: display is not valid</exception> /// <exception cref="NVIDIAApiException">Status.NvidiaDeviceNotFound: No NVIDIA GPU driving a display was found</exception> public static LogicalGPUHandle GetLogicalGPUFromDisplay(DisplayHandle display) { var status = DelegateFactory.GetDelegate <Delegates.GPU.NvAPI_GetLogicalGPUFromDisplay>()(display, out var gpu); if (status != Status.Ok) { throw new NVIDIAApiException(status); } return(gpu); }
/// <summary> /// This function returns the handle of the NVIDIA display that is associated with the given display "name" (such as "\\.\DISPLAY1"). /// </summary> /// <param name="szDisplayName"></param> /// <param name="pNvDispHandle"></param> /// <returns></returns> public static Status GetAssociatedNvidiaDisplayHandle(string szDisplayName, ref DisplayHandle pNvDispHandle) { StringBuilder builder = new StringBuilder((int)NvShortStringMax); builder.Append(szDisplayName); Status status; if (GetAssociatedNvidiaDisplayHandleInternal != null) { status = GetAssociatedNvidiaDisplayHandleInternal(builder, ref pNvDispHandle); } else { status = Status.NVAPI_FUNCTION_NOT_FOUND; } szDisplayName = builder.ToString(); return status; }
/// <summary> /// For a given NVIDIA display handle, this function returns a string (such as "\\.\DISPLAY1") to identify the display. /// </summary> /// <param name="display">Handle of the associated display</param> /// <returns>Name of the display</returns> /// <exception cref="NVIDIAApiException">Status.InvalidArgument: Display handle is null.</exception> /// <exception cref="NVIDIAApiException">Status.NvidiaDeviceNotFound: No NVIDIA device maps to that display name.</exception> public static string GetAssociatedNvidiaDisplayName(DisplayHandle display) { var getAssociatedNvidiaDisplayName = DelegateFactory.Get <Delegates.Display.NvAPI_GetAssociatedNvidiaDisplayName>(); ShortString displayName; var status = getAssociatedNvidiaDisplayName(display, out displayName); if (status != Status.Ok) { throw new NVIDIAApiException(status); } return(displayName.Value); }
/// <summary> /// This function gets the active outputId associated with the display handle. /// </summary> /// <param name="display"> /// NVIDIA Display selection. It can be DisplayHandle.DefaultHandle or a handle enumerated from /// DisplayApi.EnumNVidiaDisplayHandle(). /// </param> /// <returns> /// The active display output ID associated with the selected display handle hNvDisplay. The outputid will have /// only one bit set. In the case of Clone or Span mode, this will indicate the display outputId of the primary display /// that the GPU is driving. /// </returns> /// <exception cref="NVIDIAApiException">Status.NvidiaDeviceNotFound: No NVIDIA GPU driving a display was found.</exception> /// <exception cref="NVIDIAApiException">Status.ExpectedDisplayHandle: display is not a valid display handle.</exception> public static OutputId GetAssociatedDisplayOutputId(DisplayHandle display) { var getAssociatedDisplayOutputId = DelegateFactory.Get <Delegates.Display.NvAPI_GetAssociatedDisplayOutputId>(); OutputId outputId; var status = getAssociatedDisplayOutputId(display, out outputId); if (status != Status.Ok) { throw new NVIDIAApiException(status); } return(outputId); }
/// <summary> /// Gets the build title of the Driver Settings Database for a display /// </summary> /// <param name="displayHandle">The display handle to get DRS build title.</param> /// <returns>The DRS build title.</returns> public static string GetDisplayDriverBuildTitle(DisplayHandle displayHandle) { var status = DelegateFactory.GetDelegate <Delegates.Display.NvAPI_GetDisplayDriverBuildTitle>()(displayHandle, out var name); if (status != Status.Ok) { throw new NVIDIAApiException(status); } return(name.Value); }
/// <summary> /// This function returns the handle of the NVIDIA display specified by the enum index (thisEnum). The client should keep enumerating until it returns NVAPI_END_ENUMERATION. /// Note: Display handles can get invalidated on a modeset, so the calling applications need to renum the handles after every modeset. /// </summary> /// <param name="thisEnum">The index of the NVIDIA display.</param> /// <param name="displayHandle">Pointer to the NVIDIA display handle.</param> /// <returns></returns> public static Status EnumNvidiaDisplayHandle(int thisEnum, ref DisplayHandle displayHandle) { Status status; if (EnumNvidiaDisplayHandleInternal != null) { status = EnumNvidiaDisplayHandleInternal(thisEnum, ref displayHandle); } else { status = Status.NVAPI_FUNCTION_NOT_FOUND; } return(status); }
/// <summary> /// This function returns an array of physical GPU handles associated with the specified display. /// At least one GPU must be present in the system and running an NVIDIA display driver. /// If the display corresponds to more than one physical GPU, the first GPU returned is the one with the attached /// active output. /// </summary> /// <param name="display">Display handle to get information about</param> /// <returns>An array of physical GPU handles</returns> /// <exception cref="NVIDIAApiException">Status.InvalidArgument: display is not valid</exception> /// <exception cref="NVIDIAApiException">Status.NvidiaDeviceNotFound: No NVIDIA GPU driving a display was found</exception> public static PhysicalGPUHandle[] GetPhysicalGPUsFromDisplay(DisplayHandle display) { var gpuList = typeof(PhysicalGPUHandle).Instantiate <PhysicalGPUHandle>().Repeat(PhysicalGPUHandle.MaxPhysicalGPUs); var status = DelegateFactory.GetDelegate <Delegates.GPU.NvAPI_GetPhysicalGPUsFromDisplay>()(display, gpuList, out var count); if (status != Status.Ok) { throw new NVIDIAApiException(status); } return(gpuList.Take((int)count).ToArray()); }
/// <summary> /// This function returns the handle of the NVIDIA display that is associated with the given display "name" (such as "\\.\DISPLAY1"). /// </summary> /// <param name="szDisplayName"></param> /// <param name="pNvDispHandle"></param> /// <returns></returns> public static Status GetAssociatedNvidiaDisplayHandle(string szDisplayName, ref DisplayHandle pNvDispHandle) { StringBuilder builder = new StringBuilder((int)NvShortStringMax); builder.Append(szDisplayName); Status status; if (GetAssociatedNvidiaDisplayHandleInternal != null) { status = GetAssociatedNvidiaDisplayHandleInternal(builder, ref pNvDispHandle); } else { status = Status.NVAPI_FUNCTION_NOT_FOUND; } szDisplayName = builder.ToString(); return(status); }
/// <summary> /// Creates a new Display /// </summary> /// <param name="handle">Handle of the display device</param> public Display(DisplayHandle handle) { Handle = handle; }
/// <summary> /// Creates a new instance of the class using a DisplayHandle /// </summary> /// <param name="displayHandle">The handle of the display.</param> public DVCInformation(DisplayHandle displayHandle) { _displayHandle = displayHandle; }