/***************************************************************************\ |* *| |* Copyright 2005-2010 NVIDIA Corporation. All rights reserved. *| |* *| |* NOTICE TO USER: *| |* *| |* This source code is subject to NVIDIA ownership rights under U.S. *| |* and international Copyright laws. Users and possessors of this *| |* source code are hereby granted a nonexclusive, royalty-free *| |* license to use this code in individual and commercial software. *| |* *| |* NVIDIA MAKES NO REPRESENTATION ABOUT THE SUITABILITY OF THIS SOURCE *| |* CODE FOR ANY PURPOSE. IT IS PROVIDED "AS IS" WITHOUT EXPRESS OR *| |* IMPLIED WARRANTY OF ANY KIND. NVIDIA DISCLAIMS ALL WARRANTIES WITH *| |* REGARD TO THIS SOURCE CODE, INCLUDING ALL IMPLIED WARRANTIES OF *| |* MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR *| |* PURPOSE. IN NO EVENT SHALL NVIDIA BE LIABLE FOR ANY SPECIAL, *| |* INDIRECT, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES *| |* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN *| |* AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING *| |* OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOURCE *| |* CODE. *| |* *| |* U.S. Government End Users. This source code is a "commercial item" *| |* as that term is defined at 48 C.F.R. 2.101 (OCT 1995), consisting *| |* of "commercial computer software" and "commercial computer software *| |* documentation" as such terms are used in 48 C.F.R. 12.212 (SEPT 1995) *| |* and is provided to the U.S. Government only as a commercial end item. *| |* Consistent with 48 C.F.R.12.212 and 48 C.F.R. 227.7202-1 through *| |* 227.7202-4 (JUNE 1995), all U.S. Government End Users acquire the *| |* source code with only those rights set forth herein. *| |* *| |* Any use of this source code in individual and commercial software must *| |* include, in the user documentation and internal comments to the code, *| |* the above Disclaimer and U.S. Government End Users Notice. *| |* *| |* *| \***************************************************************************/ /////////////////////////////////////////////////////////////////////////////// // // Date: Jun 5, 2011 // File: nvapi.h // // NvAPI provides an interface to NVIDIA devices. This file contains the // interface constants, structure definitions and function prototypes. // // Target Profile: developer // Target Platform: windows // /////////////////////////////////////////////////////////////////////////////// #pragma pack(push,8) // Make sure we have consistent structure packings #ifndef _WIN32 #define __cdecl #endif #define NVAPI_INTERFACE extern NvStatus __cdecl /* 64-bit types for compilers that support them, plus some obsolete variants */ typedef unsigned __int64 NvU64; /* 0 to 18446744073709551615 */ typedef signed int NvS32; /* -2147483648 to 2147483647 */ // mac os 32-bit still needs this typedef unsigned long NvU32; /* 0 to 4294967295 */ typedef signed short NvS16; typedef unsigned short NvU16; typedef unsigned char NvU8; typedef struct _NV_RECT { NvU32 left; NvU32 top; NvU32 right; NvU32 bottom; } NV_RECT; #define NV_DECLARE_HANDLE(name) struct name##__ { int unused; }; typedef struct name##__ *name //! \addtogroup nvapihandles //! NVAPI Handles - These handles are retrieved from various calls and passed in to others in NvAPI //! These are meant to be opaque types. Do not assume they correspond to indices, HDCs, //! display indexes or anything else. //! //! Most handles remain valid until a display re-configuration (display mode set) or GPU //! reconfiguration (going into or out of SLI modes) occurs. If NVAPI_HANDLE_INVALIDATED //! is received by an app, it should discard all handles, and re-enumerate them. //! @{ NV_DECLARE_HANDLE(NvDisplayHandle); //!< Display Device driven by NVIDIA GPU(s) (an attached display) NV_DECLARE_HANDLE(NvMonitorHandle); //!< Monitor handle NV_DECLARE_HANDLE(NvUnAttachedDisplayHandle); //!< Unattached Display Device driven by NVIDIA GPU(s) NV_DECLARE_HANDLE(NvLogicalGpuHandle); //!< One or more physical GPUs acting in concert (SLI) NV_DECLARE_HANDLE(NvPhysicalGpuHandle); //!< A single physical GPU NV_DECLARE_HANDLE(NvEventHandle); //!< A handle to an event registration instance NV_DECLARE_HANDLE(NvVisualComputingDeviceHandle); //!< A handle to a Visual Computing Device NV_DECLARE_HANDLE(NvHICHandle); //!< A handle to a Host Interface Card NV_DECLARE_HANDLE(NvGSyncDeviceHandle); //!< A handle to a G-Sync device NV_DECLARE_HANDLE(NvVioHandle); //!< A handle to an SDI device NV_DECLARE_HANDLE(NvTransitionHandle); //!< A handle to address a single transition request NV_DECLARE_HANDLE(NvAudioHandle); //!< NVIDIA HD Audio Device NV_DECLARE_HANDLE(Nv3DVPContextHandle); //!< A handle for a 3D Vision Pro (3DVP) context NV_DECLARE_HANDLE(Nv3DVPTransceiverHandle); //!< A handle for a 3DVP RF transceiver NV_DECLARE_HANDLE(Nv3DVPGlassesHandle); //!< A handle for a pair of 3DVP RF shutter glasses NV_DECLARE_HANDLE(NvSourceHandle); //!< Unique source handle on the system NV_DECLARE_HANDLE(NvTargetHandle); //!< Unique target handle on the system NV_DECLARE_HANDLE(NVDX_SwapChainHandle); //!< DirectX SwapChain objects static const NVDX_SwapChainHandle NVDX_SWAPCHAIN_NONE = 0; //! \ingroup nvapihandles #define NVAPI_DEFAULT_HANDLE 0 #define NV_BIT(x)(1 << (x)) //! \addtogroup nvapitypes #define NVAPI_GENERIC_STRING_MAX 4096 #define NVAPI_LONG_STRING_MAX 256 #define NVAPI_SHORT_STRING_MAX 64 typedef struct { NvS32 sX; NvS32 sY; NvS32 sWidth; NvS32 sHeight; } NvSBox; typedef struct { NvU32 data1; NvU16 data2; NvU16 data3; NvU8 data4[8]; } NvGUID, NvLUID; #define NVAPI_MAX_PHYSICAL_GPUS 64 #define NVAPI_PHYSICAL_GPUS 32 #define NVAPI_MAX_LOGICAL_GPUS 64 #define NVAPI_MAX_AVAILABLE_GPU_TOPOLOGIES 256 #define NVAPI_MAX_AVAILABLE_SLI_GROUPS 256 #define NVAPI_MAX_GPU_TOPOLOGIES NVAPI_MAX_PHYSICAL_GPUS #define NVAPI_MAX_GPU_PER_TOPOLOGY 8 #define NVAPI_MAX_DISPLAY_HEADS 2 #define NVAPI_ADVANCED_DISPLAY_HEADS 4 #define NVAPI_MAX_DISPLAYS NVAPI_PHYSICAL_GPUS * NVAPI_ADVANCED_DISPLAY_HEADS #define NVAPI_MAX_ACPI_IDS 16 #define NVAPI_MAX_VIEW_MODES 8 #define NV_MAX_HEADS 4 //!< Maximum heads, each with NVAPI_DESKTOP_RES resolution #define NVAPI_MAX_HEADS_PER_GPU 32 #define NV_MAX_HEADS 4 //!< Maximum number of heads, each with #NVAPI_DESKTOP_RES resolution #define NV_MAX_VID_STREAMS 4 //!< Maximum number of input video streams, each with a #NVAPI_VIDEO_SRC_INFO #define NV_MAX_VID_PROFILES 4 //!< Maximum number of output video profiles supported #define NVAPI_SYSTEM_MAX_DISPLAYS NVAPI_MAX_PHYSICAL_GPUS * NV_MAX_HEADS #define NVAPI_SYSTEM_MAX_HWBCS 128 #define NVAPI_SYSTEM_HWBC_INVALID_ID 0xffffffff #define NVAPI_MAX_AUDIO_DEVICES 16 typedef char NvAPI_String[NVAPI_GENERIC_STRING_MAX]; typedef char NvAPI_LongString[NVAPI_LONG_STRING_MAX]; typedef char NvAPI_ShortString[NVAPI_SHORT_STRING_MAX]; // ========================================================================================= //! NvAPI Version Definition \n //! Maintain per structure specific version define using the MAKE_NVAPI_VERSION macro. \n //! Usage: #define NV_GENLOCK_STATUS_VER MAKE_NVAPI_VERSION(NV_GENLOCK_STATUS, 1) //! \ingroup nvapitypes // ========================================================================================= #define MAKE_NVAPI_VERSION(typeName,ver) (NvU32)(sizeof(typeName) | ((ver)<<16)) //! \ingroup nvapitypes #define GET_NVAPI_VERSION(ver) (NvU32)((ver)>>16) //! \ingroup nvapitypes #define GET_NVAPI_SIZE(ver) (NvU32)((ver) & 0xffff) // ==================================================== //! NvAPI Status Values //! All NvAPI functions return one of these codes. //! \ingroup nvapistatus // ==================================================== typedef enum _NvStatus { NVAPI_OK = 0, //!< Success. Request is completed. NVAPI_ERROR = -1, //!< Generic error NVAPI_LIBRARY_NOT_FOUND = -2, //!< NVAPI support library cannot be loaded. NVAPI_NO_IMPLEMENTATION = -3, //!< not implemented in current driver installation NVAPI_API_NOT_INITIALIZED = -4, //!< NvAPI_Initialize has not been called (successfully) NVAPI_INVALID_ARGUMENT = -5, //!< The argument/parameter value is not valid or NULL. NVAPI_NVIDIA_DEVICE_NOT_FOUND = -6, //!< No NVIDIA display driver, or NVIDIA GPU driving a display, was found. NVAPI_END_ENUMERATION = -7, //!< No more items to enumerate NVAPI_INVALID_HANDLE = -8, //!< Invalid handle NVAPI_INCOMPATIBLE_STRUCT_VERSION = -9, //!< An argument's structure version is not supported NVAPI_HANDLE_INVALIDATED = -10, //!< The handle is no longer valid (likely due to GPU or display re-configuration) NVAPI_OPENGL_CONTEXT_NOT_CURRENT = -11, //!< No NVIDIA OpenGL context is current (but needs to be) NVAPI_INVALID_POINTER = -14, //!< An invalid pointer, usually NULL, was passed as a parameter NVAPI_NO_GL_EXPERT = -12, //!< OpenGL Expert is not supported by the current drivers NVAPI_INSTRUMENTATION_DISABLED = -13, //!< OpenGL Expert is supported, but driver instrumentation is currently disabled NVAPI_NO_GL_NSIGHT = -15, //!< OpenGL does not support Nsight NVAPI_EXPECTED_LOGICAL_GPU_HANDLE = -100, //!< Expected a logical GPU handle for one or more parameters NVAPI_EXPECTED_PHYSICAL_GPU_HANDLE = -101, //!< Expected a physical GPU handle for one or more parameters NVAPI_EXPECTED_DISPLAY_HANDLE = -102, //!< Expected an NV display handle for one or more parameters NVAPI_INVALID_COMBINATION = -103, //!< The combination of parameters is not valid. NVAPI_NOT_SUPPORTED = -104, //!< Requested feature is not supported in the selected GPU NVAPI_PORTID_NOT_FOUND = -105, //!< No port ID was found for the I2C transaction NVAPI_EXPECTED_UNATTACHED_DISPLAY_HANDLE = -106, //!< Expected an unattached display handle as one of the input parameters. NVAPI_INVALID_PERF_LEVEL = -107, //!< Invalid perf level NVAPI_DEVICE_BUSY = -108, //!< Device is busy; request not fulfilled NVAPI_NV_PERSIST_FILE_NOT_FOUND = -109, //!< NV persist file is not found NVAPI_PERSIST_DATA_NOT_FOUND = -110, //!< NV persist data is not found NVAPI_EXPECTED_TV_DISPLAY = -111, //!< Expected a TV output display NVAPI_EXPECTED_TV_DISPLAY_ON_DCONNECTOR = -112, //!< Expected a TV output on the D Connector - HDTV_EIAJ4120. NVAPI_NO_ACTIVE_SLI_TOPOLOGY = -113, //!< SLI is not active on this device. NVAPI_SLI_RENDERING_MODE_NOTALLOWED = -114, //!< Setup of SLI rendering mode is not possible right now. NVAPI_EXPECTED_DIGITAL_FLAT_PANEL = -115, //!< Expected a digital flat panel. NVAPI_ARGUMENT_EXCEED_MAX_SIZE = -116, //!< Argument exceeds the expected size. NVAPI_DEVICE_SWITCHING_NOT_ALLOWED = -117, //!< Inhibit is ON due to one of the flags in NV_GPU_DISPLAY_CHANGE_INHIBIT or SLI active. NVAPI_TESTING_CLOCKS_NOT_SUPPORTED = -118, //!< Testing of clocks is not supported. NVAPI_UNKNOWN_UNDERSCAN_CONFIG = -119, //!< The specified underscan config is from an unknown source (e.g. INF) NVAPI_TIMEOUT_RECONFIGURING_GPU_TOPO = -120, //!< Timeout while reconfiguring GPUs NVAPI_DATA_NOT_FOUND = -121, //!< Requested data was not found NVAPI_EXPECTED_ANALOG_DISPLAY = -122, //!< Expected an analog display NVAPI_NO_VIDLINK = -123, //!< No SLI video bridge is present NVAPI_REQUIRES_REBOOT = -124, //!< NVAPI requires a reboot for the settings to take effect NVAPI_INVALID_HYBRID_MODE = -125, //!< The function is not supported with the current Hybrid mode. NVAPI_MIXED_TARGET_TYPES = -126, //!< The target types are not all the same NVAPI_SYSWOW64_NOT_SUPPORTED = -127, //!< The function is not supported from 32-bit on a 64-bit system. NVAPI_IMPLICIT_SET_GPU_TOPOLOGY_CHANGE_NOT_ALLOWED = -128, //!< There is no implicit GPU topology active. Use NVAPI_SetHybridMode to change topology. NVAPI_REQUEST_USER_TO_CLOSE_NON_MIGRATABLE_APPS = -129, //!< Prompt the user to close all non-migratable applications. NVAPI_OUT_OF_MEMORY = -130, //!< Could not allocate sufficient memory to complete the call. NVAPI_WAS_STILL_DRAWING = -131, //!< The previous operation that is transferring information to or from this surface is incomplete. NVAPI_FILE_NOT_FOUND = -132, //!< The file was not found. NVAPI_TOO_MANY_UNIQUE_STATE_OBJECTS = -133, //!< There are too many unique instances of a particular type of state object. NVAPI_INVALID_CALL = -134, //!< The method call is invalid. For example, a method's parameter may not be a valid pointer. NVAPI_D3D10_1_LIBRARY_NOT_FOUND = -135, //!< d3d10_1.dll cannot be loaded. NVAPI_FUNCTION_NOT_FOUND = -136, //!< Couldn't find the function in the loaded DLL. NVAPI_INVALID_USER_PRIVILEGE = -137, //!< Current User is not Admin. NVAPI_EXPECTED_NON_PRIMARY_DISPLAY_HANDLE = -138, //!< The handle corresponds to GDIPrimary. NVAPI_EXPECTED_COMPUTE_GPU_HANDLE = -139, //!< Setting Physx GPU requires that the GPU is compute-capable. NVAPI_STEREO_NOT_INITIALIZED = -140, //!< The Stereo part of NVAPI failed to initialize completely. Check if the stereo driver is installed. NVAPI_STEREO_REGISTRY_ACCESS_FAILED = -141, //!< Access to stereo-related registry keys or values has failed. NVAPI_STEREO_REGISTRY_PROFILE_TYPE_NOT_SUPPORTED = -142, //!< The given registry profile type is not supported. NVAPI_STEREO_REGISTRY_VALUE_NOT_SUPPORTED = -143, //!< The given registry value is not supported. NVAPI_STEREO_NOT_ENABLED = -144, //!< Stereo is not enabled and the function needed it to execute completely. NVAPI_STEREO_NOT_TURNED_ON = -145, //!< Stereo is not turned on and the function needed it to execute completely. NVAPI_STEREO_INVALID_DEVICE_INTERFACE = -146, //!< Invalid device interface. NVAPI_STEREO_PARAMETER_OUT_OF_RANGE = -147, //!< Separation percentage or JPEG image capture quality is out of [0-100] range. NVAPI_STEREO_FRUSTUM_ADJUST_MODE_NOT_SUPPORTED = -148, //!< The given frustum adjust mode is not supported. NVAPI_TOPO_NOT_POSSIBLE = -149, //!< The mosaic topology is not possible given the current state of the hardware. NVAPI_MODE_CHANGE_FAILED = -150, //!< An attempt to do a display resolution mode change has failed. NVAPI_D3D11_LIBRARY_NOT_FOUND = -151, //!< d3d11.dll/d3d11_beta.dll cannot be loaded. NVAPI_INVALID_ADDRESS = -152, //!< Address is outside of valid range. NVAPI_STRING_TOO_SMALL = -153, //!< The pre-allocated string is too small to hold the result. NVAPI_MATCHING_DEVICE_NOT_FOUND = -154, //!< The input does not match any of the available devices. NVAPI_DRIVER_RUNNING = -155, //!< Driver is running. NVAPI_DRIVER_NOTRUNNING = -156, //!< Driver is not running. NVAPI_ERROR_DRIVER_RELOAD_REQUIRED = -157, //!< A driver reload is required to apply these settings. NVAPI_SET_NOT_ALLOWED = -158, //!< Intended setting is not allowed. NVAPI_ADVANCED_DISPLAY_TOPOLOGY_REQUIRED = -159, //!< Information can't be returned due to "advanced display topology". NVAPI_SETTING_NOT_FOUND = -160, //!< Setting is not found. NVAPI_SETTING_SIZE_TOO_LARGE = -161, //!< Setting size is too large. NVAPI_TOO_MANY_SETTINGS_IN_PROFILE = -162, //!< There are too many settings for a profile. NVAPI_PROFILE_NOT_FOUND = -163, //!< Profile is not found. NVAPI_PROFILE_NAME_IN_USE = -164, //!< Profile name is duplicated. NVAPI_PROFILE_NAME_EMPTY = -165, //!< Profile name is empty. NVAPI_EXECUTABLE_NOT_FOUND = -166, //!< Application not found in the Profile. NVAPI_EXECUTABLE_ALREADY_IN_USE = -167, //!< Application already exists in the other profile. NVAPI_DATATYPE_MISMATCH = -168, //!< Data Type mismatch NVAPI_PROFILE_REMOVED = -169, //!< The profile passed as parameter has been removed and is no longer valid. NVAPI_UNREGISTERED_RESOURCE = -170, //!< An unregistered resource was passed as a parameter. NVAPI_ID_OUT_OF_RANGE = -171, //!< The DisplayId corresponds to a display which is not within the normal outputId range. NVAPI_DISPLAYCONFIG_VALIDATION_FAILED = -172, //!< Display topology is not valid so the driver cannot do a mode set on this configuration. NVAPI_DPMST_CHANGED = -173, //!< Display Port Multi-Stream topology has been changed. NVAPI_INSUFFICIENT_BUFFER = -174, //!< Input buffer is insufficient to hold the contents. NVAPI_ACCESS_DENIED = -175, //!< No access to the caller. NVAPI_MOSAIC_NOT_ACTIVE = -176, //!< The requested action cannot be performed without Mosaic being enabled. NVAPI_SHARE_RESOURCE_RELOCATED = -177, //!< The surface is relocated away from video memory. NVAPI_REQUEST_USER_TO_DISABLE_DWM = -178, //!< The user should disable DWM before calling NvAPI. NVAPI_D3D_DEVICE_LOST = -179, //!< D3D device status is D3DERR_DEVICELOST or D3DERR_DEVICENOTRESET - the user has to reset the device. NVAPI_INVALID_CONFIGURATION = -180, //!< The requested action cannot be performed in the current state. NVAPI_STEREO_HANDSHAKE_NOT_DONE = -181, //!< Call failed as stereo handshake not completed. NVAPI_EXECUTABLE_PATH_IS_AMBIGUOUS = -182, //!< The path provided was too short to determine the correct NVDRS_APPLICATION } NvStatus; #define NVAPI_API_NOT_INTIALIZED NVAPI_API_NOT_INITIALIZED //!< Fix typo in error code #define NVAPI_INVALID_USER_PRIVILEDGE NVAPI_INVALID_USER_PRIVILEGE //!< Fix typo in error code /////////////////////////////////////////////////////////////////////////////// // // FUNCTION NAME: NvAPI_Initialize // //! This function initializes the NvAPI library. //! This must be called before calling other NvAPI_ functions. //! // SUPPORTED OS: Mac OS X, Windows XP and higher //! //! \since //! Version: 82.61 //! //! \retval NVAPI_ERROR An error occurred during the initialization process (generic error) //! \retval NVAPI_LIBRARYNOTFOUND Failed to load the NVAPI support library //! \retval NVAPI_OK Initialized //! \sa nvapistatus //! \ingroup nvapifunctions /////////////////////////////////////////////////////////////////////////////// //NVAPI_INTERFACE NvAPI_Initialize(); typedef NvStatus (__cdecl *P_NvAPI_Initialize)(); P_NvAPI_Initialize NvAPI_Initialize; /////////////////////////////////////////////////////////////////////////////// // // FUNCTION NAME: NvAPI_Unload // //! DESCRIPTION: Unloads NVAPI library. This must be the last function called. //! // SUPPORTED OS: Mac OS X, Windows XP and higher //! //! !! This is not thread safe. In a multithreaded environment, calling NvAPI_Unload !! \n //! !! while another thread is executing another NvAPI_XXX function, results in !! \n //! !! undefined behaviour and might even cause the application to crash. Developers !! \n //! !! must make sure that they are not in any other function before calling NvAPI_Unload. !! \n //! //! //! Unloading NvAPI library is not supported when the library is in a resource locked state. //! Some functions in the NvAPI library initiates an operation or allocates certain resources //! and there are corresponding functions available, to complete the operation or free the //! allocated resources. All such function pairs are designed to prevent unloading NvAPI library. //! //! For example, if NvAPI_Unload is called after NvAPI_XXX which locks a resource, it fails with //! NVAPI_ERROR. Developers need to call the corresponding NvAPI_YYY to unlock the resources, //! before calling NvAPI_Unload again. //! //! \retval ::NVAPI_ERROR One or more resources are locked and hence cannot unload NVAPI library //! \retval ::NVAPI_OK NVAPI library unloaded //! //! \ingroup nvapifunctions /////////////////////////////////////////////////////////////////////////////// //NVAPI_INTERFACE NvAPI_Unload(); typedef NvStatus (__cdecl *P_NvAPI_Unload)(); P_NvAPI_Unload NvAPI_Unload; /////////////////////////////////////////////////////////////////////////////// // // FUNCTION NAME: NvAPI_GetErrorMessage // //! This function converts an NvAPI error code into a null terminated string. //! // SUPPORTED OS: Mac OS X, Windows XP and higher //! //! \since //! Version: 82.61 //! //! \param nr The error code to convert //! \param szDesc The string corresponding to the error code //! //! \return NULL terminated string (always, never NULL) //! \ingroup nvapifunctions /////////////////////////////////////////////////////////////////////////////// //NVAPI_INTERFACE NvAPI_GetErrorMessage(NvStatus nr, NvAPI_ShortString szDesc); typedef NvStatus (__cdecl *P_NvAPI_GetErrorMessage)(NvStatus nr, NvAPI_ShortString szDesc); P_NvAPI_GetErrorMessage NvAPI_GetErrorMessage; /////////////////////////////////////////////////////////////////////////////// // // FUNCTION NAME: NvAPI_GetInterfaceVersionString // //! This function returns a string describing the version of the NvAPI library. //! The contents of the string are human readable. Do not assume a fixed //! format. //! //! // SUPPORTED OS: Mac OS X, Windows XP and higher //! //! \since //! Version: 82.61 //! //! \param szDesc User readable string giving NvAPI version information //! //! \return See \ref nvapistatus for the list of possible return values. //! \ingroup nvapifunctions /////////////////////////////////////////////////////////////////////////////// typedef NvStatus (__cdecl *P_NvAPI_GetInterfaceVersionString)(NvAPI_ShortString szDesc); P_NvAPI_GetInterfaceVersionString NvAPI_GetInterfaceVersionString; /////////////////////////////////////////////////////////////////////////////// // // FUNCTION NAME: NvAPI_GetDisplayDriverVersion //! \fn NvAPI_GetDisplayDriverVersion(NvDisplayHandle hNvDisplay, NV_DISPLAY_DRIVER_VERSION *pVersion) //! This function returns a struct that describes aspects of the display driver //! build. //! // SUPPORTED OS: Mac OS X, Windows XP and higher //! //! \since //! Version: 82.61 //! //! \param [in] hNvDisplay NVIDIA display handle. //! \param [out] pVersion Pointer to NV_DISPLAY_DRIVER_VERSION struc //! //! \retval NVAPI_ERROR //! \retval NVAPI_OK /////////////////////////////////////////////////////////////////////////////// //! \ingroup driverapi //! Used in NvAPI_GetDisplayDriverVersion() typedef struct { NvU32 Version; // Structure version NvU32 drvVersion; NvU32 bldChangeListNum; NvAPI_ShortString szBuildBranchString; NvAPI_ShortString szAdapterString; } NV_DISPLAY_DRIVER_VERSION; #define NV_DISPLAY_DRIVER_VERSION_VER MAKE_NVAPI_VERSION(NV_DISPLAY_DRIVER_VERSION, 1) typedef NvStatus (__cdecl *P_NvAPI_GetDisplayDriverVersion)(NvDisplayHandle hNvDisplay, NV_DISPLAY_DRIVER_VERSION *pVersion); P_NvAPI_GetDisplayDriverVersion NvAPI_GetDisplayDriverVersion; /////////////////////////////////////////////////////////////////////////////// // // FUNCTION NAME: NvAPI_SYS_GetDriverAndBranchVersion // //! DESCRIPTION: This API returns display driver version and driver-branch string. //! // SUPPORTED OS: Windows XP and higher //! //! \param [out] pDriverVersion Contains the driver version after successful return. //! \param [out] szBuildBranchString Contains the driver-branch string after successful return. //! //! \retval ::NVAPI_INVALID_ARGUMENT: either pDriverVersion is NULL or enum index too big //! \retval ::NVAPI_OK - completed request //! \retval ::NVAPI_API_NOT_INTIALIZED - NVAPI not initialized //! \retval ::NVAPI_ERROR - miscellaneous error occurred //! //! \ingroup driverapi /////////////////////////////////////////////////////////////////////////////// NVAPI_INTERFACE NvAPI_SYS_GetDriverAndBranchVersion(NvU32* pDriverVersion, NvAPI_ShortString szBuildBranchString); /////////////////////////////////////////////////////////////////////////////// // // FUNCTION NAME: NvAPI_EnumNvidiaDisplayHandle // //! 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. //! // SUPPORTED OS: Windows XP and higher //! //! \since //! Version: 82.61 //! //! \param [in] thisEnum The index of the NVIDIA display. //! \param [out] pNvDispHandle Pointer to the NVIDIA display handle. //! //! \retval NVAPI_INVALID_ARGUMENT Either the handle pointer is NULL or enum index too big //! \retval NVAPI_OK Return a valid NvDisplayHandle based on the enum index //! \retval NVAPI_NVIDIA_DEVICE_NOT_FOUND No NVIDIA device found in the system //! \retval NVAPI_END_ENUMERATION No more display device to enumerate //! \ingroup disphandle /////////////////////////////////////////////////////////////////////////////// //NVAPI_INTERFACE NvAPI_EnumNvidiaDisplayHandle(NvU32 thisEnum, NvDisplayHandle *pNvDispHandle); typedef NvStatus (__cdecl *P_NvAPI_EnumNvidiaDisplayHandle)(NvU32 thisEnum, NvDisplayHandle *pNvDispHandle); P_NvAPI_EnumNvidiaDisplayHandle NvAPI_EnumNvidiaDisplayHandle; /////////////////////////////////////////////////////////////////////////////// // // FUNCTION NAME: NvAPI_EnumNvidiaUnAttachedDisplayHandle // //! This function returns the handle of the NVIDIA unattached display specified by the enum //! index (thisEnum). The client should keep enumerating until it //! returns error. //! Note: Display handles can get invalidated on a modeset, so the calling applications need to //! renum the handles after every modeset. //! // SUPPORTED OS: Windows XP and higher //! //! \since //! Version: 82.61 //! //! \param [in] thisEnum The index of the NVIDIA display. //! \param [out] pNvUnAttachedDispHandle Pointer to the NVIDIA display handle of the unattached display. //! //! \retval NVAPI_INVALID_ARGUMENT Either the handle pointer is NULL or enum index too big //! \retval NVAPI_OK Return a valid NvDisplayHandle based on the enum index //! \retval NVAPI_NVIDIA_DEVICE_NOT_FOUND No NVIDIA device found in the system //! \retval NVAPI_END_ENUMERATION No more display device to enumerate. //! \ingroup disphandle /////////////////////////////////////////////////////////////////////////////// NVAPI_INTERFACE NvAPI_EnumNvidiaUnAttachedDisplayHandle(NvU32 thisEnum, NvUnAttachedDisplayHandle *pNvUnAttachedDispHandle); /////////////////////////////////////////////////////////////////////////////// // // FUNCTION NAME: NvAPI_EnumPhysicalGPUs // //! This function returns an array of physical GPU handles. //! Each handle represents a physical GPU present in the system. //! That GPU may be part of an SLI configuration, or may not be visible to the OS directly. //! //! At least one GPU must be present in the system and running an NVIDIA display driver. //! //! The array nvGPUHandle will be filled with physical GPU handle values. The returned //! gpuCount determines how many entries in the array are valid. //! //! \note In drivers older than 105.00, all physical GPU handles get invalidated on a //! modeset. So the calling applications need to renum the handles after every modeset.\n //! With drivers 105.00 and up, all physical GPU handles are constant. //! Physical GPU handles are constant as long as the GPUs are not physically moved and //! the SBIOS VGA order is unchanged. //! // SUPPORTED OS: Mac OS X, Windows XP and higher //! //! \par Introduced in //! Version: 82.61 //! //! \retval NVAPI_INVALID_ARGUMENT nvGPUHandle or pGpuCount is NULL //! \retval NVAPI_OK One or more handles were returned //! \retval NVAPI_NVIDIA_DEVICE_NOT_FOUND No NVIDIA GPU driving a display was found //! \ingroup gpu /////////////////////////////////////////////////////////////////////////////// //NVAPI_INTERFACE NvAPI_EnumPhysicalGPUs(NvPhysicalGpuHandle nvGPUHandle[NVAPI_MAX_PHYSICAL_GPUS], NvU32 *pGpuCount); typedef NvStatus (__cdecl *P_NvAPI_EnumPhysicalGPUs)(NvPhysicalGpuHandle nvGPUHandle[NVAPI_MAX_PHYSICAL_GPUS], NvU32 *pGpuCount); P_NvAPI_EnumPhysicalGPUs NvAPI_EnumPhysicalGPUs; /////////////////////////////////////////////////////////////////////////////// // // FUNCTION NAME: NvAPI_EnumLogicalGPUs // //! This function returns an array of logical GPU handles. //! //! Each handle represents one or more GPUs acting in concert as a single graphics device. //! //! At least one GPU must be present in the system and running an NVIDIA display driver. //! //! The array nvGPUHandle will be filled with logical GPU handle values. The returned //! gpuCount determines how many entries in the array are valid. //! //! \note All logical GPUs handles get invalidated on a GPU topology change, so the calling //! application is required to renum the logical GPU handles to get latest physical handle //! mapping after every GPU topology change activated by a call to NvAPI_SetGpuTopologies(). //! //! To detect if SLI rendering is enabled, use NvAPI_D3D_GetCurrentSLIState(). //! // SUPPORTED OS: Mac OS X, Windows XP and higher //! //! \since //! Version: 82.61 //! //! \retval NVAPI_INVALID_ARGUMENT nvGPUHandle or pGpuCount is NULL //! \retval NVAPI_OK One or more handles were returned //! \retval NVAPI_NVIDIA_DEVICE_NOT_FOUND No NVIDIA GPU driving a display was found //! \ingroup gpu /////////////////////////////////////////////////////////////////////////////// NVAPI_INTERFACE NvAPI_EnumLogicalGPUs(NvLogicalGpuHandle nvGPUHandle[NVAPI_MAX_LOGICAL_GPUS], NvU32 *pGpuCount); /////////////////////////////////////////////////////////////////////////////// // // FUNCTION NAME: NvAPI_GetPhysicalGPUsFromDisplay // //! 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. //! //! The array nvGPUHandle will be filled with physical GPU handle values. The returned //! gpuCount determines how many entries in the array are valid. //! //! If the display corresponds to more than one physical GPU, the first GPU returned //! is the one with the attached active output. //! // SUPPORTED OS: Windows XP and higher //! //! \since //! Version: 82.61 //! //! \retval NVAPI_INVALID_ARGUMENT hNvDisp is not valid; nvGPUHandle or pGpuCount is NULL //! \retval NVAPI_OK One or more handles were returned //! \retval NVAPI_NVIDIA_DEVICE_NOT_FOUND no NVIDIA GPU driving a display was found //! \ingroup gpu /////////////////////////////////////////////////////////////////////////////// //NVAPI_INTERFACE NvAPI_GetPhysicalGPUsFromDisplay(NvDisplayHandle hNvDisp, NvPhysicalGpuHandle nvGPUHandle[NVAPI_MAX_PHYSICAL_GPUS], NvU32 *pGpuCount); typedef NvStatus (__cdecl *P_NvAPI_GetPhysicalGPUsFromDisplay)(NvDisplayHandle hNvDisp, NvPhysicalGpuHandle nvGPUHandle[NVAPI_MAX_PHYSICAL_GPUS], NvU32 *pGpuCount); P_NvAPI_GetPhysicalGPUsFromDisplay NvAPI_GetPhysicalGPUsFromDisplay; /////////////////////////////////////////////////////////////////////////////// // // FUNCTION NAME: NvAPI_GetPhysicalGPUFromUnAttachedDisplay // //! This function returns a physical GPU handle associated with the specified unattached display. //! The source GPU is a physical render GPU which renders the frame buffer but may or may not drive the scan out. //! //! At least one GPU must be present in the system and running an NVIDIA display driver. //! // SUPPORTED OS: Windows XP and higher //! //! \since //! Version: 82.61 //! //! \retval NVAPI_INVALID_ARGUMENT hNvUnAttachedDisp is not valid or pPhysicalGpu is NULL. //! \retval NVAPI_OK One or more handles were returned //! \retval NVAPI_NVIDIA_DEVICE_NOT_FOUND No NVIDIA GPU driving a display was found //! \ingroup gpu /////////////////////////////////////////////////////////////////////////////// NVAPI_INTERFACE NvAPI_GetPhysicalGPUFromUnAttachedDisplay(NvUnAttachedDisplayHandle hNvUnAttachedDisp, NvPhysicalGpuHandle *pPhysicalGpu); /////////////////////////////////////////////////////////////////////////////// // // FUNCTION NAME: NvAPI_CreateDisplayFromUnAttachedDisplay // //! This function converts the unattached display handle to an active attached display handle. //! //! At least one GPU must be present in the system and running an NVIDIA display driver. //! // SUPPORTED OS: Windows XP and higher //! //! \since Version: 82.61 //! //! \retval NVAPI_INVALID_ARGUMENT hNvUnAttachedDisp is not valid or pNvDisplay is NULL. //! \retval NVAPI_OK One or more handles were returned //! \retval NVAPI_NVIDIA_DEVICE_NOT_FOUND No NVIDIA GPU driving a display was found //! \ingroup dispcontrol /////////////////////////////////////////////////////////////////////////////// NVAPI_INTERFACE NvAPI_CreateDisplayFromUnAttachedDisplay(NvUnAttachedDisplayHandle hNvUnAttachedDisp, NvDisplayHandle *pNvDisplay); /////////////////////////////////////////////////////////////////////////////// // // FUNCTION NAME: NvAPI_GetLogicalGPUFromDisplay // //! 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. //! // SUPPORTED OS: Windows XP and higher //! //! \since Version: 82.61 //! //! \retval NVAPI_INVALID_ARGUMENT hNvDisp is not valid; pLogicalGPU is NULL //! \retval NVAPI_OK One or more handles were returned //! \retval NVAPI_NVIDIA_DEVICE_NOT_FOUND No NVIDIA GPU driving a display was found //! \ingroup gpu /////////////////////////////////////////////////////////////////////////////// NVAPI_INTERFACE NvAPI_GetLogicalGPUFromDisplay(NvDisplayHandle hNvDisp, NvLogicalGpuHandle *pLogicalGPU); /////////////////////////////////////////////////////////////////////////////// // // FUNCTION NAME: NvAPI_GetLogicalGPUFromPhysicalGPU // //! This function returns the logical GPU handle associated with specified physical GPU handle. //! At least one GPU must be present in the system and running an NVIDIA display driver. //! // SUPPORTED OS: Mac OS X, Windows XP and higher //! //! \since Version: 82.61 //! //! \retval NVAPI_INVALID_ARGUMENT hPhysicalGPU is not valid; pLogicalGPU is NULL //! \retval NVAPI_OK One or more handles were returned //! \retval NVAPI_NVIDIA_DEVICE_NOT_FOUND No NVIDIA GPU driving a display was found //! \ingroup gpu /////////////////////////////////////////////////////////////////////////////// NVAPI_INTERFACE NvAPI_GetLogicalGPUFromPhysicalGPU(NvPhysicalGpuHandle hPhysicalGPU, NvLogicalGpuHandle *pLogicalGPU); /////////////////////////////////////////////////////////////////////////////// // // FUNCTION NAME: NvAPI_GetPhysicalGPUsFromLogicalGPU // //! This function returns the physical GPU handles associated with the specified logical GPU handle. //! At least one GPU must be present in the system and running an NVIDIA display driver. //! //! The array hPhysicalGPU will be filled with physical GPU handle values. The returned //! gpuCount determines how many entries in the array are valid. //! // SUPPORTED OS: Windows XP and higher //! //! \since Version: 82.61 //! //! \retval NVAPI_INVALID_ARGUMENT hLogicalGPU is not valid; hPhysicalGPU is NULL //! \retval NVAPI_OK One or more handles were returned //! \retval NVAPI_NVIDIA_DEVICE_NOT_FOUND No NVIDIA GPU driving a display was found //! \retval NVAPI_EXPECTED_LOGICAL_GPU_HANDLE hLogicalGPU was not a logical GPU handle //! \ingroup gpu /////////////////////////////////////////////////////////////////////////////// NVAPI_INTERFACE NvAPI_GetPhysicalGPUsFromLogicalGPU(NvLogicalGpuHandle hLogicalGPU,NvPhysicalGpuHandle hPhysicalGPU[NVAPI_MAX_PHYSICAL_GPUS], NvU32 *pGpuCount); /////////////////////////////////////////////////////////////////////////////// // // FUNCTION NAME: NvAPI_GetAssociatedNVidiaDisplayHandle // //! This function returns the handle of the NVIDIA display that is associated //! with the given display "name" (such as "\\.\DISPLAY1"). //! // SUPPORTED OS: Windows XP and higher //! //! \since Version: 82.61 //! //! \retval NVAPI_INVALID_ARGUMENT Either argument is NULL //! \retval NVAPI_OK *pNvDispHandle is now valid //! \retval NVAPI_NVIDIA_DEVICE_NOT_FOUND No NVIDIA device maps to that display name //! \ingroup disphandle /////////////////////////////////////////////////////////////////////////////// NVAPI_INTERFACE NvAPI_GetAssociatedNvidiaDisplayHandle(const char *szDisplayName, NvDisplayHandle *pNvDispHandle); /////////////////////////////////////////////////////////////////////////////// // // FUNCTION NAME: NvAPI_DISP_GetAssociatedUnAttachedNvidiaDisplayHandle // //! DESCRIPTION: This function returns the handle of an unattached NVIDIA display that is //! associated with the given display name (such as "\\DISPLAY1"). //! // SUPPORTED OS: Windows XP and higher //! //! \since Version: 187.07 //! //! \retval ::NVAPI_INVALID_ARGUMENT Either argument is NULL. //! \retval ::NVAPI_OK *pNvUnAttachedDispHandle is now valid. //! \retval ::NVAPI_NVIDIA_DEVICE_NOT_FOUND No NVIDIA device maps to that display name. //! //! \ingroup disphandle /////////////////////////////////////////////////////////////////////////////// NVAPI_INTERFACE NvAPI_DISP_GetAssociatedUnAttachedNvidiaDisplayHandle(const char *szDisplayName, NvUnAttachedDisplayHandle *pNvUnAttachedDispHandle); /////////////////////////////////////////////////////////////////////////////// // // FUNCTION NAME: NvAPI_GetAssociatedNVidiaDisplayName // //! For a given NVIDIA display handle, this function returns a string (such as "\\.\DISPLAY1") to identify the display. //! // SUPPORTED OS: Windows XP and higher //! //! \since Version: 82.61 //! //! \retval NVAPI_INVALID_ARGUMENT Either argument is NULL //! \retval NVAPI_OK *pNvDispHandle is now valid //! \retval NVAPI_NVIDIA_DEVICE_NOT_FOUND No NVIDIA device maps to that display name //! \ingroup dispcontrol /////////////////////////////////////////////////////////////////////////////// NVAPI_INTERFACE NvAPI_GetAssociatedNvidiaDisplayName(NvDisplayHandle NvDispHandle, NvAPI_ShortString szDisplayName); /////////////////////////////////////////////////////////////////////////////// // // FUNCTION NAME: NvAPI_GetUnAttachedAssociatedDisplayName // //! This function returns the display name given, for example, "\\DISPLAY1", using the unattached NVIDIA display handle //! // SUPPORTED OS: Windows XP and higher //! //! \since Version: 97.60, 100.06 //! //! \retval NVAPI_INVALID_ARGUMENT Either argument is NULL //! \retval NVAPI_OK *pNvDispHandle is now valid //! \retval NVAPI_NVIDIA_DEVICE_NOT_FOUND No NVIDIA device maps to that display name //! \ingroup dispcontrol /////////////////////////////////////////////////////////////////////////////// NVAPI_INTERFACE NvAPI_GetUnAttachedAssociatedDisplayName(NvUnAttachedDisplayHandle hNvUnAttachedDisp, NvAPI_ShortString szDisplayName); /////////////////////////////////////////////////////////////////////////////// // // FUNCTION NAME: NvAPI_GetAssociatedDisplayOutputId // //! This function gets the active outputId associated with the display handle. //! // SUPPORTED OS: Windows XP and higher //! //! \since Version: 93.60 //! //! \param [in] hNvDisplay NVIDIA Display selection. It can be NVAPI_DEFAULT_HANDLE or a handle enumerated from NvAPI_EnumNVidiaDisplayHandle(). //! \param [out] outputId 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. See \ref handles. //! //! \retval NVAPI_OK Call successful. //! \retval NVAPI_NVIDIA_DEVICE_NOT_FOUND No NVIDIA GPU driving a display was found. //! \retval NVAPI_EXPECTED_DISPLAY_HANDLE hNvDisplay is not a valid display handle. //! \ingroup dispcontrol /////////////////////////////////////////////////////////////////////////////// NVAPI_INTERFACE NvAPI_GetAssociatedDisplayOutputId(NvDisplayHandle hNvDisplay, NvU32 *pOutputId); /////////////////////////////////////////////////////////////////////////////// // FUNCTION NAME: NvAPI_GetDisplayPortInfo // //! \fn NvAPI_GetDisplayPortInfo(NvDisplayHandle hNvDisplay, NvU32 outputId, NV_DISPLAY_PORT_INFO *pInfo) //! DESCRIPTION: This function returns the current DisplayPort-related information on the specified device (monitor). //! // SUPPORTED OS: Windows XP and higher //! //! \since Version: 165.22 //! //! \param [in] hNvDisplay NVIDIA Display selection. It can be NVAPI_DEFAULT_HANDLE or a handle enumerated from //! NvAPI_EnumNVidiaDisplayHandle(). //! \param [in] outputId The display output ID. If "0", then the default outputId from //! NvAPI_GetAssociatedDisplayOutputId() will be used. See \ref handles. //! \param [out] pInfo The DisplayPort information //! //! \retval NVAPI_OK Completed request //! \retval NVAPI_ERROR Miscellaneous error occurred //! \retval NVAPI_INVALID_ARGUMENT Invalid input parameter. // /////////////////////////////////////////////////////////////////////////////// //! \ingroup dispcontrol //! Used in NV_DISPLAY_PORT_INFO. typedef enum { NV_DP_1_62GBPS = 6, NV_DP_2_70GBPS = 0xA, } NV_DP_LINK_RATE; //! \ingroup dispcontrol //! Used in NV_DISPLAY_PORT_INFO. typedef enum { NV_DP_1_LANE = 1, NV_DP_2_LANE = 2, NV_DP_4_LANE = 4, } NV_DP_LANE_COUNT; //! \ingroup dispcontrol //! Used in NV_DISPLAY_PORT_INFO. typedef enum { NV_DP_COLOR_FORMAT_RGB = 0, NV_DP_COLOR_FORMAT_YCbCr422, NV_DP_COLOR_FORMAT_YCbCr444, } NV_DP_COLOR_FORMAT; //! \ingroup dispcontrol //! Used in NV_DISPLAY_PORT_INFO. typedef enum { NV_DP_COLORIMETRY_RGB = 0, NV_DP_COLORIMETRY_YCbCr_ITU601, NV_DP_COLORIMETRY_YCbCr_ITU709, } NV_DP_COLORIMETRY; //! \ingroup dispcontrol //! Used in NV_DISPLAY_PORT_INFO. typedef enum { NV_DP_DYNAMIC_RANGE_VESA = 0, NV_DP_DYNAMIC_RANGE_CEA, } NV_DP_DYNAMIC_RANGE; //! \ingroup dispcontrol //! Used in NV_DISPLAY_PORT_INFO. typedef enum { NV_DP_BPC_DEFAULT = 0, NV_DP_BPC_6, NV_DP_BPC_8, NV_DP_BPC_10, NV_DP_BPC_12, NV_DP_BPC_16, } NV_DP_BPC; /////////////////////////////////////////////////////////////////////////////// // FUNCTION NAME: NvAPI_SetDisplayPort // //! \fn NvAPI_SetDisplayPort(NvDisplayHandle hNvDisplay, NvU32 outputId, NV_DISPLAY_PORT_CONFIG *pCfg) //! DESCRIPTION: This function sets up DisplayPort-related configurations. //! // SUPPORTED OS: Windows XP and higher //! //! \since Version: 165.22 //! //! \param [in] hNvDisplay NVIDIA display handle. It can be NVAPI_DEFAULT_HANDLE or a handle enumerated from //! NvAPI_EnumNVidiaDisplayHandle(). //! \param [in] outputId This display output ID, when it's "0" it means the default outputId generated from the return of //! NvAPI_GetAssociatedDisplayOutputId(). See \ref handles. //! \param [in] pCfg The display port config structure. If pCfg is NULL, it means to use the driver's default value to setup. //! //! \retval NVAPI_OK Completed request //! \retval NVAPI_ERROR Miscellaneous error occurred //! \retval NVAPI_INVALID_ARGUMENT Invalid input parameter /////////////////////////////////////////////////////////////////////////////// //! \ingroup dispcontrol //! DisplayPort configuration settings - used in NvAPI_SetDisplayPort(). typedef struct { NvU32 version; //!< Structure version - 2 is the latest NV_DP_LINK_RATE linkRate; //!< Link rate NV_DP_LANE_COUNT laneCount; //!< Lane count NV_DP_COLOR_FORMAT colorFormat; //!< Color format to set NV_DP_DYNAMIC_RANGE dynamicRange; //!< Dynamic range NV_DP_COLORIMETRY colorimetry; //!< Ignored in RGB space NV_DP_BPC bpc; //!< Bit-per-component NvU32 isHPD : 1; //!< If the control panel is making this call due to HPD NvU32 isSetDeferred : 1; //!< Requires an OS modeset to finalize the setup if set NvU32 isChromaLpfOff : 1; //!< Force the chroma low_pass_filter to be off NvU32 isDitherOff : 1; //!< Force to turn off dither NvU32 testLinkTrain : 1; //!< If testing mode, skip validation NvU32 testColorChange : 1; //!< If testing mode, skip validation } NV_DISPLAY_PORT_CONFIG; //! \addtogroup dispcontrol //! @{ //! Macro for constructing the version field of NV_DISPLAY_PORT_CONFIG #define NV_DISPLAY_PORT_CONFIG_VER MAKE_NVAPI_VERSION(NV_DISPLAY_PORT_CONFIG,2) //! Macro for constructing the version field of NV_DISPLAY_PORT_CONFIG #define NV_DISPLAY_PORT_CONFIG_VER_1 MAKE_NVAPI_VERSION(NV_DISPLAY_PORT_CONFIG,1) //! Macro for constructing the version field of NV_DISPLAY_PORT_CONFIG #define NV_DISPLAY_PORT_CONFIG_VER_2 MAKE_NVAPI_VERSION(NV_DISPLAY_PORT_CONFIG,2) //! @} //! \ingroup dispcontrol NVAPI_INTERFACE NvAPI_SetDisplayPort(NvDisplayHandle hNvDisplay, NvU32 outputId, NV_DISPLAY_PORT_CONFIG *pCfg); /////////////////////////////////////////////////////////////////////////////// // FUNCTION NAME: NvAPI_GetHDMISupportInfo // //! \fn NvAPI_GetHDMISupportInfo(NvDisplayHandle hNvDisplay, NvU32 outputId, NV_HDMI_SUPPORT_INFO *pInfo) //! This API returns the current infoframe data on the specified device(monitor). //! // SUPPORTED OS: Windows Vista and higher //! //! \since Version: 97.00 //! //! \param [in] hvDisplay NVIDIA Display selection. It can be NVAPI_DEFAULT_HANDLE or a handle enumerated from NvAPI_EnumNVidiaDisplayHandle(). //! \param [in] outputId The display output id. If it's "0" then the default outputId from NvAPI_GetAssociatedDisplayOutputId() will be used. See \ref handles. //! \param [out] pInfo The monitor and GPU's HDMI support info //! //! \retval NVAPI_OK Completed request //! \retval NVAPI_ERROR Miscellaneous error occurred //! \retval NVAPI_INVALID_ARGUMENT Invalid input parameter. /////////////////////////////////////////////////////////////////////////////// //! \ingroup dispcontrol //! Used in NvAPI_GetHDMISupportInfo(). typedef struct { NvU32 version; //!< Structure version NvU32 isGpuHDMICapable : 1; //!< If the GPU can handle HDMI NvU32 isMonUnderscanCapable : 1; //!< If the monitor supports underscan NvU32 isMonBasicAudioCapable : 1; //!< If the monitor supports basic audio NvU32 isMonYCbCr444Capable : 1; //!< If YCbCr 4:4:4 is supported NvU32 isMonYCbCr422Capable : 1; //!< If YCbCr 4:2:2 is supported NvU32 isMonxvYCC601Capable : 1; //!< If xvYCC 601 is supported NvU32 isMonxvYCC709Capable : 1; //!< If xvYCC 709 is supported NvU32 isMonHDMI : 1; //!< If the monitor is HDMI (with IEEE's HDMI registry ID) NvU32 EDID861ExtRev; //!< Revision number of the EDID 861 extension } NV_HDMI_SUPPORT_INFO; //! \ingroup dispcontrol #define NV_HDMI_SUPPORT_INFO_VER MAKE_NVAPI_VERSION(NV_HDMI_SUPPORT_INFO,1) //! \ingroup dispcontrol NVAPI_INTERFACE NvAPI_GetHDMISupportInfo(NvDisplayHandle hNvDisplay, NvU32 outputId, NV_HDMI_SUPPORT_INFO *pInfo); //! \ingroup dispcontrol //! @{ /////////////////////////////////////////////////////////////////////////////// // FUNCTION NAME: NvAPI_Disp_InfoFrameControl // //! \fn NvAPI_Disp_InfoFrameControl(NvU32 displayId, NV_INFOFRAME_DATA *pInfoframeData) //! DESCRIPTION: This API controls the InfoFrame values. //! // SUPPORTED OS: Windows Vista and higher //! //! \param [in] displayId Monitor Identifier //! \param [in,out] pInfoframeData Contains data corresponding to InfoFrame //! //! \return //! ::NVAPI_OK, //! ::NVAPI_ERROR, //! ::NVAPI_INVALID_ARGUMENT // /////////////////////////////////////////////////////////////////////////////// typedef enum { NV_INFOFRAME_CMD_GET_DEFAULT = 0, //!< Returns the fields in the infoframe with values set by the manufacturer - NVIDIA/OEM. NV_INFOFRAME_CMD_RESET, //!< Sets the fields in the infoframe to auto, and infoframe to the default infoframe for use in a set. NV_INFOFRAME_CMD_GET, //!< Get the current infoframe state. NV_INFOFRAME_CMD_SET, //!< Set the current infoframe state (flushed to the monitor), the values are one time and do not persist. NV_INFOFRAME_CMD_GET_OVERRIDE, //!< Get the override infoframe state, non-override fields will be set to value = AUTO, overridden fields will have the current override values. NV_INFOFRAME_CMD_SET_OVERRIDE, //!< Set the override infoframe state, non-override fields will be set to value = AUTO, other values indicate override; persist across modeset/reboot NV_INFOFRAME_CMD_GET_PROPERTY, //!< get properties associated with infoframe (each of the infoframe type will have properties) NV_INFOFRAME_CMD_SET_PROPERTY, //!< set properties associated with infoframe } NV_INFOFRAME_CMD; typedef enum { NV_INFOFRAME_PROPERTY_MODE_AUTO = 0, //!< Driver determines whether to send infoframes. NV_INFOFRAME_PROPERTY_MODE_ENABLE, //!< Driver always sends infoframe. NV_INFOFRAME_PROPERTY_MODE_DISABLE, //!< Driver never sends infoframe. NV_INFOFRAME_PROPERTY_MODE_ALLOW_OVERRIDE, //!< Driver only sends infoframe when client requests it via infoframe escape call. } NV_INFOFRAME_PROPERTY_MODE; //! Returns whether the current monitor is in blacklist or force this monitor to be in blacklist. typedef enum { NV_INFOFRAME_PROPERTY_BLACKLIST_FALSE = 0, NV_INFOFRAME_PROPERTY_BLACKLIST_TRUE, } NV_INFOFRAME_PROPERTY_BLACKLIST; typedef struct { NvU32 mode : 4; NvU32 blackList : 2; NvU32 reserved : 10; NvU32 version : 8; NvU32 length : 8; } NV_INFOFRAME_PROPERTY; //! Byte1 related typedef enum { NV_INFOFRAME_FIELD_VALUE_AVI_SCANINFO_NODATA = 0, NV_INFOFRAME_FIELD_VALUE_AVI_SCANINFO_OVERSCAN, NV_INFOFRAME_FIELD_VALUE_AVI_SCANINFO_UNDERSCAN, NV_INFOFRAME_FIELD_VALUE_AVI_SCANINFO_FUTURE, NV_INFOFRAME_FIELD_VALUE_AVI_SCANINFO_AUTO = 7 } NV_INFOFRAME_FIELD_VALUE_AVI_SCANINFO; typedef enum { NV_INFOFRAME_FIELD_VALUE_AVI_BARDATA_NOT_PRESENT = 0, NV_INFOFRAME_FIELD_VALUE_AVI_BARDATA_VERTICAL_PRESENT, NV_INFOFRAME_FIELD_VALUE_AVI_BARDATA_HORIZONTAL_PRESENT, NV_INFOFRAME_FIELD_VALUE_AVI_BARDATA_BOTH_PRESENT, NV_INFOFRAME_FIELD_VALUE_AVI_BARDATA_AUTO = 7 } NV_INFOFRAME_FIELD_VALUE_AVI_BARDATA; typedef enum { NV_INFOFRAME_FIELD_VALUE_AVI_AFI_ABSENT = 0, NV_INFOFRAME_FIELD_VALUE_AVI_AFI_PRESENT, NV_INFOFRAME_FIELD_VALUE_AVI_AFI_AUTO = 3 } NV_INFOFRAME_FIELD_VALUE_AVI_ACTIVEFORMATINFO; typedef enum { NV_INFOFRAME_FIELD_VALUE_AVI_COLORFORMAT_RGB = 0, NV_INFOFRAME_FIELD_VALUE_AVI_COLORFORMAT_YCbCr422, NV_INFOFRAME_FIELD_VALUE_AVI_COLORFORMAT_YCbCr444, NV_INFOFRAME_FIELD_VALUE_AVI_COLORFORMAT_FUTURE, NV_INFOFRAME_FIELD_VALUE_AVI_COLORFORMAT_AUTO = 7 } NV_INFOFRAME_FIELD_VALUE_AVI_COLORFORMAT; typedef enum { NV_INFOFRAME_FIELD_VALUE_AVI_F17_FALSE = 0, NV_INFOFRAME_FIELD_VALUE_AVI_F17_TRUE, NV_INFOFRAME_FIELD_VALUE_AVI_F17_AUTO = 3 } NV_INFOFRAME_FIELD_VALUE_AVI_F17; //! Byte2 related typedef enum { NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_NO_AFD = 0, NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_RESERVE01, NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_RESERVE02, NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_RESERVE03, NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_LETTERBOX_GT16x9, NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_RESERVE05, NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_RESERVE06, NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_RESERVE07, NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_EQUAL_CODEDFRAME = 8, NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_CENTER_4x3, NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_CENTER_16x9, NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_CENTER_14x9, NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_RESERVE12, NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_4x3_ON_14x9, NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_16x9_ON_14x9, NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_16x9_ON_4x3, NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION_AUTO = 31, } NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOACTIVEPORTION; typedef enum { NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOCODEDFRAME_NO_DATA = 0, NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOCODEDFRAME_4x3, NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOCODEDFRAME_16x9, NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOCODEDFRAME_FUTURE, NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOCODEDFRAME_AUTO = 7 } NV_INFOFRAME_FIELD_VALUE_AVI_ASPECTRATIOCODEDFRAME; typedef enum { NV_INFOFRAME_FIELD_VALUE_AVI_COLORIMETRY_NO_DATA = 0, NV_INFOFRAME_FIELD_VALUE_AVI_COLORIMETRY_SMPTE_170M, NV_INFOFRAME_FIELD_VALUE_AVI_COLORIMETRY_ITUR_BT709, NV_INFOFRAME_FIELD_VALUE_AVI_COLORIMETRY_USE_EXTENDED_COLORIMETRY, NV_INFOFRAME_FIELD_VALUE_AVI_COLORIMETRY_AUTO = 7 } NV_INFOFRAME_FIELD_VALUE_AVI_COLORIMETRY; //! Byte 3 related typedef enum { NV_INFOFRAME_FIELD_VALUE_AVI_NONUNIFORMPICTURESCALING_NO_DATA = 0, NV_INFOFRAME_FIELD_VALUE_AVI_NONUNIFORMPICTURESCALING_HORIZONTAL, NV_INFOFRAME_FIELD_VALUE_AVI_NONUNIFORMPICTURESCALING_VERTICAL, NV_INFOFRAME_FIELD_VALUE_AVI_NONUNIFORMPICTURESCALING_BOTH, NV_INFOFRAME_FIELD_VALUE_AVI_NONUNIFORMPICTURESCALING_AUTO = 7 } NV_INFOFRAME_FIELD_VALUE_AVI_NONUNIFORMPICTURESCALING; typedef enum { NV_INFOFRAME_FIELD_VALUE_AVI_RGBQUANTIZATION_DEFAULT = 0, NV_INFOFRAME_FIELD_VALUE_AVI_RGBQUANTIZATION_LIMITED_RANGE, NV_INFOFRAME_FIELD_VALUE_AVI_RGBQUANTIZATION_FULL_RANGE, NV_INFOFRAME_FIELD_VALUE_AVI_RGBQUANTIZATION_RESERVED, NV_INFOFRAME_FIELD_VALUE_AVI_RGBQUANTIZATION_AUTO = 7 } NV_INFOFRAME_FIELD_VALUE_AVI_RGBQUANTIZATION; typedef enum { NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY_XVYCC601 = 0, NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY_XVYCC709, NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY_SYCC601, NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY_ADOBEYCC601, NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY_ADOBERGB, NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY_RESERVED05, NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY_RESERVED06, NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY_RESERVED07, NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY_AUTO = 15 } NV_INFOFRAME_FIELD_VALUE_AVI_EXTENDEDCOLORIMETRY; typedef enum { NV_INFOFRAME_FIELD_VALUE_AVI_ITC_VIDEO_CONTENT = 0, NV_INFOFRAME_FIELD_VALUE_AVI_ITC_ITCONTENT, NV_INFOFRAME_FIELD_VALUE_AVI_ITC_AUTO = 3 } NV_INFOFRAME_FIELD_VALUE_AVI_ITC; //! Byte 4 related typedef enum { NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_NONE = 0, NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_X02, NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_X03, NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_X04, NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_X05, NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_X06, NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_X07, NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_X08, NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_X09, NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_X10, NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_RESERVED10, NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_RESERVED11, NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_RESERVED12, NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_RESERVED13, NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_RESERVED14, NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_RESERVED15, NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION_AUTO = 31 } NV_INFOFRAME_FIELD_VALUE_AVI_PIXELREPETITION; typedef enum { NV_INFOFRAME_FIELD_VALUE_AVI_CONTENTTYPE_GRAPHICS = 0, NV_INFOFRAME_FIELD_VALUE_AVI_CONTENTTYPE_PHOTO, NV_INFOFRAME_FIELD_VALUE_AVI_CONTENTTYPE_CINEMA, NV_INFOFRAME_FIELD_VALUE_AVI_CONTENTTYPE_GAME, NV_INFOFRAME_FIELD_VALUE_AVI_CONTENTTYPE_AUTO = 7 } NV_INFOFRAME_FIELD_VALUE_AVI_CONTENTTYPE; typedef enum { NV_INFOFRAME_FIELD_VALUE_AVI_YCCQUANTIZATION_LIMITED_RANGE = 0, NV_INFOFRAME_FIELD_VALUE_AVI_YCCQUANTIZATION_FULL_RANGE, NV_INFOFRAME_FIELD_VALUE_AVI_YCCQUANTIZATION_RESERVED02, NV_INFOFRAME_FIELD_VALUE_AVI_YCCQUANTIZATION_RESERVED03, NV_INFOFRAME_FIELD_VALUE_AVI_YCCQUANTIZATION_AUTO = 7 } NV_INFOFRAME_FIELD_VALUE_AVI_YCCQUANTIZATION; //! Adding an Auto bit to each field typedef struct { NvU32 vic : 8; NvU32 pixelRepeat : 5; NvU32 colorSpace : 3; NvU32 colorimetry : 3; NvU32 extendedColorimetry : 4; NvU32 rgbQuantizationRange : 3; NvU32 yccQuantizationRange : 3; NvU32 itContent : 2; NvU32 contentTypes : 3; NvU32 scanInfo : 3; NvU32 activeFormatInfoPresent : 2; NvU32 activeFormatAspectRatio : 5; NvU32 picAspectRatio : 3; NvU32 nonuniformScaling : 3; NvU32 barInfo : 3; NvU32 top_bar : 17; NvU32 bottom_bar : 17; NvU32 left_bar : 17; NvU32 right_bar : 17; NvU32 Future17 : 2; NvU32 Future47 : 2; } NV_INFOFRAME_VIDEO; //! Byte 1 related typedef enum { NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT_IN_HEADER = 0, NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT_2, NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT_3, NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT_4, NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT_5, NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT_6, NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT_7, NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT_8, NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT_AUTO = 15 } NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELCOUNT; typedef enum { NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_IN_HEADER = 0, NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_PCM, NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_AC3, NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_MPEG1, NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_MP3, NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_MPEG2, NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_AACLC, NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_DTS, NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_ATRAC, NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_DSD, NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_EAC3, NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_DTSHD, NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_MLP, NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_DST, NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_WMAPRO, NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_USE_CODING_EXTENSION_TYPE, NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE_AUTO = 31 } NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGTYPE; //! Byte 2 related typedef enum { NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLESIZE_IN_HEADER = 0, NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLESIZE_16BITS, NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLESIZE_20BITS, NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLESIZE_24BITS, NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLESIZE_AUTO = 7 } NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLESIZE; typedef enum { NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY_IN_HEADER = 0, NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY_32000HZ, NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY_44100HZ, NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY_48000HZ, NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY_88200KHZ, NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY_96000KHZ, NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY_176400KHZ, NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY_192000KHZ, NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY_AUTO = 15 } NV_INFOFRAME_FIELD_VALUE_AUDIO_SAMPLEFREQUENCY; //! Byte 3 related typedef enum { NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_USE_CODING_TYPE = 0, NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_HEAAC, NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_HEAACV2, NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_MPEGSURROUND, NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE04, NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE05, NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE06, NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE07, NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE08, NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE09, NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE10, NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE11, NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE12, NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE13, NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE14, NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE15, NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE16, NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE17, NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE18, NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE19, NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE20, NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE21, NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE22, NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE23, NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE24, NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE25, NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE26, NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE27, NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE28, NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE29, NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE30, NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_RESERVE31, NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE_AUTO = 63 } NV_INFOFRAME_FIELD_VALUE_AUDIO_CODINGEXTENSIONTYPE; //! Byte 4 related typedef enum { NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_X_X_X_X_X_X_FR_FL =0, NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_X_X_X_X_X_LFE_FR_FL, NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_X_X_X_X_FC_X_FR_FL, NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_X_X_X_X_FC_LFE_FR_FL, NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_X_X_X_RC_X_X_FR_FL, NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_X_X_X_RC_X_LFE_FR_FL, NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_X_X_X_RC_FC_X_FR_FL, NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_X_X_X_RC_FC_LFE_FR_FL, NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_X_X_RR_RL_X_X_FR_FL, NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_X_X_RR_RL_X_LFE_FR_FL, NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_X_X_RR_RL_FC_X_FR_FL, NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_X_X_RR_RL_FC_LFE_FR_FL, NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_X_RC_RR_RL_X_X_FR_FL, NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_X_RC_RR_RL_X_LFE_FR_FL, NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_X_RC_RR_RL_FC_X_FR_FL, NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_X_RC_RR_RL_FC_LFE_FR_FL, NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_RRC_RLC_RR_RL_X_X_FR_FL, NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_RRC_RLC_RR_RL_X_LFE_FR_FL, NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_RRC_RLC_RR_RL_FC_X_FR_FL, NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_RRC_RLC_RR_RL_FC_LFE_FR_FL, NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_FRC_FLC_X_X_X_X_FR_FL, NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_FRC_FLC_X_X_X_LFE_FR_FL, NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_FRC_FLC_X_X_FC_X_FR_FL, NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_FRC_FLC_X_X_FC_LFE_FR_FL, NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_FRC_FLC_X_RC_X_X_FR_FL, NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_FRC_FLC_X_RC_X_LFE_FR_FL, NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_FRC_FLC_X_RC_FC_X_FR_FL, NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_FRC_FLC_X_RC_FC_LFE_FR_FL, NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_FRC_FLC_RR_RL_X_X_FR_FL, NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_FRC_FLC_RR_RL_X_LFE_FR_FL, NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_FRC_FLC_RR_RL_FC_X_FR_FL, NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_FRC_FLC_RR_RL_FC_LFE_FR_FL, NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_X_FCH_RR_RL_FC_X_FR_FL, NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_X_FCH_RR_RL_FC_LFE_FR_FL, NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_TC_X_RR_RL_FC_X_FR_FL, NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_TC_X_RR_RL_FC_LFE_FR_FL, NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_FRH_FLH_RR_RL_X_X_FR_FL, NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_FRH_FLH_RR_RL_X_LFE_FR_FL, NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_FRW_FLW_RR_RL_X_X_FR_FL, NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_FRW_FLW_RR_RL_X_LFE_FR_FL, NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_TC_RC_RR_RL_FC_X_FR_FL, NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_TC_RC_RR_RL_FC_LFE_FR_FL, NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_FCH_RC_RR_RL_FC_X_FR_FL, NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_FCH_RC_RR_RL_FC_LFE_FR_FL, NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_TC_FCH_RR_RL_FC_X_FR_FL, NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_TC_FCH_RR_RL_FC_LFE_FR_FL, NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_FRH_FLH_RR_RL_FC_X_FR_FL, NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_FRH_FLH_RR_RL_FC_LFE_FR_FL, NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_FRW_FLW_RR_RL_FC_X_FR_FL, NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_FRW_FLW_RR_RL_FC_LFE_FR_FL = 0X31, // all other values should default to auto NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION_AUTO = 0x1FF } NV_INFOFRAME_FIELD_VALUE_AUDIO_CHANNELALLOCATION; //! Byte 5 related typedef enum { NV_INFOFRAME_FIELD_VALUE_AUDIO_LFEPLAYBACKLEVEL_NO_DATA = 0, NV_INFOFRAME_FIELD_VALUE_AUDIO_LFEPLAYBACKLEVEL_0DB, NV_INFOFRAME_FIELD_VALUE_AUDIO_LFEPLAYBACKLEVEL_PLUS10DB, NV_INFOFRAME_FIELD_VALUE_AUDIO_LFEPLAYBACKLEVEL_RESERVED03, NV_INFOFRAME_FIELD_VALUE_AUDIO_LFEPLAYBACKLEVEL_AUTO = 7 } NV_INFOFRAME_FIELD_VALUE_AUDIO_LFEPLAYBACKLEVEL; typedef enum { NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_0DB = 0, NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_1DB, NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_2DB, NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_3DB, NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_4DB, NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_5DB, NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_6DB, NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_7DB, NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_8DB, NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_9DB, NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_10DB, NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_11DB, NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_12DB, NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_13DB, NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_14DB, NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_15DB, NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES_AUTO = 31 } NV_INFOFRAME_FIELD_VALUE_AUDIO_LEVELSHIFTVALUES; typedef enum { NV_INFOFRAME_FIELD_VALUE_AUDIO_DOWNMIX_PERMITTED = 0, NV_INFOFRAME_FIELD_VALUE_AUDIO_DOWNMIX_PROHIBITED, NV_INFOFRAME_FIELD_VALUE_AUDIO_DOWNMIX_AUTO = 3 } NV_INFOFRAME_FIELD_VALUE_AUDIO_DOWNMIX; typedef struct { NvU32 codingType : 5; NvU32 codingExtensionType : 6; NvU32 sampleSize : 3; NvU32 sampleRate : 4; NvU32 channelCount : 4; NvU32 speakerPlacement : 9; NvU32 downmixInhibit : 2; NvU32 lfePlaybackLevel : 3; NvU32 levelShift : 5; NvU32 Future12 : 2; NvU32 Future2x : 4; NvU32 Future3x : 4; NvU32 Future52 : 2; NvU32 Future6 : 9; NvU32 Future7 : 9; NvU32 Future8 : 9; NvU32 Future9 : 9; NvU32 Future10 : 9; } NV_INFOFRAME_AUDIO; typedef struct { NvU32 version; //!< version of this structure NvU16 size; //!< size of this structure NvU8 cmd; //!< The actions to perform from NV_INFOFRAME_CMD NvU8 type; //!< type of infoframe union { NV_INFOFRAME_PROPERTY property; //!< This is NVIDIA-specific and corresponds to the property cmds and associated infoframe. NV_INFOFRAME_AUDIO audio; NV_INFOFRAME_VIDEO video; } infoframe; } NV_INFOFRAME_DATA; //! Macro for constructing the version field of ::NV_INFOFRAME_DATA #define NV_INFOFRAME_DATA_VER MAKE_NVAPI_VERSION(NV_INFOFRAME_DATA,1) NVAPI_INTERFACE NvAPI_Disp_InfoFrameControl(NvU32 displayId, NV_INFOFRAME_DATA *pInfoframeData); //! @} //! \ingroup dispcontrol //! @{ /////////////////////////////////////////////////////////////////////////////// // FUNCTION NAME: NvAPI_Disp_ColorControl // //! \fn NvAPI_Disp_ColorControl(NvU32 displayId, NV_COLOR_DATA *pColorData) //! DESCRIPTION: This API controls the Color values. //! // SUPPORTED OS: Windows Vista and higher //! //! \param [in] displayId Monitor Identifier //! \param [in,out] pColorData Contains data corresponding to color information //! //! \return RETURN STATUS: //! ::NVAPI_OK, //! ::NVAPI_ERROR, //! ::NVAPI_INVALID_ARGUMENT // /////////////////////////////////////////////////////////////////////////////// typedef enum { NV_COLOR_CMD_GET = 1, NV_COLOR_CMD_SET, NV_COLOR_CMD_IS_SUPPORTED_COLOR, NV_COLOR_CMD_GET_DEFAULT } NV_COLOR_CMD; //! See Table 14 of CEA-861E. Not all of this is supported by the GPU. typedef enum { NV_COLOR_FORMAT_RGB = 0, NV_COLOR_FORMAT_YUV422, NV_COLOR_FORMAT_YUV444, NV_COLOR_FORMAT_DEFAULT = 0xFE, NV_COLOR_FORMAT_AUTO = 0xFF } NV_COLOR_FORMAT; typedef enum { NV_COLOR_COLORIMETRY_RGB = 0, NV_COLOR_COLORIMETRY_YCC601, NV_COLOR_COLORIMETRY_YCC709, NV_COLOR_COLORIMETRY_XVYCC601, NV_COLOR_COLORIMETRY_XVYCC709, NV_COLOR_COLORIMETRY_SYCC601, NV_COLOR_COLORIMETRY_ADOBEYCC601, NV_COLOR_COLORIMETRY_ADOBERGB, NV_COLOR_COLORIMETRY_DEFAULT = 0xFE, NV_COLOR_COLORIMETRY_AUTO = 0xFF } NV_COLOR_COLORIMETRY; typedef struct { NvU32 version; //!< Version of this structure NvU16 size; //!< Size of this structure NvU8 cmd; struct { NvU8 colorFormat; NvU8 colorimetry; } data; } NV_COLOR_DATA; NVAPI_INTERFACE NvAPI_Disp_ColorControl(NvU32 displayId, NV_COLOR_DATA *pColorData); //! Macro for constructing the version field of ::NV_COLOR_DATA #define NV_COLOR_DATA_VER MAKE_NVAPI_VERSION(NV_COLOR_DATA,1) //! @} //----------------------------------------------------------------------------- // DirectX APIs //----------------------------------------------------------------------------- //! \ingroup dx //! Used in NvAPI_D3D10_GetCurrentSLIState(), and NvAPI_D3D_GetCurrentSLIState(). typedef struct { NvU32 version; //!< Structure version NvU32 maxNumAFRGroups; //!< [OUT] The maximum possible value of numAFRGroups NvU32 numAFRGroups; //!< [OUT] The number of AFR groups enabled in the system NvU32 currentAFRIndex; //!< [OUT] The AFR group index for the frame currently being rendered NvU32 nextFrameAFRIndex; //!< [OUT] What the AFR group index will be for the next frame (i.e. after calling Present) NvU32 previousFrameAFRIndex; //!< [OUT] The AFR group index that was used for the previous frame (~0 if more than one frame has not been rendered yet) NvU32 bIsCurAFRGroupNew; //!< [OUT] Boolean: Is this frame the first time running on the current AFR group } NV_GET_CURRENT_SLI_STATE; //! \ingroup dx #define NV_GET_CURRENT_SLI_STATE_VER MAKE_NVAPI_VERSION(NV_GET_CURRENT_SLI_STATE,1) #if defined(_D3D9_H_) || defined(__d3d10_h__) || defined(__d3d11_h__) /////////////////////////////////////////////////////////////////////////////// // // FUNCTION NAME: NvAPI_D3D_GetCurrentSLIState // //! DESCRIPTION: This function returns the current SLI state for the specified device. The structure //! contains the number of AFR groups, the current AFR group index, //! and what the AFR group index will be for the next frame. \p //! pDevice can be either a IDirect3DDevice9 or ID3D10Device pointer. //! // SUPPORTED OS: Windows XP and higher //! //! \since Version: 174.80 //! //! \retval NVAPI_OK Completed request //! \retval NVAPI_ERROR Error occurred //! //! \ingroup dx /////////////////////////////////////////////////////////////////////////////// NVAPI_INTERFACE NvAPI_D3D_GetCurrentSLIState(IUnknown *pDevice, NV_GET_CURRENT_SLI_STATE *pSliState); #endif //if defined(_D3D9_H_) || defined(__d3d10_h__) || defined(__d3d11_h__) /////////////////////////////////////////////////////////////////////////////// // // FUNCTION NAME: NvAPI_GPU_GetGpuCoreCount // //! DESCRIPTION: Retrieves the total number of cores defined for a GPU. //! Returns 0 on architectures that don't define GPU cores. //! // SUPPORTED OS: Windows XP and higher //! //! \retval ::NVAPI_INVALID_ARGUMENT pCount is NULL //! \retval ::NVAPI_OK *pCount is set //! \retval ::NVAPI_NVIDIA_DEVICE_NOT_FOUND no NVIDIA GPU driving a display was found //! \retval ::NVAPI_EXPECTED_PHYSICAL_GPU_HANDLE hPhysicalGpu was not a physical GPU handle //! \retval ::NVAPI_NOT_SUPPORTED API call is not supported on current architecture //! //! \ingroup gpu /////////////////////////////////////////////////////////////////////////////// NVAPI_INTERFACE NvAPI_GPU_GetGpuCoreCount(NvPhysicalGpuHandle hPhysicalGpu,NvU32 *pCount); /////////////////////////////////////////////////////////////////////////////// // // FUNCTION NAME: NvAPI_GPU_GetAllOutputs // //! This function returns set of all GPU-output identifiers as a bitmask. //! // SUPPORTED OS: Windows XP and higher //! //! \since Version: 87.00 //! //! \retval NVAPI_INVALID_ARGUMENT hPhysicalGpu or pOutputsMask is NULL. //! \retval NVAPI_OK *pOutputsMask contains a set of GPU-output identifiers. //! \retval NVAPI_NVIDIA_DEVICE_NOT_FOUND No NVIDIA GPU driving a display was found. //! \retval NVAPI_EXPECTED_PHYSICAL_GPU_HANDLE hPhysicalGpu was not a physical GPU handle. //! \ingroup gpu /////////////////////////////////////////////////////////////////////////////// NVAPI_INTERFACE NvAPI_GPU_GetAllOutputs(NvPhysicalGpuHandle hPhysicalGpu,NvU32 *pOutputsMask); /////////////////////////////////////////////////////////////////////////////// // // FUNCTION NAME: NvAPI_GPU_GetConnectedOutputs // //! This function is the same as NvAPI_GPU_GetAllOutputs() but returns only the set of GPU output //! identifiers that are connected to display devices. //! // SUPPORTED OS: Windows XP and higher //! //! \since Version: 82.61 //! //! \retval NVAPI_INVALID_ARGUMENT hPhysicalGpu or pOutputsMask is NULL. //! \retval NVAPI_OK *pOutputsMask contains a set of GPU-output identifiers. //! \retval NVAPI_NVIDIA_DEVICE_NOT_FOUND No NVIDIA GPU driving a display was found. //! \retval NVAPI_EXPECTED_PHYSICAL_GPU_HANDLE hPhysicalGpu was not a physical GPU handle. //! \ingroup gpu /////////////////////////////////////////////////////////////////////////////// NVAPI_INTERFACE NvAPI_GPU_GetConnectedOutputs(NvPhysicalGpuHandle hPhysicalGpu, NvU32 *pOutputsMask); /////////////////////////////////////////////////////////////////////////////// // // FUNCTION NAME: NvAPI_GPU_GetConnectedSLIOutputs // //! DESCRIPTION: This function is the same as NvAPI_GPU_GetConnectedOutputs() but returns only the set of GPU-output //! identifiers that can be selected in an SLI configuration. //! NOTE: This function matches NvAPI_GPU_GetConnectedOutputs() //! - On systems which are not SLI capable. //! - If the queried GPU is not part of a valid SLI group. //! // SUPPORTED OS: Windows XP and higher //! //! \since Version: 171.14 //! //! \retval NVAPI_INVALID_ARGUMENT hPhysicalGpu or pOutputsMask is NULL //! \retval NVAPI_OK *pOutputsMask contains a set of GPU-output identifiers //! \retval NVAPI_NVIDIA_DEVICE_NOT_FOUND No NVIDIA GPU driving a display was found //! \retval NVAPI_EXPECTED_PHYSICAL_GPU_HANDLE: hPhysicalGpu was not a physical GPU handle //! //! \ingroup gpu /////////////////////////////////////////////////////////////////////////////// NVAPI_INTERFACE NvAPI_GPU_GetConnectedSLIOutputs(NvPhysicalGpuHandle hPhysicalGpu, NvU32 *pOutputsMask); //! \ingroup gpu typedef enum { NV_MONITOR_CONN_TYPE_UNINITIALIZED = 0, NV_MONITOR_CONN_TYPE_VGA, NV_MONITOR_CONN_TYPE_COMPONENT, NV_MONITOR_CONN_TYPE_SVIDEO, NV_MONITOR_CONN_TYPE_HDMI, NV_MONITOR_CONN_TYPE_DVI, NV_MONITOR_CONN_TYPE_LVDS, NV_MONITOR_CONN_TYPE_DP, NV_MONITOR_CONN_TYPE_COMPOSITE, NV_MONITOR_CONN_TYPE_UNKNOWN = -1 } NV_MONITOR_CONN_TYPE; /////////////////////////////////////////////////////////////////////////////// // // FUNCTION NAME: NvAPI_GPU_GetConnectedOutputsWithLidState // //! This function is similar to NvAPI_GPU_GetConnectedOutputs(), and returns the connected display identifiers that are connected //! as an output mask but unlike NvAPI_GPU_GetConnectedOutputs() this API "always" reflects the Lid State in the output mask. //! Thus if you expect the LID close state to be available in the connection mask use this API. //! - If LID is closed then this API will remove the LID panel from the connected display identifiers. //! - If LID is open then this API will reflect the LID panel in the connected display identifiers. //! //! \note This API should be used on notebook systems and on systems where the LID state is required in the connection //! output mask. On desktop systems the returned identifiers will match NvAPI_GPU_GetConnectedOutputs(). //! // SUPPORTED OS: Windows XP and higher //! //! \since Version: 97.20 //! //! \retval NVAPI_INVALID_ARGUMENT hPhysicalGpu or pOutputsMask is NULL //! \retval NVAPI_OK *pOutputsMask contains a set of GPU-output identifiers //! \retval NVAPI_NVIDIA_DEVICE_NOT_FOUND No NVIDIA GPU driving a display was found //! \retval NVAPI_EXPECTED_PHYSICAL_GPU_HANDLE hPhysicalGpu was not a physical GPU handle //! \ingroup gpu /////////////////////////////////////////////////////////////////////////////// NVAPI_INTERFACE NvAPI_GPU_GetConnectedOutputsWithLidState(NvPhysicalGpuHandle hPhysicalGpu, NvU32 *pOutputsMask); /////////////////////////////////////////////////////////////////////////////// // // FUNCTION NAME: NvAPI_GPU_GetConnectedSLIOutputsWithLidState // //! DESCRIPTION: This function is the same as NvAPI_GPU_GetConnectedOutputsWithLidState() but returns only the set //! of GPU-output identifiers that can be selected in an SLI configuration. With SLI disabled, //! this function matches NvAPI_GPU_GetConnectedOutputsWithLidState(). //! // SUPPORTED OS: Windows XP and higher //! //! \since Version: 171.14 //! //! \retval NVAPI_INVALID_ARGUMENT hPhysicalGpu or pOutputsMask is NULL //! \retval NVAPI_OK *pOutputsMask contains a set of GPU-output identifiers //! \retval NVAPI_NVIDIA_DEVICE_NOT_FOUND No NVIDIA GPU driving a display was found //! \retval NVAPI_EXPECTED_PHYSICAL_GPU_HANDLE hPhysicalGpu was not a physical GPU handle //! //! \ingroup gpu /////////////////////////////////////////////////////////////////////////////// NVAPI_INTERFACE NvAPI_GPU_GetConnectedSLIOutputsWithLidState(NvPhysicalGpuHandle hPhysicalGpu, NvU32 *pOutputsMask); /////////////////////////////////////////////////////////////////////////////// // // FUNCTION NAME: NvAPI_GPU_GetSystemType // //! \fn NvAPI_GPU_GetSystemType(NvPhysicalGpuHandle hPhysicalGpu, NV_SYSTEM_TYPE *pSystemType) //! This function identifies whether the GPU is a notebook GPU or a desktop GPU. //! // SUPPORTED OS: Windows XP and higher //! //! \since Version: 97.20 //! //! \retval NVAPI_INVALID_ARGUMENT hPhysicalGpu or pOutputsMask is NULL //! \retval NVAPI_OK *pSystemType contains the GPU system type //! \retval NVAPI_NVIDIA_DEVICE_NOT_FOUND No NVIDIA GPU driving a display was found //! \retval NVAPI_EXPECTED_PHYSICAL_GPU_HANDLE: hPhysicalGpu was not a physical GPU handle // /////////////////////////////////////////////////////////////////////////////// //! \ingroup gpu //! Used in NvAPI_GPU_GetSystemType() typedef enum { NV_SYSTEM_TYPE_UNKNOWN = 0, NV_SYSTEM_TYPE_LAPTOP = 1, NV_SYSTEM_TYPE_DESKTOP = 2, } NV_SYSTEM_TYPE; //! \ingroup gpu NVAPI_INTERFACE NvAPI_GPU_GetSystemType(NvPhysicalGpuHandle hPhysicalGpu, NV_SYSTEM_TYPE *pSystemType); /////////////////////////////////////////////////////////////////////////////// // // FUNCTION NAME: NvAPI_GPU_GetActiveOutputs // //! This function is the same as NvAPI_GPU_GetAllOutputs but returns only the set of GPU output //! identifiers that are actively driving display devices. //! // SUPPORTED OS: Windows XP and higher //! //! \since Version: 87.10 //! //! \retval NVAPI_INVALID_ARGUMENT hPhysicalGpu or pOutputsMask is NULL. //! \retval NVAPI_OK *pOutputsMask contains a set of GPU-output identifiers. //! \retval NVAPI_NVIDIA_DEVICE_NOT_FOUND No NVIDIA GPU driving a display was found. //! \retval NVAPI_EXPECTED_PHYSICAL_GPU_HANDLE hPhysicalGpu was not a physical GPU handle. //! \ingroup gpu /////////////////////////////////////////////////////////////////////////////// NVAPI_INTERFACE NvAPI_GPU_GetActiveOutputs(NvPhysicalGpuHandle hPhysicalGpu, NvU32 *pOutputsMask); /////////////////////////////////////////////////////////////////////////////// // // FUNCTION NAME: NvAPI_GPU_GetEDID // //! \fn NvAPI_GPU_GetEDID(NvPhysicalGpuHandle hPhysicalGpu, NvU32 displayOutputId, NV_EDID *pEDID) //! This function returns the EDID data for the specified GPU handle and connection bit mask. //! displayOutputId should have exactly 1 bit set to indicate a single display. See \ref handles. //! // SUPPORTED OS: Windows XP and higher //! //! \since Version: 88.50 //! //! \retval NVAPI_INVALID_ARGUMENT pEDID is NULL; displayOutputId has 0 or > 1 bits set //! \retval NVAPI_OK *pEDID contains valid data. //! \retval NVAPI_NVIDIA_DEVICE_NOT_FOUND No NVIDIA GPU driving a display was found. //! \retval NVAPI_EXPECTED_PHYSICAL_GPU_HANDLE hPhysicalGpu was not a physical GPU handle. //! \retval NVAPI_DATA_NOT_FOUND The requested display does not contain an EDID. // /////////////////////////////////////////////////////////////////////////////// //! \ingroup gpu //! @{ #define NV_EDID_V1_DATA_SIZE 256 #define NV_EDID_DATA_SIZE NV_EDID_V1_DATA_SIZE typedef struct { NvU32 version; //structure version NvU8 EDID_Data[NV_EDID_DATA_SIZE]; } NV_EDID_V1; //! Used in NvAPI_GPU_GetEDID() typedef struct { NvU32 version; //!< Structure version NvU8 EDID_Data[NV_EDID_DATA_SIZE]; NvU32 sizeofEDID; } NV_EDID_V2; //! Used in NvAPI_GPU_GetEDID() typedef struct { NvU32 version; //!< Structure version NvU8 EDID_Data[NV_EDID_DATA_SIZE]; NvU32 sizeofEDID; NvU32 edidId; //!< ID which always returned in a monotonically increasing counter. //!< Across a split-EDID read we need to verify that all calls returned the same edidId. //!< This counter is incremented if we get the updated EDID. NvU32 offset; //!< Which 256-byte page of the EDID we want to read. Start at 0. //!< If the read succeeds with edidSize > NV_EDID_DATA_SIZE, //!< call back again with offset+256 until we have read the entire buffer } NV_EDID_V3; typedef NV_EDID_V3 NV_EDID; #define NV_EDID_VER1 MAKE_NVAPI_VERSION(NV_EDID_V1,1) #define NV_EDID_VER2 MAKE_NVAPI_VERSION(NV_EDID_V2,2) #define NV_EDID_VER3 MAKE_NVAPI_VERSION(NV_EDID_V3,3) #define NV_EDID_VER NV_EDID_VER3 //! @} //! \ingroup gpu NVAPI_INTERFACE NvAPI_GPU_GetEDID(NvPhysicalGpuHandle hPhysicalGpu, NvU32 displayOutputId, NV_EDID *pEDID); /////////////////////////////////////////////////////////////////////////////// // // FUNCTION NAME: NvAPI_GPU_SetEDID // //! Thus function sets the EDID data for the specified GPU handle and connection bit mask. //! displayOutputId should have exactly 1 bit set to indicate a single display. See \ref handles. //! \note The EDID will be cached across the boot session and will be enumerated to the OS in this call. //! To remove the EDID set sizeofEDID to zero. //! OS and NVAPI connection status APIs will reflect the newly set or removed EDID dynamically. //! //! This feature will NOT be supported on the following boards: //! - GeForce //! - Quadro VX //! - Tesla //! // SUPPORTED OS: Windows XP and higher //! //! \since Version: 100.40 //! //! \retval NVAPI_INVALID_ARGUMENT pEDID is NULL; displayOutputId has 0 or > 1 bits set //! \retval NVAPI_OK *pEDID data was applied to the requested displayOutputId. //! \retval NVAPI_NVIDIA_DEVICE_NOT_FOUND No NVIDIA GPU driving a display was found. //! \retval NVAPI_EXPECTED_PHYSICAL_GPU_HANDLE: hPhysicalGpu was not a physical GPU handle. //! \retval NVAPI_NOT_SUPPORTED For the above mentioned GPUs //! \ingroup gpu /////////////////////////////////////////////////////////////////////////////// NVAPI_INTERFACE NvAPI_GPU_SetEDID(NvPhysicalGpuHandle hPhysicalGpu, NvU32 displayOutputId, NV_EDID *pEDID); /////////////////////////////////////////////////////////////////////////////// // // FUNCTION NAME: NvAPI_GPU_GetOutputType // //! \fn NvAPI_GPU_GetOutputType(NvPhysicalGpuHandle hPhysicalGpu, NvU32 outputId, NV_GPU_OUTPUT_TYPE *pOutputType) //! This function returns the output type for a specific physical GPU handle and outputId (exactly 1 bit set - see \ref handles). //! // SUPPORTED OS: Windows XP and higher //! //! \Version Earliest supported ForceWare version: 82.61 //! //! \retval NVAPI_INVALID_ARGUMENT hPhysicalGpu, outputId, or pOutputsMask is NULL; or outputId has > 1 bit set //! \retval NVAPI_OK *pOutputType contains a NvGpuOutputType value //! \retval NVAPI_NVIDIA_DEVICE_NOT_FOUND No NVIDIA GPU driving a display was found //! \retval NVAPI_EXPECTED_PHYSICAL_GPU_HANDLE hPhysicalGpu was not a physical GPU handle // /////////////////////////////////////////////////////////////////////////////// //! \ingroup gpu //! used in NvAPI_GPU_GetOutputType() typedef enum _NV_GPU_OUTPUT_TYPE { NVAPI_GPU_OUTPUT_UNKNOWN = 0, NVAPI_GPU_OUTPUT_CRT = 1, //!< CRT display device NVAPI_GPU_OUTPUT_DFP = 2, //!< Digital Flat Panel display device NVAPI_GPU_OUTPUT_TV = 3, //!< TV display device } NV_GPU_OUTPUT_TYPE; //! \ingroup gpu NVAPI_INTERFACE NvAPI_GPU_GetOutputType(NvPhysicalGpuHandle hPhysicalGpu, NvU32 outputId, NV_GPU_OUTPUT_TYPE *pOutputType); /////////////////////////////////////////////////////////////////////////////// // // FUNCTION NAME: NvAPI_GPU_ValidateOutputCombination // //! This function determines if a set of GPU outputs can be active //! simultaneously. While a GPU may have outputs, typically they cannot //! all be active at the same time due to internal resource sharing. //! //! Given a physical GPU handle and a mask of candidate outputs, this call //! will return NVAPI_OK if all of the specified outputs can be driven //! simultaneously. It will return NVAPI_INVALID_COMBINATION if they cannot. //! //! Use NvAPI_GPU_GetAllOutputs() to determine which outputs are candidates. //! // SUPPORTED OS: Windows XP and higher //! //! \since Version: 87.10 //! //! \retval NVAPI_OK Combination of outputs in outputsMask are valid (can be active simultaneously). //! \retval NVAPI_INVALID_COMBINATION Combination of outputs in outputsMask are NOT valid. //! \retval NVAPI_INVALID_ARGUMENT hPhysicalGpu or outputsMask does not have at least 2 bits set. //! \retval NVAPI_EXPECTED_PHYSICAL_GPU_HANDLE hPhysicalGpu was not a physical GPU handle. //! \retval NVAPI_NVIDIA_DEVICE_NOT_FOUND No NVIDIA GPU driving a display was found. //! \ingroup gpu /////////////////////////////////////////////////////////////////////////////// NVAPI_INTERFACE NvAPI_GPU_ValidateOutputCombination(NvPhysicalGpuHandle hPhysicalGpu, NvU32 outputsMask); //! \ingroup gpu //! Used in NV_GPU_CONNECTOR_DATA typedef enum _NV_GPU_CONNECTOR_TYPE { NVAPI_GPU_CONNECTOR_VGA_15_PIN = 0x00000000, NVAPI_GPU_CONNECTOR_TV_COMPOSITE = 0x00000010, NVAPI_GPU_CONNECTOR_TV_SVIDEO = 0x00000011, NVAPI_GPU_CONNECTOR_TV_HDTV_COMPONENT = 0x00000013, NVAPI_GPU_CONNECTOR_TV_SCART = 0x00000014, NVAPI_GPU_CONNECTOR_TV_COMPOSITE_SCART_ON_EIAJ4120 = 0x00000016, NVAPI_GPU_CONNECTOR_TV_HDTV_EIAJ4120 = 0x00000017, NVAPI_GPU_CONNECTOR_PC_POD_HDTV_YPRPB = 0x00000018, NVAPI_GPU_CONNECTOR_PC_POD_SVIDEO = 0x00000019, NVAPI_GPU_CONNECTOR_PC_POD_COMPOSITE = 0x0000001A, NVAPI_GPU_CONNECTOR_DVI_I_TV_SVIDEO = 0x00000020, NVAPI_GPU_CONNECTOR_DVI_I_TV_COMPOSITE = 0x00000021, NVAPI_GPU_CONNECTOR_DVI_I = 0x00000030, NVAPI_GPU_CONNECTOR_DVI_D = 0x00000031, NVAPI_GPU_CONNECTOR_ADC = 0x00000032, NVAPI_GPU_CONNECTOR_LFH_DVI_I_1 = 0x00000038, NVAPI_GPU_CONNECTOR_LFH_DVI_I_2 = 0x00000039, NVAPI_GPU_CONNECTOR_SPWG = 0x00000040, NVAPI_GPU_CONNECTOR_OEM = 0x00000041, NVAPI_GPU_CONNECTOR_DISPLAYPORT_EXTERNAL = 0x00000046, NVAPI_GPU_CONNECTOR_DISPLAYPORT_INTERNAL = 0x00000047, NVAPI_GPU_CONNECTOR_DISPLAYPORT_MINI_EXT = 0x00000048, NVAPI_GPU_CONNECTOR_HDMI_A = 0x00000061, NVAPI_GPU_CONNECTOR_HDMI_C_MINI = 0x00000063, NVAPI_GPU_CONNECTOR_LFH_DISPLAYPORT_1 = 0x00000064, NVAPI_GPU_CONNECTOR_LFH_DISPLAYPORT_2 = 0x00000065, NVAPI_GPU_CONNECTOR_UNKNOWN = 0xFFFFFFFF, } NV_GPU_CONNECTOR_TYPE; /////////////////////////////////////////////////////////////////////////////// // // FUNCTION NAME: NvAPI_GPU_GetFullName // //! This function retrieves the full GPU name as an ASCII string - for example, "Quadro FX 1400". //! // SUPPORTED OS: Mac OS X, Windows XP and higher //! //! \since Version: 92.10 //! //! \return NVAPI_ERROR or NVAPI_OK //! \ingroup gpu /////////////////////////////////////////////////////////////////////////////// //NVAPI_INTERFACE NvAPI_GPU_GetFullName(NvPhysicalGpuHandle hPhysicalGpu, NvAPI_ShortString szName); typedef NvStatus (__cdecl *P_NvAPI_GPU_GetFullName)(NvPhysicalGpuHandle hPhysicalGpu, NvAPI_ShortString szName); P_NvAPI_GPU_GetFullName NvAPI_GetFullName; /////////////////////////////////////////////////////////////////////////////// // // FUNCTION NAME: NvAPI_GPU_GetPCIIdentifiers // //! This function returns the PCI identifiers associated with this GPU. //! // SUPPORTED OS: Windows XP and higher //! //! \since Version: 92.10 //! //! \param DeviceId The internal PCI device identifier for the GPU. //! \param SubSystemId The internal PCI subsystem identifier for the GPU. //! \param RevisionId The internal PCI device-specific revision identifier for the GPU. //! \param ExtDeviceId The external PCI device identifier for the GPU. //! //! \retval NVAPI_INVALID_ARGUMENT hPhysicalGpu or an argument is NULL //! \retval NVAPI_OK Arguments are populated with PCI identifiers //! \retval NVAPI_NVIDIA_DEVICE_NOT_FOUND No NVIDIA GPU driving a display was found //! \retval NVAPI_EXPECTED_PHYSICAL_GPU_HANDLE hPhysicalGpu was not a physical GPU handle //! \ingroup gpu /////////////////////////////////////////////////////////////////////////////// NVAPI_INTERFACE NvAPI_GPU_GetPCIIdentifiers(NvPhysicalGpuHandle hPhysicalGpu,NvU32 *pDeviceId,NvU32 *pSubSystemId,NvU32 *pRevisionId,NvU32 *pExtDeviceId); //! \ingroup gpu //! Used in NvAPI_GPU_GetGPUType(). typedef enum _NV_GPU_TYPE { NV_SYSTEM_TYPE_GPU_UNKNOWN = 0, NV_SYSTEM_TYPE_IGPU = 1, //!< Integrated GPU NV_SYSTEM_TYPE_DGPU = 2, //!< Discrete GPU } NV_GPU_TYPE; /////////////////////////////////////////////////////////////////////////////// // // FUNCTION NAME: NvAPI_GPU_GetGPUType // //! DESCRIPTION: This function returns the GPU type (integrated or discrete). //! See ::NV_GPU_TYPE. //! // SUPPORTED OS: Mac OS X, Windows XP and higher //! //! \since Version: 174.32 //! //! \retval NVAPI_INVALID_ARGUMENT hPhysicalGpu //! \retval NVAPI_OK *pGpuType contains the GPU type //! \retval NVAPI_NVIDIA_DEVICE_NOT_FOUND No NVIDIA GPU driving a display was found //! \retval NVAPI_EXPECTED_PHYSICAL_GPU_HANDLE: hPhysicalGpu was not a physical GPU handle //! //! \ingroup gpu /////////////////////////////////////////////////////////////////////////////// NVAPI_INTERFACE NvAPI_GPU_GetGPUType(NvPhysicalGpuHandle hPhysicalGpu, NV_GPU_TYPE *pGpuType); //! \ingroup gpu //! Used in NvAPI_GPU_GetBusType() typedef enum _NV_GPU_BUS_TYPE { NVAPI_GPU_BUS_TYPE_UNDEFINED = 0, NVAPI_GPU_BUS_TYPE_PCI = 1, NVAPI_GPU_BUS_TYPE_AGP = 2, NVAPI_GPU_BUS_TYPE_PCI_EXPRESS = 3, NVAPI_GPU_BUS_TYPE_FPCI = 4, } NV_GPU_BUS_TYPE; /////////////////////////////////////////////////////////////////////////////// // // FUNCTION NAME: NvAPI_GPU_GetBusType // //! This function returns the type of bus associated with this GPU. //! // SUPPORTED OS: Mac OS X, Windows XP and higher //! //! \since Version: 92.10 //! //! \retval NVAPI_INVALID_ARGUMENT hPhysicalGpu or pBusType is NULL. //! \retval NVAPI_OK *pBusType contains bus identifier. //! \retval NVAPI_NVIDIA_DEVICE_NOT_FOUND No NVIDIA GPU driving a display was found. //! \retval NVAPI_EXPECTED_PHYSICAL_GPU_HANDLE hPhysicalGpu was not a physical GPU handle. //! \ingroup gpu /////////////////////////////////////////////////////////////////////////////// NVAPI_INTERFACE NvAPI_GPU_GetBusType(NvPhysicalGpuHandle hPhysicalGpu,NV_GPU_BUS_TYPE *pBusType); /////////////////////////////////////////////////////////////////////////////// // // FUNCTION NAME: NvAPI_GPU_GetBusId // //! DESCRIPTION: Returns the ID of the bus associated with this GPU. //! // SUPPORTED OS: Mac OS X, Windows XP and higher //! //! \since Version: 167.00 //! //! \retval NVAPI_INVALID_ARGUMENT hPhysicalGpu or pBusId is NULL. //! \retval NVAPI_OK *pBusId contains the bus ID. //! \retval NVAPI_NVIDIA_DEVICE_NOT_FOUND No NVIDIA GPU driving a display was found. //! \retval NVAPI_EXPECTED_PHYSICAL_GPU_HANDLE hPhysicalGpu was not a physical GPU handle. //! //! \ingroup gpu /////////////////////////////////////////////////////////////////////////////// NVAPI_INTERFACE NvAPI_GPU_GetBusId(NvPhysicalGpuHandle hPhysicalGpu, NvU32 *pBusId); /////////////////////////////////////////////////////////////////////////////// // // FUNCTION NAME: NvAPI_GPU_GetBusSlotId // //! DESCRIPTION: Returns the ID of the bus slot associated with this GPU. //! // SUPPORTED OS: Mac OS X, Windows XP and higher //! //! \since Version: 167.00 //! //! \retval NVAPI_INVALID_ARGUMENT hPhysicalGpu or pBusSlotId is NULL. //! \retval NVAPI_OK *pBusSlotId contains the bus slot ID. //! \retval NVAPI_NVIDIA_DEVICE_NOT_FOUND No NVIDIA GPU driving a display was found. //! \retval NVAPI_EXPECTED_PHYSICAL_GPU_HANDLE hPhysicalGpu was not a physical GPU handle. //! //! \ingroup gpu /////////////////////////////////////////////////////////////////////////////// NVAPI_INTERFACE NvAPI_GPU_GetBusSlotId(NvPhysicalGpuHandle hPhysicalGpu, NvU32 *pBusSlotId); /////////////////////////////////////////////////////////////////////////////// // // FUNCTION NAME: NvAPI_GPU_GetIRQ // //! This function returns the interrupt number associated with this GPU. //! // SUPPORTED OS: Mac OS X, Windows XP and higher //! //! \since Version: 92.10 //! //! \retval NVAPI_INVALID_ARGUMENT hPhysicalGpu or pIRQ is NULL. //! \retval NVAPI_OK *pIRQ contains interrupt number. //! \retval NVAPI_NVIDIA_DEVICE_NOT_FOUND No NVIDIA GPU driving a display was found. //! \retval NVAPI_EXPECTED_PHYSICAL_GPU_HANDLE hPhysicalGpu was not a physical GPU handle. //! \ingroup gpu /////////////////////////////////////////////////////////////////////////////// NVAPI_INTERFACE NvAPI_GPU_GetIRQ(NvPhysicalGpuHandle hPhysicalGpu,NvU32 *pIRQ); /////////////////////////////////////////////////////////////////////////////// // // FUNCTION NAME: NvAPI_GPU_GetVbiosRevision // //! This function returns the revision of the video BIOS associated with this GPU. //! // SUPPORTED OS: Mac OS X, Windows XP and higher //! //! \since Version: 92.10 //! //! \retval NVAPI_INVALID_ARGUMENT hPhysicalGpu or pBiosRevision is NULL. //! \retval NVAPI_OK *pBiosRevision contains revision number. //! \retval NVAPI_NVIDIA_DEVICE_NOT_FOUND No NVIDIA GPU driving a display was found. //! \retval NVAPI_EXPECTED_PHYSICAL_GPU_HANDLE hPhysicalGpu was not a physical GPU handle. //! \ingroup gpu /////////////////////////////////////////////////////////////////////////////// NVAPI_INTERFACE NvAPI_GPU_GetVbiosRevision(NvPhysicalGpuHandle hPhysicalGpu,NvU32 *pBiosRevision); /////////////////////////////////////////////////////////////////////////////// // // FUNCTION NAME: NvAPI_GPU_GetVbiosOEMRevision // //! This function returns the OEM revision of the video BIOS associated with this GPU. //! // SUPPORTED OS: Windows XP and higher //! //! \since Version: 92.10 //! //! \retval NVAPI_INVALID_ARGUMENT hPhysicalGpu or pBiosRevision is NULL //! \retval NVAPI_OK *pBiosRevision contains revision number //! \retval NVAPI_NVIDIA_DEVICE_NOT_FOUND No NVIDIA GPU driving a display was found //! \retval NVAPI_EXPECTED_PHYSICAL_GPU_HANDLE hPhysicalGpu was not a physical GPU handle //! \ingroup gpu /////////////////////////////////////////////////////////////////////////////// NVAPI_INTERFACE NvAPI_GPU_GetVbiosOEMRevision(NvPhysicalGpuHandle hPhysicalGpu,NvU32 *pBiosRevision); /////////////////////////////////////////////////////////////////////////////// // // FUNCTION NAME: NvAPI_GPU_GetVbiosVersionString // //! This function returns the full video BIOS version string in the form of xx.xx.xx.xx.yy where //! - xx numbers come from NvAPI_GPU_GetVbiosRevision() and //! - yy comes from NvAPI_GPU_GetVbiosOEMRevision(). //! // SUPPORTED OS: Mac OS X, Windows XP and higher //! //! \since Version: 92.10 //! //! \retval NVAPI_INVALID_ARGUMENT hPhysicalGpu is NULL. //! \retval NVAPI_OK szBiosRevision contains version string. //! \retval NVAPI_NVIDIA_DEVICE_NOT_FOUND No NVIDIA GPU driving a display was found. //! \retval NVAPI_EXPECTED_PHYSICAL_GPU_HANDLE hPhysicalGpu was not a physical GPU handle. //! \ingroup gpu /////////////////////////////////////////////////////////////////////////////// NVAPI_INTERFACE NvAPI_GPU_GetVbiosVersionString(NvPhysicalGpuHandle hPhysicalGpu,NvAPI_ShortString szBiosRevision); /////////////////////////////////////////////////////////////////////////////// // // FUNCTION NAME: NvAPI_GPU_GetAGPAperture // //! This function returns the AGP aperture in megabytes. //! // SUPPORTED OS: Mac OS X, Windows XP and higher //! //! \since Version: 92.10 //! //! \retval NVAPI_INVALID_ARGUMENT pSize is NULL. //! \retval NVAPI_OK Call successful. //! \retval NVAPI_NVIDIA_DEVICE_NOT_FOUND No NVIDIA GPU driving a display was found. //! \retval NVAPI_EXPECTED_PHYSICAL_GPU_HANDLE hPhysicalGpu was not a physical GPU handle. //! \ingroup gpu /////////////////////////////////////////////////////////////////////////////// NVAPI_INTERFACE NvAPI_GPU_GetAGPAperture(NvPhysicalGpuHandle hPhysicalGpu,NvU32 *pSize); /////////////////////////////////////////////////////////////////////////////// // // FUNCTION NAME: NvAPI_GPU_GetCurrentAGPRate // //! This function returns the current AGP Rate (0 = AGP not present, 1 = 1x, 2 = 2x, etc.). //! // SUPPORTED OS: Mac OS X, Windows XP and higher //! //! \since Version: 92.10 //! //! \retval NVAPI_INVALID_ARGUMENT pRate is NULL. //! \retval NVAPI_OK Call successful. //! \retval NVAPI_NVIDIA_DEVICE_NOT_FOUND No NVIDIA GPU driving a display was found. //! \retval NVAPI_EXPECTED_PHYSICAL_GPU_HANDLE hPhysicalGpu was not a physical GPU handle. //! \ingroup gpu /////////////////////////////////////////////////////////////////////////////// NVAPI_INTERFACE NvAPI_GPU_GetCurrentAGPRate(NvPhysicalGpuHandle hPhysicalGpu,NvU32 *pRate); /////////////////////////////////////////////////////////////////////////////// // // FUNCTION NAME: NvAPI_GPU_GetCurrentPCIEDownstreamWidth // //! This function returns the number of PCIE lanes being used for the PCIE interface //! downstream from the GPU. //! // SUPPORTED OS: Mac OS X, Windows XP and higher //! //! \since Version: 92.10 //! //! \retval NVAPI_INVALID_ARGUMENT pWidth is NULL. //! \retval NVAPI_OK Call successful. //! \retval NVAPI_NVIDIA_DEVICE_NOT_FOUND No NVIDIA GPU driving a display was found. //! \retval NVAPI_EXPECTED_PHYSICAL_GPU_HANDLE hPhysicalGpu was not a physical GPU handle. //! \ingroup gpu /////////////////////////////////////////////////////////////////////////////// NVAPI_INTERFACE NvAPI_GPU_GetCurrentPCIEDownstreamWidth(NvPhysicalGpuHandle hPhysicalGpu,NvU32 *pWidth); /////////////////////////////////////////////////////////////////////////////// // // FUNCTION NAME: NvAPI_GPU_GetPhysicalFrameBufferSize // //! This function returns the physical size of framebuffer in KB. This does NOT include any //! system RAM that may be dedicated for use by the GPU. //! // SUPPORTED OS: Mac OS X, Windows XP and higher //! //! \since Version: 92.10 //! //! \retval NVAPI_INVALID_ARGUMENT pSize is NULL //! \retval NVAPI_OK Call successful //! \retval NVAPI_NVIDIA_DEVICE_NOT_FOUND No NVIDIA GPU driving a display was found //! \retval NVAPI_EXPECTED_PHYSICAL_GPU_HANDLE hPhysicalGpu was not a physical GPU handle //! \ingroup gpu /////////////////////////////////////////////////////////////////////////////// NVAPI_INTERFACE NvAPI_GPU_GetPhysicalFrameBufferSize(NvPhysicalGpuHandle hPhysicalGpu,NvU32 *pSize); /////////////////////////////////////////////////////////////////////////////// // // FUNCTION NAME: NvAPI_GPU_GetVirtualFrameBufferSize // //! This function returns the virtual size of framebuffer in KB. This includes the physical RAM plus any //! system RAM that has been dedicated for use by the GPU. //! // SUPPORTED OS: Mac OS X, Windows XP and higher //! //! \since Version: 92.10 //! //! \retval NVAPI_INVALID_ARGUMENT pSize is NULL. //! \retval NVAPI_OK Call successful. //! \retval NVAPI_NVIDIA_DEVICE_NOT_FOUND No NVIDIA GPU driving a display was found. //! \retval NVAPI_EXPECTED_PHYSICAL_GPU_HANDLE hPhysicalGpu was not a physical GPU handle. //! \ingroup gpu /////////////////////////////////////////////////////////////////////////////// NVAPI_INTERFACE NvAPI_GPU_GetVirtualFrameBufferSize(NvPhysicalGpuHandle hPhysicalGpu,NvU32 *pSize); //! \ingroup gpu typedef struct _NV_BOARD_INFO { NvU32 version; //!< structure version NvU8 BoardNum[16]; //!< Board Serial Number }NV_BOARD_INFO_V1; //! \ingroup gpu typedef NV_BOARD_INFO_V1 NV_BOARD_INFO; //! \ingroup gpu #define NV_BOARD_INFO_VER1 MAKE_NVAPI_VERSION(NV_BOARD_INFO_V1,1) //! \ingroup gpu #define NV_BOARD_INFO_VER NV_BOARD_INFO_VER1 // SUPPORTED OS: Windows XP and higher /////////////////////////////////////////////////////////////////////////////// // // FUNCTION NAME: NvAPI_GPU_GetBoardInfo // //! DESCRIPTION: This API Retrieves the Board information (a unique GPU Board Serial Number) stored in the InfoROM. //! //! \param [in] hPhysicalGpu Physical GPU Handle. //! \param [in,out] NV_BOARD_INFO Board Information. //! //! \retval ::NVAPI_OK completed request //! \retval ::NVAPI_ERROR miscellaneous error occurred //! \retval ::NVAPI_EXPECTED_PHYSICAL_GPU_HANDLE handle passed is not a physical GPU handle //! \retval ::NVAPI_API_NOT_INTIALIZED NVAPI not initialized //! \retval ::NVAPI_INVALID_POINTER pBoardInfo is NULL //! \retval ::NVAPI_INCOMPATIBLE_STRUCT_VERSION the version of the INFO struct is not supported //! //! \ingroup gpu /////////////////////////////////////////////////////////////////////////////// NVAPI_INTERFACE NvAPI_GPU_GetBoardInfo(NvPhysicalGpuHandle hPhysicalGpu, NV_BOARD_INFO *pBoardInfo); //! \ingroup gpupstate #define NVAPI_MAX_GPU_UTILIZATIONS 8 //! \ingroup gpupstate //! Used in NvAPI_GPU_GetDynamicPstatesInfoEx(). typedef struct { NvU32 version; //!< Structure version NvU32 flags; //!< bit 0 indicates if the dynamic Pstate is enabled or not struct { NvU32 bIsPresent:1; //!< Set if this utilization domain is present on this GPU NvU32 percentage; //!< Percentage of time where the domain is considered busy in the last 1 second interval } utilization[NVAPI_MAX_GPU_UTILIZATIONS]; } NV_GPU_DYNAMIC_PSTATES_INFO_EX; //! \ingroup gpupstate //! Macro for constructing the version field of NV_GPU_DYNAMIC_PSTATES_INFO_EX #define NV_GPU_DYNAMIC_PSTATES_INFO_EX_VER MAKE_NVAPI_VERSION(NV_GPU_DYNAMIC_PSTATES_INFO_EX,1) /////////////////////////////////////////////////////////////////////////////// // // FUNCTION NAME: NvAPI_GPU_GetDynamicPstatesInfoEx // //! DESCRIPTION: This API retrieves the NV_GPU_DYNAMIC_PSTATES_INFO_EX structure for the specified physical GPU. //! Each domain's info is indexed in the array. For example: //! - pDynamicPstatesInfo->utilization[NVAPI_GPU_UTILIZATION_DOMAIN_GPU] holds the info for the GPU domain. \p //! There are currently 3 domains for which GPU utilization and dynamic P-State thresholds can be retrieved: //! graphic engine (GPU), frame buffer (FB), and video engine (VID). //! // SUPPORTED OS: Mac OS X, Windows XP and higher //! //! \since version 185.50 //! //! \retval ::NVAPI_OK //! \retval ::NVAPI_ERROR //! \retval ::NVAPI_INVALID_ARGUMENT pDynamicPstatesInfo is NULL //! \retval ::NVAPI_HANDLE_INVALIDATED //! \retval ::NVAPI_EXPECTED_PHYSICAL_GPU_HANDLE //! \retval ::NVAPI_INCOMPATIBLE_STRUCT_VERSION The version of the INFO struct is not supported //! //! \ingroup gpupstate /////////////////////////////////////////////////////////////////////////////// NVAPI_INTERFACE NvAPI_GPU_GetDynamicPstatesInfoEx(NvPhysicalGpuHandle hPhysicalGpu, NV_GPU_DYNAMIC_PSTATES_INFO_EX *pDynamicPstatesInfoEx); /////////////////////////////////////////////////////////////////////////////////// // Thermal API // Provides ability to get temperature levels from the various thermal sensors associated with the GPU //! \ingroup gputhermal #define NVAPI_MAX_THERMAL_SENSORS_PER_GPU 3 //! \ingroup gputhermal //! Used in NV_GPU_THERMAL_SETTINGS typedef enum { NVAPI_THERMAL_TARGET_NONE = 0, NVAPI_THERMAL_TARGET_GPU = 1, //!< GPU core temperature requires NvPhysicalGpuHandle NVAPI_THERMAL_TARGET_MEMORY = 2, //!< GPU memory temperature requires NvPhysicalGpuHandle NVAPI_THERMAL_TARGET_POWER_SUPPLY = 4, //!< GPU power supply temperature requires NvPhysicalGpuHandle NVAPI_THERMAL_TARGET_BOARD = 8, //!< GPU board ambient temperature requires NvPhysicalGpuHandle NVAPI_THERMAL_TARGET_VCD_BOARD = 9, //!< Visual Computing Device Board temperature requires NvVisualComputingDeviceHandle NVAPI_THERMAL_TARGET_VCD_INLET = 10, //!< Visual Computing Device Inlet temperature requires NvVisualComputingDeviceHandle NVAPI_THERMAL_TARGET_VCD_OUTLET = 11, //!< Visual Computing Device Outlet temperature requires NvVisualComputingDeviceHandle NVAPI_THERMAL_TARGET_ALL = 15, NVAPI_THERMAL_TARGET_UNKNOWN = -1, } NV_THERMAL_TARGET; //! \ingroup gputhermal //! Used in NV_GPU_THERMAL_SETTINGS typedef enum { NVAPI_THERMAL_CONTROLLER_NONE = 0, NVAPI_THERMAL_CONTROLLER_GPU_INTERNAL, NVAPI_THERMAL_CONTROLLER_ADM1032, NVAPI_THERMAL_CONTROLLER_MAX6649, NVAPI_THERMAL_CONTROLLER_MAX1617, NVAPI_THERMAL_CONTROLLER_LM99, NVAPI_THERMAL_CONTROLLER_LM89, NVAPI_THERMAL_CONTROLLER_LM64, NVAPI_THERMAL_CONTROLLER_ADT7473, NVAPI_THERMAL_CONTROLLER_SBMAX6649, NVAPI_THERMAL_CONTROLLER_VBIOSEVT, NVAPI_THERMAL_CONTROLLER_OS, NVAPI_THERMAL_CONTROLLER_UNKNOWN = -1, } NV_THERMAL_CONTROLLER; //! \ingroup gputhermal //! Used in NvAPI_GPU_GetThermalSettings() typedef struct { NvU32 version; //!< structure version NvU32 Count; //!< number of associated thermal sensors struct { NV_THERMAL_CONTROLLER controller; //!< internal, ADM1032, MAX6649... NvU32 defaultMinTemp; //!< The min default temperature value of the thermal sensor in degrees centigrade NvU32 defaultMaxTemp; //!< The max default temperature value of the thermal sensor in degrees centigrade NvU32 currentTemp; //!< The current temperature value of the thermal sensor in degrees centigrade NV_THERMAL_TARGET target; //!< Thermal sensor targeted @ GPU, memory, chipset, powersupply, Visual Computing Device, etc. } sensor[NVAPI_MAX_THERMAL_SENSORS_PER_GPU]; } NV_GPU_THERMAL_SETTINGS_V1; //! \ingroup gputhermal typedef struct { NvU32 Version; //!< structure version NvU32 Count; //!< number of associated thermal sensors struct { NV_THERMAL_CONTROLLER Controller; //!< internal, ADM1032, MAX6649... NvS32 DefaultMinTemp; //!< Minimum default temperature value of the thermal sensor in degrees C NvS32 DefaultMaxTemp; //!< Maximum default temperature value of the thermal sensor in degrees C NvS32 CurrentTemp; //!< Current temperature value of the thermal sensor in degrees C NV_THERMAL_TARGET Target; //!< Thermal sensor targeted - GPU, memory, chipset, powersupply, Visual Computing Device, etc } Sensor[NVAPI_MAX_THERMAL_SENSORS_PER_GPU]; } NV_GPU_THERMAL_SETTINGS_V2; //! \ingroup gputhermal typedef NV_GPU_THERMAL_SETTINGS_V2 NV_GPU_THERMAL_SETTINGS; //! Macro for constructing the version field of NV_GPU_THERMAL_SETTINGS_V1 #define NV_GPU_THERMAL_SETTINGS_VER_1 MAKE_NVAPI_VERSION(NV_GPU_THERMAL_SETTINGS_V1, 1) //! Macro for constructing the version field of NV_GPU_THERMAL_SETTINGS_V2 #define NV_GPU_THERMAL_SETTINGS_VER_2 MAKE_NVAPI_VERSION(NV_GPU_THERMAL_SETTINGS_V2, 2) //! Macro for constructing the version field of NV_GPU_THERMAL_SETTINGS #define NV_GPU_THERMAL_SETTINGS_VER NV_GPU_THERMAL_SETTINGS_VER_2 /////////////////////////////////////////////////////////////////////////////// // // FUNCTION NAME: NvAPI_GPU_GetThermalSettings // //! This function retrieves the thermal information of all thermal sensors or specific thermal sensor associated with the selected GPU. //! Thermal sensors are indexed 0 to NVAPI_MAX_THERMAL_SENSORS_PER_GPU-1. //! //! - To retrieve specific thermal sensor info, set the sensorIndex to the required thermal sensor index. //! - To retrieve info for all sensors, set sensorIndex to NVAPI_THERMAL_TARGET_ALL. //! // SUPPORTED OS: Windows XP and higher //! //! \since Version: 87.60 (Rel85), 92.40 (Rel90) //! //! \param [in] hPhysicalGPU GPU selection. //! \param [in] sensorIndex Explicit thermal sensor index selection. //! \param [out] pThermalSettings Array of thermal settings. //! //! \retval NVAPI_OK Completed request //! \retval NVAPI_ERROR Miscellaneous error occurred. //! \retval NVAPI_INVALID_ARGUMENT pThermalInfo is NULL. //! \retval NVAPI_HANDLE_INVALIDATED Handle passed has been invalidated (see user guide). //! \retval NVAPI_EXPECTED_PHYSICAL_GPU_HANDLE Handle passed is not a physical GPU handle. //! \retval NVAPI_INCOMPATIBLE_STRUCT_VERSION The version of the INFO struct is not supported. //! \ingroup gputhermal /////////////////////////////////////////////////////////////////////////////// //NVAPI_INTERFACE NvAPI_GPU_GetThermalSettings(NvPhysicalGpuHandle hPhysicalGpu, NvU32 sensorIndex, NV_GPU_THERMAL_SETTINGS *pThermalSettings); typedef NvStatus (__cdecl *P_NvAPI_GPU_GetThermalSettings)(NvPhysicalGpuHandle hPhysicalGpu, NvU32 sensorIndex, NV_GPU_THERMAL_SETTINGS *pThermalSettings); P_NvAPI_GPU_GetThermalSettings NvAPI_GetThermalSettings; //////////////////////////////////////////////////////////////////////////////// // // NvAPI_TVOutput Information // /////////////////////////////////////////////////////////////////////////////// //! \ingroup tvapi //! Used in NV_DISPLAY_TV_OUTPUT_INFO typedef enum _NV_DISPLAY_TV_FORMAT { NV_DISPLAY_TV_FORMAT_NONE = 0, NV_DISPLAY_TV_FORMAT_SD_NTSCM = 0x00000001, NV_DISPLAY_TV_FORMAT_SD_NTSCJ = 0x00000002, NV_DISPLAY_TV_FORMAT_SD_PALM = 0x00000004, NV_DISPLAY_TV_FORMAT_SD_PALBDGH = 0x00000008, NV_DISPLAY_TV_FORMAT_SD_PALN = 0x00000010, NV_DISPLAY_TV_FORMAT_SD_PALNC = 0x00000020, NV_DISPLAY_TV_FORMAT_SD_576i = 0x00000100, NV_DISPLAY_TV_FORMAT_SD_480i = 0x00000200, NV_DISPLAY_TV_FORMAT_ED_480p = 0x00000400, NV_DISPLAY_TV_FORMAT_ED_576p = 0x00000800, NV_DISPLAY_TV_FORMAT_HD_720p = 0x00001000, NV_DISPLAY_TV_FORMAT_HD_1080i = 0x00002000, NV_DISPLAY_TV_FORMAT_HD_1080p = 0x00004000, NV_DISPLAY_TV_FORMAT_HD_720p50 = 0x00008000, NV_DISPLAY_TV_FORMAT_HD_1080p24 = 0x00010000, NV_DISPLAY_TV_FORMAT_HD_1080i50 = 0x00020000, NV_DISPLAY_TV_FORMAT_HD_1080p50 = 0x00040000, NV_DISPLAY_TV_FORMAT_SD_OTHER = 0x01000000, NV_DISPLAY_TV_FORMAT_ED_OTHER = 0x02000000, NV_DISPLAY_TV_FORMAT_HD_OTHER = 0x04000000, NV_DISPLAY_TV_FORMAT_ANY = 0x80000000, } NV_DISPLAY_TV_FORMAT; /////////////////////////////////////////////////////////////////////////////////// // I2C API // Provides ability to read or write data using I2C protocol. // These APIs allow I2C access only to DDC monitors //! \addtogroup i2capi //! @{ #define NVAPI_MAX_SIZEOF_I2C_DATA_BUFFER 4096 #define NVAPI_MAX_SIZEOF_I2C_REG_ADDRESS 4 #define NVAPI_DISPLAY_DEVICE_MASK_MAX 24 //! Used in NvAPI_I2CRead() and NvAPI_I2CWrite() typedef struct { NvU32 version; //!< The structure version. NvU32 displayMask; //!< The Display Mask of the concerned display. NvU8 bIsDDCPort; //!< This flag indicates either the DDC port (TRUE) or the communication port //!< (FALSE) of the concerned display. NvU8 i2cDevAddress; //!< The address of the I2C slave. The address should be shifted left by one. For //!< example, the I2C address 0x50, often used for reading EDIDs, would be stored //!< here as 0xA0. This matches the position within the byte sent by the master, as //!< the last bit is reserved to specify the read or write direction. NvU8* pbI2cRegAddress; //!< The I2C target register address. May be NULL, which indicates no register //!< address should be sent. NvU32 regAddrSize; //!< The size in bytes of target register address. If pbI2cRegAddress is NULL, this //!< field must be 0. NvU8* pbData; //!< The buffer of data which is to be read or written (depending on the command). NvU32 cbSize; //!< The size of the data buffer, pbData, to be read or written. NvU32 i2cSpeed; //!< The target speed of the transaction (between 28kbps to 40kbps; not guaranteed). } NV_I2C_INFO; #define NV_I2C_INFO_VER MAKE_NVAPI_VERSION(NV_I2C_INFO,1) //! @} /***********************************************************************************/ /////////////////////////////////////////////////////////////////////////////// // // FUNCTION NAME: NvAPI_I2CRead // //! This function reads the data buffer from the I2C port. //! The I2C request must be for a DDC port: pI2cInfo->bIsDDCPort = 1. //! //! A data buffer size larger than 16 bytes may be rejected if a register address is specified. In such a case, //! NVAPI_ARGUMENT_EXCEED_MAX_SIZE would be returned. //! //! If a register address is specified (i.e. regAddrSize is positive), then the transaction will be performed in //! the combined format described in the I2C specification. The register address will be written, followed by //! reading into the data buffer. //! // SUPPORTED OS: Mac OS X, Windows XP and higher //! //! \since Version: 87.90 //! //! \param [in] hPhysicalGPU GPU selection. //! \param [out] NV_I2C_INFO *pI2cInfo The I2C data input structure //! //! \retval NVAPI_OK Completed request //! \retval NVAPI_ERROR Miscellaneous error occurred. //! \retval NVAPI_HANDLE_INVALIDATED Handle passed has been invalidated (see user guide). //! \retval NVAPI_EXPECTED_PHYSICAL_GPU_HANDLE Handle passed is not a physical GPU handle. //! \retval NVAPI_INCOMPATIBLE_STRUCT_VERSION Structure version is not supported. //! \retval NVAPI_INVALID_ARGUMENT - argument does not meet specified requirements //! \retval NVAPI_ARGUMENT_EXCEED_MAX_SIZE - an argument exceeds the maximum //! //! \ingroup i2capi /////////////////////////////////////////////////////////////////////////////// NVAPI_INTERFACE NvAPI_I2CRead(NvPhysicalGpuHandle hPhysicalGpu, NV_I2C_INFO *pI2cInfo); /////////////////////////////////////////////////////////////////////////////// // // FUNCTION NAME: NvAPI_I2CWrite // //! This function writes the data buffer to the I2C port. //! //! The I2C request must be for a DDC port: pI2cInfo->bIsDDCPort = 1. //! //! A data buffer size larger than 16 bytes may be rejected if a register address is specified. In such a case, //! NVAPI_ARGUMENT_EXCEED_MAX_SIZE would be returned. //! //! If a register address is specified (i.e. regAddrSize is positive), then the register address will be written //! and the data buffer will immediately follow without a restart. //! // SUPPORTED OS: Mac OS X, Windows XP and higher //! //! \since Version: 87.90 //! //! \param [in] hPhysicalGPU GPU selection. //! \param [in] pI2cInfo The I2C data input structure //! //! \retval NVAPI_OK Completed request //! \retval NVAPI_ERROR Miscellaneous error occurred. //! \retval NVAPI_HANDLE_INVALIDATED Handle passed has been invalidated (see user guide). //! \retval NVAPI_EXPECTED_PHYSICAL_GPU_HANDLE Handle passed is not a physical GPU handle. //! \retval NVAPI_INCOMPATIBLE_STRUCT_VERSION Structure version is not supported. //! \retval NVAPI_INVALID_ARGUMENT Argument does not meet specified requirements //! \retval NVAPI_ARGUMENT_EXCEED_MAX_SIZE Argument exceeds the maximum //! //! \ingroup i2capi /////////////////////////////////////////////////////////////////////////////// NVAPI_INTERFACE NvAPI_I2CWrite(NvPhysicalGpuHandle hPhysicalGpu, NV_I2C_INFO *pI2cInfo); //! \addtogroup sysgeneral //! @{ typedef struct { NvU32 version; //!< structure version NvU32 vendorId; //!< Chipset vendor identification NvU32 deviceId; //!< Chipset device identification NvAPI_ShortString szVendorName; //!< Chipset vendor Name NvAPI_ShortString szChipsetName; //!< Chipset device Name NvU32 flags; //!< Chipset info flags - obsolete NvU32 subSysVendorId; //!< Chipset subsystem vendor identification NvU32 subSysDeviceId; //!< Chipset subsystem device identification NvAPI_ShortString szSubSysVendorName; //!< subsystem vendor Name NvU32 HBvendorId; //!< Host bridge vendor identification NvU32 HBdeviceId; //!< Host bridge device identification NvU32 HBsubSysVendorId; //!< Host bridge subsystem vendor identification NvU32 HBsubSysDeviceId; //!< Host bridge subsystem device identification } NV_CHIPSET_INFO_v4; typedef struct { NvU32 version; //!< structure version NvU32 vendorId; //!< vendor ID NvU32 deviceId; //!< device ID NvAPI_ShortString szVendorName; //!< vendor Name NvAPI_ShortString szChipsetName; //!< device Name NvU32 flags; //!< Chipset info flags - obsolete NvU32 subSysVendorId; //!< subsystem vendor ID NvU32 subSysDeviceId; //!< subsystem device ID NvAPI_ShortString szSubSysVendorName; //!< subsystem vendor Name } NV_CHIPSET_INFO_v3; typedef enum { NV_CHIPSET_INFO_HYBRID = 0x00000001, } NV_CHIPSET_INFO_FLAGS; typedef struct { NvU32 version; //!< structure version NvU32 vendorId; //!< vendor ID NvU32 deviceId; //!< device ID NvAPI_ShortString szVendorName; //!< vendor Name NvAPI_ShortString szChipsetName; //!< device Name NvU32 flags; //!< Chipset info flags } NV_CHIPSET_INFO_v2; typedef struct { NvU32 version; //structure version NvU32 vendorId; //vendor ID NvU32 deviceId; //device ID NvAPI_ShortString szVendorName; //vendor Name NvAPI_ShortString szChipsetName; //device Name } NV_CHIPSET_INFO_v1; #define NV_CHIPSET_INFO_VER_1 MAKE_NVAPI_VERSION(NV_CHIPSET_INFO_v1,1) #define NV_CHIPSET_INFO_VER_2 MAKE_NVAPI_VERSION(NV_CHIPSET_INFO_v2,2) #define NV_CHIPSET_INFO_VER_3 MAKE_NVAPI_VERSION(NV_CHIPSET_INFO_v3,3) #define NV_CHIPSET_INFO_VER_4 MAKE_NVAPI_VERSION(NV_CHIPSET_INFO_v4,4) #define NV_CHIPSET_INFO NV_CHIPSET_INFO_v4 #define NV_CHIPSET_INFO_VER NV_CHIPSET_INFO_VER_4 //! @} /////////////////////////////////////////////////////////////////////////////// // // FUNCTION NAME: NvAPI_SYS_GetChipSetInfo // //! This function returns information about the system's chipset. //! // SUPPORTED OS: Mac OS X, Windows XP and higher //! //! \since Version: 96.60 //! //! \retval NVAPI_INVALID_ARGUMENT pChipSetInfo is NULL. //! \retval NVAPI_OK *pChipSetInfo is now set. //! \retval NVAPI_INCOMPATIBLE_STRUCT_VERSION NV_CHIPSET_INFO version not compatible with driver. //! \ingroup sysgeneral /////////////////////////////////////////////////////////////////////////////// NVAPI_INTERFACE NvAPI_SYS_GetChipSetInfo(NV_CHIPSET_INFO *pChipSetInfo); //! \ingroup sysgeneral //! Lid and dock information - used in NvAPI_GetLidDockInfo() typedef struct { NvU32 version; //! Structure version, constructed from the macro #NV_LID_DOCK_PARAMS_VER NvU32 currentLidState; NvU32 currentDockState; NvU32 currentLidPolicy; NvU32 currentDockPolicy; NvU32 forcedLidMechanismPresent; NvU32 forcedDockMechanismPresent; }NV_LID_DOCK_PARAMS; //! ingroup sysgeneral #define NV_LID_DOCK_PARAMS_VER MAKE_NVAPI_VERSION(NV_LID_DOCK_PARAMS,1) /////////////////////////////////////////////////////////////////////////////// // // FUNCTION NAME: NvAPI_GetLidDockInfo // //! DESCRIPTION: This function returns the current lid and dock information. //! // SUPPORTED OS: Windows XP and higher //! //! \since Version: 177.61 //! //! \retval ::NVAPI_OK //! \retval ::NVAPI_ERROR //! \retval ::NVAPI_NOT_SUPPORTED //! \retval ::NVAPI_HANDLE_INVALIDATED //! \retval ::NVAPI_API_NOT_INTIALIZED //! //! \ingroup sysgeneral /////////////////////////////////////////////////////////////////////////////// NVAPI_INTERFACE NvAPI_SYS_GetLidAndDockInfo(NV_LID_DOCK_PARAMS *pLidAndDock); /////////////////////////////////////////////////////////////////////////////// // // FUNCTION NAME: NvAPI_OGL_ExpertModeSet[Get] // //! \name NvAPI_OGL_ExpertModeSet[Get] Functions //@{ //! This function configures OpenGL Expert Mode, an API usage feedback and //! advice reporting mechanism. The effects of this call are //! applied only to the current context, and are reset to the //! defaults when the context is destroyed. //! //! \note This feature is valid at runtime only when GLExpert //! functionality has been built into the OpenGL driver //! installed on the system. All Windows Vista OpenGL //! drivers provided by NVIDIA have this instrumentation //! included by default. Windows XP, however, requires a //! special display driver available with the NVIDIA //! PerfSDK found at developer.nvidia.com. //! //! \note These functions are valid only for the current OpenGL //! context. Calling these functions prior to creating a //! context and calling MakeCurrent with it will result //! in errors and undefined behavior. //! // SUPPORTED OS: Windows XP and higher //! //! \since Version: 84.11 (Rel80) / 88.00 (Rel85) //! //! \param expertDetailMask Mask made up of NVAPI_OGLEXPERT_DETAIL bits, //! this parameter specifies the detail level in //! the feedback stream. //! //! \param expertReportMask Mask made up of NVAPI_OGLEXPERT_REPORT bits, //! this parameter specifies the areas of //! functional interest. //! //! \param expertOutputMask Mask made up of NVAPI_OGLEXPERT_OUTPUT bits, //! this parameter specifies the feedback output //! location. //! //! \param expertCallback Used in conjunction with OUTPUT_TO_CALLBACK, //! this is a simple callback function the user //! may use to obtain the feedback stream. The //! function will be called once per fully //! qualified feedback stream extry. //! //! \retval NVAPI_API_NOT_INTIALIZED NVAPI not initialized //! \retval NVAPI_NVIDIA_DEVICE_NOT_FOUND No NVIDIA GPU found //! \retval NVAPI_OPENGL_CONTEXT_NOT_CURRENT No NVIDIA OpenGL context //! which supports GLExpert //! has been made current //! \retval NVAPI_ERROR OpenGL driver failed to load properly //! \retval NVAPI_OK Success // /////////////////////////////////////////////////////////////////////////////// //! \addtogroup oglapi //! @{ #define NVAPI_OGLEXPERT_DETAIL_NONE 0x00000000 #define NVAPI_OGLEXPERT_DETAIL_ERROR 0x00000001 #define NVAPI_OGLEXPERT_DETAIL_SWFALLBACK 0x00000002 #define NVAPI_OGLEXPERT_DETAIL_BASIC_INFO 0x00000004 #define NVAPI_OGLEXPERT_DETAIL_DETAILED_INFO 0x00000008 #define NVAPI_OGLEXPERT_DETAIL_PERFORMANCE_WARNING 0x00000010 #define NVAPI_OGLEXPERT_DETAIL_QUALITY_WARNING 0x00000020 #define NVAPI_OGLEXPERT_DETAIL_USAGE_WARNING 0x00000040 #define NVAPI_OGLEXPERT_DETAIL_ALL 0xFFFFFFFF #define NVAPI_OGLEXPERT_REPORT_NONE 0x00000000 #define NVAPI_OGLEXPERT_REPORT_ERROR 0x00000001 #define NVAPI_OGLEXPERT_REPORT_SWFALLBACK 0x00000002 #define NVAPI_OGLEXPERT_REPORT_PIPELINE_VERTEX 0x00000004 #define NVAPI_OGLEXPERT_REPORT_PIPELINE_GEOMETRY 0x00000008 #define NVAPI_OGLEXPERT_REPORT_PIPELINE_XFB 0x00000010 #define NVAPI_OGLEXPERT_REPORT_PIPELINE_RASTER 0x00000020 #define NVAPI_OGLEXPERT_REPORT_PIPELINE_FRAGMENT 0x00000040 #define NVAPI_OGLEXPERT_REPORT_PIPELINE_ROP 0x00000080 #define NVAPI_OGLEXPERT_REPORT_PIPELINE_FRAMEBUFFER 0x00000100 #define NVAPI_OGLEXPERT_REPORT_PIPELINE_PIXEL 0x00000200 #define NVAPI_OGLEXPERT_REPORT_PIPELINE_TEXTURE 0x00000400 #define NVAPI_OGLEXPERT_REPORT_OBJECT_BUFFEROBJECT 0x00000800 #define NVAPI_OGLEXPERT_REPORT_OBJECT_TEXTURE 0x00001000 #define NVAPI_OGLEXPERT_REPORT_OBJECT_PROGRAM 0x00002000 #define NVAPI_OGLEXPERT_REPORT_OBJECT_FBO 0x00004000 #define NVAPI_OGLEXPERT_REPORT_FEATURE_SLI 0x00008000 #define NVAPI_OGLEXPERT_REPORT_ALL 0xFFFFFFFF #define NVAPI_OGLEXPERT_OUTPUT_TO_NONE 0x00000000 #define NVAPI_OGLEXPERT_OUTPUT_TO_CONSOLE 0x00000001 #define NVAPI_OGLEXPERT_OUTPUT_TO_DEBUGGER 0x00000004 #define NVAPI_OGLEXPERT_OUTPUT_TO_CALLBACK 0x00000008 #define NVAPI_OGLEXPERT_OUTPUT_TO_ALL 0xFFFFFFFF //! @} /////////////////////////////////////////////////////////////////////////////// // // FUNCTION TYPE: NVAPI_OGLEXPERT_CALLBACK // //! DESCRIPTION: Used in conjunction with OUTPUT_TO_CALLBACK, this is a simple //! callback function the user may use to obtain the feedback //! stream. The function will be called once per fully qualified //! feedback stream entry. //! //! \param categoryId Contains the bit from the NVAPI_OGLEXPERT_REPORT //! mask that corresponds to the current message //! \param messageId Unique ID for the current message //! \param detailLevel Contains the bit from the NVAPI_OGLEXPERT_DETAIL //! mask that corresponds to the current message //! \param objectId Unique ID of the object that corresponds to the //! current message //! \param messageStr Text string from the current message //! //! \ingroup oglapi /////////////////////////////////////////////////////////////////////////////// typedef void (* NVAPI_OGLEXPERT_CALLBACK) (unsigned int categoryId, unsigned int messageId, unsigned int detailLevel, int objectId, const char *messageStr); //! \ingroup oglapi // SUPPORTED OS: Windows XP and higher NVAPI_INTERFACE NvAPI_OGL_ExpertModeSet(NvU32 expertDetailLevel, NvU32 expertReportMask, NvU32 expertOutputMask, NVAPI_OGLEXPERT_CALLBACK expertCallback); //! \addtogroup oglapi // SUPPORTED OS: Windows XP and higher NVAPI_INTERFACE NvAPI_OGL_ExpertModeGet(NvU32 *pExpertDetailLevel, NvU32 *pExpertReportMask, NvU32 *pExpertOutputMask, NVAPI_OGLEXPERT_CALLBACK *pExpertCallback); //@} /////////////////////////////////////////////////////////////////////////////// // //! \name NvAPI_OGL_ExpertModeDefaultsSet[Get] Functions //! //@{ //! This function configures OpenGL Expert Mode global defaults. These settings //! apply to any OpenGL application which starts up after these //! values are applied (i.e. these settings *do not* apply to //! currently running applications). //! // SUPPORTED OS: Windows XP and higher //! //! \since Version: 84.11 (Rel80) / 88.00 (Rel85) //! //! \param expertDetailLevel Value which specifies the detail level in //! the feedback stream. This is a mask made up //! of NVAPI_OGLEXPERT_LEVEL bits. //! //! \param expertReportMask Mask made up of NVAPI_OGLEXPERT_REPORT bits, //! this parameter specifies the areas of //! functional interest. //! //! \param expertOutputMask Mask made up of NVAPI_OGLEXPERT_OUTPUT bits, //! this parameter specifies the feedback output //! location. Note that using OUTPUT_TO_CALLBACK //! here is meaningless and has no effect, but //! using it will not cause an error. //! //! \return ::NVAPI_ERROR or ::NVAPI_OK // /////////////////////////////////////////////////////////////////////////////// //! \ingroup oglapi // SUPPORTED OS: Windows XP and higher NVAPI_INTERFACE NvAPI_OGL_ExpertModeDefaultsSet(NvU32 expertDetailLevel, NvU32 expertReportMask, NvU32 expertOutputMask); //! \addtogroup oglapi // SUPPORTED OS: Windows XP and higher NVAPI_INTERFACE NvAPI_OGL_ExpertModeDefaultsGet(NvU32 *pExpertDetailLevel, NvU32 *pExpertReportMask, NvU32 *pExpertOutputMask); //@} //! \ingroup dispcontrol //! @{ #define NVAPI_MAX_VIEW_TARGET 2 #define NVAPI_ADVANCED_MAX_VIEW_TARGET 4 #ifndef _NV_TARGET_VIEW_MODE_ #define _NV_TARGET_VIEW_MODE_ //! Used in NvAPI_SetView(). typedef enum _NV_TARGET_VIEW_MODE { NV_VIEW_MODE_STANDARD = 0, NV_VIEW_MODE_CLONE = 1, NV_VIEW_MODE_HSPAN = 2, NV_VIEW_MODE_VSPAN = 3, NV_VIEW_MODE_DUALVIEW = 4, NV_VIEW_MODE_MULTIVIEW = 5, } NV_TARGET_VIEW_MODE; #endif //! @} // Following definitions are used in NvAPI_SetViewEx. //! Scaling modes - used in NvAPI_SetViewEx(). //! \ingroup dispcontrol typedef enum _NV_SCALING { NV_SCALING_DEFAULT = 0, //!< No change // New Scaling Declarations NV_SCALING_GPU_SCALING_TO_CLOSEST = 1, //!< Balanced - Full Screen NV_SCALING_GPU_SCALING_TO_NATIVE = 2, //!< Force GPU - Full Screen NV_SCALING_GPU_SCANOUT_TO_NATIVE = 3, //!< Force GPU - Centered\No Scaling NV_SCALING_GPU_SCALING_TO_ASPECT_SCANOUT_TO_NATIVE = 5, //!< Force GPU - Aspect Ratio NV_SCALING_GPU_SCALING_TO_ASPECT_SCANOUT_TO_CLOSEST = 6, //!< Balanced - Aspect Ratio NV_SCALING_GPU_SCANOUT_TO_CLOSEST = 7, //!< Balanced - Centered\No Scaling // Legacy Declarations NV_SCALING_MONITOR_SCALING = NV_SCALING_GPU_SCALING_TO_CLOSEST, NV_SCALING_ADAPTER_SCALING = NV_SCALING_GPU_SCALING_TO_NATIVE, NV_SCALING_CENTERED = NV_SCALING_GPU_SCANOUT_TO_NATIVE, NV_SCALING_ASPECT_SCALING = NV_SCALING_GPU_SCALING_TO_ASPECT_SCANOUT_TO_NATIVE, NV_SCALING_CUSTOMIZED = 255 //!< For future use } NV_SCALING; //! Rotate modes- used in NvAPI_SetViewEx(). //! \ingroup dispcontrol typedef enum _NV_ROTATE { NV_ROTATE_0 = 0, NV_ROTATE_90 = 1, NV_ROTATE_180 = 2, NV_ROTATE_270 = 3, NV_ROTATE_IGNORED = 4, } NV_ROTATE; //! Color formats- used in NvAPI_SetViewEx(). //! \ingroup dispcontrol #define NVFORMAT_MAKEFOURCC(ch0, ch1, ch2, ch3) \ ((NvU32)(NvU8)(ch0) | ((NvU32)(NvU8)(ch1) << 8) | \ ((NvU32)(NvU8)(ch2) << 16) | ((NvU32)(NvU8)(ch3) << 24 )) //! Color formats- used in NvAPI_SetViewEx(). //! \ingroup dispcontrol typedef enum _NV_FORMAT { NV_FORMAT_UNKNOWN = 0, //!< unknown. Driver will choose one as following value. NV_FORMAT_P8 = 41, //!< for 8bpp mode NV_FORMAT_R5G6B5 = 23, //!< for 16bpp mode NV_FORMAT_A8R8G8B8 = 21, //!< for 32bpp mode NV_FORMAT_A16B16G16R16F = 113, //!< for 64bpp(floating point) mode. } NV_FORMAT; // TV standard /////////////////////////////////////////////////////////////////////////////// // FUNCTION NAME: NvAPI_DISP_GetMonitorCapabilities // //! \fn NvAPI_DISP_GetMonitorCapabilities(NvU32 displayId, NV_MONITOR_CAPABILITIES *pMonitorCapabilities) //! DESCRIPTION: This API returns the Monitor capabilities //! // SUPPORTED OS: Windows Vista and higher //! //! \param [in] displayId Monitor Identifier //! \param [out] pMonitorCapabilities The monitor support info //! //! \return ::NVAPI_OK, //! ::NVAPI_ERROR, //! ::NVAPI_INVALID_ARGUMENT // /////////////////////////////////////////////////////////////////////////////// //! \ingroup dispcontrol //! @{ //! HDMI-related and extended CAPs typedef enum { // hdmi related caps NV_MONITOR_CAPS_TYPE_HDMI_VSDB = 0x1000, NV_MONITOR_CAPS_TYPE_HDMI_VCDB = 0x1001, } NV_MONITOR_CAPS_TYPE; typedef struct _NV_MONITOR_CAPS_VCDB { NvU8 quantizationRangeYcc : 1; NvU8 quantizationRangeRgb : 1; NvU8 scanInfoPreferredVideoFormat : 2; NvU8 scanInfoITVideoFormats : 2; NvU8 scanInfoCEVideoFormats : 2; } NV_MONITOR_CAPS_VCDB; //! See NvAPI_DISP_GetMonitorCapabilities(). typedef struct _NV_MONITOR_CAPS_VSDB { // byte 1 NvU8 sourcePhysicalAddressB : 4; //!< Byte 1 NvU8 sourcePhysicalAddressA : 4; //!< Byte 1 // byte 2 NvU8 sourcePhysicalAddressD : 4; //!< Byte 2 NvU8 sourcePhysicalAddressC : 4; //!< Byte 2 // byte 3 NvU8 supportDualDviOperation : 1; //!< Byte 3 NvU8 reserved6 : 2; //!< Byte 3 NvU8 supportDeepColorYCbCr444 : 1; //!< Byte 3 NvU8 supportDeepColor30bits : 1; //!< Byte 3 NvU8 supportDeepColor36bits : 1; //!< Byte 3 NvU8 supportDeepColor48bits : 1; //!< Byte 3 NvU8 supportAI : 1; //!< Byte 3 // byte 4 NvU8 maxTmdsClock; //!< Bye 4 // byte 5 NvU8 cnc0SupportGraphicsTextContent : 1; //!< Byte 5 NvU8 cnc1SupportPhotoContent : 1; //!< Byte 5 NvU8 cnc2SupportCinemaContent : 1; //!< Byte 5 NvU8 cnc3SupportGameContent : 1; //!< Byte 5 NvU8 reserved8 : 1; //!< Byte 5 NvU8 hasVicEntries : 1; //!< Byte 5 NvU8 hasInterlacedLatencyField : 1; //!< Byte 5 NvU8 hasLatencyField : 1; //!< Byte 5 // byte 6 NvU8 videoLatency; //!< Byte 6 // byte 7 NvU8 audioLatency; //!< Byte 7 // byte 8 NvU8 interlacedVideoLatency; //!< Byte 8 // byte 9 NvU8 interlacedAudioLatency; //!< Byte 9 // byte 10 NvU8 reserved13 : 7; //!< Byte 10 NvU8 has3dEntries : 1; //!< Byte 10 // byte 11 NvU8 hdmi3dLength : 5; //!< Byte 11 NvU8 hdmiVicLength : 3; //!< Byte 11 // Remaining bytes NvU8 hdmi_vic[7]; //!< Keeping maximum length for 3 bits NvU8 hdmi_3d[31]; //!< Keeping maximum length for 5 bits } NV_MONITOR_CAPS_VSDB; //! See NvAPI_DISP_GetMonitorCapabilities(). typedef struct _NV_MONITOR_CAPABILITIES { NvU32 version; NvU16 size; NvU32 infoType; NvU32 connectorType; //!< Out: VGA, TV, DVI, HDMI, DP NvU8 bIsValidInfo : 1; //!< Boolean : Returns invalid if requested info is not present such as VCDB not present union { NV_MONITOR_CAPS_VSDB vsdb; NV_MONITOR_CAPS_VCDB vcdb; } data; } NV_MONITOR_CAPABILITIES; //! Macro for constructing the version field of ::NV_MONITOR_CAPABILITIES #define NV_MONITOR_CAPABILITIES_VER MAKE_NVAPI_VERSION(NV_MONITOR_CAPABILITIES,1) //! @} // SUPPORTED OS: Windows Vista and higher //! \ingroup dispcontrol NVAPI_INTERFACE NvAPI_DISP_GetMonitorCapabilities(NvU32 displayId, NV_MONITOR_CAPABILITIES *pMonitorCapabilities); /////////////////////////////////////////////////////////////////////////////// // // FUNCTION NAME: NvAPI_SetView // //! \fn NvAPI_SetView(NvDisplayHandle hNvDisplay, NV_VIEW_TARGET_INFO *pTargetInfo, NV_TARGET_VIEW_MODE targetView) //! This function lets the caller modify the target display arrangement of the selected source display handle in any nView mode. //! It can also modify or extend the source display in Dualview mode. //! \note Maps the selected source to the associated target Ids. //! \note Display PATH with this API is limited to single GPU. DUALVIEW across GPUs cannot be enabled with this API. //! // SUPPORTED OS: Windows Vista and higher //! //! \since Version: 90.18 //! //! \param [in] hNvDisplay NVIDIA Display selection. #NVAPI_DEFAULT_HANDLE is not allowed, it has to be a handle enumerated with NvAPI_EnumNVidiaDisplayHandle(). //! \param [in] pTargetInfo Pointer to array of NV_VIEW_TARGET_INFO, specifying device properties in this view. //! The first device entry in the array is the physical primary. //! The device entry with the lowest source id is the desktop primary. //! \param [in] targetCount Count of target devices specified in pTargetInfo. //! \param [in] targetView Target view selected from NV_TARGET_VIEW_MODE. //! //! \retval NVAPI_OK Completed request //! \retval NVAPI_ERROR Miscellaneous error occurred //! \retval NVAPI_INVALID_ARGUMENT Invalid input parameter. // /////////////////////////////////////////////////////////////////////////////// //! \ingroup dispcontrol //! Used in NvAPI_SetView() and NvAPI_GetView() typedef struct { NvU32 version; //!< (IN) structure version NvU32 count; //!< (IN) target count struct { NvU32 deviceMask; //!< (IN/OUT) Device mask NvU32 sourceId; //!< (IN/OUT) Source ID - values will be based on the number of heads exposed per GPU. NvU32 bPrimary:1; //!< (OUT) Indicates if this is the GPU's primary view target. This is not the desktop GDI primary. //!< NvAPI_SetView automatically selects the first target in NV_VIEW_TARGET_INFO index 0 as the GPU's primary view. NvU32 bInterlaced:1; //!< (IN/OUT) Indicates if the timing being used on this monitor is interlaced. NvU32 bGDIPrimary:1; //!< (IN/OUT) Indicates if this is the desktop GDI primary. NvU32 bForceModeSet:1;//!< (IN) Used only on Win7 and higher during a call to NvAPI_SetView(). Turns off optimization & forces OS to set supplied mode. } target[NVAPI_MAX_VIEW_TARGET]; } NV_VIEW_TARGET_INFO; //! \ingroup dispcontrol #define NV_VIEW_TARGET_INFO_VER MAKE_NVAPI_VERSION(NV_VIEW_TARGET_INFO,2) //! \ingroup dispcontrol NVAPI_INTERFACE NvAPI_SetView(NvDisplayHandle hNvDisplay, NV_VIEW_TARGET_INFO *pTargetInfo, NV_TARGET_VIEW_MODE targetView); /////////////////////////////////////////////////////////////////////////////// // FUNCTION NAME: NvAPI_GetView // //! This API lets caller retrieve the target display arrangement for selected source display handle. //! \note Display PATH with this API is limited to single GPU. DUALVIEW across GPUs will be returned as STANDARD VIEW. //! Use NvAPI_SYS_GetDisplayTopologies() to query views across GPUs. //! // SUPPORTED OS: Windows Vista and higher //! //! \since Version: 86.90 //! //! \param [in] hNvDisplay NVIDIA Display selection. It can be #NVAPI_DEFAULT_HANDLE or a handle enumerated from //! NvAPI_EnumNVidiaDisplayHandle(). //! \param [out] pTargets User allocated storage to retrieve an array of NV_VIEW_TARGET_INFO. Can be NULL to retrieve //! the targetCount. //! \param [in,out] targetMaskCount Count of target device mask specified in pTargetMask. //! \param [out] targetView Target view selected from NV_TARGET_VIEW_MODE. //! //! \retval NVAPI_OK Completed request //! \retval NVAPI_ERROR Miscellaneous error occurred //! \retval NVAPI_INVALID_ARGUMENT Invalid input parameter. //! \ingroup dispcontrol /////////////////////////////////////////////////////////////////////////////// NVAPI_INTERFACE NvAPI_GetView(NvDisplayHandle hNvDisplay, NV_VIEW_TARGET_INFO *pTargets, NvU32 *pTargetMaskCount, NV_TARGET_VIEW_MODE *pTargetView); /////////////////////////////////////////////////////////////////////////////// // // FUNCTION NAME: NvAPI_SetViewEx // //! \fn NvAPI_SetViewEx(NvDisplayHandle hNvDisplay, NV_DISPLAY_PATH_INFO *pPathInfo, NV_TARGET_VIEW_MODE displayView) //! This function lets caller to modify the display arrangement for selected source display handle in any of the nview modes. //! It also allows to modify or extend the source display in dualview mode. //! \note Maps the selected source to the associated target Ids. //! \note Display PATH with this API is limited to single GPU. DUALVIEW across GPUs cannot be enabled with this API. //! // SUPPORTED OS: Windows Vista and higher //! //! \since Version: 97.20 //! //! \param [in] hNvDisplay NVIDIA Display selection. #NVAPI_DEFAULT_HANDLE is not allowed, it has to be a handle enumerated with //! NvAPI_EnumNVidiaDisplayHandle(). //! \param [in] pPathInfo Pointer to array of NV_VIEW_PATH_INFO, specifying device properties in this view. //! The first device entry in the array is the physical primary. //! The device entry with the lowest source id is the desktop primary. //! \param [in] pathCount Count of paths specified in pPathInfo. //! \param [in] displayView Display view selected from NV_TARGET_VIEW_MODE. //! //! \retval NVAPI_OK Completed request //! \retval NVAPI_ERROR Miscellaneous error occurred //! \retval NVAPI_INVALID_ARGUMENT Invalid input parameter. // /////////////////////////////////////////////////////////////////////////////// //! \ingroup dispcontrol #define NVAPI_MAX_DISPLAY_PATH NVAPI_MAX_VIEW_TARGET //! \ingroup dispcontrol #define NVAPI_ADVANCED_MAX_DISPLAY_PATH NVAPI_ADVANCED_MAX_VIEW_TARGET //! \ingroup dispcontrol //! Used in NV_DISPLAY_PATH_INFO. typedef struct { NvU32 deviceMask; //!< (IN) Device mask NvU32 sourceId; //!< (IN) Values will be based on the number of heads exposed per GPU(0, 1?) NvU32 bPrimary:1; //!< (IN/OUT) Indicates if this is the GPU's primary view target. This is not the desktop GDI primary. //!< NvAPI_SetViewEx() automatically selects the first target in NV_DISPLAY_PATH_INFO index 0 as the GPU's primary view. NV_GPU_CONNECTOR_TYPE connector; //!< (IN) Specify connector type. For TV only. // source mode information NvU32 width; //!< (IN) Width of the mode NvU32 height; //!< (IN) Height of the mode NvU32 depth; //!< (IN) Depth of the mode NV_FORMAT colorFormat; //!< Color format if it needs to be specified. Not used now. //rotation setting of the mode NV_ROTATE rotation; //!< (IN) Rotation setting. // the scaling mode NV_SCALING scaling; //!< (IN) Scaling setting // Timing info NvU32 refreshRate; //!< (IN) Refresh rate of the mode NvU32 interlaced:1; //!< (IN) Interlaced mode flag NV_DISPLAY_TV_FORMAT tvFormat; //!< (IN) To choose the last TV format set this value to NV_DISPLAY_TV_FORMAT_NONE // Windows desktop position NvU32 posx; //!< (IN/OUT) X-offset of this display on the Windows desktop NvU32 posy; //!< (IN/OUT) Y-offset of this display on the Windows desktop NvU32 bGDIPrimary:1; //!< (IN/OUT) Indicates if this is the desktop GDI primary. NvU32 bForceModeSet:1;//!< (IN) Used only on Win7 and higher during a call to NvAPI_SetViewEx(). Turns off optimization & forces OS to set supplied mode. NvU32 bFocusDisplay:1;//!< (IN) If set, this display path should have the focus after the GPU topology change NvU32 gpuId:24; //!< (IN) the physical display/target Gpu id which is the owner of the scan out (for SLI multimon, display from the slave Gpu) } NV_DISPLAY_PATH; //! \ingroup dispcontrol //! Used in NvAPI_SetViewEx() and NvAPI_GetViewEx(). typedef struct { NvU32 version; //!< (IN) Structure version NvU32 count; //!< (IN) Path count NV_DISPLAY_PATH path[NVAPI_MAX_DISPLAY_PATH]; } NV_DISPLAY_PATH_INFO; //! \addtogroup dispcontrol //! Macro for constructing the version fields of NV_DISPLAY_PATH_INFO //! @{ #define NV_DISPLAY_PATH_INFO_VER NV_DISPLAY_PATH_INFO_VER3 #define NV_DISPLAY_PATH_INFO_VER3 MAKE_NVAPI_VERSION(NV_DISPLAY_PATH_INFO,3) #define NV_DISPLAY_PATH_INFO_VER2 MAKE_NVAPI_VERSION(NV_DISPLAY_PATH_INFO,2) #define NV_DISPLAY_PATH_INFO_VER1 MAKE_NVAPI_VERSION(NV_DISPLAY_PATH_INFO,1) //! @} //! \ingroup dispcontrol NVAPI_INTERFACE NvAPI_SetViewEx(NvDisplayHandle hNvDisplay, NV_DISPLAY_PATH_INFO *pPathInfo, NV_TARGET_VIEW_MODE displayView); /////////////////////////////////////////////////////////////////////////////// // FUNCTION NAME: NvAPI_GetViewEx // //! DESCRIPTION: This API lets caller retrieve the target display arrangement for selected source display handle. //! \note Display PATH with this API is limited to single GPU. DUALVIEW across GPUs will be returned as STANDARD VIEW. //! Use NvAPI_SYS_GetDisplayTopologies() to query views across GPUs. //! // SUPPORTED OS: Windows Vista and higher //! //! \since Version: 165.02 //! //! \param [in] hNvDisplay NVIDIA Display selection. #NVAPI_DEFAULT_HANDLE is not allowed, it has to be a handle enumerated with //! NvAPI_EnumNVidiaDisplayHandle(). //! \param [in,out] pPathInfo Count field should be set to NVAPI_MAX_DISPLAY_PATH. Can be NULL to retrieve just the pathCount. //! \param [in,out] pPathCount Number of elements in array pPathInfo->path. //! \param [out] pTargetViewMode Display view selected from NV_TARGET_VIEW_MODE. //! //! \retval NVAPI_OK Completed request //! \retval NVAPI_API_NOT_INTIALIZED NVAPI not initialized //! \retval NVAPI_ERROR Miscellaneous error occurred //! \retval NVAPI_INVALID_ARGUMENT Invalid input parameter. //! \retval NVAPI_EXPECTED_DISPLAY_HANDLE hNvDisplay is not a valid display handle. //! //! \ingroup dispcontrol /////////////////////////////////////////////////////////////////////////////// NVAPI_INTERFACE NvAPI_GetViewEx(NvDisplayHandle hNvDisplay, NV_DISPLAY_PATH_INFO *pPathInfo, NvU32 *pPathCount, NV_TARGET_VIEW_MODE *pTargetViewMode); /////////////////////////////////////////////////////////////////////////////// // FUNCTION NAME: NvAPI_GetSupportedViews // //! This API lets caller enumerate all the supported NVIDIA display views - nView and Dualview modes. //! // SUPPORTED OS: Windows XP and higher //! //! \since Version: 86.90 //! //! \param [in] hNvDisplay NVIDIA Display selection. It can be #NVAPI_DEFAULT_HANDLE or a handle enumerated from //! NvAPI_EnumNVidiaDisplayHandle(). //! \param [out] pTargetViews Array of supported views. Can be NULL to retrieve the pViewCount first. //! \param [in,out] pViewCount Count of supported views. //! //! \retval NVAPI_OK Completed request //! \retval NVAPI_ERROR Miscellaneous error occurred //! \retval NVAPI_INVALID_ARGUMENT Invalid input parameter. //! \ingroup dispcontrol /////////////////////////////////////////////////////////////////////////////// NVAPI_INTERFACE NvAPI_GetSupportedViews(NvDisplayHandle hNvDisplay, NV_TARGET_VIEW_MODE *pTargetViews, NvU32 *pViewCount); //////////////////////////////////////////////////////////////////////////////////////// // // MOSAIC allows a multi display target output scanout on a single source. // // SAMPLE of MOSAIC 1x4 topo with 8 pixel horizontal overlap // //+-------------------------++-------------------------++-------------------------++-------------------------+ //| || || || | //| || || || | //| || || || | //| DVI1 || DVI2 || DVI3 || DVI4 | //| || || || | //| || || || | //| || || || | //| || || || | //+-------------------------++-------------------------++-------------------------++-------------------------+ //! \addtogroup mosaicapi //! @{ #define NVAPI_MAX_MOSAIC_DISPLAY_ROWS 8 #define NVAPI_MAX_MOSAIC_DISPLAY_COLUMNS 8 #define NV_MOSAIC_MAX_DISPLAYS (64) // // These bits are used to describe the validity of a topo. // #define NV_MOSAIC_TOPO_VALIDITY_VALID 0x00000000 //!< The topology is valid #define NV_MOSAIC_TOPO_VALIDITY_MISSING_GPU 0x00000001 //!< Not enough SLI GPUs were found to fill the entire //! topology. hPhysicalGPU will be 0 for these. #define NV_MOSAIC_TOPO_VALIDITY_MISSING_DISPLAY 0x00000002 //!< Not enough displays were found to fill the entire //! topology. displayOutputId will be 0 for these. #define NV_MOSAIC_TOPO_VALIDITY_MIXED_DISPLAY_TYPES 0x00000004 //!< The topoogy is only possible with displays of the same //! NV_GPU_OUTPUT_TYPE. Check displayOutputIds to make //! sure they are all CRTs, or all DFPs. // //! This structure defines the topology details. typedef struct { NvU32 version; //!< Version of this structure NvLogicalGpuHandle hLogicalGPU; //!< Logical GPU for this topology NvU32 validityMask; //!< 0 means topology is valid with the current hardware. //! If not 0, inspect bits against NV_MOSAIC_TOPO_VALIDITY_*. NvU32 rowCount; //!< Number of displays in a row NvU32 colCount; //!< Number of displays in a column struct { NvPhysicalGpuHandle hPhysicalGPU; //!< Physical GPU to be used in the topology (0 if GPU missing) NvU32 displayOutputId; //!< Connected display target (0 if no display connected) NvS32 overlapX; //!< Pixels of overlap on left of target: (+overlap, -gap) NvS32 overlapY; //!< Pixels of overlap on top of target: (+overlap, -gap) } gpuLayout[NVAPI_MAX_MOSAIC_DISPLAY_ROWS][NVAPI_MAX_MOSAIC_DISPLAY_COLUMNS]; } NV_MOSAIC_TOPO_DETAILS; //! Macro for constructing te vesion field of NV_MOSAIC_TOPO_DETAILS #define NVAPI_MOSAIC_TOPO_DETAILS_VER MAKE_NVAPI_VERSION(NV_MOSAIC_TOPO_DETAILS,1) // //! These values refer to the different types of Mosaic topologies that are possible. When //! getting the supported Mosaic topologies, you can specify one of these types to narrow down //! the returned list to only those that match the given type. typedef enum { NV_MOSAIC_TOPO_TYPE_ALL, //!< All mosaic topologies NV_MOSAIC_TOPO_TYPE_BASIC, //!< Basic Mosaic topologies NV_MOSAIC_TOPO_TYPE_PASSIVE_STEREO, //!< Passive Stereo topologies NV_MOSAIC_TOPO_TYPE_SCALED_CLONE, //!< Not supported at this time NV_MOSAIC_TOPO_TYPE_PASSIVE_STEREO_SCALED_CLONE, //!< Not supported at this time NV_MOSAIC_TOPO_TYPE_MAX, //!< Always leave this at end of the enum } NV_MOSAIC_TOPO_TYPE; // //! This is a complete list of supported Mosaic topologies. //! //! Using a "Basic" topology combines multiple monitors to create a single desktop. //! //! Using a "Passive" topology combines multiples monitors to create a passive stereo desktop. //! In passive stereo, two identical topologies combine - one topology is used for the right eye and the other identical //! topology (targeting different displays) is used for the left eye. \n //! NOTE: common\inc\nvEscDef.h shadows a couple PASSIVE_STEREO enums. If this //! enum list changes and effects the value of NV_MOSAIC_TOPO_BEGIN_PASSIVE_STEREO //! please update the corresponding value in nvEscDef.h typedef enum { NV_MOSAIC_TOPO_NONE, // 'BASIC' topos start here // // The result of using one of these Mosaic topos is that multiple monitors // will combine to create a single desktop. // NV_MOSAIC_TOPO_BEGIN_BASIC, NV_MOSAIC_TOPO_1x2_BASIC = NV_MOSAIC_TOPO_BEGIN_BASIC, NV_MOSAIC_TOPO_2x1_BASIC, NV_MOSAIC_TOPO_1x3_BASIC, NV_MOSAIC_TOPO_3x1_BASIC, NV_MOSAIC_TOPO_1x4_BASIC, NV_MOSAIC_TOPO_4x1_BASIC, NV_MOSAIC_TOPO_2x2_BASIC, NV_MOSAIC_TOPO_2x3_BASIC, NV_MOSAIC_TOPO_2x4_BASIC, NV_MOSAIC_TOPO_3x2_BASIC, NV_MOSAIC_TOPO_4x2_BASIC, NV_MOSAIC_TOPO_1x5_BASIC, NV_MOSAIC_TOPO_1x6_BASIC, NV_MOSAIC_TOPO_7x1_BASIC, // Add padding for 10 more entries. 6 will be enough room to specify every // possible topology with 8 or fewer displays, so this gives us a little // extra should we need it. NV_MOSAIC_TOPO_END_BASIC = NV_MOSAIC_TOPO_7x1_BASIC + 9, // 'PASSIVE_STEREO' topos start here // // The result of using one of these Mosaic topos is that multiple monitors // will combine to create a single PASSIVE STEREO desktop. What this means is // that there will be two topos that combine to create the overall desktop. // One topo will be used for the left eye, and the other topo (of the // same rows x cols), will be used for the right eye. The difference between // the two topos is that different GPUs and displays will be used. // NV_MOSAIC_TOPO_BEGIN_PASSIVE_STEREO, // value shadowed in nvEscDef.h NV_MOSAIC_TOPO_1x2_PASSIVE_STEREO = NV_MOSAIC_TOPO_BEGIN_PASSIVE_STEREO, NV_MOSAIC_TOPO_2x1_PASSIVE_STEREO, NV_MOSAIC_TOPO_1x3_PASSIVE_STEREO, NV_MOSAIC_TOPO_3x1_PASSIVE_STEREO, NV_MOSAIC_TOPO_1x4_PASSIVE_STEREO, NV_MOSAIC_TOPO_4x1_PASSIVE_STEREO, NV_MOSAIC_TOPO_2x2_PASSIVE_STEREO, NV_MOSAIC_TOPO_END_PASSIVE_STEREO = NV_MOSAIC_TOPO_2x2_PASSIVE_STEREO + 4, // // Total number of topos. Always leave this at the end of the enumeration. // NV_MOSAIC_TOPO_MAX //! Total number of topologies. } NV_MOSAIC_TOPO; // //! This is a "topology brief" structure. It tells you what you need to know about //! a topology at a high level. A list of these is returned when you query for the //! supported Mosaic information. //! //! If you need more detailed information about the topology, call //! NvAPI_Mosaic_GetTopoGroup() with the topology value from this structure. typedef struct { NvU32 version; //!< Version of this structure NV_MOSAIC_TOPO topo; //!< The topology NvU32 enabled; //!< 1 if topo is enabled, else 0 NvU32 isPossible; //!< 1 if topo *can* be enabled, else 0 } NV_MOSAIC_TOPO_BRIEF; //! Macro for constructing the version field of NV_MOSAIC_TOPO_BRIEF #define NVAPI_MOSAIC_TOPO_BRIEF_VER MAKE_NVAPI_VERSION(NV_MOSAIC_TOPO_BRIEF,1) // //! Basic per-display settings that are used in setting/getting the Mosaic mode typedef struct { NvU32 version; //!< Version of this structure NvU32 width; //!< Per-display width NvU32 height; //!< Per-display height NvU32 bpp; //!< Bits per pixel NvU32 freq; //!< Display frequency } NV_MOSAIC_DISPLAY_SETTING; //! Macro for constructing the version field of NV_MOSAIC_DISPLAY_SETTING #define NVAPI_MOSAIC_DISPLAY_SETTING_VER MAKE_NVAPI_VERSION(NV_MOSAIC_DISPLAY_SETTING,1) // // Set a reasonable max number of display settings to support // so arrays are bound. // #define NV_MOSAIC_DISPLAY_SETTINGS_MAX 40 //!< Set a reasonable maximum number of display settings to support //! so arrays are bound. // //! This structure is used to contain a list of supported Mosaic topologies //! along with the display settings that can be used. typedef struct { NvU32 version; //!< Version of this structure NvU32 topoBriefsCount; //!< Number of topologies in below array NV_MOSAIC_TOPO_BRIEF topoBriefs[NV_MOSAIC_TOPO_MAX]; //!< List of supported topologies with only brief details NvU32 displaySettingsCount; //!< Number of display settings in below array NV_MOSAIC_DISPLAY_SETTING displaySettings[NV_MOSAIC_DISPLAY_SETTINGS_MAX]; //!< List of per display settings possible } NV_MOSAIC_SUPPORTED_TOPO_INFO; //! Macro forconstructing the version field of NV_MOSAIC_SUPPORTED_TOPO_INFO #define NVAPI_MOSAIC_SUPPORTED_TOPO_INFO_VER MAKE_NVAPI_VERSION(NV_MOSAIC_SUPPORTED_TOPO_INFO,1) // // Indices to use to access the topos array within the mosaic topology #define NV_MOSAIC_TOPO_IDX_DEFAULT 0 #define NV_MOSAIC_TOPO_IDX_LEFT_EYE 0 #define NV_MOSAIC_TOPO_IDX_RIGHT_EYE 1 #define NV_MOSAIC_TOPO_NUM_EYES 2 // //! This defines the maximum number of topos that can be in a topo group. //! At this time, it is set to 2 because our largest topo group (passive //! stereo) only needs 2 topos (left eye and right eye). //! //! If a new topo group with more than 2 topos is added above, then this //! number will also have to be incremented. #define NV_MOSAIC_MAX_TOPO_PER_TOPO_GROUP 2 // //! This structure defines a group of topologies that work together to create one //! overall layout. All of the supported topologies are represented with this //! structure. //! //! For example, a 'Passive Stereo' topology would be represented with this //! structure, and would have separate topology details for the left and right eyes. //! The count would be 2. A 'Basic' topology is also represented by this structure, //! with a count of 1. //! //! The structure is primarily used internally, but is exposed to applications in a //! read-only fashion because there are some details in it that might be useful //! (like the number of rows/cols, or connected display information). A user can //! get the filled-in structure by calling NvAPI_Mosaic_GetTopoGroup(). //! //! You can then look at the detailed values within the structure. There are no //! entrypoints which take this structure as input (effectively making it read-only). typedef struct { NvU32 version; //!< Version of this structure NV_MOSAIC_TOPO_BRIEF brief; //!< The brief details of this topo NvU32 count; //!< Number of topos in array below NV_MOSAIC_TOPO_DETAILS topos[NV_MOSAIC_MAX_TOPO_PER_TOPO_GROUP]; } NV_MOSAIC_TOPO_GROUP; //! Macro for constructing the version field of NV_MOSAIC_TOPO_GROUP #define NVAPI_MOSAIC_TOPO_GROUP_VER MAKE_NVAPI_VERSION(NV_MOSAIC_TOPO_GROUP,1) //! @} /////////////////////////////////////////////////////////////////////////////// // // FUNCTION NAME: NvAPI_Mosaic_GetSupportedTopoInfo // //! DESCRIPTION: This API returns information on the topologies and display resolutions //! supported by Mosaic mode. //! //! NOTE: Not all topologies returned can be set immediately. //! See 'OUT' Notes below. //! //! Once you get the list of supported topologies, you can call //! NvAPI_Mosaic_GetTopoGroup() with one of the Mosaic topologies if you need //! more information about it. //! //! 'IN' Notes: pSupportedTopoInfo->version must be set before calling this function. //! If the specified version is not supported by this implementation, //! an error will be returned (NVAPI_INCOMPATIBLE_STRUCT_VERSION). //! //! 'OUT' Notes: Some of the topologies returned might not be valid for one reason or //! another. It could be due to mismatched or missing displays. It //! could also be because the required number of GPUs is not found. //! At a high level, you can see if the topology is valid and can be enabled //! by looking at the pSupportedTopoInfo->topoBriefs[xxx].isPossible flag. //! If this is true, the topology can be enabled. If it //! is false, you can find out why it cannot be enabled by getting the //! details of the topology via NvAPI_Mosaic_GetTopoGroup(). From there, //! look at the validityMask of the individual topologies. The bits can //! be tested against the NV_MOSAIC_TOPO_VALIDITY_* bits. //! //! It is possible for this function to return NVAPI_OK with no topologies //! listed in the return structure. If this is the case, it means that //! the current hardware DOES support Mosaic, but with the given configuration //! no valid topologies were found. This most likely means that SLI was not //! enabled for the hardware. Once enabled, you should see valid topologies //! returned from this function. //! // SUPPORTED OS: Windows XP and higher //! //! \since Version 185.20 //! //! //! \param [in,out] pSupportedTopoInfo Information about what topologies and display resolutions //! are supported for Mosaic. //! \param [in] type The type of topologies the caller is interested in //! getting. See NV_MOSAIC_TOPO_TYPE for possible values. //! //! \retval ::NVAPI_OK No errors in returning supported topologies. //! \retval ::NVAPI_NOT_SUPPORTED Mosaic is not supported with the existing hardware. //! \retval ::NVAPI_INVALID_ARGUMENT One or more arguments passed in are invalid. //! \retval ::NVAPI_API_NOT_INTIALIZED The NvAPI API needs to be initialized first. //! \retval ::NVAPI_NO_IMPLEMENTATION This entrypoint not available. //! \retval ::NVAPI_INCOMPATIBLE_STRUCT_VERSION The version of the structure passed in is not // compatible with this entry point. //! \retval ::NVAPI_ERROR: Miscellaneous error occurred. //! //! \ingroup mosaicapi /////////////////////////////////////////////////////////////////////////////// NVAPI_INTERFACE NvAPI_Mosaic_GetSupportedTopoInfo(NV_MOSAIC_SUPPORTED_TOPO_INFO *pSupportedTopoInfo, NV_MOSAIC_TOPO_TYPE type); /////////////////////////////////////////////////////////////////////////////// // // FUNCTION NAME: NvAPI_Mosaic_GetTopoGroup // //! DESCRIPTION: This API returns a structure filled with the details //! of the specified Mosaic topology. //! //! If the pTopoBrief passed in matches the current topology, //! then information in the brief and group structures //! will reflect what is current. Thus the brief would have //! the current 'enable' status, and the group would have the //! current overlap values. If there is no match, then the //! returned brief has an 'enable' status of FALSE (since it //! is obviously not enabled), and the overlap values will be 0. //! //! 'IN' Notes: pTopoGroup->version must be set before calling this function. //! If the specified version is not supported by this implementation, //! an error will be returned (NVAPI_INCOMPATIBLE_STRUCT_VERSION). //! //! // SUPPORTED OS: Windows XP and higher //! //! \since Version 185.20 //! //! \param [in] pTopoBrief The topology for getting the details //! This must be one of the topology briefs //! returned from NvAPI_Mosaic_GetSupportedTopoInfo(). //! \param [in,out] pTopoGroup The topology details matching the brief //! //! \retval ::NVAPI_OK Details were retrieved successfully. //! \retval ::NVAPI_NOT_SUPPORTED Mosaic is not supported with the existing hardware. //! \retval ::NVAPI_INVALID_ARGUMENT One or more argumentss passed in are invalid. //! \retval ::NVAPI_API_NOT_INTIALIZED The NvAPI API needs to be initialized first. //! \retval ::NVAPI_NO_IMPLEMENTATION This entrypoint not available. //! \retval ::NVAPI_INCOMPATIBLE_STRUCT_VERSION The version of the structure passed in is not // compatible with this entry point. //! \retval ::NVAPI_ERROR: Miscellaneous error occurred. //! //! \ingroup mosaicapi /////////////////////////////////////////////////////////////////////////////// NVAPI_INTERFACE NvAPI_Mosaic_GetTopoGroup(NV_MOSAIC_TOPO_BRIEF *pTopoBrief, NV_MOSAIC_TOPO_GROUP *pTopoGroup); /////////////////////////////////////////////////////////////////////////////// // // FUNCTION NAME: NvAPI_Mosaic_GetOverlapLimits // //! DESCRIPTION: This API returns the X and Y overlap limits required if //! the given Mosaic topology and display settings are to be used. //! // SUPPORTED OS: Windows XP and higher //! //! \since Version 185.20 //! //! \param [in] pTopoBrief The topology for getting limits //! This must be one of the topo briefs //! returned from NvAPI_Mosaic_GetSupportedTopoInfo(). //! \param [in] pDisplaySetting The display settings for getting the limits. //! This must be one of the settings //! returned from NvAPI_Mosaic_GetSupportedTopoInfo(). //! \param [out] pMinOverlapX X overlap minimum //! \param [out] pMaxOverlapX X overlap maximum //! \param [out] pMinOverlapY Y overlap minimum //! \param [out] pMaxOverlapY Y overlap maximum //! //! \retval ::NVAPI_OK Details were retrieved successfully. //! \retval ::NVAPI_NOT_SUPPORTED Mosaic is not supported with the existing hardware. //! \retval ::NVAPI_INVALID_ARGUMENT One or more argumentss passed in are invalid. //! \retval ::NVAPI_API_NOT_INTIALIZED The NvAPI API needs to be initialized first. //! \retval ::NVAPI_NO_IMPLEMENTATION This entrypoint not available. //! \retval ::NVAPI_INCOMPATIBLE_STRUCT_VERSION The version of the structure passed in is not //! compatible with this entry point. //! \retval ::NVAPI_ERROR Miscellaneous error occurred. //! //! \ingroup mosaicapi /////////////////////////////////////////////////////////////////////////////// NVAPI_INTERFACE NvAPI_Mosaic_GetOverlapLimits(NV_MOSAIC_TOPO_BRIEF *pTopoBrief, NV_MOSAIC_DISPLAY_SETTING *pDisplaySetting, NvS32 *pMinOverlapX, NvS32 *pMaxOverlapX, NvS32 *pMinOverlapY, NvS32 *pMaxOverlapY); /////////////////////////////////////////////////////////////////////////////// // // FUNCTION NAME: NvAPI_Mosaic_SetCurrentTopo // //! DESCRIPTION: This API sets the Mosaic topology and performs a mode switch //! using the given display settings. //! //! If NVAPI_OK is returned, the current Mosaic topology was set //! correctly. Any other status returned means the //! topology was not set, and remains what it was before this //! function was called. //! // SUPPORTED OS: Windows XP and higher //! //! \since Version 185.20 //! //! \param [in] pTopoBrief The topology to set. This must be one of the topologies returned from //! NvAPI_Mosaic_GetSupportedTopoInfo(), and it must have an isPossible value of 1. //! \param [in] pDisplaySetting The per display settings to be used in the Mosaic mode. This must be one of the //! settings returned from NvAPI_Mosaic_GetSupportedTopoInfo(). //! \param [in] overlapX The pixel overlap to use between horizontal displays (use positive a number for //! overlap, or a negative number to create a gap.) If the overlap is out of bounds //! for what is possible given the topo and display setting, the overlap will be clamped. //! \param [in] overlapY The pixel overlap to use between vertical displays (use positive a number for //! overlap, or a negative number to create a gap.) If the overlap is out of bounds for //! what is possible given the topo and display setting, the overlap will be clamped. //! \param [in] enable If 1, the topology being set will also be enabled, meaning that the mode set will //! occur. \n //! If 0, you don't want to be in Mosaic mode right now, but want to set the current //! Mosaic topology so you can enable it later with NvAPI_Mosaic_EnableCurrentTopo(). //! //! \retval ::NVAPI_OK The Mosaic topology was set. //! \retval ::NVAPI_NOT_SUPPORTED Mosaic is not supported with the existing hardware. //! \retval ::NVAPI_INVALID_ARGUMENT One or more argumentss passed in are invalid. //! \retval ::NVAPI_TOPO_NOT_POSSIBLE The topology passed in is not currently possible. //! \retval ::NVAPI_API_NOT_INTIALIZED The NvAPI API needs to be initialized first. //! \retval ::NVAPI_NO_IMPLEMENTATION This entrypoint not available. //! \retval ::NVAPI_INCOMPATIBLE_STRUCT_VERSION The version of the structure passed in is not //! compatible with this entrypoint. //! \retval ::NVAPI_MODE_CHANGE_FAILED There was an error changing the display mode. //! \retval ::NVAPI_ERROR Miscellaneous error occurred. //! //! \ingroup mosaicapi /////////////////////////////////////////////////////////////////////////////// NVAPI_INTERFACE NvAPI_Mosaic_SetCurrentTopo(NV_MOSAIC_TOPO_BRIEF *pTopoBrief, NV_MOSAIC_DISPLAY_SETTING *pDisplaySetting, NvS32 overlapX, NvS32 overlapY, NvU32 enable); /////////////////////////////////////////////////////////////////////////////// // // FUNCTION NAME: NvAPI_Mosaic_GetCurrentTopo // //! DESCRIPTION: This API returns information for the current Mosaic topology. //! This includes topology, display settings, and overlap values. //! //! You can call NvAPI_Mosaic_GetTopoGroup() with the topology //! if you require more information. //! //! If there isn't a current topology, then pTopoBrief->topo will //! be NV_MOSAIC_TOPO_NONE. //! // SUPPORTED OS: Windows XP and higher //! //! \since Version 185.20 //! //! \param [out] pTopoBrief The current Mosaic topology //! \param [out] pDisplaySetting The current per-display settings //! \param [out] pOverlapX The pixel overlap between horizontal displays //! \param [out] pOverlapY The pixel overlap between vertical displays //! //! \retval ::NVAPI_OK Success getting current info. //! \retval ::NVAPI_NOT_SUPPORTED Mosaic is not supported with the existing hardware. //! \retval ::NVAPI_INVALID_ARGUMENT One or more argumentss passed in are invalid. //! \retval ::NVAPI_API_NOT_INTIALIZED The NvAPI API needs to be initialized first. //! \retval ::NVAPI_NO_IMPLEMENTATION This entry point not available. //! \retval ::NVAPI_ERROR Miscellaneous error occurred. //! //! \ingroup mosaicapi /////////////////////////////////////////////////////////////////////////////// NVAPI_INTERFACE NvAPI_Mosaic_GetCurrentTopo(NV_MOSAIC_TOPO_BRIEF *pTopoBrief, NV_MOSAIC_DISPLAY_SETTING *pDisplaySetting, NvS32 *pOverlapX, NvS32 *pOverlapY); /////////////////////////////////////////////////////////////////////////////// // // FUNCTION NAME: NvAPI_Mosaic_EnableCurrentTopo // //! DESCRIPTION: This API enables or disables the current Mosaic topology //! based on the setting of the incoming 'enable' parameter. //! //! An "enable" setting enables the current (previously set) Mosaic topology. //! Note that when the current Mosaic topology is retrieved, it must have an isPossible value of 1 or //! an error will occur. //! //! A "disable" setting disables the current Mosaic topology. //! The topology information will persist, even across reboots. //! To re-enable the Mosaic topology, call this function //! again with the enable parameter set to 1. //! // SUPPORTED OS: Windows XP and higher //! //! \since Version 185.20 //! //! \param [in] enable 1 to enable the current Mosaic topo, 0 to disable it. //! //! \retval ::NVAPI_OK The Mosaic topo was enabled/disabled. //! \retval ::NVAPI_NOT_SUPPORTED Mosaic is not supported with the existing hardware. //! \retval ::NVAPI_INVALID_ARGUMENT One or more arguments passed in are invalid. //! \retval ::NVAPI_TOPO_NOT_POSSIBLE The current topology is not currently possible. //! \retval ::NVAPI_MODE_CHANGE_FAILED There was an error changing the display mode. //! \retval ::NVAPI_ERROR: Miscellaneous error occurred. //! //! \ingroup mosaicapi /////////////////////////////////////////////////////////////////////////////// NVAPI_INTERFACE NvAPI_Mosaic_EnableCurrentTopo(NvU32 enable); // SUPPORTED OS: Windows Vista and higher /////////////////////////////////////////////////////////////////////////////// // // FUNCTION NAME: NvAPI_Mosaic_GetDisplayViewportsByResolution // //! DESCRIPTION: This API returns the viewports that would be applied on //! the requested display. //! //! \param [in] displayId Display ID of a single display in the active //! mosaic topology to query. //! \param [in] srcWidth Width of full display topology. If both //! width and height are 0, the current //! resolution is used. //! \param [in] srcHeight Height of full display topology. If both //! width and height are 0, the current //! resolution is used. //! \param [out] viewports Array of NV_RECT viewports which represent //! the displays as identified in //! NvAPI_Mosaic_EnumGridTopologies. If the //! requested resolution is a single-wide //! resolution, only viewports[0] will //! contain the viewport details, regardless //! of which display is driving the display. //! \param [out] bezelCorrected Returns 1 if the requested resolution is //! bezel corrected. May be NULL. //! //! \retval ::NVAPI_OK Capabilties have been returned. //! \retval ::NVAPI_INVALID_ARGUMENT One or more args passed in are invalid. //! \retval ::NVAPI_API_NOT_INTIALIZED The NvAPI API needs to be initialized first //! \retval ::NVAPI_MOSAIC_NOT_ACTIVE The display does not belong to an active Mosaic Topology //! \retval ::NVAPI_NO_IMPLEMENTATION This entrypoint not available //! \retval ::NVAPI_ERROR Miscellaneous error occurred //! //! \ingroup mosaicapi /////////////////////////////////////////////////////////////////////////////// NVAPI_INTERFACE NvAPI_Mosaic_GetDisplayViewportsByResolution(NvU32 displayId, NvU32 srcWidth, NvU32 srcHeight, NV_RECT viewports[NV_MOSAIC_MAX_DISPLAYS], NvU8* bezelCorrected); //////////////////////////////////////////////////////////////////////////////////////// // // ########################################################################### // DELME_RUSS - DELME_RUSS - DELME_RUSS - DELME_RUSS - DELME_RUSS - DELME_RUSS // // Below is the Phase 1 Mosaic stuff, the Phase 2 stuff above is what will remain // once Phase 2 is complete. For a small amount of time, the two will co-exist. As // soon as apps (nvapichk, NvAPITestMosaic, and CPL) are updated to use the Phase 2 // entrypoints, the code below will be deleted. // // DELME_RUSS - DELME_RUSS - DELME_RUSS - DELME_RUSS - DELME_RUSS - DELME_RUSS // ########################################################################### // // Supported topos 1x4, 4x1 and 2x2 to start with. // // Selected scan out targets can be one per GPU or more than one on the same GPU. // // SAMPLE of MOSAIC 1x4 SCAN OUT TOPO with 8 pixel horizontal overlap // //+-------------------------++-------------------------++-------------------------++-------------------------+ //| || || || | //| || || || | //| || || || | //| DVI1 || DVI2 || DVI3 || DVI4 | //| || || || | //| || || || | //| || || || | //| || || || | //+-------------------------++-------------------------++-------------------------++-------------------------+ //! \addtogroup mosaicapi //! @{ //! Used in NV_MOSAIC_TOPOLOGY. #define NVAPI_MAX_MOSAIC_DISPLAY_ROWS 8 //! Used in NV_MOSAIC_TOPOLOGY. #define NVAPI_MAX_MOSAIC_DISPLAY_COLUMNS 8 //! Used in NV_MOSAIC_TOPOLOGY. #define NVAPI_MAX_MOSAIC_TOPOS 16 //! Used in NvAPI_GetCurrentMosaicTopology() and NvAPI_SetCurrentMosaicTopology(). typedef struct { NvU32 version; //!< Version number of the mosaic topology NvU32 rowCount; //!< Horizontal display count NvU32 colCount; //!< Vertical display count struct { NvPhysicalGpuHandle hPhysicalGPU; //!< Physical GPU to be used in the topology NvU32 displayOutputId; //!< Connected display target NvS32 overlapX; //!< Pixels of overlap on the left of target: (+overlap, -gap) NvS32 overlapY; //!< Pixels of overlap on the top of target: (+overlap, -gap) } gpuLayout[NVAPI_MAX_MOSAIC_DISPLAY_ROWS][NVAPI_MAX_MOSAIC_DISPLAY_COLUMNS]; } NV_MOSAIC_TOPOLOGY; //! Used in NV_MOSAIC_TOPOLOGY. #define NVAPI_MOSAIC_TOPOLOGY_VER MAKE_NVAPI_VERSION(NV_MOSAIC_TOPOLOGY,1) //! Used in NvAPI_GetSupportedMosaicTopologies(). typedef struct { NvU32 version; NvU32 totalCount; //!< Count of valid topologies NV_MOSAIC_TOPOLOGY topos[NVAPI_MAX_MOSAIC_TOPOS]; //!< Maximum number of topologies } NV_MOSAIC_SUPPORTED_TOPOLOGIES; //! Used in NV_MOSAIC_SUPPORTED_TOPOLOGIES. #define NVAPI_MOSAIC_SUPPORTED_TOPOLOGIES_VER MAKE_NVAPI_VERSION(NV_MOSAIC_SUPPORTED_TOPOLOGIES,1) //!@} /////////////////////////////////////////////////////////////////////////////// // // FUNCTION NAME: NvAPI_GetSupportedMosaicTopologies // //! DESCRIPTION: This API returns all valid Mosaic topologies. //! // SUPPORTED OS: Windows XP //! //! \since Version: R177_00 //! //! \param [out] pMosaicTopos An array of valid Mosaic topologies. //! //! \retval NVAPI_OK Call succeeded; 1 or more topologies were returned //! \retval NVAPI_INVALID_ARGUMENT One or more arguments are invalid //! \retval NVAPI_MIXED_TARGET_TYPES Mosaic topology is only possible with all targets of the same NV_GPU_OUTPUT_TYPE. //! \retval NVAPI_NVIDIA_DEVICE_NOT_FOUND No NVIDIA GPU driving a display was found //! \retval NVAPI_NOT_SUPPORTED Mosaic is not supported with GPUs on this system. //! \retval NVAPI_NO_ACTIVE_SLI_TOPOLOGY SLI is not enabled, yet needs to be, in order for this function to succeed. //! //! \ingroup mosaicapi /////////////////////////////////////////////////////////////////////////////// NVAPI_INTERFACE NvAPI_GetSupportedMosaicTopologies(NV_MOSAIC_SUPPORTED_TOPOLOGIES *pMosaicTopos); /////////////////////////////////////////////////////////////////////////////// // // FUNCTION NAME: NvAPI_GetCurrentMosaicTopology // //! DESCRIPTION: This API gets the current Mosaic topology. //! // SUPPORTED OS: Windows XP //! //! \since Version: R177_00 //! //! \param [out] pMosaicTopo The current Mosaic topology //! \param [out] pEnabled TRUE if returned topology is currently enabled, else FALSE //! //! \retval NVAPI_OK Call succeeded //! \retval NVAPI_INVALID_ARGUMENT One or more arguments are invalid //! \retval NVAPI_NVIDIA_DEVICE_NOT_FOUND No NVIDIA GPU driving a display was found //! \retval NVAPI_NOT_SUPPORTED Mosaic is not supported with GPUs on this system. //! \retval NVAPI_NO_ACTIVE_SLI_TOPOLOGY SLI is not enabled, yet needs to be, in order for this function to succeed. //! //! \ingroup mosaicapi /////////////////////////////////////////////////////////////////////////////// NVAPI_INTERFACE NvAPI_GetCurrentMosaicTopology(NV_MOSAIC_TOPOLOGY *pMosaicTopo, NvU32 *pEnabled); /////////////////////////////////////////////////////////////////////////////// // // FUNCTION NAME: NvAPI_SetCurrentMosaicTopology // //! DESCRIPTION: This API sets the Mosaic topology, and enables it so that the //! Mosaic display settings are enumerated upon request. //! // SUPPORTED OS: Windows XP //! //! \since Version: R177_00 //! //! \param [in] pMosaicTopo A valid Mosaic topology //! //! \retval NVAPI_OK Call succeeded //! \retval NVAPI_INVALID_ARGUMENT One or more arguments are invalid //! \retval NVAPI_NVIDIA_DEVICE_NOT_FOUND No NVIDIA GPU driving a display was found //! \retval NVAPI_NOT_SUPPORTED Mosaic is not supported with GPUs on this system. //! \retval NVAPI_NO_ACTIVE_SLI_TOPOLOGY SLI is not enabled, yet needs to be, in order for this function to succeed. //! //! \ingroup mosaicapi /////////////////////////////////////////////////////////////////////////////// NVAPI_INTERFACE NvAPI_SetCurrentMosaicTopology(NV_MOSAIC_TOPOLOGY *pMosaicTopo); /////////////////////////////////////////////////////////////////////////////// // // FUNCTION NAME: NvAPI_EnableCurrentMosaicTopology // //! DESCRIPTION: This API enables or disables the current Mosaic topology. //! When enabling, the last Mosaic topology will be set. //! //! - If enabled, enumeration of display settings will include valid Mosaic resolutions. //! - If disabled, enumeration of display settings will not include Mosaic resolutions. //! // SUPPORTED OS: Windows XP //! //! \since Version: R177_00 //! //! \param [in] enable TRUE to enable the Mosaic Topology, FALSE to disable it. //! //! \retval NVAPI_OK Call succeeded //! \retval NVAPI_INVALID_ARGUMENT One or more arguments are invalid //! \retval NVAPI_NVIDIA_DEVICE_NOT_FOUND No NVIDIA GPU driving a display was found //! \retval NVAPI_NOT_SUPPORTED Mosaic is not supported with GPUs on this system. //! \retval NVAPI_NO_ACTIVE_SLI_TOPOLOGY SLI is not enabled, yet needs to be, in order for this function to succeed. //! //! \ingroup mosaicapi /////////////////////////////////////////////////////////////////////////////// NVAPI_INTERFACE NvAPI_EnableCurrentMosaicTopology(NvU32 enable); /////////////////////////////////////////////////////////////////////////////// // // FUNCTION NAME: NvAPI_GPU_GetHDCPSupportStatus // //! \fn NvAPI_GPU_GetHDCPSupportStatus(NvPhysicalGpuHandle hPhysicalGpu, NV_GPU_GET_HDCP_SUPPORT_STATUS *pGetHDCPSupportStatus) //! DESCRIPTION: This function returns a GPU's HDCP support status. //! // SUPPORTED OS: Windows XP and higher //! //! \since Version: 175.86 //! //! \retval ::NVAPI_OK //! \retval ::NVAPI_ERROR //! \retval ::NVAPI_INVALID_ARGUMENT //! \retval ::NVAPI_HANDLE_INVALIDATED //! \retval ::NVAPI_EXPECTED_PHYSICAL_GPU_HANDLE //! \retval ::NVAPI_INCOMPATIBLE_STRUCT_VERSION // //////////////////////////////////////////////////////////////////////////////// //! HDCP fuse states - used in NV_GPU_GET_HDCP_SUPPORT_STATUS typedef enum _NV_GPU_HDCP_FUSE_STATE { NV_GPU_HDCP_FUSE_STATE_UNKNOWN = 0, NV_GPU_HDCP_FUSE_STATE_DISABLED = 1, NV_GPU_HDCP_FUSE_STATE_ENABLED = 2, } NV_GPU_HDCP_FUSE_STATE; //! HDCP key sources - used in NV_GPU_GET_HDCP_SUPPORT_STATUS typedef enum _NV_GPU_HDCP_KEY_SOURCE { NV_GPU_HDCP_KEY_SOURCE_UNKNOWN = 0, NV_GPU_HDCP_KEY_SOURCE_NONE = 1, NV_GPU_HDCP_KEY_SOURCE_CRYPTO_ROM = 2, NV_GPU_HDCP_KEY_SOURCE_SBIOS = 3, NV_GPU_HDCP_KEY_SOURCE_I2C_ROM = 4, NV_GPU_HDCP_KEY_SOURCE_FUSES = 5, } NV_GPU_HDCP_KEY_SOURCE; //! HDCP key source states - used in NV_GPU_GET_HDCP_SUPPORT_STATUS typedef enum _NV_GPU_HDCP_KEY_SOURCE_STATE { NV_GPU_HDCP_KEY_SOURCE_STATE_UNKNOWN = 0, NV_GPU_HDCP_KEY_SOURCE_STATE_ABSENT = 1, NV_GPU_HDCP_KEY_SOURCE_STATE_PRESENT = 2, } NV_GPU_HDCP_KEY_SOURCE_STATE; //! HDPC support status - used in NvAPI_GPU_GetHDCPSupportStatus() typedef struct { NvU32 version; //! Structure version constucted by macro #NV_GPU_GET_HDCP_SUPPORT_STATUS NV_GPU_HDCP_FUSE_STATE hdcpFuseState; //! GPU's HDCP fuse state NV_GPU_HDCP_KEY_SOURCE hdcpKeySource; //! GPU's HDCP key source NV_GPU_HDCP_KEY_SOURCE_STATE hdcpKeySourceState; //! GPU's HDCP key source state } NV_GPU_GET_HDCP_SUPPORT_STATUS; //! Macro for constructing the version for structure NV_GPU_GET_HDCP_SUPPORT_STATUS #define NV_GPU_GET_HDCP_SUPPORT_STATUS_VER MAKE_NVAPI_VERSION(NV_GPU_GET_HDCP_SUPPORT_STATUS,1) //! \ingroup gpu NVAPI_INTERFACE NvAPI_GPU_GetHDCPSupportStatus(NvPhysicalGpuHandle hPhysicalGpu, NV_GPU_GET_HDCP_SUPPORT_STATUS *pGetHDCPSupportStatus); #if defined(_D3D9_H_) || defined(__d3d10_h__) || defined(__d3d11_h__) /////////////////////////////////////////////////////////////////////////////// // // FUNCTION NAME: NvAPI_Stereo_CreateHandleFromIUnknown // //! DESCRIPTION: This API creates a stereo handle that is used in subsequent calls related to a given device interface. //! This must be called before any other NvAPI_Stereo_ function for that handle. //! Multiple devices can be used at one time using multiple calls to this function (one per each device). //! //! HOW TO USE: After the Direct3D device is created, create the stereo handle. //! On call success: //! -# Use all other NvAPI_Stereo_ functions that have stereo handle as first parameter. //! -# After the device interface that corresponds to the the stereo handle is destroyed, //! the application should call NvAPI_DestroyStereoHandle() for that stereo handle. //! //! WHEN TO USE: After the stereo handle for the device interface is created via successfull call to the appropriate NvAPI_Stereo_CreateHandleFrom() function. //! // SUPPORTED OS: Windows Vista and higher //! //! \since Version 180.51 //! //! \param [in] pDevice Pointer to IUnknown interface that is IDirect3DDevice9* in DX9, ID3D10Device*. //! \param [out] pStereoHandle Pointer to the newly created stereo handle. //! //! \retval ::NVAPI_OK Stereo handle is created for given device interface. //! \retval ::NVAPI_INVALID_ARGUMENT Provided device interface is invalid. //! \retval ::NVAPI_API_NOT_INTIALIZED //! \retval ::NVAPI_STEREO_NOT_INITIALIZED Stereo part of NVAPI not initialized. //! \retval ::NVAPI_ERROR //! //! \ingroup stereoapi /////////////////////////////////////////////////////////////////////////////// NVAPI_INTERFACE NvAPI_Stereo_CreateHandleFromIUnknown(IUnknown *pDevice, StereoHandle *pStereoHandle); #endif // defined(_D3D9_H_) || defined(__d3d10_h__) //! \ingroup vidio //! Unique identifier for VIO owner (process identifier or NVVIOOWNERID_NONE) typedef NvU32 NVVIOOWNERID; //! \addtogroup vidio //! @{ #define NVVIOOWNERID_NONE 0 //!< Unregistered ownerId //! Owner type for device typedef enum _NVVIOOWNERTYPE { NVVIOOWNERTYPE_NONE , //!< No owner for the device NVVIOOWNERTYPE_APPLICATION , //!< Application owns the device NVVIOOWNERTYPE_DESKTOP , //!< Desktop transparent mode owns the device (not applicable for video input) }NVVIOOWNERTYPE; // Access rights for NvAPI_VIO_Open() //! Read access (not applicable for video output) #define NVVIO_O_READ 0x00000000 //! Write exclusive access (not applicable for video input) #define NVVIO_O_WRITE_EXCLUSIVE 0x00010001 //! #define NVVIO_VALID_ACCESSRIGHTS (NVVIO_O_READ | \ NVVIO_O_WRITE_EXCLUSIVE ) //! VIO_DATA.ulOwnerID high-bit is set only if device has been initialized by VIOAPI //! examined at NvAPI_GetCapabilities|NvAPI_VIO_Open to determine if settings need to be applied from registry or POR state read #define NVVIO_OWNERID_INITIALIZED 0x80000000 //! VIO_DATA.ulOwnerID next-bit is set only if device is currently in exclusive write access mode from NvAPI_VIO_Open() #define NVVIO_OWNERID_EXCLUSIVE 0x40000000 //! VIO_DATA.ulOwnerID lower bits are: //! NVGVOOWNERTYPE_xxx enumerations indicating use context #define NVVIO_OWNERID_TYPEMASK 0x0FFFFFFF //!< mask for NVVIOOWNERTYPE_xxx //! @} //--------------------------------------------------------------------- // Enumerations //--------------------------------------------------------------------- //! \addtogroup vidio //! @{ //! Video signal format and resolution typedef enum _NVVIOSIGNALFORMAT { NVVIOSIGNALFORMAT_NONE, //!< Invalid signal format NVVIOSIGNALFORMAT_487I_59_94_SMPTE259_NTSC, //!< 01 487i 59.94Hz (SMPTE259) NTSC NVVIOSIGNALFORMAT_576I_50_00_SMPTE259_PAL, //!< 02 576i 50.00Hz (SMPTE259) PAL NVVIOSIGNALFORMAT_1035I_60_00_SMPTE260, //!< 03 1035i 60.00Hz (SMPTE260) NVVIOSIGNALFORMAT_1035I_59_94_SMPTE260, //!< 04 1035i 59.94Hz (SMPTE260) NVVIOSIGNALFORMAT_1080I_50_00_SMPTE295, //!< 05 1080i 50.00Hz (SMPTE295) NVVIOSIGNALFORMAT_1080I_60_00_SMPTE274, //!< 06 1080i 60.00Hz (SMPTE274) NVVIOSIGNALFORMAT_1080I_59_94_SMPTE274, //!< 07 1080i 59.94Hz (SMPTE274) NVVIOSIGNALFORMAT_1080I_50_00_SMPTE274, //!< 08 1080i 50.00Hz (SMPTE274) NVVIOSIGNALFORMAT_1080P_30_00_SMPTE274, //!< 09 1080p 30.00Hz (SMPTE274) NVVIOSIGNALFORMAT_1080P_29_97_SMPTE274, //!< 10 1080p 29.97Hz (SMPTE274) NVVIOSIGNALFORMAT_1080P_25_00_SMPTE274, //!< 11 1080p 25.00Hz (SMPTE274) NVVIOSIGNALFORMAT_1080P_24_00_SMPTE274, //!< 12 1080p 24.00Hz (SMPTE274) NVVIOSIGNALFORMAT_1080P_23_976_SMPTE274, //!< 13 1080p 23.976Hz (SMPTE274) NVVIOSIGNALFORMAT_720P_60_00_SMPTE296, //!< 14 720p 60.00Hz (SMPTE296) NVVIOSIGNALFORMAT_720P_59_94_SMPTE296, //!< 15 720p 59.94Hz (SMPTE296) NVVIOSIGNALFORMAT_720P_50_00_SMPTE296, //!< 16 720p 50.00Hz (SMPTE296) NVVIOSIGNALFORMAT_1080I_48_00_SMPTE274, //!< 17 1080I 48.00Hz (SMPTE274) NVVIOSIGNALFORMAT_1080I_47_96_SMPTE274, //!< 18 1080I 47.96Hz (SMPTE274) NVVIOSIGNALFORMAT_720P_30_00_SMPTE296, //!< 19 720p 30.00Hz (SMPTE296) NVVIOSIGNALFORMAT_720P_29_97_SMPTE296, //!< 20 720p 29.97Hz (SMPTE296) NVVIOSIGNALFORMAT_720P_25_00_SMPTE296, //!< 21 720p 25.00Hz (SMPTE296) NVVIOSIGNALFORMAT_720P_24_00_SMPTE296, //!< 22 720p 24.00Hz (SMPTE296) NVVIOSIGNALFORMAT_720P_23_98_SMPTE296, //!< 23 720p 23.98Hz (SMPTE296) NVVIOSIGNALFORMAT_2048P_30_00_SMPTE372, //!< 24 2048p 30.00Hz (SMPTE372) NVVIOSIGNALFORMAT_2048P_29_97_SMPTE372, //!< 25 2048p 29.97Hz (SMPTE372) NVVIOSIGNALFORMAT_2048I_60_00_SMPTE372, //!< 26 2048i 60.00Hz (SMPTE372) NVVIOSIGNALFORMAT_2048I_59_94_SMPTE372, //!< 27 2048i 59.94Hz (SMPTE372) NVVIOSIGNALFORMAT_2048P_25_00_SMPTE372, //!< 28 2048p 25.00Hz (SMPTE372) NVVIOSIGNALFORMAT_2048I_50_00_SMPTE372, //!< 29 2048i 50.00Hz (SMPTE372) NVVIOSIGNALFORMAT_2048P_24_00_SMPTE372, //!< 30 2048p 24.00Hz (SMPTE372) NVVIOSIGNALFORMAT_2048P_23_98_SMPTE372, //!< 31 2048p 23.98Hz (SMPTE372) NVVIOSIGNALFORMAT_2048I_48_00_SMPTE372, //!< 32 2048i 48.00Hz (SMPTE372) NVVIOSIGNALFORMAT_2048I_47_96_SMPTE372, //!< 33 2048i 47.96Hz (SMPTE372) NVVIOSIGNALFORMAT_1080PSF_25_00_SMPTE274, //!< 34 1080PsF 25.00Hz (SMPTE274) NVVIOSIGNALFORMAT_1080PSF_29_97_SMPTE274, //!< 35 1080PsF 29.97Hz (SMPTE274) NVVIOSIGNALFORMAT_1080PSF_30_00_SMPTE274, //!< 36 1080PsF 30.00Hz (SMPTE274) NVVIOSIGNALFORMAT_1080PSF_24_00_SMPTE274, //!< 37 1080PsF 24.00Hz (SMPTE274) NVVIOSIGNALFORMAT_1080PSF_23_98_SMPTE274, //!< 38 1080PsF 23.98Hz (SMPTE274) NVVIOSIGNALFORMAT_1080P_50_00_SMPTE274_3G_LEVEL_A, //!< 39 1080P 50.00Hz (SMPTE274) 3G Level A NVVIOSIGNALFORMAT_1080P_59_94_SMPTE274_3G_LEVEL_A, //!< 40 1080P 59.94Hz (SMPTE274) 3G Level A NVVIOSIGNALFORMAT_1080P_60_00_SMPTE274_3G_LEVEL_A, //!< 41 1080P 60.00Hz (SMPTE274) 3G Level A NVVIOSIGNALFORMAT_1080P_60_00_SMPTE274_3G_LEVEL_B, //!< 42 1080p 60.00Hz (SMPTE274) 3G Level B NVVIOSIGNALFORMAT_1080I_60_00_SMPTE274_3G_LEVEL_B, //!< 43 1080i 60.00Hz (SMPTE274) 3G Level B NVVIOSIGNALFORMAT_2048I_60_00_SMPTE372_3G_LEVEL_B, //!< 44 2048i 60.00Hz (SMPTE372) 3G Level B NVVIOSIGNALFORMAT_1080P_50_00_SMPTE274_3G_LEVEL_B, //!< 45 1080p 50.00Hz (SMPTE274) 3G Level B NVVIOSIGNALFORMAT_1080I_50_00_SMPTE274_3G_LEVEL_B, //!< 46 1080i 50.00Hz (SMPTE274) 3G Level B NVVIOSIGNALFORMAT_2048I_50_00_SMPTE372_3G_LEVEL_B, //!< 47 2048i 50.00Hz (SMPTE372) 3G Level B NVVIOSIGNALFORMAT_1080P_30_00_SMPTE274_3G_LEVEL_B, //!< 48 1080p 30.00Hz (SMPTE274) 3G Level B NVVIOSIGNALFORMAT_2048P_30_00_SMPTE372_3G_LEVEL_B, //!< 49 2048p 30.00Hz (SMPTE372) 3G Level B NVVIOSIGNALFORMAT_1080P_25_00_SMPTE274_3G_LEVEL_B, //!< 50 1080p 25.00Hz (SMPTE274) 3G Level B NVVIOSIGNALFORMAT_2048P_25_00_SMPTE372_3G_LEVEL_B, //!< 51 2048p 25.00Hz (SMPTE372) 3G Level B NVVIOSIGNALFORMAT_1080P_24_00_SMPTE274_3G_LEVEL_B, //!< 52 1080p 24.00Hz (SMPTE274) 3G Level B NVVIOSIGNALFORMAT_2048P_24_00_SMPTE372_3G_LEVEL_B, //!< 53 2048p 24.00Hz (SMPTE372) 3G Level B NVVIOSIGNALFORMAT_1080I_48_00_SMPTE274_3G_LEVEL_B, //!< 54 1080i 48.00Hz (SMPTE274) 3G Level B NVVIOSIGNALFORMAT_2048I_48_00_SMPTE372_3G_LEVEL_B, //!< 55 2048i 48.00Hz (SMPTE372) 3G Level B NVVIOSIGNALFORMAT_1080P_59_94_SMPTE274_3G_LEVEL_B, //!< 56 1080p 59.94Hz (SMPTE274) 3G Level B NVVIOSIGNALFORMAT_1080I_59_94_SMPTE274_3G_LEVEL_B, //!< 57 1080i 59.94Hz (SMPTE274) 3G Level B NVVIOSIGNALFORMAT_2048I_59_94_SMPTE372_3G_LEVEL_B, //!< 58 2048i 59.94Hz (SMPTE372) 3G Level B NVVIOSIGNALFORMAT_1080P_29_97_SMPTE274_3G_LEVEL_B, //!< 59 1080p 29.97Hz (SMPTE274) 3G Level B NVVIOSIGNALFORMAT_2048P_29_97_SMPTE372_3G_LEVEL_B, //!< 60 2048p 29.97Hz (SMPTE372) 3G Level B NVVIOSIGNALFORMAT_1080P_23_98_SMPTE274_3G_LEVEL_B, //!< 61 1080p 29.98Hz (SMPTE274) 3G Level B NVVIOSIGNALFORMAT_2048P_23_98_SMPTE372_3G_LEVEL_B, //!< 62 2048p 29.98Hz (SMPTE372) 3G Level B NVVIOSIGNALFORMAT_1080I_47_96_SMPTE274_3G_LEVEL_B, //!< 63 1080i 47.96Hz (SMPTE274) 3G Level B NVVIOSIGNALFORMAT_2048I_47_96_SMPTE372_3G_LEVEL_B, //!< 64 2048i 47.96Hz (SMPTE372) 3G Level B NVVIOSIGNALFORMAT_END //!< 65 To indicate end of signal format list }NVVIOSIGNALFORMAT; //! SMPTE standards format typedef enum _NVVIOVIDEOSTANDARD { NVVIOVIDEOSTANDARD_SMPTE259 , //!< SMPTE259 NVVIOVIDEOSTANDARD_SMPTE260 , //!< SMPTE260 NVVIOVIDEOSTANDARD_SMPTE274 , //!< SMPTE274 NVVIOVIDEOSTANDARD_SMPTE295 , //!< SMPTE295 NVVIOVIDEOSTANDARD_SMPTE296 , //!< SMPTE296 NVVIOVIDEOSTANDARD_SMPTE372 , //!< SMPTE372 }NVVIOVIDEOSTANDARD; //! HD or SD video type typedef enum _NVVIOVIDEOTYPE { NVVIOVIDEOTYPE_SD , //!< Standard-definition (SD) NVVIOVIDEOTYPE_HD , //!< High-definition (HD) }NVVIOVIDEOTYPE; //! Interlace mode typedef enum _NVVIOINTERLACEMODE { NVVIOINTERLACEMODE_PROGRESSIVE , //!< Progressive (p) NVVIOINTERLACEMODE_INTERLACE , //!< Interlace (i) NVVIOINTERLACEMODE_PSF , //!< Progressive Segment Frame (psf) }NVVIOINTERLACEMODE; //! Video data format typedef enum _NVVIODATAFORMAT { NVVIODATAFORMAT_UNKNOWN = -1 , //!< Invalid DataFormat NVVIODATAFORMAT_R8G8B8_TO_YCRCB444 , //!< R8:G8:B8 => YCrCb (4:4:4) NVVIODATAFORMAT_R8G8B8A8_TO_YCRCBA4444 , //!< R8:G8:B8:A8 => YCrCbA (4:4:4:4) NVVIODATAFORMAT_R8G8B8Z10_TO_YCRCBZ4444 , //!< R8:G8:B8:Z10 => YCrCbZ (4:4:4:4) NVVIODATAFORMAT_R8G8B8_TO_YCRCB422 , //!< R8:G8:B8 => YCrCb (4:2:2) NVVIODATAFORMAT_R8G8B8A8_TO_YCRCBA4224 , //!< R8:G8:B8:A8 => YCrCbA (4:2:2:4) NVVIODATAFORMAT_R8G8B8Z10_TO_YCRCBZ4224 , //!< R8:G8:B8:Z10 => YCrCbZ (4:2:2:4) NVVIODATAFORMAT_X8X8X8_444_PASSTHRU , //!< R8:G8:B8 => RGB (4:4:4) NVVIODATAFORMAT_X8X8X8A8_4444_PASSTHRU , //!< R8:G8:B8:A8 => RGBA (4:4:4:4) NVVIODATAFORMAT_X8X8X8Z10_4444_PASSTHRU , //!< R8:G8:B8:Z10 => RGBZ (4:4:4:4) NVVIODATAFORMAT_X10X10X10_444_PASSTHRU , //!< Y10:CR10:CB10 => YCrCb (4:4:4) NVVIODATAFORMAT_X10X8X8_444_PASSTHRU , //!< Y10:CR8:CB8 => YCrCb (4:4:4) NVVIODATAFORMAT_X10X8X8A10_4444_PASSTHRU , //!< Y10:CR8:CB8:A10 => YCrCbA (4:4:4:4) NVVIODATAFORMAT_X10X8X8Z10_4444_PASSTHRU , //!< Y10:CR8:CB8:Z10 => YCrCbZ (4:4:4:4) NVVIODATAFORMAT_DUAL_R8G8B8_TO_DUAL_YCRCB422 , //!< R8:G8:B8 + R8:G8:B8 => YCrCb (4:2:2 + 4:2:2) NVVIODATAFORMAT_DUAL_X8X8X8_TO_DUAL_422_PASSTHRU , //!< Y8:CR8:CB8 + Y8:CR8:CB8 => YCrCb (4:2:2 + 4:2:2) NVVIODATAFORMAT_R10G10B10_TO_YCRCB422 , //!< R10:G10:B10 => YCrCb (4:2:2) NVVIODATAFORMAT_R10G10B10_TO_YCRCB444 , //!< R10:G10:B10 => YCrCb (4:4:4) NVVIODATAFORMAT_X12X12X12_444_PASSTHRU , //!< X12:X12:X12 => XXX (4:4:4) NVVIODATAFORMAT_X12X12X12_422_PASSTHRU , //!< X12:X12:X12 => XXX (4:2:2) NVVIODATAFORMAT_Y10CR10CB10_TO_YCRCB422 , //!< Y10:CR10:CB10 => YCrCb (4:2:2) NVVIODATAFORMAT_Y8CR8CB8_TO_YCRCB422 , //!< Y8:CR8:CB8 => YCrCb (4:2:2) NVVIODATAFORMAT_Y10CR8CB8A10_TO_YCRCBA4224 , //!< Y10:CR8:CB8:A10 => YCrCbA (4:2:2:4) NVVIODATAFORMAT_R10G10B10_TO_RGB444 , //!< R10:G10:B10 => RGB (4:4:4) NVVIODATAFORMAT_R12G12B12_TO_YCRCB444 , //!< R12:G12:B12 => YCrCb (4:4:4) NVVIODATAFORMAT_R12G12B12_TO_YCRCB422 , //!< R12:G12:B12 => YCrCb (4:2:2) }NVVIODATAFORMAT; //! Video output area typedef enum _NVVIOOUTPUTAREA { NVVIOOUTPUTAREA_FULLSIZE , //!< Output to entire video resolution (full size) NVVIOOUTPUTAREA_SAFEACTION , //!< Output to centered 90% of video resolution (safe action) NVVIOOUTPUTAREA_SAFETITLE , //!< Output to centered 80% of video resolution (safe title) }NVVIOOUTPUTAREA; //! Synchronization source typedef enum _NVVIOSYNCSOURCE { NVVIOSYNCSOURCE_SDISYNC , //!< SDI Sync (Digital input) NVVIOSYNCSOURCE_COMPSYNC , //!< COMP Sync (Composite input) }NVVIOSYNCSOURCE; //! Composite synchronization type typedef enum _NVVIOCOMPSYNCTYPE { NVVIOCOMPSYNCTYPE_AUTO , //!< Auto-detect NVVIOCOMPSYNCTYPE_BILEVEL , //!< Bi-level signal NVVIOCOMPSYNCTYPE_TRILEVEL , //!< Tri-level signal }NVVIOCOMPSYNCTYPE; //! Video input output status typedef enum _NVVIOINPUTOUTPUTSTATUS { NVINPUTOUTPUTSTATUS_OFF , //!< Not in use NVINPUTOUTPUTSTATUS_ERROR , //!< Error detected NVINPUTOUTPUTSTATUS_SDI_SD , //!< SDI (standard-definition) NVINPUTOUTPUTSTATUS_SDI_HD , //!< SDI (high-definition) }NVVIOINPUTOUTPUTSTATUS; //! Synchronization input status typedef enum _NVVIOSYNCSTATUS { NVVIOSYNCSTATUS_OFF , //!< Sync not detected NVVIOSYNCSTATUS_ERROR , //!< Error detected NVVIOSYNCSTATUS_SYNCLOSS , //!< Genlock in use, format mismatch with output NVVIOSYNCSTATUS_COMPOSITE , //!< Composite sync NVVIOSYNCSTATUS_SDI_SD , //!< SDI sync (standard-definition) NVVIOSYNCSTATUS_SDI_HD , //!< SDI sync (high-definition) }NVVIOSYNCSTATUS; //! Video Capture Status typedef enum _NVVIOCAPTURESTATUS { NVVIOSTATUS_STOPPED , //!< Sync not detected NVVIOSTATUS_RUNNING , //!< Error detected NVVIOSTATUS_ERROR , //!< Genlock in use, format mismatch with output }NVVIOCAPTURESTATUS; //! Video Capture Status typedef enum _NVVIOSTATUSTYPE { NVVIOSTATUSTYPE_IN , //!< Input Status NVVIOSTATUSTYPE_OUT , //!< Output Status }NVVIOSTATUSTYPE; //! Assumption, maximum 4 SDI input and 4 SDI output cards supported on a system #define NVAPI_MAX_VIO_DEVICES 8 //! 4 physical jacks supported on each SDI input card. #define NVAPI_MAX_VIO_JACKS 4 //! Each physical jack an on SDI input card can have //! two "channels" in the case of "3G" VideoFormats, as specified //! by SMPTE 425; for non-3G VideoFormats, only the first channel within //! a physical jack is valid. #define NVAPI_MAX_VIO_CHANNELS_PER_JACK 2 //! 4 Streams, 1 per physical jack #define NVAPI_MAX_VIO_STREAMS 4 #define NVAPI_MIN_VIO_STREAMS 1 //! SDI input supports a max of 2 links per stream #define NVAPI_MAX_VIO_LINKS_PER_STREAM 2 #define NVAPI_MAX_FRAMELOCK_MAPPING_MODES 20 //! Min number of capture images #define NVAPI_GVI_MIN_RAW_CAPTURE_IMAGES 1 //! Max number of capture images #define NVAPI_GVI_MAX_RAW_CAPTURE_IMAGES 32 //! Default number of capture images #define NVAPI_GVI_DEFAULT_RAW_CAPTURE_IMAGES 5 // Data Signal notification events. These need a event handler in RM. // Register/Unregister and PopEvent NVAPI's are already available. //! Device configuration typedef enum _NVVIOCONFIGTYPE { NVVIOCONFIGTYPE_IN , //!< Input Status NVVIOCONFIGTYPE_OUT , //!< Output Status }NVVIOCONFIGTYPE; typedef enum _NVVIOCOLORSPACE { NVVIOCOLORSPACE_UNKNOWN, NVVIOCOLORSPACE_YCBCR, NVVIOCOLORSPACE_YCBCRA, NVVIOCOLORSPACE_YCBCRD, NVVIOCOLORSPACE_GBR, NVVIOCOLORSPACE_GBRA, NVVIOCOLORSPACE_GBRD, } NVVIOCOLORSPACE; //! Component sampling typedef enum _NVVIOCOMPONENTSAMPLING { NVVIOCOMPONENTSAMPLING_UNKNOWN, NVVIOCOMPONENTSAMPLING_4444, NVVIOCOMPONENTSAMPLING_4224, NVVIOCOMPONENTSAMPLING_444, NVVIOCOMPONENTSAMPLING_422 } NVVIOCOMPONENTSAMPLING; typedef enum _NVVIOBITSPERCOMPONENT { NVVIOBITSPERCOMPONENT_UNKNOWN, NVVIOBITSPERCOMPONENT_8, NVVIOBITSPERCOMPONENT_10, NVVIOBITSPERCOMPONENT_12, } NVVIOBITSPERCOMPONENT; typedef enum _NVVIOLINKID { NVVIOLINKID_UNKNOWN, NVVIOLINKID_A, NVVIOLINKID_B, NVVIOLINKID_C, NVVIOLINKID_D } NVVIOLINKID; typedef enum _NVVIOANCPARITYCOMPUTATION { NVVIOANCPARITYCOMPUTATION_AUTO, NVVIOANCPARITYCOMPUTATION_ON, NVVIOANCPARITYCOMPUTATION_OFF } NVVIOANCPARITYCOMPUTATION; //! @} //--------------------------------------------------------------------- // Structures //--------------------------------------------------------------------- //! \addtogroup vidio //! @{ //! Supports Serial Digital Interface (SDI) output #define NVVIOCAPS_VIDOUT_SDI 0x00000001 //! Supports Internal timing source #define NVVIOCAPS_SYNC_INTERNAL 0x00000100 //! Supports Genlock timing source #define NVVIOCAPS_SYNC_GENLOCK 0x00000200 //! Supports Serial Digital Interface (SDI) synchronization input #define NVVIOCAPS_SYNCSRC_SDI 0x00001000 //! Supports Composite synchronization input #define NVVIOCAPS_SYNCSRC_COMP 0x00002000 //! Supports Desktop transparent mode #define NVVIOCAPS_OUTPUTMODE_DESKTOP 0x00010000 //! Supports OpenGL application mode #define NVVIOCAPS_OUTPUTMODE_OPENGL 0x00020000 //! Supports Serial Digital Interface (SDI) input #define NVVIOCAPS_VIDIN_SDI 0x00100000 //! Supports Packed ANC #define NVVIOCAPS_PACKED_ANC_SUPPORTED 0x00200000 //! SDI-class interface: SDI output with two genlock inputs #define NVVIOCLASS_SDI 0x00000001 //! Device capabilities typedef struct _NVVIOCAPS { NvU32 version; //!< Structure version NvAPI_String adapterName; //!< Graphics adapter name NvU32 adapterClass; //!< Graphics adapter classes (NVVIOCLASS_SDI mask) NvU32 adapterCaps; //!< Graphics adapter capabilities (NVVIOCAPS_* mask) NvU32 dipSwitch; //!< On-board DIP switch settings bits NvU32 dipSwitchReserved; //!< On-board DIP switch settings reserved bits NvU32 boardID; //!< Board ID //! Driver version struct // { NvU32 majorVersion; //!< Major version NvU32 minorVersion; //!< Minor version } driver; // //! Firmware version struct { NvU32 majorVersion; //!< Major version NvU32 minorVersion; //!< Minor version } firmWare; // NVVIOOWNERID ownerId; //!< Unique identifier for owner of video output (NVVIOOWNERID_INVALID if free running) NVVIOOWNERTYPE ownerType; //!< Owner type (OpenGL application or Desktop mode) } NVVIOCAPS; //! Macro for constructing the version field of NVVIOCAPS #define NVVIOCAPS_VER MAKE_NVAPI_VERSION(NVVIOCAPS,1) //! Input channel status typedef struct _NVVIOCHANNELSTATUS { NvU32 smpte352; //!< 4-byte SMPTE 352 video payload identifier NVVIOSIGNALFORMAT signalFormat; //!< Signal format NVVIOBITSPERCOMPONENT bitsPerComponent; //!< Bits per component NVVIOCOMPONENTSAMPLING samplingFormat; //!< Sampling format NVVIOCOLORSPACE colorSpace; //!< Color space NVVIOLINKID linkID; //!< Link ID } NVVIOCHANNELSTATUS; //! Input device status typedef struct _NVVIOINPUTSTATUS { NVVIOCHANNELSTATUS vidIn[NVAPI_MAX_VIO_JACKS][NVAPI_MAX_VIO_CHANNELS_PER_JACK]; //!< Video input status per channel within a jack NVVIOCAPTURESTATUS captureStatus; //!< status of video capture } NVVIOINPUTSTATUS; //! Output device status typedef struct _NVVIOOUTPUTSTATUS { NVVIOINPUTOUTPUTSTATUS vid1Out; //!< Video 1 output status NVVIOINPUTOUTPUTSTATUS vid2Out; //!< Video 2 output status NVVIOSYNCSTATUS sdiSyncIn; //!< SDI sync input status NVVIOSYNCSTATUS compSyncIn; //!< Composite sync input status NvU32 syncEnable; //!< Sync enable (TRUE if using syncSource) NVVIOSYNCSOURCE syncSource; //!< Sync source NVVIOSIGNALFORMAT syncFormat; //!< Sync format NvU32 frameLockEnable; //!< Framelock enable flag NvU32 outputVideoLocked; //!< Output locked status NvU32 dataIntegrityCheckErrorCount; //!< Data integrity check error count NvU32 dataIntegrityCheckEnabled; //!< Data integrity check status enabled NvU32 dataIntegrityCheckFailed; //!< Data integrity check status failed NvU32 uSyncSourceLocked; //!< genlocked to framelocked to ref signal NvU32 uPowerOn; //!< TRUE: indicates there is sufficient power } NVVIOOUTPUTSTATUS; //! Video device status. typedef struct _NVVIOSTATUS { NvU32 version; //!< Structure version NVVIOSTATUSTYPE nvvioStatusType; //!< Input or Output status union { NVVIOINPUTSTATUS inStatus; //!< Input device status NVVIOOUTPUTSTATUS outStatus; //!< Output device status }vioStatus; } NVVIOSTATUS; //! Macro for constructingthe version field of NVVIOSTATUS #define NVVIOSTATUS_VER MAKE_NVAPI_VERSION(NVVIOSTATUS,1) //! Output region typedef struct _NVVIOOUTPUTREGION { NvU32 x; //!< Horizontal origin in pixels NvU32 y; //!< Vertical origin in pixels NvU32 width; //!< Width of region in pixels NvU32 height; //!< Height of region in pixels } NVVIOOUTPUTREGION; //! Gamma ramp (8-bit index) typedef struct _NVVIOGAMMARAMP8 { NvU16 uRed[256]; //!< Red channel gamma ramp (8-bit index, 16-bit values) NvU16 uGreen[256]; //!< Green channel gamma ramp (8-bit index, 16-bit values) NvU16 uBlue[256]; //!< Blue channel gamma ramp (8-bit index, 16-bit values) } NVVIOGAMMARAMP8; //! Gamma ramp (10-bit index) typedef struct _NVVIOGAMMARAMP10 { NvU16 uRed[1024]; //!< Red channel gamma ramp (10-bit index, 16-bit values) NvU16 uGreen[1024]; //!< Green channel gamma ramp (10-bit index, 16-bit values) NvU16 uBlue[1024]; //!< Blue channel gamma ramp (10-bit index, 16-bit values) } NVVIOGAMMARAMP10; //! Sync delay typedef struct _NVVIOSYNCDELAY { NvU32 version; //!< Structure version NvU32 horizontalDelay; //!< Horizontal delay in pixels NvU32 verticalDelay; //!< Vertical delay in lines } NVVIOSYNCDELAY; //! Macro for constructing the version field of NVVIOSYNCDELAY #define NVVIOSYNCDELAY_VER MAKE_NVAPI_VERSION(NVVIOSYNCDELAY,1) //! Video mode information typedef struct _NVVIOVIDEOMODE { NvU32 horizontalPixels; //!< Horizontal resolution (in pixels) NvU32 verticalLines; //!< Vertical resolution for frame (in lines) float fFrameRate; //!< Frame rate NVVIOINTERLACEMODE interlaceMode; //!< Interlace mode NVVIOVIDEOSTANDARD videoStandard; //!< SMPTE standards format NVVIOVIDEOTYPE videoType; //!< HD or SD signal classification } NVVIOVIDEOMODE; //! Signal format details typedef struct _NVVIOSIGNALFORMATDETAIL { NVVIOSIGNALFORMAT signalFormat; //!< Signal format enumerated value NVVIOVIDEOMODE videoMode; //!< Video mode for signal format }NVVIOSIGNALFORMATDETAIL; //! R8:G8:B8 #define NVVIOBUFFERFORMAT_R8G8B8 0x00000001 //! R8:G8:B8:Z24 #define NVVIOBUFFERFORMAT_R8G8B8Z24 0x00000002 //! R8:G8:B8:A8 #define NVVIOBUFFERFORMAT_R8G8B8A8 0x00000004 //! R8:G8:B8:A8:Z24 #define NVVIOBUFFERFORMAT_R8G8B8A8Z24 0x00000008 //! R16FP:G16FP:B16FP #define NVVIOBUFFERFORMAT_R16FPG16FPB16FP 0x00000010 //! R16FP:G16FP:B16FP:Z24 #define NVVIOBUFFERFORMAT_R16FPG16FPB16FPZ24 0x00000020 //! R16FP:G16FP:B16FP:A16FP #define NVVIOBUFFERFORMAT_R16FPG16FPB16FPA16FP 0x00000040 //! R16FP:G16FP:B16FP:A16FP:Z24 #define NVVIOBUFFERFORMAT_R16FPG16FPB16FPA16FPZ24 0x00000080 //! Data format details typedef struct _NVVIODATAFORMATDETAIL { NVVIODATAFORMAT dataFormat; //!< Data format enumerated value NvU32 vioCaps; //!< Data format capabilities (NVVIOCAPS_* mask) }NVVIODATAFORMATDETAIL; //! Colorspace conversion typedef struct _NVVIOCOLORCONVERSION { NvU32 version; //!< Structure version float colorMatrix[3][3]; //!< Output[n] = float colorOffset[3]; //!< Input[0] * colorMatrix[n][0] + float colorScale[3]; //!< Input[1] * colorMatrix[n][1] + //!< Input[2] * colorMatrix[n][2] + //!< OutputRange * colorOffset[n] //!< where OutputRange is the standard magnitude of //!< Output[n][n] and colorMatrix and colorOffset //!< values are within the range -1.0 to +1.0 NvU32 compositeSafe; //!< compositeSafe constrains luminance range when using composite output } NVVIOCOLORCONVERSION; //! macro for constructing the version field of _NVVIOCOLORCONVERSION. #define NVVIOCOLORCONVERSION_VER MAKE_NVAPI_VERSION(NVVIOCOLORCONVERSION,1) //! Gamma correction typedef struct _NVVIOGAMMACORRECTION { NvU32 version; //!< Structure version NvU32 vioGammaCorrectionType; //!< Gamma correction type (8-bit or 10-bit) //! Gamma correction: union { NVVIOGAMMARAMP8 gammaRamp8; //!< Gamma ramp (8-bit index, 16-bit values) NVVIOGAMMARAMP10 gammaRamp10; //!< Gamma ramp (10-bit index, 16-bit values) }gammaRamp; float fGammaValueR; //!< Red Gamma value within gamma ranges. 0.5 - 6.0 float fGammaValueG; //!< Green Gamma value within gamma ranges. 0.5 - 6.0 float fGammaValueB; //!< Blue Gamma value within gamma ranges. 0.5 - 6.0 } NVVIOGAMMACORRECTION; //! Macro for constructing thevesion field of _NVVIOGAMMACORRECTION #define NVVIOGAMMACORRECTION_VER MAKE_NVAPI_VERSION(NVVIOGAMMACORRECTION,1) //! Maximum number of ranges per channel #define MAX_NUM_COMPOSITE_RANGE 2 typedef struct _NVVIOCOMPOSITERANGE { NvU32 uRange; NvU32 uEnabled; NvU32 uMin; NvU32 uMax; } NVVIOCOMPOSITERANGE; // Device configuration (fields masks indicating NVVIOCONFIG fields to use for NvAPI_VIO_GetConfig/NvAPI_VIO_SetConfig() ) // #define NVVIOCONFIG_SIGNALFORMAT 0x00000001 //!< fields: signalFormat #define NVVIOCONFIG_DATAFORMAT 0x00000002 //!< fields: dataFormat #define NVVIOCONFIG_OUTPUTREGION 0x00000004 //!< fields: outputRegion #define NVVIOCONFIG_OUTPUTAREA 0x00000008 //!< fields: outputArea #define NVVIOCONFIG_COLORCONVERSION 0x00000010 //!< fields: colorConversion #define NVVIOCONFIG_GAMMACORRECTION 0x00000020 //!< fields: gammaCorrection #define NVVIOCONFIG_SYNCSOURCEENABLE 0x00000040 //!< fields: syncSource and syncEnable #define NVVIOCONFIG_SYNCDELAY 0x00000080 //!< fields: syncDelay #define NVVIOCONFIG_COMPOSITESYNCTYPE 0x00000100 //!< fields: compositeSyncType #define NVVIOCONFIG_FRAMELOCKENABLE 0x00000200 //!< fields: EnableFramelock #define NVVIOCONFIG_422FILTER 0x00000400 //!< fields: bEnable422Filter #define NVVIOCONFIG_COMPOSITETERMINATE 0x00000800 //!< fields: bCompositeTerminate (Not supported on Quadro FX 4000 SDI) #define NVVIOCONFIG_DATAINTEGRITYCHECK 0x00001000 //!< fields: bEnableDataIntegrityCheck (Not supported on Quadro FX 4000 SDI) #define NVVIOCONFIG_CSCOVERRIDE 0x00002000 //!< fields: colorConversion override #define NVVIOCONFIG_FLIPQUEUELENGTH 0x00004000 //!< fields: flipqueuelength control #define NVVIOCONFIG_ANCTIMECODEGENERATION 0x00008000 //!< fields: bEnableANCTimeCodeGeneration #define NVVIOCONFIG_COMPOSITE 0x00010000 //!< fields: bEnableComposite #define NVVIOCONFIG_ALPHAKEYCOMPOSITE 0x00020000 //!< fields: bEnableAlphaKeyComposite #define NVVIOCONFIG_COMPOSITE_Y 0x00040000 //!< fields: compRange #define NVVIOCONFIG_COMPOSITE_CR 0x00080000 //!< fields: compRange #define NVVIOCONFIG_COMPOSITE_CB 0x00100000 //!< fields: compRange #define NVVIOCONFIG_FULL_COLOR_RANGE 0x00200000 //!< fields: bEnableFullColorRange #define NVVIOCONFIG_RGB_DATA 0x00400000 //!< fields: bEnableRGBData #define NVVIOCONFIG_RESERVED_SDIOUTPUTENABLE 0x00800000 //!< fields: bEnableSDIOutput #define NVVIOCONFIG_STREAMS 0x01000000 //!< fields: streams #define NVVIOCONFIG_ANC_PARITY_COMPUTATION 0x02000000 //!< fields: ancParityComputation // Don't forget to update NVVIOCONFIG_VALIDFIELDS in nvapi.spec when NVVIOCONFIG_ALLFIELDS changes. #define NVVIOCONFIG_ALLFIELDS ( NVVIOCONFIG_SIGNALFORMAT | \ NVVIOCONFIG_DATAFORMAT | \ NVVIOCONFIG_OUTPUTREGION | \ NVVIOCONFIG_OUTPUTAREA | \ NVVIOCONFIG_COLORCONVERSION | \ NVVIOCONFIG_GAMMACORRECTION | \ NVVIOCONFIG_SYNCSOURCEENABLE | \ NVVIOCONFIG_SYNCDELAY | \ NVVIOCONFIG_COMPOSITESYNCTYPE | \ NVVIOCONFIG_FRAMELOCKENABLE | \ NVVIOCONFIG_422FILTER | \ NVVIOCONFIG_COMPOSITETERMINATE | \ NVVIOCONFIG_DATAINTEGRITYCHECK | \ NVVIOCONFIG_CSCOVERRIDE | \ NVVIOCONFIG_FLIPQUEUELENGTH | \ NVVIOCONFIG_ANCTIMECODEGENERATION | \ NVVIOCONFIG_COMPOSITE | \ NVVIOCONFIG_ALPHAKEYCOMPOSITE | \ NVVIOCONFIG_COMPOSITE_Y | \ NVVIOCONFIG_COMPOSITE_CR | \ NVVIOCONFIG_COMPOSITE_CB | \ NVVIOCONFIG_FULL_COLOR_RANGE | \ NVVIOCONFIG_RGB_DATA | \ NVVIOCONFIG_RESERVED_SDIOUTPUTENABLE | \ NVVIOCONFIG_STREAMS | \ NVVIOCONFIG_ANC_PARITY_COMPUTATION) #define NVVIOCONFIG_VALIDFIELDS ( NVVIOCONFIG_SIGNALFORMAT | \ NVVIOCONFIG_DATAFORMAT | \ NVVIOCONFIG_OUTPUTREGION | \ NVVIOCONFIG_OUTPUTAREA | \ NVVIOCONFIG_COLORCONVERSION | \ NVVIOCONFIG_GAMMACORRECTION | \ NVVIOCONFIG_SYNCSOURCEENABLE | \ NVVIOCONFIG_SYNCDELAY | \ NVVIOCONFIG_COMPOSITESYNCTYPE | \ NVVIOCONFIG_FRAMELOCKENABLE | \ NVVIOCONFIG_RESERVED_SDIOUTPUTENABLE | \ NVVIOCONFIG_422FILTER | \ NVVIOCONFIG_COMPOSITETERMINATE | \ NVVIOCONFIG_DATAINTEGRITYCHECK | \ NVVIOCONFIG_CSCOVERRIDE | \ NVVIOCONFIG_FLIPQUEUELENGTH | \ NVVIOCONFIG_ANCTIMECODEGENERATION | \ NVVIOCONFIG_COMPOSITE | \ NVVIOCONFIG_ALPHAKEYCOMPOSITE | \ NVVIOCONFIG_COMPOSITE_Y | \ NVVIOCONFIG_COMPOSITE_CR | \ NVVIOCONFIG_COMPOSITE_CB | \ NVVIOCONFIG_FULL_COLOR_RANGE | \ NVVIOCONFIG_RGB_DATA | \ NVVIOCONFIG_RESERVED_SDIOUTPUTENABLE | \ NVVIOCONFIG_STREAMS | \ NVVIOCONFIG_ANC_PARITY_COMPUTATION) #define NVVIOCONFIG_DRIVERFIELDS ( NVVIOCONFIG_OUTPUTREGION | \ NVVIOCONFIG_OUTPUTAREA | \ NVVIOCONFIG_COLORCONVERSION | \ NVVIOCONFIG_FLIPQUEUELENGTH) #define NVVIOCONFIG_GAMMAFIELDS ( NVVIOCONFIG_GAMMACORRECTION ) #define NVVIOCONFIG_RMCTRLFIELDS ( NVVIOCONFIG_SIGNALFORMAT | \ NVVIOCONFIG_DATAFORMAT | \ NVVIOCONFIG_SYNCSOURCEENABLE | \ NVVIOCONFIG_COMPOSITESYNCTYPE | \ NVVIOCONFIG_FRAMELOCKENABLE | \ NVVIOCONFIG_422FILTER | \ NVVIOCONFIG_COMPOSITETERMINATE | \ NVVIOCONFIG_DATAINTEGRITYCHECK | \ NVVIOCONFIG_COMPOSITE | \ NVVIOCONFIG_ALPHAKEYCOMPOSITE | \ NVVIOCONFIG_COMPOSITE_Y | \ NVVIOCONFIG_COMPOSITE_CR | \ NVVIOCONFIG_COMPOSITE_CB) #define NVVIOCONFIG_RMSKEWFIELDS ( NVVIOCONFIG_SYNCDELAY ) #define NVVIOCONFIG_ALLOWSDIRUNNING_FIELDS ( NVVIOCONFIG_DATAINTEGRITYCHECK | \ NVVIOCONFIG_SYNCDELAY | \ NVVIOCONFIG_CSCOVERRIDE | \ NVVIOCONFIG_ANCTIMECODEGENERATION | \ NVVIOCONFIG_COMPOSITE | \ NVVIOCONFIG_ALPHAKEYCOMPOSITE | \ NVVIOCONFIG_COMPOSITE_Y | \ NVVIOCONFIG_COMPOSITE_CR | \ NVVIOCONFIG_COMPOSITE_CB | \ NVVIOCONFIG_ANC_PARITY_COMPUTATION) #define NVVIOCONFIG_RMMODESET_FIELDS ( NVVIOCONFIG_SIGNALFORMAT | \ NVVIOCONFIG_DATAFORMAT | \ NVVIOCONFIG_SYNCSOURCEENABLE | \ NVVIOCONFIG_FRAMELOCKENABLE | \ NVVIOCONFIG_COMPOSITESYNCTYPE ) //! Output device configuration // No members can be deleted from below structure. Only add new members at the // end of the structure. typedef struct _NVVIOOUTPUTCONFIG_V1 { NVVIOSIGNALFORMAT signalFormat; //!< Signal format for video output NVVIODATAFORMAT dataFormat; //!< Data format for video output NVVIOOUTPUTREGION outputRegion; //!< Region for video output (Desktop mode) NVVIOOUTPUTAREA outputArea; //!< Usable resolution for video output (safe area) NVVIOCOLORCONVERSION colorConversion; //!< Color conversion. NVVIOGAMMACORRECTION gammaCorrection; NvU32 syncEnable; //!< Sync enable (TRUE to use syncSource) NVVIOSYNCSOURCE syncSource; //!< Sync source NVVIOSYNCDELAY syncDelay; //!< Sync delay NVVIOCOMPSYNCTYPE compositeSyncType; //!< Composite sync type NvU32 frameLockEnable; //!< Flag indicating whether framelock was on/off NvU32 psfSignalFormat; //!< Indicates whether contained format is PSF Signal format NvU32 enable422Filter; //!< Enables/Disables 4:2:2 filter NvU32 compositeTerminate; //!< Composite termination NvU32 enableDataIntegrityCheck; //!< Enable data integrity check: true - enable, false - disable NvU32 cscOverride; //!< Use provided CSC color matrix to overwrite NvU32 flipQueueLength; //!< Number of buffers used for the internal flipqueue NvU32 enableANCTimeCodeGeneration; //!< Enable SDI ANC time code generation NvU32 enableComposite; //!< Enable composite NvU32 enableAlphaKeyComposite; //!< Enable Alpha key composite NVVIOCOMPOSITERANGE compRange; //!< Composite ranges NvU8 reservedData[256]; //!< Inicates last stored SDI output state TRUE-ON / FALSE-OFF NvU32 enableFullColorRange; //!< Flag indicating Full Color Range NvU32 enableRGBData; //!< Indicates data is in RGB format } NVVIOOUTPUTCONFIG_V1; typedef struct _NVVIOOUTPUTCONFIG_V2 { NVVIOSIGNALFORMAT signalFormat; //!< Signal format for video output NVVIODATAFORMAT dataFormat; //!< Data format for video output NVVIOOUTPUTREGION outputRegion; //!< Region for video output (Desktop mode) NVVIOOUTPUTAREA outputArea; //!< Usable resolution for video output (safe area) NVVIOCOLORCONVERSION colorConversion; //!< Color conversion. NVVIOGAMMACORRECTION gammaCorrection; NvU32 syncEnable; //!< Sync enable (TRUE to use syncSource) NVVIOSYNCSOURCE syncSource; //!< Sync source NVVIOSYNCDELAY syncDelay; //!< Sync delay NVVIOCOMPSYNCTYPE compositeSyncType; //!< Composite sync type NvU32 frameLockEnable; //!< Flag indicating whether framelock was on/off NvU32 psfSignalFormat; //!< Indicates whether contained format is PSF Signal format NvU32 enable422Filter; //!< Enables/Disables 4:2:2 filter NvU32 compositeTerminate; //!< Composite termination NvU32 enableDataIntegrityCheck; //!< Enable data integrity check: true - enable, false - disable NvU32 cscOverride; //!< Use provided CSC color matrix to overwrite NvU32 flipQueueLength; //!< Number of buffers used for the internal flip queue NvU32 enableANCTimeCodeGeneration; //!< Enable SDI ANC time code generation NvU32 enableComposite; //!< Enable composite NvU32 enableAlphaKeyComposite; //!< Enable Alpha key composite NVVIOCOMPOSITERANGE compRange; //!< Composite ranges NvU8 reservedData[256]; //!< Indicates last stored SDI output state TRUE-ON / FALSE-OFF NvU32 enableFullColorRange; //!< Flag indicating Full Color Range NvU32 enableRGBData; //!< Indicates data is in RGB format NVVIOANCPARITYCOMPUTATION ancParityComputation; //!< Enable HW ANC parity bit computation (auto/on/off) } NVVIOOUTPUTCONFIG_V2; //! Stream configuration typedef struct _NVVIOSTREAM { NvU32 bitsPerComponent; //!< Bits per component NVVIOCOMPONENTSAMPLING sampling; //!< Sampling NvU32 expansionEnable; //!< Enable/disable 4:2:2->4:4:4 expansion NvU32 numLinks; //!< Number of active links struct { NvU32 jack; //!< This stream's link[i] will use the specified (0-based) channel within the NvU32 channel; //!< specified (0-based) jack } links[NVAPI_MAX_VIO_LINKS_PER_STREAM]; } NVVIOSTREAM; //! Input device configuration typedef struct _NVVIOINPUTCONFIG { NvU32 numRawCaptureImages; //!< numRawCaptureImages is the number of frames to keep in the capture queue. //!< must be between NVAPI_GVI_MIN_RAW_CAPTURE_IMAGES and NVAPI_GVI_MAX_RAW_CAPTURE_IMAGES, NVVIOSIGNALFORMAT signalFormat; //!< Signal format. //!< Please note that both numRawCaptureImages and signalFormat should be set together. NvU32 numStreams; //!< Number of active streams. NVVIOSTREAM streams[NVAPI_MAX_VIO_STREAMS]; //!< Stream configurations NvU32 bTestMode; //!< This attribute controls the GVI test mode. //!< Possible values 0/1. When testmode enabled, the //!< GVI device will generate fake data as quickly as possible. } NVVIOINPUTCONFIG; typedef struct _NVVIOCONFIG_V1 { NvU32 version; //!< Structure version NvU32 fields; //!< Caller sets to NVVIOCONFIG_* mask for fields to use NVVIOCONFIGTYPE nvvioConfigType; //!< Input or Output configuration union { NVVIOINPUTCONFIG inConfig; //!< Input device configuration NVVIOOUTPUTCONFIG_V1 outConfig; //!< Output device configuration }vioConfig; } NVVIOCONFIG_V1; typedef struct _NVVIOCONFIG_V2 { NvU32 version; //!< Structure version NvU32 fields; //!< Caller sets to NVVIOCONFIG_* mask for fields to use NVVIOCONFIGTYPE nvvioConfigType; //!< Input or Output configuration union { NVVIOINPUTCONFIG inConfig; //!< Input device configuration NVVIOOUTPUTCONFIG_V2 outConfig; //!< Output device configuration }vioConfig; } NVVIOCONFIG_V2; typedef NVVIOOUTPUTCONFIG_V2 NVVIOOUTPUTCONFIG; typedef NVVIOCONFIG_V2 NVVIOCONFIG; #define NVVIOCONFIG_VER1 MAKE_NVAPI_VERSION(NVVIOCONFIG_V1,1) #define NVVIOCONFIG_VER2 MAKE_NVAPI_VERSION(NVVIOCONFIG_V2,2) #define NVVIOCONFIG_VER NVVIOCONFIG_VER2 typedef struct { NvPhysicalGpuHandle hPhysicalGpu; //!< Handle to Physical GPU (This could be NULL for GVI device if its not binded) NvVioHandle hVioHandle; //!BATT event NV_GPU_PERF_DECREASE_REASON_API_TRIGGERED = 0x00000008, //!< API triggered slowdown NV_GPU_PERF_DECREASE_REASON_INSUFFICIENT_POWER = 0x00000010, //!< Power connector missing NV_GPU_PERF_DECREASE_REASON_UNKNOWN = 0x80000000, //!< Unknown reason } NVAPI_GPU_PERF_DECREASE; /////////////////////////////////////////////////////////////////////////////// // // FUNCTION NAME: NvAPI_GPU_GetPerfDecreaseInfo // //! DESCRIPTION: This function retrieves - in NvU32 variable - reasons for the current performance decrease. //! // SUPPORTED OS: Windows XP and higher //! \param [in] hPhysicalGPU (IN) - GPU for which performance decrease is to be evaluated. //! \param [out] pPerfDecrInfo (OUT) - Pointer to a NvU32 variable containing performance decrease info //! //! \return This API can return any of the error codes enumerated in #NvStatus. //! //! \ingroup gpu /////////////////////////////////////////////////////////////////////////////// //NVAPI_INTERFACE NvAPI_GPU_GetPerfDecreaseInfo(__in NvPhysicalGpuHandle hPhysicalGpu, __inout NvU32 *pPerfDecrInfo); typedef NvStatus (__cdecl *P_NvAPI_GPU_GetPerfDecreaseInfo)(NvPhysicalGpuHandle hPhysicalGpu, NVAPI_GPU_PERF_DECREASE *pPerfDecrInfo); P_NvAPI_GPU_GetPerfDecreaseInfo NvAPI_GetPerfDecreaseInfo; #pragma pack(pop)