nvapi.h

#include"nvapi_lite_salstart.h"
#include"nvapi_lite_common.h"
#include"nvapi_lite_sli.h"
#include"nvapi_lite_surround.h"
#include"nvapi_lite_stereo.h"
#include"nvapi_lite_d3dext.h"
 /************************************************************************************************************************************\
|*                                                                                                                                    *|
|*     Copyright © 2012 NVIDIA Corporation.  All rights reserved.                                                                     *|
|*                                                                                                                                    *|
|*  NOTICE TO USER:                                                                                                                   *|
|*                                                                                                                                    *|
|*  This software is subject to NVIDIA ownership rights under U.S. and international Copyright laws.                                  *|
|*                                                                                                                                    *|
|*  This software and the information contained herein are PROPRIETARY and CONFIDENTIAL to NVIDIA                                     *|
|*  and are being provided solely under the terms and conditions of an NVIDIA software license agreement.                             *|
|*  Otherwise, you have no rights to use or access this software in any manner.                                                       *|
|*                                                                                                                                    *|
|*  If not covered by the applicable NVIDIA software license agreement:                                                               *|
|*  NVIDIA MAKES NO REPRESENTATION ABOUT THE SUITABILITY OF THIS SOFTWARE FOR ANY PURPOSE.                                            *|
|*  IT IS PROVIDED "AS IS" WITHOUT EXPRESS OR IMPLIED WARRANTY OF ANY KIND.                                                           *|
|*  NVIDIA DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,                                                                     *|
|*  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 software 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 software with only those rights set forth herein.                                       *|
|*                                                                                                                                    *|
|*  Any use of this software in individual and commercial software must include,                                                      *|
|*  in the user documentation and internal comments to the code,                                                                      *|
|*  the above Disclaimer (as applicable) and U.S. Government End Users Notice.                                                        *|
|*                                                                                                                                    *|
 \************************************************************************************************************************************/
 
 
//
// Date: Oct 20, 2023 
// 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
//
#ifndef _NVAPI_H
#define _NVAPI_H
 
#pragma pack(push,8) // Make sure we have consistent structure packings
 
#ifdef __cplusplus
extern "C" {
#endif
// ====================================================
// Universal NvAPI Definitions
// ====================================================
#ifndef _WIN32
#define __cdecl
#endif
 
 
 
 
 
#define NVAPI_API_NOT_INTIALIZED        NVAPI_API_NOT_INITIALIZED       
 
//
// FUNCTION NAME: NvAPI_Initialize
//
NVAPI_INTERFACE NvAPI_Initialize();
 
 
//
// FUNCTION NAME: NvAPI_Unload
//
NVAPI_INTERFACE NvAPI_Unload();
 
//
// FUNCTION NAME: NvAPI_GetErrorMessage
//
NVAPI_INTERFACE NvAPI_GetErrorMessage(NvAPI_Status nr,NvAPI_ShortString szDesc);
 
//
// FUNCTION NAME: NvAPI_GetInterfaceVersionString
//
NVAPI_INTERFACE NvAPI_GetInterfaceVersionString(NvAPI_ShortString szDesc);
 
//
// FUNCTION NAME: NvAPI_GetInterfaceVersionStringEx
//
NVAPI_INTERFACE NvAPI_GetInterfaceVersionStringEx(NvAPI_ShortString szDesc);
 
 
//              All display port related data types definition starts
 
// This category is intentionally added before the #ifdef. The #endif should also be in the same scope
 
#ifndef DISPLAYPORT_STRUCTS_DEFINED
#define DISPLAYPORT_STRUCTS_DEFINED
 
typedef enum _NV_DP_LINK_RATE
{
    NV_DP_1_62GBPS            = 6,
    NV_DP_2_70GBPS            = 0xA,
    NV_DP_5_40GBPS            = 0x14,
    NV_DP_8_10GBPS            = 0x1E,
// Recommended Intermidiate Link Transfer Rates
    NV_EDP_2_16GBPS           = 8,
    NV_EDP_2_43GBPS           = 9,
    NV_EDP_3_24GBPS           = 0xC,
    NV_EDP_4_32GBPS           = 0x10
} NV_DP_LINK_RATE;
 
 
typedef enum _NV_DP_LANE_COUNT
{
    NV_DP_1_LANE              = 1,
    NV_DP_2_LANE              = 2,
    NV_DP_4_LANE              = 4,
} NV_DP_LANE_COUNT;
 
 
typedef enum _NV_DP_COLOR_FORMAT
{
    NV_DP_COLOR_FORMAT_RGB     = 0,
    NV_DP_COLOR_FORMAT_YCbCr422,
    NV_DP_COLOR_FORMAT_YCbCr444,
} NV_DP_COLOR_FORMAT;
 
 
typedef enum _NV_DP_COLORIMETRY
{
    NV_DP_COLORIMETRY_RGB     = 0,
    NV_DP_COLORIMETRY_YCbCr_ITU601,
    NV_DP_COLORIMETRY_YCbCr_ITU709,
} NV_DP_COLORIMETRY;
 
 
typedef enum _NV_DP_DYNAMIC_RANGE
{
    NV_DP_DYNAMIC_RANGE_VESA  = 0,
    NV_DP_DYNAMIC_RANGE_CEA,
} NV_DP_DYNAMIC_RANGE;
 
 
typedef enum _NV_DP_BPC
{
    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;
 
 
#endif  //#ifndef DISPLAYPORT_STRUCTS_DEFINED
 
//              All display port related data types definitions end
 
//
// FUNCTION NAME: NvAPI_GPU_GetEDID
//
//
 
 
#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;
 
typedef struct
{
    NvU32   version;        
    NvU8    EDID_Data[NV_EDID_DATA_SIZE];
    NvU32   sizeofEDID;
} NV_EDID_V2;
 
typedef struct
{
    NvU32   version;        
    NvU8    EDID_Data[NV_EDID_DATA_SIZE];
    NvU32   sizeofEDID;
    NvU32   edidId;     
    NvU32   offset;    
} 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
 
 
NVAPI_INTERFACE NvAPI_GPU_GetEDID(NvPhysicalGpuHandle hPhysicalGpu, NvU32 displayOutputId, NV_EDID *pEDID);
 
 
 
#define NV_EDID_DATA_SIZE_MAX  1024   
 
typedef enum
{
    NV_EDID_FLAG_DEFAULT  = 0,   
    NV_EDID_FLAG_RAW      = 1,   
    NV_EDID_FLAG_COOKED   = 2,   
    NV_EDID_FLAG_FORCED   = 3,   
    NV_EDID_FLAG_INF      = 4,   
    NV_EDID_FLAG_HW       = 5,   
} NV_EDID_FLAG;
 
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_VIRTUAL_WFD                     = 0x00000070, 
    NVAPI_GPU_CONNECTOR_USB_C                           = 0x00000071,
    NVAPI_GPU_CONNECTOR_UNKNOWN                         = 0xFFFFFFFF,
} NV_GPU_CONNECTOR_TYPE;
 
//
// NvAPI_TVOutput Information
//
 
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_UHD_4Kp30          = 0x00080000,
    NV_DISPLAY_TV_FORMAT_UHD_4Kp30_3840     = NV_DISPLAY_TV_FORMAT_UHD_4Kp30,
    NV_DISPLAY_TV_FORMAT_UHD_4Kp25          = 0x00100000,
    NV_DISPLAY_TV_FORMAT_UHD_4Kp25_3840     = NV_DISPLAY_TV_FORMAT_UHD_4Kp25,
    NV_DISPLAY_TV_FORMAT_UHD_4Kp24          = 0x00200000,
    NV_DISPLAY_TV_FORMAT_UHD_4Kp24_3840     = NV_DISPLAY_TV_FORMAT_UHD_4Kp24,
    NV_DISPLAY_TV_FORMAT_UHD_4Kp24_SMPTE    = 0x00400000,
    NV_DISPLAY_TV_FORMAT_UHD_4Kp50_3840     = 0x00800000,
    NV_DISPLAY_TV_FORMAT_UHD_4Kp60_3840     = 0x00900000,
    NV_DISPLAY_TV_FORMAT_UHD_4Kp30_4096     = 0x00A00000,
    NV_DISPLAY_TV_FORMAT_UHD_4Kp25_4096     = 0x00B00000,
    NV_DISPLAY_TV_FORMAT_UHD_4Kp24_4096     = 0x00C00000,
    NV_DISPLAY_TV_FORMAT_UHD_4Kp50_4096     = 0x00D00000,
    NV_DISPLAY_TV_FORMAT_UHD_4Kp60_4096     = 0x00E00000,
    NV_DISPLAY_TV_FORMAT_UHD_8Kp24_7680     = 0x01000000,
    NV_DISPLAY_TV_FORMAT_UHD_8Kp25_7680     = 0x02000000,
    NV_DISPLAY_TV_FORMAT_UHD_8Kp30_7680     = 0x04000000,
    NV_DISPLAY_TV_FORMAT_UHD_8Kp48_7680     = 0x08000000,
    NV_DISPLAY_TV_FORMAT_UHD_8Kp50_7680     = 0x09000000,
    NV_DISPLAY_TV_FORMAT_UHD_8Kp60_7680     = 0x0A000000,
    NV_DISPLAY_TV_FORMAT_UHD_8Kp100_7680    = 0x0B000000,
    NV_DISPLAY_TV_FORMAT_UHD_8Kp120_7680    = 0x0C000000,
    NV_DISPLAY_TV_FORMAT_UHD_4Kp48_3840     = 0x0D000000,
    NV_DISPLAY_TV_FORMAT_UHD_4Kp48_4096     = 0x0E000000,
    NV_DISPLAY_TV_FORMAT_UHD_4Kp100_4096    = 0x0F000000,
    NV_DISPLAY_TV_FORMAT_UHD_4Kp100_3840    = 0x10000000,
    NV_DISPLAY_TV_FORMAT_UHD_4Kp120_4096    = 0x11000000,
    NV_DISPLAY_TV_FORMAT_UHD_4Kp120_3840    = 0x12000000,
    NV_DISPLAY_TV_FORMAT_UHD_4Kp100_5120    = 0x13000000,
    NV_DISPLAY_TV_FORMAT_UHD_4Kp120_5120    = 0x14000000,
    NV_DISPLAY_TV_FORMAT_UHD_4Kp24_5120     = 0x15000000,
    NV_DISPLAY_TV_FORMAT_UHD_4Kp25_5120     = 0x16000000,
    NV_DISPLAY_TV_FORMAT_UHD_4Kp30_5120     = 0x17000000,
    NV_DISPLAY_TV_FORMAT_UHD_4Kp48_5120     = 0x18000000,
    NV_DISPLAY_TV_FORMAT_UHD_4Kp50_5120     = 0x19000000,
    NV_DISPLAY_TV_FORMAT_UHD_4Kp60_5120     = 0x20000000,
    NV_DISPLAY_TV_FORMAT_UHD_10Kp24_10240   = 0x21000000,
    NV_DISPLAY_TV_FORMAT_UHD_10Kp25_10240   = 0x22000000,
    NV_DISPLAY_TV_FORMAT_UHD_10Kp30_10240   = 0x23000000,
    NV_DISPLAY_TV_FORMAT_UHD_10Kp48_10240   = 0x24000000,
    NV_DISPLAY_TV_FORMAT_UHD_10Kp50_10240   = 0x25000000,
    NV_DISPLAY_TV_FORMAT_UHD_10Kp60_10240   = 0x26000000,
    NV_DISPLAY_TV_FORMAT_UHD_10Kp100_10240   = 0x27000000,
    NV_DISPLAY_TV_FORMAT_UHD_10Kp120_10240   = 0x28000000,
 
 
    NV_DISPLAY_TV_FORMAT_SD_OTHER           = 0x30000000,
    NV_DISPLAY_TV_FORMAT_ED_OTHER           = 0x40000000,
    NV_DISPLAY_TV_FORMAT_HD_OTHER           = 0x50000000,
 
    NV_DISPLAY_TV_FORMAT_ANY                = 0x80000000,
 
} NV_DISPLAY_TV_FORMAT;
 
 
#define NVAPI_MAX_VIEW_TARGET  2
#define NVAPI_ADVANCED_MAX_VIEW_TARGET 4
 
#ifndef _NV_TARGET_VIEW_MODE_
#define _NV_TARGET_VIEW_MODE_
 
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.
 
typedef enum _NV_SCALING
{
    NV_SCALING_DEFAULT          = 0,        
 
    // New Scaling Declarations
    NV_SCALING_GPU_SCALING_TO_CLOSEST                   = 1,  
    NV_SCALING_GPU_SCALING_TO_NATIVE                    = 2,  
    NV_SCALING_GPU_SCANOUT_TO_NATIVE                    = 3,  
    NV_SCALING_GPU_SCALING_TO_ASPECT_SCANOUT_TO_NATIVE  = 5,  
    NV_SCALING_GPU_SCALING_TO_ASPECT_SCANOUT_TO_CLOSEST = 6,  
    NV_SCALING_GPU_SCANOUT_TO_CLOSEST                   = 7,  
    NV_SCALING_GPU_INTEGER_ASPECT_SCALING               = 8,  
 
    // 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       
} NV_SCALING;
 
 
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;
 
#define NVFORMAT_MAKEFOURCC(ch0, ch1, ch2, ch3)                              \
                         ((NvU32)(NvU8)(ch0) | ((NvU32)(NvU8)(ch1) << 8) |   \
                     ((NvU32)(NvU8)(ch2) << 16) | ((NvU32)(NvU8)(ch3) << 24 ))
 
 
 
typedef enum _NV_FORMAT
{
    NV_FORMAT_UNKNOWN           =  0,       
    NV_FORMAT_P8                = 41,       
    NV_FORMAT_R5G6B5            = 23,       
    NV_FORMAT_A8R8G8B8          = 21,       
    NV_FORMAT_A16B16G16R16F     = 113,      
 
} NV_FORMAT;
 
// TV standard
 
typedef struct
{
    float x;    
    float y;    
    float w;    
    float h;    
} NV_VIEWPORTF;
 
 
 
 
 
typedef enum _NV_TIMING_OVERRIDE
{
    NV_TIMING_OVERRIDE_CURRENT = 0,          
    NV_TIMING_OVERRIDE_AUTO,                 
    NV_TIMING_OVERRIDE_EDID,                 
    NV_TIMING_OVERRIDE_DMT,                  
    NV_TIMING_OVERRIDE_DMT_RB,               
    NV_TIMING_OVERRIDE_CVT,                  
    NV_TIMING_OVERRIDE_CVT_RB,               
    NV_TIMING_OVERRIDE_GTF,                  
    NV_TIMING_OVERRIDE_EIA861,               
    NV_TIMING_OVERRIDE_ANALOG_TV,            
    NV_TIMING_OVERRIDE_CUST,                 
    NV_TIMING_OVERRIDE_NV_PREDEFINED,        
    NV_TIMING_OVERRIDE_NV_PSF                = NV_TIMING_OVERRIDE_NV_PREDEFINED,
    NV_TIMING_OVERRIDE_NV_ASPR,
    NV_TIMING_OVERRIDE_SDI,                  
 
    NV_TIMING_OVRRIDE_MAX,
}NV_TIMING_OVERRIDE;
 
 
#ifndef NV_TIMING_STRUCTS_DEFINED
#define NV_TIMING_STRUCTS_DEFINED
 
//***********************
// The Timing Structure
//***********************
//
typedef struct tagNV_TIMINGEXT
{
    NvU32   flag;          
    NvU16   rr;            
    NvU32   rrx1k;         
    NvU32   aspect;        
    NvU16   rep;           
    NvU32   status;        
    NvU8    name[40];      
}NV_TIMINGEXT;
 
 
 
typedef struct _NV_TIMING
{
    // VESA scan out timing parameters:
    NvU16 HVisible;         
    NvU16 HBorder;          
    NvU16 HFrontPorch;      
    NvU16 HSyncWidth;       
    NvU16 HTotal;           
    NvU8  HSyncPol;         
 
    NvU16 VVisible;         
    NvU16 VBorder;          
    NvU16 VFrontPorch;      
    NvU16 VSyncWidth;       
    NvU16 VTotal;           
    NvU8  VSyncPol;         
 
    NvU16 interlaced;       
    NvU32 pclk;             
 
    //other timing related extras
    NV_TIMINGEXT etc;
}NV_TIMING;
#endif //NV_TIMING_STRUCTS_DEFINED
 
 
#define NV_TIMING_H_SYNC_POSITIVE                             0
#define NV_TIMING_H_SYNC_NEGATIVE                             1
#define NV_TIMING_H_SYNC_DEFAULT                              NV_TIMING_H_SYNC_NEGATIVE
//
#define NV_TIMING_V_SYNC_POSITIVE                             0
#define NV_TIMING_V_SYNC_NEGATIVE                             1
#define NV_TIMING_V_SYNC_DEFAULT                              NV_TIMING_V_SYNC_POSITIVE
//
#define NV_TIMING_PROGRESSIVE                                 0
#define NV_TIMING_INTERLACED                                  1
#define NV_TIMING_INTERLACED_EXTRA_VBLANK_ON_FIELD2           1
#define NV_TIMING_INTERLACED_NO_EXTRA_VBLANK_ON_FIELD2        2
 
//
// FUNCTION NAME:   NvAPI_SetView
//
//
 
typedef struct
{
    NvU32 version;     
    NvU32 count;       
    struct
    {
        NvU32 deviceMask;    
        NvU32 sourceId;      
        NvU32 bPrimary:1;    
        NvU32 bInterlaced:1; 
        NvU32 bGDIPrimary:1; 
        NvU32 bForceModeSet:1;
    } target[NVAPI_MAX_VIEW_TARGET];
} NV_VIEW_TARGET_INFO;
 
#define NV_VIEW_TARGET_INFO_VER  MAKE_NVAPI_VERSION(NV_VIEW_TARGET_INFO,2)
 
__nvapi_deprecated_function("Do not use this function - it is deprecated in release 290. Instead, use NvAPI_DISP_SetDisplayConfig.")
NVAPI_INTERFACE NvAPI_SetView(NvDisplayHandle hNvDisplay, NV_VIEW_TARGET_INFO *pTargetInfo, NV_TARGET_VIEW_MODE targetView);
 
 
//
// FUNCTION NAME:   NvAPI_SetViewEx
//
//
 
#define NVAPI_MAX_DISPLAY_PATH  NVAPI_MAX_VIEW_TARGET
 
#define NVAPI_ADVANCED_MAX_DISPLAY_PATH  NVAPI_ADVANCED_MAX_VIEW_TARGET
 
 
 
typedef struct
{
    NvU32                   deviceMask;     
    NvU32                   sourceId;       
    NvU32                   bPrimary:1;     
    NV_GPU_CONNECTOR_TYPE   connector;      
 
    // source mode information
    NvU32                   width;          
    NvU32                   height;         
    NvU32                   depth;          
    NV_FORMAT               colorFormat;    
 
    //rotation setting of the mode
    NV_ROTATE               rotation;       
 
    // the scaling mode
    NV_SCALING              scaling;        
 
    // Timing info
    NvU32                   refreshRate;    
    NvU32                   interlaced:1;   
 
    NV_DISPLAY_TV_FORMAT    tvFormat;       
 
    // Windows desktop position
    NvU32                   posx;           
    NvU32                   posy;           
    NvU32                   bGDIPrimary:1;  
 
    NvU32                   bForceModeSet:1;
    NvU32                   bFocusDisplay:1;
    NvU32                   gpuId:24;       
 
} NV_DISPLAY_PATH;
 
typedef struct
{
    NvU32 version;     
    NvU32 count;       
    NV_DISPLAY_PATH path[NVAPI_MAX_DISPLAY_PATH];
} NV_DISPLAY_PATH_INFO_V3;
 
typedef struct
{
    NvU32 version;     
    NvU32 count;       
    NV_DISPLAY_PATH path[NVAPI_ADVANCED_MAX_DISPLAY_PATH];
} NV_DISPLAY_PATH_INFO;
 
#define NV_DISPLAY_PATH_INFO_VER  NV_DISPLAY_PATH_INFO_VER4
#define NV_DISPLAY_PATH_INFO_VER4 MAKE_NVAPI_VERSION(NV_DISPLAY_PATH_INFO,4)
#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)
//
// FUNCTION NAME:   NvAPI_SetViewEx
//
//
 
__nvapi_deprecated_function("Do not use this function - it is deprecated in release 290. Instead, use NvAPI_DISP_SetDisplayConfig.")
NVAPI_INTERFACE NvAPI_SetViewEx(NvDisplayHandle hNvDisplay, NV_DISPLAY_PATH_INFO *pPathInfo, NV_TARGET_VIEW_MODE displayView);
 
 
 
// SetDisplayConfig/GetDisplayConfig
 
typedef struct _NV_POSITION
{
    NvS32   x;
    NvS32   y;
} NV_POSITION;
 
typedef struct _NV_RESOLUTION
{
    NvU32   width;
    NvU32   height;
    NvU32   colorDepth;
} NV_RESOLUTION;
 
typedef struct _NV_DISPLAYCONFIG_PATH_ADVANCED_TARGET_INFO_V1
{
    NvU32                   version;
 
    // Rotation and Scaling
    NV_ROTATE               rotation;       
    NV_SCALING              scaling;        
 
    // Refresh Rate
    NvU32                   refreshRate1K;  
    // Flags
    NvU32                   interlaced:1;   
    NvU32                   primary:1;      
#ifdef NV_PAN_AND_SCAN_DEFINED
    NvU32                   isPanAndScanTarget:1; 
#else
    NvU32                   reservedBit1:1;
#endif
    NvU32                   disableVirtualModeSupport:1;
    NvU32                   isPreferredUnscaledTarget:1;
    NvU32                   reserved:27;
    // TV format information
    NV_GPU_CONNECTOR_TYPE   connector;      
    NV_DISPLAY_TV_FORMAT    tvFormat;       
 
    // Backend (raster) timing standard
    NV_TIMING_OVERRIDE      timingOverride;     
    NV_TIMING               timing;             
} NV_DISPLAYCONFIG_PATH_ADVANCED_TARGET_INFO_V1;
 
typedef NV_DISPLAYCONFIG_PATH_ADVANCED_TARGET_INFO_V1 NV_DISPLAYCONFIG_PATH_ADVANCED_TARGET_INFO;
 
#define NV_DISPLAYCONFIG_PATH_ADVANCED_TARGET_INFO_VER1     MAKE_NVAPI_VERSION(NV_DISPLAYCONFIG_PATH_ADVANCED_TARGET_INFO_V1,1)
 
#define NV_DISPLAYCONFIG_PATH_ADVANCED_TARGET_INFO_VER      NV_DISPLAYCONFIG_PATH_ADVANCED_TARGET_INFO_VER1
 
typedef struct _NV_DISPLAYCONFIG_PATH_TARGET_INFO_V1
{
    NvU32                                           displayId;  
    NV_DISPLAYCONFIG_PATH_ADVANCED_TARGET_INFO*     details;    
} NV_DISPLAYCONFIG_PATH_TARGET_INFO_V1;
 
typedef struct _NV_DISPLAYCONFIG_PATH_TARGET_INFO_V2
{
    NvU32                                           displayId;  
    NV_DISPLAYCONFIG_PATH_ADVANCED_TARGET_INFO*     details;    
    NvU32                                           targetId;   
} NV_DISPLAYCONFIG_PATH_TARGET_INFO_V2;
 
 
typedef NV_DISPLAYCONFIG_PATH_TARGET_INFO_V2 NV_DISPLAYCONFIG_PATH_TARGET_INFO;
 
 
typedef enum _NV_DISPLAYCONFIG_SPANNING_ORIENTATION
{
    NV_DISPLAYCONFIG_SPAN_NONE          = 0,
    NV_DISPLAYCONFIG_SPAN_HORIZONTAL    = 1,
    NV_DISPLAYCONFIG_SPAN_VERTICAL      = 2,
} NV_DISPLAYCONFIG_SPANNING_ORIENTATION;
 
typedef struct _NV_DISPLAYCONFIG_SOURCE_MODE_INFO_V1
{
    NV_RESOLUTION                           resolution;
    NV_FORMAT                               colorFormat;                
    NV_POSITION                             position;                   
    NV_DISPLAYCONFIG_SPANNING_ORIENTATION   spanningOrientation;        
    NvU32                                   bGDIPrimary : 1;
    NvU32                                   bSLIFocus : 1;
    NvU32                                   reserved : 30;              
} NV_DISPLAYCONFIG_SOURCE_MODE_INFO_V1;
 
 
 
typedef struct _NV_DISPLAYCONFIG_PATH_INFO_V1
{
    NvU32                                   version;
    NvU32                                   reserved_sourceId;      
    NvU32                                   targetInfoCount;            
    NV_DISPLAYCONFIG_PATH_TARGET_INFO_V1*   targetInfo;
    NV_DISPLAYCONFIG_SOURCE_MODE_INFO_V1*   sourceModeInfo;             
} NV_DISPLAYCONFIG_PATH_INFO_V1;
 
#define _NV_DISPLAYCONFIG_PATH_INFO_V2 _NV_DISPLAYCONFIG_PATH_INFO
 
typedef struct _NV_DISPLAYCONFIG_PATH_INFO_V2
{
    NvU32                                   version;
    union {
        NvU32                                   sourceId;               
        NvU32                                   reserved_sourceId;      
    };
 
    NvU32                                   targetInfoCount;            
    NV_DISPLAYCONFIG_PATH_TARGET_INFO_V2*   targetInfo;
    NV_DISPLAYCONFIG_SOURCE_MODE_INFO_V1*   sourceModeInfo;             
    NvU32                                   IsNonNVIDIAAdapter : 1;     
    NvU32                                   reserved : 31;              
    void                                    *pOSAdapterID;              
} NV_DISPLAYCONFIG_PATH_INFO_V2;
 
#define NV_DISPLAYCONFIG_PATH_INFO_VER1                 MAKE_NVAPI_VERSION(NV_DISPLAYCONFIG_PATH_INFO_V1,1)
 
#define NV_DISPLAYCONFIG_PATH_INFO_VER2                 MAKE_NVAPI_VERSION(NV_DISPLAYCONFIG_PATH_INFO_V2,2)
 
#ifndef NV_DISPLAYCONFIG_PATH_INFO_VER
 
typedef NV_DISPLAYCONFIG_PATH_INFO_V2 NV_DISPLAYCONFIG_PATH_INFO;
 
#define NV_DISPLAYCONFIG_PATH_INFO_VER                  NV_DISPLAYCONFIG_PATH_INFO_VER2
 
typedef NV_DISPLAYCONFIG_SOURCE_MODE_INFO_V1 NV_DISPLAYCONFIG_SOURCE_MODE_INFO;
 
#endif
 
 
typedef enum _NV_DISPLAYCONFIG_FLAGS
{
    NV_DISPLAYCONFIG_VALIDATE_ONLY          = 0x00000001,
    NV_DISPLAYCONFIG_SAVE_TO_PERSISTENCE    = 0x00000002,
    NV_DISPLAYCONFIG_DRIVER_RELOAD_ALLOWED  = 0x00000004,               
    NV_DISPLAYCONFIG_FORCE_MODE_ENUMERATION = 0x00000008,               
    NV_FORCE_COMMIT_VIDPN                   = 0x00000010,               
} NV_DISPLAYCONFIG_FLAGS;
 
 
#define NVAPI_UNICODE_STRING_MAX                             2048
#define NVAPI_BINARY_DATA_MAX                                4096
 
typedef NvU16 NvAPI_UnicodeString[NVAPI_UNICODE_STRING_MAX];
typedef const NvU16 *NvAPI_LPCWSTR;
 
// Common
 
 
 
#define NVAPI_MAX_GPU_CLOCKS            32
#define NVAPI_MAX_GPU_PUBLIC_CLOCKS     32
#define NVAPI_MAX_GPU_PERF_CLOCKS       32
#define NVAPI_MAX_GPU_PERF_VOLTAGES     16
#define NVAPI_MAX_GPU_PERF_PSTATES      16
 
typedef enum _NV_GPU_PERF_VOLTAGE_INFO_DOMAIN_ID
{
    NVAPI_GPU_PERF_VOLTAGE_INFO_DOMAIN_CORE      = 0,
    NVAPI_GPU_PERF_VOLTAGE_INFO_DOMAIN_UNDEFINED = NVAPI_MAX_GPU_PERF_VOLTAGES,
} NV_GPU_PERF_VOLTAGE_INFO_DOMAIN_ID;
 
typedef enum _NV_GPU_PUBLIC_CLOCK_ID
{
    NVAPI_GPU_PUBLIC_CLOCK_GRAPHICS  = 0,
    NVAPI_GPU_PUBLIC_CLOCK_MEMORY    = 4,
    NVAPI_GPU_PUBLIC_CLOCK_PROCESSOR = 7,
    NVAPI_GPU_PUBLIC_CLOCK_VIDEO     = 8,
    NVAPI_GPU_PUBLIC_CLOCK_UNDEFINED = NVAPI_MAX_GPU_PUBLIC_CLOCKS,
} NV_GPU_PUBLIC_CLOCK_ID;
 
 
 
typedef enum _NV_GPU_PERF_PSTATE_ID
{
    NVAPI_GPU_PERF_PSTATE_P0 = 0,
    NVAPI_GPU_PERF_PSTATE_P1,
    NVAPI_GPU_PERF_PSTATE_P2,
    NVAPI_GPU_PERF_PSTATE_P3,
    NVAPI_GPU_PERF_PSTATE_P4,
    NVAPI_GPU_PERF_PSTATE_P5,
    NVAPI_GPU_PERF_PSTATE_P6,
    NVAPI_GPU_PERF_PSTATE_P7,
    NVAPI_GPU_PERF_PSTATE_P8,
    NVAPI_GPU_PERF_PSTATE_P9,
    NVAPI_GPU_PERF_PSTATE_P10,
    NVAPI_GPU_PERF_PSTATE_P11,
    NVAPI_GPU_PERF_PSTATE_P12,
    NVAPI_GPU_PERF_PSTATE_P13,
    NVAPI_GPU_PERF_PSTATE_P14,
    NVAPI_GPU_PERF_PSTATE_P15,
    NVAPI_GPU_PERF_PSTATE_UNDEFINED = NVAPI_MAX_GPU_PERF_PSTATES,
    NVAPI_GPU_PERF_PSTATE_ALL,
 
} NV_GPU_PERF_PSTATE_ID;
 
 
 
 
 
#define NVAPI_MAX_GPU_PSTATE20_PSTATES          16
#define NVAPI_MAX_GPU_PSTATE20_CLOCKS           8
#define NVAPI_MAX_GPU_PSTATE20_BASE_VOLTAGES    4
 
typedef enum
{
    NVAPI_GPU_PERF_PSTATE20_CLOCK_TYPE_SINGLE = 0,
 
    NVAPI_GPU_PERF_PSTATE20_CLOCK_TYPE_RANGE,
} NV_GPU_PERF_PSTATE20_CLOCK_TYPE_ID;
 
typedef struct
{
    NvS32       value;
 
    struct
    {
        NvS32   min;
 
        NvS32   max;
    } valueRange;
} NV_GPU_PERF_PSTATES20_PARAM_DELTA;
 
typedef struct
{
    NV_GPU_PUBLIC_CLOCK_ID                      domainId;
 
    NV_GPU_PERF_PSTATE20_CLOCK_TYPE_ID          typeId;
    NvU32                                       bIsEditable:1;
 
    NvU32                                       reserved:31;
 
    NV_GPU_PERF_PSTATES20_PARAM_DELTA           freqDelta_kHz;
 
    union
    {
        struct
        {
            NvU32                               freq_kHz;
        } single;
 
        struct
        {
            NvU32                               minFreq_kHz;
 
            NvU32                               maxFreq_kHz;
 
            NV_GPU_PERF_VOLTAGE_INFO_DOMAIN_ID  domainId;
            NvU32                               minVoltage_uV;
            NvU32                               maxVoltage_uV;
        } range;
    } data;
} NV_GPU_PSTATE20_CLOCK_ENTRY_V1;
 
typedef struct
{
    NV_GPU_PERF_VOLTAGE_INFO_DOMAIN_ID  domainId;
    NvU32                               bIsEditable:1;
 
    NvU32                               reserved:31;
 
    NvU32                               volt_uV;
 
    NV_GPU_PERF_PSTATES20_PARAM_DELTA   voltDelta_uV; // Current base voltage delta from nominal settings in [uV]
} NV_GPU_PSTATE20_BASE_VOLTAGE_ENTRY_V1;
 
 
typedef struct
{
    NvU32   version;
 
    NvU32   bIsEditable:1;
 
    NvU32   reserved:31;
 
    NvU32   numPstates;
 
    NvU32   numClocks;
 
    NvU32   numBaseVoltages;
 
    struct
    {
        NV_GPU_PERF_PSTATE_ID                   pstateId;
 
        NvU32                                   bIsEditable:1;
 
        NvU32                                   reserved:31;
 
        NV_GPU_PSTATE20_CLOCK_ENTRY_V1          clocks[NVAPI_MAX_GPU_PSTATE20_CLOCKS];
 
        NV_GPU_PSTATE20_BASE_VOLTAGE_ENTRY_V1   baseVoltages[NVAPI_MAX_GPU_PSTATE20_BASE_VOLTAGES];
    } pstates[NVAPI_MAX_GPU_PSTATE20_PSTATES];
} NV_GPU_PERF_PSTATES20_INFO_V1;
 
 
typedef struct _NV_GPU_PERF_PSTATES20_INFO_V2
{
    NvU32   version;
 
    NvU32   bIsEditable:1;
 
    NvU32   reserved:31;
 
    NvU32   numPstates;
 
    NvU32   numClocks;
 
    NvU32   numBaseVoltages;
 
    struct
    {
        NV_GPU_PERF_PSTATE_ID                   pstateId;
 
        NvU32                                   bIsEditable:1;
 
        NvU32                                   reserved:31;
 
        NV_GPU_PSTATE20_CLOCK_ENTRY_V1          clocks[NVAPI_MAX_GPU_PSTATE20_CLOCKS];
 
        NV_GPU_PSTATE20_BASE_VOLTAGE_ENTRY_V1   baseVoltages[NVAPI_MAX_GPU_PSTATE20_BASE_VOLTAGES];
    } pstates[NVAPI_MAX_GPU_PSTATE20_PSTATES];
 
    struct
    {
        NvU32                                 numVoltages;
 
        NV_GPU_PSTATE20_BASE_VOLTAGE_ENTRY_V1 voltages[NVAPI_MAX_GPU_PSTATE20_BASE_VOLTAGES];
    } ov;
} NV_GPU_PERF_PSTATES20_INFO_V2;
 
typedef NV_GPU_PERF_PSTATES20_INFO_V2   NV_GPU_PERF_PSTATES20_INFO;
 
#define NV_GPU_PERF_PSTATES20_INFO_VER1 MAKE_NVAPI_VERSION(NV_GPU_PERF_PSTATES20_INFO_V1,1)
 
#define NV_GPU_PERF_PSTATES20_INFO_VER2 MAKE_NVAPI_VERSION(NV_GPU_PERF_PSTATES20_INFO_V2,2)
 
#define NV_GPU_PERF_PSTATES20_INFO_VER3 MAKE_NVAPI_VERSION(NV_GPU_PERF_PSTATES20_INFO_V2,3)
 
#define NV_GPU_PERF_PSTATES20_INFO_VER  NV_GPU_PERF_PSTATES20_INFO_VER3
 
 
//
// FUNCTION NAME: 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)
 
 
__nvapi_deprecated_function("Do not use this function - it is deprecated in release 290. Instead, use NvAPI_SYS_GetDriverAndBranchVersion.")
NVAPI_INTERFACE NvAPI_GetDisplayDriverVersion(NvDisplayHandle hNvDisplay, NV_DISPLAY_DRIVER_VERSION *pVersion);
 
 
 
 
//
// FUNCTION NAME: NvAPI_OGL_ExpertModeSet[Get]
//
 
 
//
 
#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
//
typedef void (* NVAPI_OGLEXPERT_CALLBACK) (unsigned int categoryId, unsigned int messageId, unsigned int detailLevel, int objectId, const char *messageStr);
 
 
 
NVAPI_INTERFACE NvAPI_OGL_ExpertModeSet(NvU32 expertDetailLevel,
                                        NvU32 expertReportMask,
                                        NvU32 expertOutputMask,
                     NVAPI_OGLEXPERT_CALLBACK expertCallback);
 
NVAPI_INTERFACE NvAPI_OGL_ExpertModeGet(NvU32 *pExpertDetailLevel,
                                        NvU32 *pExpertReportMask,
                                        NvU32 *pExpertOutputMask,
                     NVAPI_OGLEXPERT_CALLBACK *pExpertCallback);
 
 
//
 
 
//
 
NVAPI_INTERFACE NvAPI_OGL_ExpertModeDefaultsSet(NvU32 expertDetailLevel,
                                                NvU32 expertReportMask,
                                                NvU32 expertOutputMask);
 
NVAPI_INTERFACE NvAPI_OGL_ExpertModeDefaultsGet(NvU32 *pExpertDetailLevel,
                                                NvU32 *pExpertReportMask,
                                                NvU32 *pExpertOutputMask);
 
 
 
 
//
// FUNCTION NAME: NvAPI_EnumTCCPhysicalGPUs
//
NVAPI_INTERFACE NvAPI_EnumTCCPhysicalGPUs( NvPhysicalGpuHandle nvGPUHandle[NVAPI_MAX_PHYSICAL_GPUS], NvU32 *pGpuCount);
 
//
// FUNCTION NAME: NvAPI_EnumLogicalGPUs
//
NVAPI_INTERFACE NvAPI_EnumLogicalGPUs(NvLogicalGpuHandle nvGPUHandle[NVAPI_MAX_LOGICAL_GPUS], NvU32 *pGpuCount);
 
//
// FUNCTION NAME: NvAPI_GetPhysicalGPUsFromDisplay
//
NVAPI_INTERFACE NvAPI_GetPhysicalGPUsFromDisplay(NvDisplayHandle hNvDisp, NvPhysicalGpuHandle nvGPUHandle[NVAPI_MAX_PHYSICAL_GPUS], NvU32 *pGpuCount);
 
 
//
// FUNCTION NAME: NvAPI_GetPhysicalGPUFromUnAttachedDisplay
//
NVAPI_INTERFACE NvAPI_GetPhysicalGPUFromUnAttachedDisplay(NvUnAttachedDisplayHandle hNvUnAttachedDisp, NvPhysicalGpuHandle *pPhysicalGpu);
 
 
 
//
// FUNCTION NAME: NvAPI_GetLogicalGPUFromDisplay
//
NVAPI_INTERFACE NvAPI_GetLogicalGPUFromDisplay(NvDisplayHandle hNvDisp, NvLogicalGpuHandle *pLogicalGPU);
 
 
//
// FUNCTION NAME: NvAPI_GetLogicalGPUFromPhysicalGPU
//
NVAPI_INTERFACE NvAPI_GetLogicalGPUFromPhysicalGPU(NvPhysicalGpuHandle hPhysicalGPU, NvLogicalGpuHandle *pLogicalGPU);
 
//
// FUNCTION NAME: NvAPI_GetPhysicalGPUsFromLogicalGPU
//
NVAPI_INTERFACE NvAPI_GetPhysicalGPUsFromLogicalGPU(NvLogicalGpuHandle hLogicalGPU,NvPhysicalGpuHandle hPhysicalGPU[NVAPI_MAX_PHYSICAL_GPUS], NvU32 *pGpuCount);
 
//
// FUNCTION NAME: NvAPI_GetPhysicalGPUFromGPUID
//
NVAPI_INTERFACE NvAPI_GetPhysicalGPUFromGPUID(NvU32 gpuId, NvPhysicalGpuHandle *pPhysicalGPU);
 
//
// FUNCTION NAME: NvAPI_GetGPUIDfromPhysicalGPU
//
//
NVAPI_INTERFACE NvAPI_GetGPUIDfromPhysicalGPU(NvPhysicalGpuHandle hPhysicalGpu, NvU32 *pGpuId);
 
//
// FUNCTION NAME: NvAPI_GPU_GetShaderSubPipeCount
//
NVAPI_INTERFACE NvAPI_GPU_GetShaderSubPipeCount(NvPhysicalGpuHandle hPhysicalGpu,NvU32 *pCount);
 
 
//
// FUNCTION NAME: NvAPI_GPU_GetGpuCoreCount
//
NVAPI_INTERFACE NvAPI_GPU_GetGpuCoreCount(NvPhysicalGpuHandle hPhysicalGpu,NvU32 *pCount);
 
 
//
// FUNCTION NAME: NvAPI_GPU_GetAllOutputs
//
__nvapi_deprecated_function("Do not use this function - it is deprecated in release 290. Instead, use NvAPI_GPU_GetAllDisplayIds.")
NVAPI_INTERFACE NvAPI_GPU_GetAllOutputs(NvPhysicalGpuHandle hPhysicalGpu,NvU32 *pOutputsMask);
 
 
 
//
// FUNCTION NAME: NvAPI_GPU_GetConnectedOutputs
//
__nvapi_deprecated_function("Do not use this function - it is deprecated in release 290. Instead, use NvAPI_GPU_GetConnectedDisplayIds.")
NVAPI_INTERFACE NvAPI_GPU_GetConnectedOutputs(NvPhysicalGpuHandle hPhysicalGpu, NvU32 *pOutputsMask);
 
 
//
// FUNCTION NAME: NvAPI_GPU_GetConnectedSLIOutputs
//
__nvapi_deprecated_function("Do not use this function - it is deprecated in release 290. Instead, use NvAPI_GPU_GetConnectedDisplayIds.")
NVAPI_INTERFACE NvAPI_GPU_GetConnectedSLIOutputs(NvPhysicalGpuHandle hPhysicalGpu, NvU32 *pOutputsMask);
 
 
 
 
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;
 
 
#define NV_GPU_CONNECTED_IDS_FLAG_UNCACHED          NV_BIT(0) 
#define NV_GPU_CONNECTED_IDS_FLAG_SLI               NV_BIT(1) 
#define NV_GPU_CONNECTED_IDS_FLAG_LIDSTATE          NV_BIT(2) 
#define NV_GPU_CONNECTED_IDS_FLAG_FAKE              NV_BIT(3) 
#define NV_GPU_CONNECTED_IDS_FLAG_EXCLUDE_MST       NV_BIT(4) 
 
 
typedef struct _NV_GPU_DISPLAYIDS
{
    NvU32    version;
    NV_MONITOR_CONN_TYPE connectorType;     
    NvU32    displayId;                     
 
    NvU32    isDynamic              : 1;    
    NvU32    isMultiStreamRootNode  : 1;    
    NvU32    isActive               : 1;    
    NvU32    isCluster              : 1;    
    NvU32    isOSVisible            : 1;    
    NvU32    isWFD                  : 1;    
    NvU32    isConnected            : 1;    
 
    NvU32    reservedInternal       : 10;    
    NvU32    isPhysicallyConnected  : 1;    
    NvU32    reserved               : 14;   
} NV_GPU_DISPLAYIDS;
 
#define NV_GPU_DISPLAYIDS_VER1          MAKE_NVAPI_VERSION(NV_GPU_DISPLAYIDS,1)
#define NV_GPU_DISPLAYIDS_VER2          MAKE_NVAPI_VERSION(NV_GPU_DISPLAYIDS,3)
 
#define NV_GPU_DISPLAYIDS_VER NV_GPU_DISPLAYIDS_VER2
 
//
// FUNCTION NAME: NvAPI_GPU_GetConnectedDisplayIds
//
NVAPI_INTERFACE NvAPI_GPU_GetConnectedDisplayIds(__in NvPhysicalGpuHandle hPhysicalGpu,  __inout_ecount_part_opt(*pDisplayIdCount, *pDisplayIdCount) NV_GPU_DISPLAYIDS* pDisplayIds, __inout NvU32* pDisplayIdCount, __in NvU32 flags);
 
 
//
// FUNCTION NAME: NvAPI_GPU_GetAllDisplayIds
//
NVAPI_INTERFACE NvAPI_GPU_GetAllDisplayIds(__in NvPhysicalGpuHandle hPhysicalGpu, __inout_ecount_part_opt(*pDisplayIdCount, *pDisplayIdCount) NV_GPU_DISPLAYIDS* pDisplayIds, __inout NvU32* pDisplayIdCount);
 
 
 
 
//
// FUNCTION NAME: NvAPI_GPU_GetConnectedOutputsWithLidState
//
__nvapi_deprecated_function("Do not use this function - it is deprecated in release 290. Instead, use NvAPI_GPU_GetConnectedDisplayIds.")
NVAPI_INTERFACE NvAPI_GPU_GetConnectedOutputsWithLidState(NvPhysicalGpuHandle hPhysicalGpu, NvU32 *pOutputsMask);
 
 
//
// FUNCTION NAME: NvAPI_GPU_GetConnectedSLIOutputsWithLidState
//
__nvapi_deprecated_function("Do not use this function - it is deprecated in release 290. Instead, use NvAPI_GPU_GetConnectedDisplayIds.")
NVAPI_INTERFACE NvAPI_GPU_GetConnectedSLIOutputsWithLidState(NvPhysicalGpuHandle hPhysicalGpu, NvU32 *pOutputsMask);
 
 
//
// FUNCTION NAME: NvAPI_GPU_GetSystemType
//
//
 
typedef enum
{
    NV_SYSTEM_TYPE_UNKNOWN = 0,
    NV_SYSTEM_TYPE_LAPTOP  = 1,
    NV_SYSTEM_TYPE_DESKTOP = 2,
 
} NV_SYSTEM_TYPE;
 
 
 
NVAPI_INTERFACE NvAPI_GPU_GetSystemType(NvPhysicalGpuHandle hPhysicalGpu, NV_SYSTEM_TYPE *pSystemType);
 
 
//
// FUNCTION NAME: NvAPI_GPU_GetActiveOutputs
//
NVAPI_INTERFACE NvAPI_GPU_GetActiveOutputs(NvPhysicalGpuHandle hPhysicalGpu, NvU32 *pOutputsMask);
 
//
// FUNCTION NAME: NvAPI_GPU_SetEDID
//
NVAPI_INTERFACE NvAPI_GPU_SetEDID(NvPhysicalGpuHandle hPhysicalGpu, NvU32 displayOutputId, NV_EDID *pEDID);
 
 
//
// FUNCTION NAME: NvAPI_GPU_GetOutputType
//
//
 
typedef enum _NV_GPU_OUTPUT_TYPE
{
    NVAPI_GPU_OUTPUT_UNKNOWN  = 0,
    NVAPI_GPU_OUTPUT_CRT      = 1,     
    NVAPI_GPU_OUTPUT_DFP      = 2,     
    NVAPI_GPU_OUTPUT_TV       = 3,     
} NV_GPU_OUTPUT_TYPE;
 
 
 
 
NVAPI_INTERFACE NvAPI_GPU_GetOutputType(NvPhysicalGpuHandle hPhysicalGpu, NvU32 outputId, NV_GPU_OUTPUT_TYPE *pOutputType);
 
 
//
// FUNCTION NAME: NvAPI_GPU_ValidateOutputCombination
//
NVAPI_INTERFACE NvAPI_GPU_ValidateOutputCombination(NvPhysicalGpuHandle hPhysicalGpu, NvU32 outputsMask);
 
 
 
 
//
// FUNCTION NAME: NvAPI_GPU_GetFullName
//
NVAPI_INTERFACE NvAPI_GPU_GetFullName(NvPhysicalGpuHandle hPhysicalGpu, NvAPI_ShortString szName);
 
//
// FUNCTION NAME: NvAPI_GPU_GetPCIIdentifiers
//
NVAPI_INTERFACE NvAPI_GPU_GetPCIIdentifiers(NvPhysicalGpuHandle hPhysicalGpu,NvU32 *pDeviceId,NvU32 *pSubSystemId,NvU32 *pRevisionId,NvU32 *pExtDeviceId);
 
 
 
 
typedef enum _NV_GPU_TYPE
{
    NV_SYSTEM_TYPE_GPU_UNKNOWN     = 0,
    NV_SYSTEM_TYPE_IGPU            = 1, 
    NV_SYSTEM_TYPE_DGPU            = 2, 
} NV_GPU_TYPE;
 
 
//
// FUNCTION NAME: NvAPI_GPU_GetGPUType
//
NVAPI_INTERFACE NvAPI_GPU_GetGPUType(__in NvPhysicalGpuHandle hPhysicalGpu, __inout NV_GPU_TYPE *pGpuType);
 
 
 
 
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,
    NVAPI_GPU_BUS_TYPE_AXI          = 5,
} NV_GPU_BUS_TYPE;
//
// FUNCTION NAME: NvAPI_GPU_GetBusType
//
NVAPI_INTERFACE NvAPI_GPU_GetBusType(NvPhysicalGpuHandle hPhysicalGpu,NV_GPU_BUS_TYPE *pBusType);
 
 
//
// FUNCTION NAME: NvAPI_GPU_GetBusId
//
NVAPI_INTERFACE NvAPI_GPU_GetBusId(NvPhysicalGpuHandle hPhysicalGpu, NvU32 *pBusId);
 
//
// FUNCTION NAME: NvAPI_GPU_GetBusSlotId
//
NVAPI_INTERFACE NvAPI_GPU_GetBusSlotId(NvPhysicalGpuHandle hPhysicalGpu, NvU32 *pBusSlotId);
 
 
 
//
// FUNCTION NAME: NvAPI_GPU_GetIRQ
//
NVAPI_INTERFACE NvAPI_GPU_GetIRQ(NvPhysicalGpuHandle hPhysicalGpu,NvU32 *pIRQ);
 
//
// FUNCTION NAME: NvAPI_GPU_GetVbiosRevision
//
NVAPI_INTERFACE NvAPI_GPU_GetVbiosRevision(NvPhysicalGpuHandle hPhysicalGpu,NvU32 *pBiosRevision);
 
//
// FUNCTION NAME: NvAPI_GPU_GetVbiosOEMRevision
//
NVAPI_INTERFACE NvAPI_GPU_GetVbiosOEMRevision(NvPhysicalGpuHandle hPhysicalGpu,NvU32 *pBiosRevision);
 
//
// FUNCTION NAME: NvAPI_GPU_GetVbiosVersionString
//
NVAPI_INTERFACE NvAPI_GPU_GetVbiosVersionString(NvPhysicalGpuHandle hPhysicalGpu,NvAPI_ShortString szBiosRevision);
 
 
//
// FUNCTION NAME: NvAPI_GPU_GetAGPAperture
//
__nvapi_deprecated_function("Do not use this function - it is deprecated in release 455.")
NVAPI_INTERFACE NvAPI_GPU_GetAGPAperture(NvPhysicalGpuHandle hPhysicalGpu,NvU32 *pSize);
 
//
// FUNCTION NAME: NvAPI_GPU_GetCurrentAGPRate
//
__nvapi_deprecated_function("Do not use this function - it is deprecated in release 455.")
NVAPI_INTERFACE NvAPI_GPU_GetCurrentAGPRate(NvPhysicalGpuHandle hPhysicalGpu,NvU32 *pRate);
 
//
// FUNCTION NAME: NvAPI_GPU_GetCurrentPCIEDownstreamWidth
//
NVAPI_INTERFACE NvAPI_GPU_GetCurrentPCIEDownstreamWidth(NvPhysicalGpuHandle hPhysicalGpu,NvU32 *pWidth);
 
 
 
//
// FUNCTION NAME: NvAPI_GPU_GetPhysicalFrameBufferSize
//
NVAPI_INTERFACE NvAPI_GPU_GetPhysicalFrameBufferSize(NvPhysicalGpuHandle hPhysicalGpu,NvU32 *pSize);
 
//
// FUNCTION NAME: NvAPI_GPU_GetVirtualFrameBufferSize
//
NVAPI_INTERFACE NvAPI_GPU_GetVirtualFrameBufferSize(NvPhysicalGpuHandle hPhysicalGpu,NvU32 *pSize);
 
 
 
//
// FUNCTION NAME: NvAPI_GPU_GetQuadroStatus
//
__nvapi_deprecated_function("Do not use this function - it is deprecated in release 460.")
NVAPI_INTERFACE NvAPI_GPU_GetQuadroStatus(NvPhysicalGpuHandle hPhysicalGpu, NvU32 *pStatus);
 
 
typedef struct _NV_BOARD_INFO
{
    NvU32 version;                   
    NvU8 BoardNum[16];               
 
}NV_BOARD_INFO_V1;
 
#define NV_BOARD_INFO_VER1  MAKE_NVAPI_VERSION(NV_BOARD_INFO_V1,1)
#ifndef NV_BOARD_INFO_VER
typedef NV_BOARD_INFO_V1    NV_BOARD_INFO;
#define NV_BOARD_INFO_VER   NV_BOARD_INFO_VER1
#endif
 
//
// FUNCTION NAME: NvAPI_GPU_GetBoardInfo
//
NVAPI_INTERFACE NvAPI_GPU_GetBoardInfo(NvPhysicalGpuHandle hPhysicalGpu, NV_BOARD_INFO *pBoardInfo);
 
 
 
 
//
// FUNCTION NAME: NvAPI_GPU_GetRamBusWidth
//
NVAPI_INTERFACE NvAPI_GPU_GetRamBusWidth(NvPhysicalGpuHandle hPhysicalGpu, NvU32 *pBusWidth);
 
 
 
typedef struct
{
    NvU32 version;
 
    NvU32 architecture;
    NvU32 implementation;
    NvU32 revision;
 
} NV_GPU_ARCH_INFO_V1;
 
typedef enum _NV_GPU_ARCHITECTURE_ID
{
 
    NV_GPU_ARCHITECTURE_T2X   = 0xE0000020,
    NV_GPU_ARCHITECTURE_T3X   = 0xE0000030,
    NV_GPU_ARCHITECTURE_T4X   = 0xE0000040,
    NV_GPU_ARCHITECTURE_T12X  = 0xE0000040,
    NV_GPU_ARCHITECTURE_NV40  = 0x00000040,
    NV_GPU_ARCHITECTURE_NV50  = 0x00000050,
    NV_GPU_ARCHITECTURE_G78   = 0x00000060,
    NV_GPU_ARCHITECTURE_G80   = 0x00000080,
    NV_GPU_ARCHITECTURE_G90   = 0x00000090,
    NV_GPU_ARCHITECTURE_GT200 = 0x000000A0,
    NV_GPU_ARCHITECTURE_GF100 = 0x000000C0,
    NV_GPU_ARCHITECTURE_GF110 = 0x000000D0,
    NV_GPU_ARCHITECTURE_GK100 = 0x000000E0,
    NV_GPU_ARCHITECTURE_GK110 = 0x000000F0,
    NV_GPU_ARCHITECTURE_GK200 = 0x00000100,
    NV_GPU_ARCHITECTURE_GM000 = 0x00000110,
    NV_GPU_ARCHITECTURE_GM200 = 0x00000120,
    NV_GPU_ARCHITECTURE_GP100 = 0x00000130,
    NV_GPU_ARCHITECTURE_GV100 = 0x00000140,
    NV_GPU_ARCHITECTURE_GV110 = 0x00000150,
    NV_GPU_ARCHITECTURE_TU100 = 0x00000160,
    NV_GPU_ARCHITECTURE_GA100 = 0x00000170,
    NV_GPU_ARCHITECTURE_AD100 = 0x00000190,
 
}NV_GPU_ARCHITECTURE_ID;
 
typedef enum _NV_GPU_ARCH_IMPLEMENTATION_ID
{
 
    NV_GPU_ARCH_IMPLEMENTATION_T20    = 0x00000000,
 
    NV_GPU_ARCH_IMPLEMENTATION_T30    = 0x00000000,
    NV_GPU_ARCH_IMPLEMENTATION_T35    = 0x00000005,
 
    NV_GPU_ARCH_IMPLEMENTATION_T40    = 0x00000000,
    NV_GPU_ARCH_IMPLEMENTATION_T124   = 0x00000000,
 
    NV_GPU_ARCH_IMPLEMENTATION_NV40   = 0x00000000,
    NV_GPU_ARCH_IMPLEMENTATION_NV41   = 0x00000001,
    NV_GPU_ARCH_IMPLEMENTATION_NV42   = 0x00000002,
    NV_GPU_ARCH_IMPLEMENTATION_NV43   = 0x00000003,
    NV_GPU_ARCH_IMPLEMENTATION_NV44   = 0x00000004,
    NV_GPU_ARCH_IMPLEMENTATION_NV44A  = 0x0000000A,
    NV_GPU_ARCH_IMPLEMENTATION_NV46   = 0x00000006,
    NV_GPU_ARCH_IMPLEMENTATION_NV47   = 0x00000007,
    NV_GPU_ARCH_IMPLEMENTATION_NV49   = 0x00000009,
    NV_GPU_ARCH_IMPLEMENTATION_NV4B   = 0x0000000B,
    NV_GPU_ARCH_IMPLEMENTATION_NV4C   = 0x0000000C,
    NV_GPU_ARCH_IMPLEMENTATION_NV4E   = 0x0000000E,
 
    NV_GPU_ARCH_IMPLEMENTATION_NV50   = 0x00000000,
 
    NV_GPU_ARCH_IMPLEMENTATION_NV63   = 0x00000003,
    NV_GPU_ARCH_IMPLEMENTATION_NV67   = 0x00000007,
 
    NV_GPU_ARCH_IMPLEMENTATION_G84    = 0x00000004,
    NV_GPU_ARCH_IMPLEMENTATION_G86    = 0x00000006,
 
    NV_GPU_ARCH_IMPLEMENTATION_G92    = 0x00000002,
    NV_GPU_ARCH_IMPLEMENTATION_G94    = 0x00000004,
    NV_GPU_ARCH_IMPLEMENTATION_G96    = 0x00000006,
    NV_GPU_ARCH_IMPLEMENTATION_G98    = 0x00000008,
 
    NV_GPU_ARCH_IMPLEMENTATION_GT200  = 0x00000000,
    NV_GPU_ARCH_IMPLEMENTATION_GT212  = 0x00000002,
    NV_GPU_ARCH_IMPLEMENTATION_GT214  = 0x00000004,
    NV_GPU_ARCH_IMPLEMENTATION_GT215  = 0x00000003,
    NV_GPU_ARCH_IMPLEMENTATION_GT216  = 0x00000005,
    NV_GPU_ARCH_IMPLEMENTATION_GT218  = 0x00000008,
    NV_GPU_ARCH_IMPLEMENTATION_MCP77  = 0x0000000A,
    NV_GPU_ARCH_IMPLEMENTATION_GT21C  = 0x0000000B,
    NV_GPU_ARCH_IMPLEMENTATION_MCP79  = 0x0000000C,
    NV_GPU_ARCH_IMPLEMENTATION_GT21A  = 0x0000000D,
    NV_GPU_ARCH_IMPLEMENTATION_MCP89  = 0x0000000F,
 
    NV_GPU_ARCH_IMPLEMENTATION_GF100  = 0x00000000,
    NV_GPU_ARCH_IMPLEMENTATION_GF104  = 0x00000004,
    NV_GPU_ARCH_IMPLEMENTATION_GF106  = 0x00000003,
    NV_GPU_ARCH_IMPLEMENTATION_GF108  = 0x00000001,
 
    NV_GPU_ARCH_IMPLEMENTATION_GF110  = 0x00000000,
    NV_GPU_ARCH_IMPLEMENTATION_GF116  = 0x00000006,
    NV_GPU_ARCH_IMPLEMENTATION_GF117  = 0x00000007,
    NV_GPU_ARCH_IMPLEMENTATION_GF118  = 0x00000008,
    NV_GPU_ARCH_IMPLEMENTATION_GF119  = 0x00000009,
 
    NV_GPU_ARCH_IMPLEMENTATION_GK104  = 0x00000004,
    NV_GPU_ARCH_IMPLEMENTATION_GK106  = 0x00000006,
    NV_GPU_ARCH_IMPLEMENTATION_GK107  = 0x00000007,
    NV_GPU_ARCH_IMPLEMENTATION_GK20A  = 0x0000000A,
    NV_GPU_ARCH_IMPLEMENTATION_GK110  = 0x00000000,
 
    NV_GPU_ARCH_IMPLEMENTATION_GK208  = 0x00000008,
 
    NV_GPU_ARCH_IMPLEMENTATION_GM204  = 0x00000004,
    NV_GPU_ARCH_IMPLEMENTATION_GM206  = 0x00000006,
 
    NV_GPU_ARCH_IMPLEMENTATION_GP100  = 0x00000000,
    NV_GPU_ARCH_IMPLEMENTATION_GP000  = 0x00000001,
    NV_GPU_ARCH_IMPLEMENTATION_GP102  = 0x00000002,
    NV_GPU_ARCH_IMPLEMENTATION_GP104  = 0x00000004,
    NV_GPU_ARCH_IMPLEMENTATION_GP106  = 0x00000006,
    NV_GPU_ARCH_IMPLEMENTATION_GP107  = 0x00000007,
    NV_GPU_ARCH_IMPLEMENTATION_GP108  = 0x00000008,
 
    NV_GPU_ARCH_IMPLEMENTATION_GV100  = 0x00000000,
    NV_GPU_ARCH_IMPLEMENTATION_GV10B  = 0x0000000B,
    
    NV_GPU_ARCH_IMPLEMENTATION_TU100  = 0x00000000,
    NV_GPU_ARCH_IMPLEMENTATION_TU102  = 0x00000002,
    NV_GPU_ARCH_IMPLEMENTATION_TU104  = 0x00000004,
    NV_GPU_ARCH_IMPLEMENTATION_TU106  = 0x00000006,
    NV_GPU_ARCH_IMPLEMENTATION_TU116  = 0x00000008,
    NV_GPU_ARCH_IMPLEMENTATION_TU117  = 0x00000007,
    NV_GPU_ARCH_IMPLEMENTATION_TU000  = 0x00000001,
 
    NV_GPU_ARCH_IMPLEMENTATION_GA100  = 0x00000000,
    NV_GPU_ARCH_IMPLEMENTATION_GA102  = 0x00000002,
    NV_GPU_ARCH_IMPLEMENTATION_GA104  = 0x00000004,
 
    NV_GPU_ARCH_IMPLEMENTATION_AD102  = 0x00000002,
    NV_GPU_ARCH_IMPLEMENTATION_AD103  = 0x00000003,
    NV_GPU_ARCH_IMPLEMENTATION_AD104  = 0x00000004,
 
}NV_GPU_ARCH_IMPLEMENTATION_ID;
 
typedef enum _NV_GPU_CHIP_REVISION
{
    NV_GPU_CHIP_REV_EMULATION_QT        = 0x00000000,   
    NV_GPU_CHIP_REV_EMULATION_FPGA      = 0x00000001,   
    NV_GPU_CHIP_REV_A01                 = 0x00000011,   
    NV_GPU_CHIP_REV_A02                 = 0x00000012,   
    NV_GPU_CHIP_REV_A03                 = 0x00000013,   
    NV_GPU_CHIP_REV_UNKNOWN             = 0xffffffff,   
}NV_GPU_CHIP_REVISION;
 
typedef struct
{
    NvU32 version;
 
    union
    {
        NvU32                           architecture;       
        NV_GPU_ARCHITECTURE_ID          architecture_id;    
    };
    union
    {
        NvU32                           implementation;     
        NV_GPU_ARCH_IMPLEMENTATION_ID   implementation_id;  
    };
    union
    {
        NvU32                           revision;           
        NV_GPU_CHIP_REVISION            revision_id;        
    };
 
} NV_GPU_ARCH_INFO_V2;
 
typedef NV_GPU_ARCH_INFO_V2 NV_GPU_ARCH_INFO;
 
#define NV_GPU_ARCH_INFO_VER_1  MAKE_NVAPI_VERSION(NV_GPU_ARCH_INFO_V1,1)
#define NV_GPU_ARCH_INFO_VER_2  MAKE_NVAPI_VERSION(NV_GPU_ARCH_INFO_V2,2)
#define NV_GPU_ARCH_INFO_VER    NV_GPU_ARCH_INFO_VER_2
 
//
// FUNCTION NAME: NvAPI_GPU_GetArchInfo
//
//
 
NVAPI_INTERFACE NvAPI_GPU_GetArchInfo(NvPhysicalGpuHandle hPhysicalGpu, NV_GPU_ARCH_INFO *pGpuArchInfo);
 
 
 
//  I2C API
//  Provides ability to read or write data using I2C protocol.
//  These APIs allow I2C access only to DDC monitors
 
 
#define NVAPI_MAX_SIZEOF_I2C_DATA_BUFFER    4096
#define NVAPI_MAX_SIZEOF_I2C_REG_ADDRESS       4
#define NVAPI_DISPLAY_DEVICE_MASK_MAX         24
#define NVAPI_I2C_SPEED_DEPRECATED        0xFFFF
 
typedef enum
{
    NVAPI_I2C_SPEED_DEFAULT,    
    NVAPI_I2C_SPEED_3KHZ,
    NVAPI_I2C_SPEED_10KHZ,
    NVAPI_I2C_SPEED_33KHZ,
    NVAPI_I2C_SPEED_100KHZ,
    NVAPI_I2C_SPEED_200KHZ,
    NVAPI_I2C_SPEED_400KHZ,
} NV_I2C_SPEED;
 
typedef struct
{
    NvU32                   version;            
    NvU32                   displayMask;        
    NvU8                    bIsDDCPort;         
    NvU8                    i2cDevAddress;      
    NvU8*                   pbI2cRegAddress;    
    NvU32                   regAddrSize;        
    NvU8*                   pbData;             
    NvU32                   cbSize;             
    NvU32                   i2cSpeed;           
} NV_I2C_INFO_V1;
 
typedef struct
{
    NvU32                   version;            
    NvU32                   displayMask;        
    NvU8                    bIsDDCPort;         
    NvU8                    i2cDevAddress;      
    NvU8*                   pbI2cRegAddress;    
    NvU32                   regAddrSize;        
    NvU8*                   pbData;             
    NvU32                   cbSize;             
    NvU32                   i2cSpeed;           
    NV_I2C_SPEED            i2cSpeedKhz;        
} NV_I2C_INFO_V2;
 
typedef struct
{
    NvU32                   version;            
    NvU32                   displayMask;        
    NvU8                    bIsDDCPort;         
    NvU8                    i2cDevAddress;      
    NvU8*                   pbI2cRegAddress;    
    NvU32                   regAddrSize;        
    NvU8*                   pbData;             
    NvU32                   cbSize;             
    NvU32                   i2cSpeed;           
    NV_I2C_SPEED            i2cSpeedKhz;        
    NvU8                    portId;             
    NvU32                   bIsPortIdSet;       
} NV_I2C_INFO_V3;
 
typedef NV_I2C_INFO_V3                     NV_I2C_INFO;
 
#define NV_I2C_INFO_VER3  MAKE_NVAPI_VERSION(NV_I2C_INFO_V3,3)
#define NV_I2C_INFO_VER2  MAKE_NVAPI_VERSION(NV_I2C_INFO_V2,2)
#define NV_I2C_INFO_VER1  MAKE_NVAPI_VERSION(NV_I2C_INFO_V1,1)
 
#define NV_I2C_INFO_VER  NV_I2C_INFO_VER3
 
/***********************************************************************************/
 
 
//
// FUNCTION NAME:  NvAPI_I2CRead
//
NVAPI_INTERFACE NvAPI_I2CRead(NvPhysicalGpuHandle hPhysicalGpu, NV_I2C_INFO *pI2cInfo);
 
//
// FUNCTION NAME:  NvAPI_I2CWrite
//
NVAPI_INTERFACE NvAPI_I2CWrite(NvPhysicalGpuHandle hPhysicalGpu, NV_I2C_INFO *pI2cInfo);
 
 
//
// FUNCTION NAME: NvAPI_GPU_WorkstationFeatureSetup
//
//
 
typedef enum
{
    NVAPI_GPU_WORKSTATION_FEATURE_MASK_SWAPGROUP     = 0x00000001,
    NVAPI_GPU_WORKSTATION_FEATURE_MASK_STEREO        = 0x00000010,
    NVAPI_GPU_WORKSTATION_FEATURE_MASK_WARPING       = 0x00000100,
    NVAPI_GPU_WORKSTATION_FEATURE_MASK_PIXINTENSITY  = 0x00000200,
    NVAPI_GPU_WORKSTATION_FEATURE_MASK_GRAYSCALE     = 0x00000400,
    NVAPI_GPU_WORKSTATION_FEATURE_MASK_BPC10         = 0x00001000
} NVAPI_GPU_WORKSTATION_FEATURE_MASK;
 
NVAPI_INTERFACE NvAPI_GPU_WorkstationFeatureSetup(__in NvPhysicalGpuHandle hPhysicalGpu, __in NvU32 featureEnableMask, __in NvU32 featureDisableMask);
 
//
// FUNCTION NAME: NvAPI_GPU_WorkstationFeatureQuery
//
//
 
NVAPI_INTERFACE NvAPI_GPU_WorkstationFeatureQuery(__in NvPhysicalGpuHandle hPhysicalGpu, __out_opt NvU32 *pConfiguredFeatureMask, __out_opt NvU32 *pConsistentFeatureMask);
 
//
// FUNCTION NAME: NvAPI_GPU_GetHDCPSupportStatus
//
//
 
 
 
 
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;
 
 
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;
 
 
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;
 
 
typedef struct
{
    NvU32                        version;               
    NV_GPU_HDCP_FUSE_STATE       hdcpFuseState;         
    NV_GPU_HDCP_KEY_SOURCE       hdcpKeySource;         
    NV_GPU_HDCP_KEY_SOURCE_STATE hdcpKeySourceState;    
} NV_GPU_GET_HDCP_SUPPORT_STATUS;
 
 
#define NV_GPU_GET_HDCP_SUPPORT_STATUS_VER MAKE_NVAPI_VERSION(NV_GPU_GET_HDCP_SUPPORT_STATUS,1)
 
 
 
 
NVAPI_INTERFACE NvAPI_GPU_GetHDCPSupportStatus(NvPhysicalGpuHandle hPhysicalGpu, NV_GPU_GET_HDCP_SUPPORT_STATUS *pGetHDCPSupportStatus);
 
 
 
 
 
 
#define NV_COMPUTE_GPU_TOPOLOGY_PHYSICS_CAPABLE           NV_BIT(0)   
#define NV_COMPUTE_GPU_TOPOLOGY_PHYSICS_ENABLE            NV_BIT(1)   
#define NV_COMPUTE_GPU_TOPOLOGY_PHYSICS_DEDICATED         NV_BIT(2)   
#define NV_COMPUTE_GPU_TOPOLOGY_PHYSICS_RECOMMENDED       NV_BIT(3)   
#define NV_COMPUTE_GPU_TOPOLOGY_CUDA_AVAILABLE            NV_BIT(4)   
#define NV_COMPUTE_GPU_TOPOLOGY_CUDA_CAPABLE              NV_BIT(16)  
#define NV_COMPUTE_GPU_TOPOLOGY_CUDA_DISABLED             NV_BIT(17)  
#define NV_COMPUTE_GPU_TOPOLOGY_PHYSICS_AVAILABLE         NV_BIT(21)  
 
 
typedef struct
{
    NvU32 version;  
    NvU32 gpuCount; 
 
    struct
    {
        NvPhysicalGpuHandle  hPhysicalGpu;      
        NvU32                flags;             
 
    } computeGpus[NVAPI_MAX_GPU_PER_TOPOLOGY];  
 
} NV_COMPUTE_GPU_TOPOLOGY_V1;
 
 
typedef struct _NV_COMPUTE_GPU
{
     NvPhysicalGpuHandle  hPhysicalGpu;      
     NvU32                flags;             
 
} NV_COMPUTE_GPU;
 
typedef struct _NV_COMPUTE_GPU_TOPOLOGY_V2
{
    NvU32 version;                 
    NvU32 gpuCount;                
    NV_COMPUTE_GPU *computeGpus;   
 
} NV_COMPUTE_GPU_TOPOLOGY_V2;
 
#define NV_COMPUTE_GPU_TOPOLOGY_VER1  MAKE_NVAPI_VERSION(NV_COMPUTE_GPU_TOPOLOGY_V1,1)
 
#define NV_COMPUTE_GPU_TOPOLOGY_VER  MAKE_NVAPI_VERSION(NV_COMPUTE_GPU_TOPOLOGY_V2,2)
typedef NV_COMPUTE_GPU_TOPOLOGY_V2 NV_COMPUTE_GPU_TOPOLOGY;
 
 
//
// FUNCTION NAME:  NvAPI_GPU_CudaEnumComputeCapableGpus
//
__nvapi_deprecated_function("Do not use this function - it is deprecated in release 319.")
NVAPI_INTERFACE NvAPI_GPU_CudaEnumComputeCapableGpus(__inout NV_COMPUTE_GPU_TOPOLOGY *pComputeTopo);
 
//
// FUNCTION NAME: NvAPI_GPU_GetTachReading
//
NVAPI_INTERFACE NvAPI_GPU_GetTachReading(NvPhysicalGpuHandle hPhysicalGPU, NvU32 *pValue);
 
 
 
 
//
// FUNCTION NAME:   NvAPI_GPU_GetECCStatusInfo
//
//
 
typedef enum _NV_ECC_CONFIGURATION
{
    NV_ECC_CONFIGURATION_NOT_SUPPORTED = 0,
    NV_ECC_CONFIGURATION_DEFERRED,           
    NV_ECC_CONFIGURATION_IMMEDIATE,          
} NV_ECC_CONFIGURATION;
 
typedef struct
{
    NvU32                 version;               
    NvU32                 isSupported : 1;       
    NV_ECC_CONFIGURATION  configurationOptions;  
    NvU32                 isEnabled : 1;         
} NV_GPU_ECC_STATUS_INFO;
 
#define NV_GPU_ECC_STATUS_INFO_VER MAKE_NVAPI_VERSION(NV_GPU_ECC_STATUS_INFO,1)
 
NVAPI_INTERFACE NvAPI_GPU_GetECCStatusInfo(NvPhysicalGpuHandle hPhysicalGpu,
                                           NV_GPU_ECC_STATUS_INFO *pECCStatusInfo);
 
typedef struct
{
    NvU32   version;             
    struct
    {
        NvU64  singleBitErrors;  
        NvU64  doubleBitErrors;  
    } current;
    struct
    {
        NvU64  singleBitErrors;  
        NvU64  doubleBitErrors;  
    } aggregate;
} NV_GPU_ECC_ERROR_INFO;
 
#define NV_GPU_ECC_ERROR_INFO_VER MAKE_NVAPI_VERSION(NV_GPU_ECC_ERROR_INFO,1)
 
//
// FUNCTION NAME:   NvAPI_GPU_GetECCErrorInfo
//
//
 
NVAPI_INTERFACE NvAPI_GPU_GetECCErrorInfo(NvPhysicalGpuHandle hPhysicalGpu,
                                          NV_GPU_ECC_ERROR_INFO *pECCErrorInfo);
 
 
//
// FUNCTION NAME:   NvAPI_GPU_ResetECCErrorInfo
//
NVAPI_INTERFACE NvAPI_GPU_ResetECCErrorInfo(NvPhysicalGpuHandle hPhysicalGpu, NvU8 bResetCurrent,
                                            NvU8 bResetAggregate);
 
//
// FUNCTION NAME:   NvAPI_GPU_GetECCConfigurationInfo
//
//
 
typedef struct
{
    NvU32  version;                 
    NvU32  isEnabled : 1;           
    NvU32  isEnabledByDefault : 1;  
} NV_GPU_ECC_CONFIGURATION_INFO;
 
#define NV_GPU_ECC_CONFIGURATION_INFO_VER MAKE_NVAPI_VERSION(NV_GPU_ECC_CONFIGURATION_INFO,1)
 
NVAPI_INTERFACE NvAPI_GPU_GetECCConfigurationInfo(NvPhysicalGpuHandle hPhysicalGpu,
                                                  NV_GPU_ECC_CONFIGURATION_INFO *pECCConfigurationInfo);
 
 
//
// FUNCTION NAME:   NvAPI_GPU_SetECCConfiguration
//
NVAPI_INTERFACE NvAPI_GPU_SetECCConfiguration(NvPhysicalGpuHandle hPhysicalGpu, NvU8 bEnable,
                                              NvU8 bEnableImmediately);
 
 
 
// The following enum is providing definitions for events signaled by a Quadro Sync (QSYNC) device.
// QSYNC event broadcast is supported for Windows 10 and later OS.
typedef enum
{
    NV_QSYNC_EVENT_NONE                    =  0,
    NV_QSYNC_EVENT_SYNC_LOSS               =  1,    // Frame Lock sync loss event
    NV_QSYNC_EVENT_SYNC_GAIN               =  2,    // Frame Lock sync gain event
    NV_QSYNC_EVENT_HOUSESYNC_GAIN          =  3,    // House cable gain(plug in) event
    NV_QSYNC_EVENT_HOUSESYNC_LOSS          =  4,    // House cable loss(plug out) event
    NV_QSYNC_EVENT_RJ45_GAIN               =  5,    // RJ45 cable gain(plug in) event
    NV_QSYNC_EVENT_RJ45_LOSS               =  6,    // RJ45 cable loss(plug out) event
} NV_QSYNC_EVENT;
 
typedef struct
{
    NV_QSYNC_EVENT   qsyncEvent;       // One of the value of the enum NV_QSYNC_EVENT
    NvU32            reserved[7];      // Reserved for future use. Do not use this.
} NV_QSYNC_EVENT_DATA;
 
typedef void(__cdecl *NVAPI_CALLBACK_QSYNCEVENT)(NV_QSYNC_EVENT_DATA qyncEventData, void *callbackParam);
 
 
typedef enum
{
    NV_EVENT_TYPE_NONE = 0,
    NV_EVENT_TYPE_QSYNC = 6,
} NV_EVENT_TYPE;
 
typedef struct
{
    NvU32                 version;          
    NV_EVENT_TYPE         eventId;          
    void                  *callbackParam;   
    union
    {
        NVAPI_CALLBACK_QSYNCEVENT    nvQSYNCEventCallback;                     
    }nvCallBackFunc;
 
} NV_EVENT_REGISTER_CALLBACK, *PNV_EVENT_REGISTER_CALLBACK;
 
#define NV_EVENT_REGISTER_CALLBACK_VERSION     MAKE_NVAPI_VERSION(NV_EVENT_REGISTER_CALLBACK,1)
 
 
typedef enum _NV_GPU_WORKSTATION_FEATURE_TYPE
{
    NV_GPU_WORKSTATION_FEATURE_TYPE_NVIDIA_RTX_VR_READY  = 1,  
    NV_GPU_WORKSTATION_FEATURE_TYPE_QUADRO_VR_READY  = NV_GPU_WORKSTATION_FEATURE_TYPE_NVIDIA_RTX_VR_READY,  
    NV_GPU_WORKSTATION_FEATURE_TYPE_PROVIZ = 2,
} NV_GPU_WORKSTATION_FEATURE_TYPE;
 
 
// FUNCTION NAME:   NvAPI_GPU_QueryWorkstationFeatureSupport
//
NVAPI_INTERFACE NvAPI_GPU_QueryWorkstationFeatureSupport(NvPhysicalGpuHandle physicalGpu, NV_GPU_WORKSTATION_FEATURE_TYPE gpuWorkstationFeature);
 
 
 
typedef struct
{
    NvU32  version;              
    NvU32  width;                
    NvU32  height;               
    float* blendingTexture;      
} NV_SCANOUT_INTENSITY_DATA_V1;
 
typedef struct
{
    NvU32  version;              
    NvU32  width;                
    NvU32  height;               
    float* blendingTexture;      
    float* offsetTexture;        
    NvU32  offsetTexChannels;    
} NV_SCANOUT_INTENSITY_DATA_V2;
 
typedef NV_SCANOUT_INTENSITY_DATA_V2 NV_SCANOUT_INTENSITY_DATA;
 
#define NV_SCANOUT_INTENSITY_DATA_VER1    MAKE_NVAPI_VERSION(NV_SCANOUT_INTENSITY_DATA_V1, 1)
#define NV_SCANOUT_INTENSITY_DATA_VER2    MAKE_NVAPI_VERSION(NV_SCANOUT_INTENSITY_DATA_V2, 2)
#define NV_SCANOUT_INTENSITY_DATA_VER      NV_SCANOUT_INTENSITY_DATA_VER2
 
// FUNCTION NAME: NvAPI_GPU_SetScanoutIntensity
//
NVAPI_INTERFACE NvAPI_GPU_SetScanoutIntensity(NvU32 displayId, NV_SCANOUT_INTENSITY_DATA* scanoutIntensityData, int *pbSticky);
 
 
typedef struct _NV_SCANOUT_INTENSITY_STATE_DATA
{
    NvU32  version;                                 
    NvU32  bEnabled;                                
} NV_SCANOUT_INTENSITY_STATE_DATA;
 
#define NV_SCANOUT_INTENSITY_STATE_VER    MAKE_NVAPI_VERSION(NV_SCANOUT_INTENSITY_STATE_DATA, 1)
 
// FUNCTION NAME: NvAPI_GPU_GetScanoutIntensityState
//
NVAPI_INTERFACE NvAPI_GPU_GetScanoutIntensityState(__in NvU32 displayId, __inout NV_SCANOUT_INTENSITY_STATE_DATA* scanoutIntensityStateData);
 
 
typedef enum
{
    NV_GPU_WARPING_VERTICE_FORMAT_TRIANGLESTRIP_XYUVRQ = 0,
    NV_GPU_WARPING_VERTICE_FORMAT_TRIANGLES_XYUVRQ     = 1,
} NV_GPU_WARPING_VERTICE_FORMAT;
 
typedef struct
{
    NvU32  version;                                 
    float* vertices;                                
    NV_GPU_WARPING_VERTICE_FORMAT vertexFormat;     
    int    numVertices;                             
    NvSBox* textureRect;                            
} NV_SCANOUT_WARPING_DATA;
 
#define NV_SCANOUT_WARPING_VER    MAKE_NVAPI_VERSION(NV_SCANOUT_WARPING_DATA, 1)
 
 
// FUNCTION NAME: NvAPI_GPU_SetScanoutWarping
//
 
NVAPI_INTERFACE NvAPI_GPU_SetScanoutWarping(NvU32 displayId, NV_SCANOUT_WARPING_DATA* scanoutWarpingData, int* piMaxNumVertices, int* pbSticky);
 
 
typedef struct _NV_SCANOUT_WARPING_STATE_DATA
{
    NvU32  version;                                  
    NvU32  bEnabled;                                 
} NV_SCANOUT_WARPING_STATE_DATA;
 
#define NV_SCANOUT_WARPING_STATE_VER    MAKE_NVAPI_VERSION(NV_SCANOUT_WARPING_STATE_DATA, 1)
 
// FUNCTION NAME: NvAPI_GPU_GetScanoutWarpingState
//
NVAPI_INTERFACE NvAPI_GPU_GetScanoutWarpingState(__in NvU32 displayId, __inout NV_SCANOUT_WARPING_STATE_DATA* scanoutWarpingStateData);
 
typedef enum
{
    NV_GPU_SCANOUT_COMPOSITION_PARAMETER_WARPING_RESAMPLING_METHOD      = 0
} NV_GPU_SCANOUT_COMPOSITION_PARAMETER;
 
typedef enum
{
    NV_GPU_SCANOUT_COMPOSITION_PARAMETER_SET_TO_DEFAULT = 0,                                  // Set parameter to default value.
    // WARPING_RESAMPLING_METHOD section:
    NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE_WARPING_RESAMPLING_METHOD_BILINEAR                       = 0x100,
    NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE_WARPING_RESAMPLING_METHOD_BICUBIC_TRIANGULAR             = 0x101,
    NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE_WARPING_RESAMPLING_METHOD_BICUBIC_BELL_SHAPED            = 0x102,
    NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE_WARPING_RESAMPLING_METHOD_BICUBIC_BSPLINE                = 0x103,
    NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE_WARPING_RESAMPLING_METHOD_BICUBIC_ADAPTIVE_TRIANGULAR    = 0x104,
    NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE_WARPING_RESAMPLING_METHOD_BICUBIC_ADAPTIVE_BELL_SHAPED   = 0x105,
    NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE_WARPING_RESAMPLING_METHOD_BICUBIC_ADAPTIVE_BSPLINE       = 0x106
} NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE;
 
// FUNCTION NAME: NvAPI_GPU_SetScanoutCompositionParameter
//
 
NVAPI_INTERFACE NvAPI_GPU_SetScanoutCompositionParameter(NvU32 displayId, NV_GPU_SCANOUT_COMPOSITION_PARAMETER parameter,
                                                         NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE parameterValue, float *pContainer);
 
 
// FUNCTION NAME: NvAPI_GPU_GetScanoutCompositionParameter
//
NVAPI_INTERFACE NvAPI_GPU_GetScanoutCompositionParameter(__in NvU32 displayId, __in NV_GPU_SCANOUT_COMPOSITION_PARAMETER parameter,
                                                         __out NV_GPU_SCANOUT_COMPOSITION_PARAMETER_VALUE *parameterData, __out float *pContainer);
 
 
// FUNCTION NAME: NvAPI_GPU_GetScanoutConfiguration
//
NVAPI_INTERFACE NvAPI_GPU_GetScanoutConfiguration(NvU32 displayId, NvSBox* desktopRect, NvSBox* scanoutRect);
 
 
 
typedef struct _NV_SCANOUT_INFORMATION
{
    NvU32      version;                 
 
    NvSBox     sourceDesktopRect;       
    NvSBox     sourceViewportRect;      
    NvSBox     targetViewportRect;      
    NvU32      targetDisplayWidth;      
    NvU32      targetDisplayHeight;     
    NvU32      cloneImportance;         
    NV_ROTATE  sourceToTargetRotation;  
} NV_SCANOUT_INFORMATION;
 
#define NV_SCANOUT_INFORMATION_VER  MAKE_NVAPI_VERSION(NV_SCANOUT_INFORMATION,1)
 
// FUNCTION NAME: NvAPI_GPU_GetScanoutConfigurationEx
//
NVAPI_INTERFACE NvAPI_GPU_GetScanoutConfigurationEx(__in NvU32 displayId, __inout NV_SCANOUT_INFORMATION *pScanoutInformation);
 
//
// FUNCTION NAME: NvAPI_GPU_GetAdapterIdFromPhysicalGpu
//
__nvapi_deprecated_function("Do not use this function - it is deprecated in release 520. Instead, use NvAPI_GPU_GetLogicalGpuInfo.")
NVAPI_INTERFACE NvAPI_GPU_GetAdapterIdFromPhysicalGpu(NvPhysicalGpuHandle hPhysicalGpu, void *pOSAdapterId);
 
 
 
 
typedef enum _NV_VIRTUALIZATION_MODE
{
    NV_VIRTUALIZATION_MODE_NONE       = 0,   
    NV_VIRTUALIZATION_MODE_NMOS       = 1,   
    NV_VIRTUALIZATION_MODE_VGX        = 2,   
    NV_VIRTUALIZATION_MODE_HOST_VGPU  = 3    
} NV_VIRTUALIZATION_MODE;
 
typedef struct _NV_GPU_VIRTUALIZATION_INFO
{
    NvU32                    version;                      
 
    NV_VIRTUALIZATION_MODE   virtualizationMode;           
    NvU32                    reserved;                     
} NV_GPU_VIRTUALIZATION_INFO_V1;
 
typedef NV_GPU_VIRTUALIZATION_INFO_V1     NV_GPU_VIRTUALIZATION_INFO;
 
#define NV_GPU_VIRTUALIZATION_INFO_VER1   MAKE_NVAPI_VERSION(NV_GPU_VIRTUALIZATION_INFO_V1,1)
 
#define NV_GPU_VIRTUALIZATION_INFO_VER    NV_GPU_VIRTUALIZATION_INFO_VER1
 
 
NVAPI_INTERFACE NvAPI_GPU_GetVirtualizationInfo(__in NvPhysicalGpuHandle hPhysicalGpu, __inout NV_GPU_VIRTUALIZATION_INFO *pVirtualizationInfo);
 
 
typedef struct _NV_LOGICAL_GPU_DATA_V1
{
    NvU32 version;                                                   
    void *pOSAdapterId;                                              
    NvU32 physicalGpuCount;                                          
 
    NvPhysicalGpuHandle physicalGpuHandles[NVAPI_MAX_PHYSICAL_GPUS]; 
    NvU32 reserved[8];                                               
} NV_LOGICAL_GPU_DATA_V1;
 
typedef NV_LOGICAL_GPU_DATA_V1     NV_LOGICAL_GPU_DATA;
#define NV_LOGICAL_GPU_DATA_VER1   MAKE_NVAPI_VERSION(NV_LOGICAL_GPU_DATA_V1,1)
#define NV_LOGICAL_GPU_DATA_VER    NV_LOGICAL_GPU_DATA_VER1
 
//
// FUNCTION NAME: NvAPI_GPU_GetLogicalGpuInfo
//
NVAPI_INTERFACE NvAPI_GPU_GetLogicalGpuInfo(__in NvLogicalGpuHandle hLogicalGpu, __inout NV_LOGICAL_GPU_DATA *pLogicalGpuData);
 
 
 
#define NV_LICENSE_MAX_COUNT                              3
 
#define NV_LICENSE_SIGNATURE_SIZE                         (128)
 
#define NV_LICENSE_INFO_MAX_LENGTH                         (128)
 
typedef char NvAPI_LicenseString[NV_LICENSE_INFO_MAX_LENGTH];
 
typedef enum _NV_LICENSE_FEATURE_TYPE
{
    NV_LICENSE_FEATURE_UNKNOWN   = 0,
    NV_LICENSE_FEATURE_VGPU      = 1,
    NV_LICENSE_FEATURE_NVIDIA_RTX = 2,
    NV_LICENSE_FEATURE_QUADRO    = NV_LICENSE_FEATURE_NVIDIA_RTX, 
    NV_LICENSE_FEATURE_GAMING    = 3,
    NV_LICENSE_FEATURE_COMPUTE   = 4,
} NV_LICENSE_FEATURE_TYPE;
 
typedef struct _NV_LICENSE_EXPIRY_DETAILS
{
    NvU32 year;     
    NvU16 month;    
    NvU16 day;      
    NvU16 hour;     
    NvU16 min;      
    NvU16 sec;      
 
    NvU8 status;    
}NV_LICENSE_EXPIRY_DETAILS;
 
typedef struct _NV_LICENSE_FEATURE_DETAILS_V1
{
    NvU32                           version;                
    NvU32                           isEnabled  : 1;         
    NvU32                           reserved   : 31;        
    NV_LICENSE_FEATURE_TYPE         featureCode;            
    NvAPI_LicenseString             licenseInfo;            
}NV_LICENSE_FEATURE_DETAILS_V1;
 
typedef struct _NV_LICENSE_FEATURE_DETAILS_V2
{
    NvU32                           version;                
    NvU32                           isEnabled  : 1;         
    NvU32                           reserved   : 31;        
    NV_LICENSE_FEATURE_TYPE         featureCode;            
    NvAPI_LicenseString             licenseInfo;            
    NvAPI_LicenseString             productName;            
}NV_LICENSE_FEATURE_DETAILS_V2;
 
typedef struct _NV_LICENSE_FEATURE_DETAILS_V3
{
    NvU32                           version;                
    NvU32                           isEnabled        : 1;   
    NvU32                           isFeatureEnabled : 1;   
    NvU32                           reserved         : 30;  
    NV_LICENSE_FEATURE_TYPE         featureCode;            
    NvAPI_LicenseString             licenseInfo;            
    NvAPI_LicenseString             productName;            
}NV_LICENSE_FEATURE_DETAILS_V3;
 
typedef struct _NV_LICENSE_FEATURE_DETAILS_V4
{
    NvU32                           version;                
    NvU32                           isEnabled        : 1;   
    NvU32                           isFeatureEnabled : 1;   
    NvU32                           reserved         : 30;  
    NV_LICENSE_FEATURE_TYPE         featureCode;            
    NvAPI_LicenseString             licenseInfo;            
    NvAPI_LicenseString             productName;            
    NV_LICENSE_EXPIRY_DETAILS       licenseExpiry;          
}NV_LICENSE_FEATURE_DETAILS_V4;
 
typedef NV_LICENSE_FEATURE_DETAILS_V1     NV_LICENSE_FEATURE_DETAILS;
 
#define NV_LICENSE_FEATURE_DETAILS_VER1   MAKE_NVAPI_VERSION(NV_LICENSE_FEATURE_DETAILS_V1, 1)
#define NV_LICENSE_FEATURE_DETAILS_VER    NV_LICENSE_FEATURE_DETAILS_VER1
 
typedef struct _NV_LICENSABLE_FEATURES_V1
{
    NvU32                              version;                                         
    NvU32                              isLicenseSupported  : 1;                         
    NvU32                              reserved            : 31;                        
    NvU32                              licensableFeatureCount;                          
    NvU8                               signature[NV_LICENSE_SIGNATURE_SIZE];            
    NV_LICENSE_FEATURE_DETAILS_V1      licenseDetails[NV_LICENSE_MAX_COUNT];            
}NV_LICENSABLE_FEATURES_V1;
 
typedef struct _NV_LICENSABLE_FEATURES_V2
{
    NvU32                              version;                                         
    NvU32                              isLicenseSupported  : 1;                         
    NvU32                              reserved            : 31;                        
    NvU32                              licensableFeatureCount;                          
    NvU8                               signature[NV_LICENSE_SIGNATURE_SIZE];            
    NV_LICENSE_FEATURE_DETAILS_V2      licenseDetails[NV_LICENSE_MAX_COUNT];            
}NV_LICENSABLE_FEATURES_V2;
 
typedef struct _NV_LICENSABLE_FEATURES_V3
{
    NvU32                              version;                                         
    NvU32                              isLicenseSupported  : 1;                         
    NvU32                              reserved            : 31;                        
    NvU32                              licensableFeatureCount;                          
    NvU8                               signature[NV_LICENSE_SIGNATURE_SIZE];            
    NV_LICENSE_FEATURE_DETAILS_V3      licenseDetails[NV_LICENSE_MAX_COUNT];            
}NV_LICENSABLE_FEATURES_V3;
 
typedef struct _NV_LICENSABLE_FEATURES_V4
{
    NvU32                              version;                                         
    NvU32                              isLicenseSupported  : 1;                         
    NvU32                              reserved            : 31;                        
    NvU32                              licensableFeatureCount;                          
    NvU8                               signature[NV_LICENSE_SIGNATURE_SIZE];            
    NV_LICENSE_FEATURE_DETAILS_V4      licenseDetails[NV_LICENSE_MAX_COUNT];            
}NV_LICENSABLE_FEATURES_V4;
 
typedef NV_LICENSABLE_FEATURES_V4     NV_LICENSABLE_FEATURES;
 
#define NV_LICENSABLE_FEATURES_VER1   MAKE_NVAPI_VERSION(NV_LICENSABLE_FEATURES_V1, 1)
#define NV_LICENSABLE_FEATURES_VER2   MAKE_NVAPI_VERSION(NV_LICENSABLE_FEATURES_V2, 2)
#define NV_LICENSABLE_FEATURES_VER3   MAKE_NVAPI_VERSION(NV_LICENSABLE_FEATURES_V3, 3)
#define NV_LICENSABLE_FEATURES_VER4   MAKE_NVAPI_VERSION(NV_LICENSABLE_FEATURES_V4, 4)
#define NV_LICENSABLE_FEATURES_VER    NV_LICENSABLE_FEATURES_VER4
 
 
//
// FUNCTION NAME:   NvAPI_GPU_GetLicensableFeatures
//
NVAPI_INTERFACE NvAPI_GPU_GetLicensableFeatures(__in NvPhysicalGpuHandle hPhysicalGpu, __inout NV_LICENSABLE_FEATURES *pLicensableFeatures);
 
 
#define NVAPI_NVLINK_COUNTER_MAX_TYPES                    32
#define NVAPI_NVLINK_MAX_LINKS                            32
 
 
/* caps format is byte_index:bit_mask */
#define NVAPI_NVLINK_CAPS_SUPPORTED                          0x00000001                   
#define NVAPI_NVLINK_CAPS_P2P_SUPPORTED                      0x00000002                   
#define NVAPI_NVLINK_CAPS_SYSMEM_ACCESS                      0x00000004                   
#define NVAPI_NVLINK_CAPS_P2P_ATOMICS                        0x00000008                   
#define NVAPI_NVLINK_CAPS_SYSMEM_ATOMICS                     0x00000010                   
#define NVAPI_NVLINK_CAPS_PEX_TUNNELING                      0x00000020                   
#define NVAPI_NVLINK_CAPS_SLI_BRIDGE                         0x00000040                   
#define NVAPI_NVLINK_CAPS_SLI_BRIDGE_SENSABLE                0x00000080                    
#define NVAPI_NVLINK_CAPS_POWER_STATE_L0                     0x00000100                    
#define NVAPI_NVLINK_CAPS_POWER_STATE_L1                     0x00000200                    
#define NVAPI_NVLINK_CAPS_POWER_STATE_L2                     0x00000400                    
#define NVAPI_NVLINK_CAPS_POWER_STATE_L3                     0x00000800                    
 
#define NVAPI_NVLINK_CAPS_VALID                              0x00001000                   
 
#define NVAPI_NVLINK_CAPS_NVLINK_VERSION_INVALID             (0x00000000)
#define NVAPI_NVLINK_CAPS_NVLINK_VERSION_1_0                 (0x00000001)
#define NVAPI_NVLINK_CAPS_NVLINK_VERSION_2_0                 (0x00000002)
 
#define NVAPI_NVLINK_CAPS_NCI_VERSION_INVALID                (0x00000000)
#define NVAPI_NVLINK_CAPS_NCI_VERSION_1_0                    (0x00000001)
#define NVAPI_NVLINK_CAPS_NCI_VERSION_2_0                    (0x00000002)
 
typedef struct
{
    NvU32   version;               
    NvU32   capsTbl;               
    NvU8    lowestNvlinkVersion;   
    NvU8    highestNvlinkVersion;  
    NvU8    lowestNciVersion;      
    NvU8    highestNciVersion;     
    NvU32   linkMask;              
}NVLINK_GET_CAPS_V1;
 
typedef NVLINK_GET_CAPS_V1 NVLINK_GET_CAPS;
#define NVLINK_GET_CAPS_VER1 MAKE_NVAPI_VERSION(NVLINK_GET_CAPS_V1, 1)
 
#define NVLINK_GET_CAPS_VER NVLINK_GET_CAPS_VER1
//
// FUNCTION NAME:    NvAPI_GPU_NVLINK_GetCaps
//
NVAPI_INTERFACE NvAPI_GPU_NVLINK_GetCaps(__in NvPhysicalGpuHandle hPhysicalGpu, __inout NVLINK_GET_CAPS *capsParams);
 
 
 
#define NVAPI_NVLINK_DEVICE_INFO_DEVICE_ID_FLAGS_NONE   (0x00000000)
#define NVAPI_NVLINK_DEVICE_INFO_DEVICE_ID_FLAGS_PCI    (0x00000001)
#define NVAPI_NVLINK_DEVICE_INFO_DEVICE_ID_FLAGS_UUID   (0x00000002)
 
typedef enum _NVAPI_NVLINK_DEVICE_INFO_DEVICE_TYPE
{
    NVAPI_NVLINK_DEVICE_INFO_DEVICE_TYPE_EBRIDGE,
    NVAPI_NVLINK_DEVICE_INFO_DEVICE_TYPE_NPU,
    NVAPI_NVLINK_DEVICE_INFO_DEVICE_TYPE_GPU,
    NVAPI_NVLINK_DEVICE_INFO_DEVICE_TYPE_SWITCH,
    NVAPI_NVLINK_DEVICE_INFO_DEVICE_TYPE_TEGRA,
    NVAPI_NVLINK_DEVICE_INFO_DEVICE_TYPE_NONE,
    NVAPI_NVLINK_DEVICE_INFO_DEVICE_UUID_INVALID,
} NVAPI_NVLINK_DEVICE_INFO_DEVICE_TYPE;
 
typedef struct
{
    NvU32  deviceIdFlags;    
    NvU16  domain;           
    NvU16  bus;
    NvU16  device;
    NvU16  function;
    NvU32  pciDeviceId;
    NvU64  deviceType;       
    NvU8   deviceUUID[16];   
}NVLINK_DEVICE_INFO_V1;
 
typedef enum _NVAPI_NVLINK_STATUS_LINK_STATE
{
    NVAPI_NVLINK_STATUS_LINK_STATE_UNKNOWN,
    NVAPI_NVLINK_STATUS_LINK_STATE_INIT,
    NVAPI_NVLINK_STATUS_LINK_STATE_HWCFG,
    NVAPI_NVLINK_STATUS_LINK_STATE_SWCFG,
    NVAPI_NVLINK_STATUS_LINK_STATE_ACTIVE,
    NVAPI_NVLINK_STATUS_LINK_STATE_FAULT,
    NVAPI_NVLINK_STATUS_LINK_STATE_RECOVERY,
    NVAPI_NVLINK_STATUS_LINK_STATE_RECOVERY_AC,
    NVAPI_NVLINK_STATUS_LINK_STATE_RECOVERY_AX,
    NVAPI_NVLINK_STATUS_LINK_STATE_INVALID = 0xFFFFFFFF,
}NVAPI_NVLINK_STATUS_LINK_STATE;
 
typedef enum _NVAPI_NVLINK_STATUS_SUBLINK_RX_STATE
{
    NVAPI_NVLINK_STATUS_SUBLINK_RX_STATE_UNKNOWN,
    NVAPI_NVLINK_STATUS_SUBLINK_RX_STATE_HIGH_SPEED_1,
    NVAPI_NVLINK_STATUS_SUBLINK_RX_STATE_LOW_POWER,
    NVAPI_NVLINK_STATUS_SUBLINK_RX_STATE_TRAINING,
    NVAPI_NVLINK_STATUS_SUBLINK_RX_STATE_SAFE_MODE,
    NVAPI_NVLINK_STATUS_SUBLINK_RX_STATE_OFF,
    NVAPI_NVLINK_STATUS_SUBLINK_RX_STATE_TEST,
    NVAPI_NVLINK_STATUS_SUBLINK_RX_STATE_FAULT,
    NVAPI_NVLINK_STATUS_SUBLINK_RX_STATE_INVALID = 0xFF,
}NVAPI_NVLINK_STATUS_SUBLINK_RX_STATE;
 
typedef enum _NVAPI_NVLINK_STATUS_SUBLINK_TX_STATE
{
    NVAPI_NVLINK_STATUS_SUBLINK_TX_STATE_UNKNOWN,
    NVAPI_NVLINK_STATUS_SUBLINK_TX_STATE_HIGH_SPEED_1,
    NVAPI_NVLINK_STATUS_SUBLINK_TX_STATE_LOW_POWER,
    NVAPI_NVLINK_STATUS_SUBLINK_TX_STATE_TRAINING,
    NVAPI_NVLINK_STATUS_SUBLINK_TX_STATE_SAFE_MODE,
    NVAPI_NVLINK_STATUS_SUBLINK_TX_STATE_OFF,
    NVAPI_NVLINK_STATUS_SUBLINK_TX_STATE_TEST,
    NVAPI_NVLINK_STATUS_SUBLINK_TX_STATE_FAULT,
 
    NVAPI_NVLINK_STATUS_SUBLINK_TX_STATE_INVALID= 0xFF,
} NVAPI_NVLINK_STATUS_SUBLINK_TX_STATE;
 
 
#define NVAPI_NVLINK_STATUS_PHY_NVHS                      (0x00000001)
#define NVAPI_NVLINK_STATUS_PHY_GRS                       (0x00000002)
#define NVAPI_NVLINK_STATUS_PHY_INVALID                   (0x000000FF)
 
#define NVAPI_NVLINK_STATUS_NVLINK_VERSION_1_0            (0x00000001)
#define NVAPI_NVLINK_STATUS_NVLINK_VERSION_2_0            (0x00000002)
#define NVAPI_NVLINK_STATUS_NVLINK_VERSION_INVALID        (0x000000FF)
 
#define NVAPI_NVLINK_STATUS_NCI_VERSION_1_0               (0x00000001)
#define NVAPI_NVLINK_STATUS_NCI_VERSION_2_0               (0x00000002)
#define NVAPI_NVLINK_STATUS_NCI_VERSION_INVALID           (0x000000FF)
 
#define NVAPI_NVLINK_STATUS_NVHS_VERSION_1_0              (0x00000001)
#define NVAPI_NVLINK_STATUS_NVHS_VERSION_INVALID          (0x000000FF)
 
#define NVAPI_NVLINK_STATUS_GRS_VERSION_1_0               (0x00000001)
#define NVAPI_NVLINK_STATUS_GRS_VERSION_INVALID           (0x000000FF)
 
#define NVAPI_NVLINK_STATUS_CONNECTED_TRUE                (0x00000001)
#define NVAPI_NVLINK_STATUS_CONNECTED_FALSE               (0x00000000)
 
#define NVAPI_NVLINK_STATUS_LOOP_PROPERTY_LOOPBACK        (0x00000001)
#define NVAPI_NVLINK_STATUS_LOOP_PROPERTY_LOOPOUT         (0x00000002)
#define NVAPI_NVLINK_STATUS_LOOP_PROPERTY_NONE            (0x00000000)
 
#define NVAPI_NVLINK_STATUS_REMOTE_LINK_NUMBER_INVALID    (0x000000FF)
 
#define NVAPI_NVLINK_REFCLK_TYPE_INVALID                  (0x00)
#define NVAPI_NVLINK_REFCLK_TYPE_NVHS                     (0x01)
#define NVAPI_NVLINK_REFCLK_TYPE_PEX                      (0x02)
 
 
typedef struct
{
    NvU32   capsTbl;                                
    NvU8    phyType;                                
    NvU8    subLinkWidth;                           
    NvU32   linkState;                              
    NvU8    rxSublinkStatus;                        
    NvU8    txSublinkStatus;                        
    NvU8    nvlinkVersion;                          
    NvU8    nciVersion;                             
    NvU8    phyVersion;                             
    NvU32   nvlinkCommonClockSpeedMhz;              
    NvU32   nvlinkRefClkSpeedMhz;                   
    NvU8    nvlinkRefClkType;                       
    NvU32   nvlinkLinkClockMhz;                     
    NvU32   connected:1 ;                           
    NvU32   reserved:31;                            
    NvU8    loopProperty;                           
    NvU8    remoteDeviceLinkNumber;                 
    NVLINK_DEVICE_INFO_V1 remoteDeviceInfo;         
}NVLINK_LINK_STATUS_INFO_V1;
 
typedef struct
{
    NvU32   capsTbl;                                
    NvU8    phyType;                                
    NvU8    subLinkWidth;                           
    NvU32   linkState;                              
    NvU8    rxSublinkStatus;                        
    NvU8    txSublinkStatus;                        
    NvU8    nvlinkVersion;                          
    NvU8    nciVersion;                             
    NvU8    phyVersion;                             
    NvU32   nvlinkCommonClockSpeedMhz;              
    NvU32   nvlinkRefClkSpeedMhz;                   
    NvU8    nvlinkRefClkType;                       
    NvU32   nvlinkLinkClockMhz;                     
    NvU32   connected:1 ;                           
    NvU32   reserved:31;                            
    NvU8    loopProperty;                           
    NvU8    remoteDeviceLinkNumber;                 
    NVLINK_DEVICE_INFO_V1 remoteDeviceInfo;         
    NvU8    localDeviceLinkNumber;                  
    NVLINK_DEVICE_INFO_V1 localDeviceInfo;          
    NvU32   nvlinkLineRateMbps;                     
    NvU32   reservedEx[8];                          
}NVLINK_LINK_STATUS_INFO_V2;
 
typedef struct
{
    NvU32 version;                                                        
    NvU32 linkMask;                                                       
    NVLINK_LINK_STATUS_INFO_V1 linkInfo[NVAPI_NVLINK_MAX_LINKS];          
}NVLINK_GET_STATUS_V1;
 
typedef struct
{
    NvU32 version;                                                        
    NvU32 linkMask;                                                       
    NVLINK_LINK_STATUS_INFO_V2 linkInfo[NVAPI_NVLINK_MAX_LINKS];          
}NVLINK_GET_STATUS_V2;
 
 
typedef NVLINK_GET_STATUS_V2   NVLINK_GET_STATUS;
#define NVLINK_GET_STATUS_VER1 MAKE_NVAPI_VERSION(NVLINK_GET_STATUS_V1, 1)
#define NVLINK_GET_STATUS_VER2 MAKE_NVAPI_VERSION(NVLINK_GET_STATUS_V2, 2)
 
#define NVLINK_GET_STATUS_VER NVLINK_GET_STATUS_VER2
//
// FUNCTION NAME:    NvAPI_GPU_NVLINK_GetStatus
//
NVAPI_INTERFACE NvAPI_GPU_NVLINK_GetStatus(__in NvPhysicalGpuHandle hPhysicalGpu, __inout NVLINK_GET_STATUS* statusParams);
 
 
typedef struct _NV_GPU_INFO_V1
{
    NvU32 version;                            
    NvU32 bIsExternalGpu:1;                   
    NvU32 reserved:31;                        
} NV_GPU_INFO_V1;
 
typedef struct _NV_GPU_INFO_V2
{
    NvU32 version;                            
    NvU32 bIsExternalGpu:1;                   
    NvU32 reserved0:31;                       
    NvU64 reserved1;                          
    NvU32 rayTracingCores;                    
    NvU32 tensorCores;                        
    NvU32 reserved2[14];                      
} NV_GPU_INFO_V2;
 
#define NV_GPU_INFO_VER1             MAKE_NVAPI_VERSION(NV_GPU_INFO_V1, 1)
#define NV_GPU_INFO_VER2             MAKE_NVAPI_VERSION(NV_GPU_INFO_V2, 2)
#define NV_GPU_INFO_VER              NV_GPU_INFO_VER2
typedef NV_GPU_INFO_V2               NV_GPU_INFO;
 
//
// FUNCTION NAME: NvAPI_GPU_GetGPUInfo
//
NVAPI_INTERFACE NvAPI_GPU_GetGPUInfo(__in NvPhysicalGpuHandle hPhysicalGpu, __inout NV_GPU_INFO *pGpuInfo);
 
 
 
typedef struct _NV_GPU_VR_READY_V1
{
    NvU32  version;                            
    NvU32  isVRReady : 1;                      
    NvU32  reserved  : 31;
} NV_GPU_VR_READY_V1;
 
#define NV_GPU_VR_READY_VER1             MAKE_NVAPI_VERSION(NV_GPU_VR_READY_V1, 1)
#define NV_GPU_VR_READY_VER              NV_GPU_VR_READY_VER1
typedef NV_GPU_VR_READY_V1               NV_GPU_VR_READY;
 
//
// FUNCTION NAME: NvAPI_GPU_GetVRReadyData
//
NVAPI_INTERFACE NvAPI_GPU_GetVRReadyData(__in NvPhysicalGpuHandle hPhysicalGpu, __inout NV_GPU_VR_READY *pGpuVrReadyData);
 
typedef enum _NVAPI_GPU_PERF_DECREASE
{
    NV_GPU_PERF_DECREASE_NONE                        = 0,          
    NV_GPU_PERF_DECREASE_REASON_THERMAL_PROTECTION   = 0x00000001, 
    NV_GPU_PERF_DECREASE_REASON_POWER_CONTROL        = 0x00000002, 
    NV_GPU_PERF_DECREASE_REASON_AC_BATT              = 0x00000004, 
    NV_GPU_PERF_DECREASE_REASON_API_TRIGGERED        = 0x00000008, 
    NV_GPU_PERF_DECREASE_REASON_INSUFFICIENT_POWER   = 0x00000010, 
    NV_GPU_PERF_DECREASE_REASON_UNKNOWN              = 0x80000000, 
} NVAPI_GPU_PERF_DECREASE;
 
 
//
// FUNCTION NAME: NvAPI_GPU_GetPerfDecreaseInfo
//
NVAPI_INTERFACE NvAPI_GPU_GetPerfDecreaseInfo(__in NvPhysicalGpuHandle hPhysicalGpu, __inout NvU32 *pPerfDecrInfo);
 
 
typedef struct
{
    NvU32   version;
    NvU32   flags;           
    NvU32   numPstates;      
    NvU32   numClocks;       
    struct
    {
        NV_GPU_PERF_PSTATE_ID   pstateId; 
        NvU32                   flags;    
        struct
        {
            NV_GPU_PUBLIC_CLOCK_ID           domainId;  
            NvU32                               flags;  
            NvU32                                freq;  
 
        } clocks[NVAPI_MAX_GPU_PERF_CLOCKS];
    } pstates[NVAPI_MAX_GPU_PERF_PSTATES];
 
} NV_GPU_PERF_PSTATES_INFO_V1;
 
 
typedef struct
{
    NvU32   version;
    NvU32   flags;             
    NvU32   numPstates;        
    NvU32   numClocks;         
    NvU32   numVoltages;
    struct
    {
        NV_GPU_PERF_PSTATE_ID   pstateId;  
        NvU32                   flags;     
        struct
        {
            NV_GPU_PUBLIC_CLOCK_ID            domainId;
            NvU32                                flags; 
            NvU32                                 freq;
 
        } clocks[NVAPI_MAX_GPU_PERF_CLOCKS];
        struct
        {
            NV_GPU_PERF_VOLTAGE_INFO_DOMAIN_ID domainId; 
            NvU32                       flags;           
            NvU32                       mvolt;           
 
        } voltages[NVAPI_MAX_GPU_PERF_VOLTAGES];
 
    } pstates[NVAPI_MAX_GPU_PERF_PSTATES];  
 
} NV_GPU_PERF_PSTATES_INFO_V2;
 
typedef  NV_GPU_PERF_PSTATES_INFO_V2 NV_GPU_PERF_PSTATES_INFO;
 
 
 
#define NV_GPU_PERF_PSTATES_INFO_VER1  MAKE_NVAPI_VERSION(NV_GPU_PERF_PSTATES_INFO_V1,1)
 
#define NV_GPU_PERF_PSTATES_INFO_VER2  MAKE_NVAPI_VERSION(NV_GPU_PERF_PSTATES_INFO_V2,2)
 
#define NV_GPU_PERF_PSTATES_INFO_VER3  MAKE_NVAPI_VERSION(NV_GPU_PERF_PSTATES_INFO_V2,3)
 
#define NV_GPU_PERF_PSTATES_INFO_VER   NV_GPU_PERF_PSTATES_INFO_VER3
 
 
//
// FUNCTION NAME:   NvAPI_GPU_GetPstatesInfoEx
//
__nvapi_deprecated_function("Do not use this function - it is deprecated in release 304. Instead, use NvAPI_GPU_GetPstates20.")
NVAPI_INTERFACE NvAPI_GPU_GetPstatesInfoEx(NvPhysicalGpuHandle hPhysicalGpu, NV_GPU_PERF_PSTATES_INFO *pPerfPstatesInfo, NvU32 inputFlags);
 
 
//
// FUNCTION NAME:   NvAPI_GPU_GetPstates20
//
NVAPI_INTERFACE NvAPI_GPU_GetPstates20(__in NvPhysicalGpuHandle hPhysicalGpu, __inout NV_GPU_PERF_PSTATES20_INFO *pPstatesInfo);
 
//
// FUNCTION NAME:   NvAPI_GPU_GetCurrentPstate
//
NVAPI_INTERFACE NvAPI_GPU_GetCurrentPstate(NvPhysicalGpuHandle hPhysicalGpu, NV_GPU_PERF_PSTATE_ID *pCurrentPstate);
 
 
 
 
#define NVAPI_MAX_GPU_UTILIZATIONS 8
 
 
 
typedef struct
{
    NvU32       version;        
    NvU32       flags;          
    struct
    {
        NvU32   bIsPresent:1;   
        NvU32   percentage;     
    } utilization[NVAPI_MAX_GPU_UTILIZATIONS];
} 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
//
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
 
#define NVAPI_MAX_THERMAL_SENSORS_PER_GPU 3
 
typedef enum
{
    NVAPI_THERMAL_TARGET_NONE          = 0,
    NVAPI_THERMAL_TARGET_GPU           = 1,     
    NVAPI_THERMAL_TARGET_MEMORY        = 2,     
    NVAPI_THERMAL_TARGET_POWER_SUPPLY  = 4,     
    NVAPI_THERMAL_TARGET_BOARD         = 8,     
    NVAPI_THERMAL_TARGET_VCD_BOARD     = 9,     
    NVAPI_THERMAL_TARGET_VCD_INLET     = 10,    
    NVAPI_THERMAL_TARGET_VCD_OUTLET    = 11,    
 
    NVAPI_THERMAL_TARGET_ALL           = 15,
    NVAPI_THERMAL_TARGET_UNKNOWN       = -1,
} NV_THERMAL_TARGET;
 
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;
 
typedef struct
{
    NvU32   version;                
    NvU32   count;                  
    struct
    {
        NV_THERMAL_CONTROLLER       controller;        
        NvU32                       defaultMinTemp;    
        NvU32                       defaultMaxTemp;    
        NvU32                       currentTemp;       
        NV_THERMAL_TARGET           target;            
    } sensor[NVAPI_MAX_THERMAL_SENSORS_PER_GPU];
 
} NV_GPU_THERMAL_SETTINGS_V1;
 
typedef struct
{
    NvU32   version;                
    NvU32   count;                  
    struct
    {
        NV_THERMAL_CONTROLLER       controller;         
        NvS32                       defaultMinTemp;     
        NvS32                       defaultMaxTemp;     
        NvS32                       currentTemp;        
        NV_THERMAL_TARGET           target;             
    } sensor[NVAPI_MAX_THERMAL_SENSORS_PER_GPU];
 
} NV_GPU_THERMAL_SETTINGS_V2;
 
typedef NV_GPU_THERMAL_SETTINGS_V2  NV_GPU_THERMAL_SETTINGS;
 
 
#define NV_GPU_THERMAL_SETTINGS_VER_1   MAKE_NVAPI_VERSION(NV_GPU_THERMAL_SETTINGS_V1,1)
 
#define NV_GPU_THERMAL_SETTINGS_VER_2   MAKE_NVAPI_VERSION(NV_GPU_THERMAL_SETTINGS_V2,2)
 
#define NV_GPU_THERMAL_SETTINGS_VER     NV_GPU_THERMAL_SETTINGS_VER_2
 
 
//
// FUNCTION NAME:   NvAPI_GPU_GetThermalSettings
//
NVAPI_INTERFACE NvAPI_GPU_GetThermalSettings(NvPhysicalGpuHandle hPhysicalGpu, NvU32 sensorIndex, NV_GPU_THERMAL_SETTINGS *pThermalSettings);
 
 
 
typedef struct
{
    NvU32   version;    
    NvU32   reserved;   
    struct
    {
        NvU32 bIsPresent:1;         
        NvU32 reserved:31;          
        NvU32 frequency;            
    }domain[NVAPI_MAX_GPU_PUBLIC_CLOCKS];
} NV_GPU_CLOCK_FREQUENCIES_V1;
 
#ifndef NV_GPU_MAX_CLOCK_FREQUENCIES
    #define NV_GPU_MAX_CLOCK_FREQUENCIES 3
#endif
 
typedef enum
{
    NV_GPU_CLOCK_FREQUENCIES_CURRENT_FREQ                = 0,
    NV_GPU_CLOCK_FREQUENCIES_BASE_CLOCK                  = 1,
    NV_GPU_CLOCK_FREQUENCIES_BOOST_CLOCK                 = 2,
    NV_GPU_CLOCK_FREQUENCIES_CLOCK_TYPE_NUM              = NV_GPU_MAX_CLOCK_FREQUENCIES
}   NV_GPU_CLOCK_FREQUENCIES_CLOCK_TYPE;
 
typedef struct
{
    NvU32   version;        
    NvU32   ClockType:4;    
    NvU32   reserved:20;    
    NvU32   reserved1:8;    
    struct
    {
        NvU32 bIsPresent:1;         
        NvU32 reserved:31;          
        NvU32 frequency;            
    }domain[NVAPI_MAX_GPU_PUBLIC_CLOCKS];
} NV_GPU_CLOCK_FREQUENCIES_V2;
 
typedef NV_GPU_CLOCK_FREQUENCIES_V2 NV_GPU_CLOCK_FREQUENCIES;
 
#define NV_GPU_CLOCK_FREQUENCIES_VER_1    MAKE_NVAPI_VERSION(NV_GPU_CLOCK_FREQUENCIES_V1,1)
#define NV_GPU_CLOCK_FREQUENCIES_VER_2    MAKE_NVAPI_VERSION(NV_GPU_CLOCK_FREQUENCIES_V2,2)
#define NV_GPU_CLOCK_FREQUENCIES_VER_3    MAKE_NVAPI_VERSION(NV_GPU_CLOCK_FREQUENCIES_V2,3)
#define NV_GPU_CLOCK_FREQUENCIES_VER      NV_GPU_CLOCK_FREQUENCIES_VER_3
 
//
// FUNCTION NAME: NvAPI_GPU_GetAllClockFrequencies
//
NVAPI_INTERFACE NvAPI_GPU_GetAllClockFrequencies(__in NvPhysicalGpuHandle hPhysicalGPU, __inout NV_GPU_CLOCK_FREQUENCIES *pClkFreqs);
 
 
//
 
typedef enum _NV_GPU_ILLUMINATION_ATTRIB
{
    NV_GPU_IA_LOGO_BRIGHTNESS  = 0,
    NV_GPU_IA_SLI_BRIGHTNESS   = 1,
} NV_GPU_ILLUMINATION_ATTRIB;
 
typedef struct _NV_GPU_QUERY_ILLUMINATION_SUPPORT_PARM_V1 {
 
    // IN
    NvU32   version;                        
    NvPhysicalGpuHandle hPhysicalGpu;       
    NV_GPU_ILLUMINATION_ATTRIB Attribute;   
 
    // OUT
    NvU32    bSupported;                    
 
} NV_GPU_QUERY_ILLUMINATION_SUPPORT_PARM_V1;
 
typedef NV_GPU_QUERY_ILLUMINATION_SUPPORT_PARM_V1      NV_GPU_QUERY_ILLUMINATION_SUPPORT_PARM;
#define NV_GPU_QUERY_ILLUMINATION_SUPPORT_PARM_VER_1   MAKE_NVAPI_VERSION(NV_GPU_QUERY_ILLUMINATION_SUPPORT_PARM_V1,1)
#define NV_GPU_QUERY_ILLUMINATION_SUPPORT_PARM_VER     NV_GPU_QUERY_ILLUMINATION_SUPPORT_PARM_VER_1
 
NVAPI_INTERFACE NvAPI_GPU_QueryIlluminationSupport(__inout NV_GPU_QUERY_ILLUMINATION_SUPPORT_PARM *pIlluminationSupportInfo);
 
 
 
 
//
 
typedef struct _NV_GPU_GET_ILLUMINATION_PARM_V1 {
 
    // IN
    NvU32   version;                        
    NvPhysicalGpuHandle hPhysicalGpu;       
    NV_GPU_ILLUMINATION_ATTRIB Attribute;   
 
    // OUT
    NvU32    Value;                         
 
} NV_GPU_GET_ILLUMINATION_PARM_V1;
 
typedef NV_GPU_GET_ILLUMINATION_PARM_V1      NV_GPU_GET_ILLUMINATION_PARM;
#define NV_GPU_GET_ILLUMINATION_PARM_VER_1   MAKE_NVAPI_VERSION(NV_GPU_GET_ILLUMINATION_PARM_V1,1)
#define NV_GPU_GET_ILLUMINATION_PARM_VER     NV_GPU_GET_ILLUMINATION_PARM_VER_1
 
NVAPI_INTERFACE NvAPI_GPU_GetIllumination(NV_GPU_GET_ILLUMINATION_PARM *pIlluminationInfo);
 
 
 
 
//
 
typedef struct _NV_GPU_SET_ILLUMINATION_PARM_V1 {
 
    // IN
    NvU32   version;                        
    NvPhysicalGpuHandle hPhysicalGpu;       
    NV_GPU_ILLUMINATION_ATTRIB Attribute;   
    NvU32    Value;                         
 
    // OUT
 
} NV_GPU_SET_ILLUMINATION_PARM_V1;
 
typedef NV_GPU_SET_ILLUMINATION_PARM_V1      NV_GPU_SET_ILLUMINATION_PARM;
#define NV_GPU_SET_ILLUMINATION_PARM_VER_1   MAKE_NVAPI_VERSION(NV_GPU_SET_ILLUMINATION_PARM_V1,1)
#define NV_GPU_SET_ILLUMINATION_PARM_VER     NV_GPU_SET_ILLUMINATION_PARM_VER_1
 
NVAPI_INTERFACE NvAPI_GPU_SetIllumination(NV_GPU_SET_ILLUMINATION_PARM *pIlluminationInfo);
 
 
 
typedef enum
{
    NV_GPU_CLIENT_ILLUM_CTRL_MODE_MANUAL_RGB = 0,       // deprecated
    NV_GPU_CLIENT_ILLUM_CTRL_MODE_PIECEWISE_LINEAR_RGB, // deprecated
 
    NV_GPU_CLIENT_ILLUM_CTRL_MODE_MANUAL = 0,        
    NV_GPU_CLIENT_ILLUM_CTRL_MODE_PIECEWISE_LINEAR,
 
    // Strictly add new control modes above this.
    NV_GPU_CLIENT_ILLUM_CTRL_MODE_INVALID = 0xFF,
} NV_GPU_CLIENT_ILLUM_CTRL_MODE;
 
typedef enum
{
    NV_GPU_CLIENT_ILLUM_ZONE_LOCATION_GPU_TOP_0   = 0x00,
    NV_GPU_CLIENT_ILLUM_ZONE_LOCATION_GPU_FRONT_0 = 0x08,
    NV_GPU_CLIENT_ILLUM_ZONE_LOCATION_GPU_BACK_0  = 0x0C,
    NV_GPU_CLIENT_ILLUM_ZONE_LOCATION_SLI_TOP_0   = 0x20,
    NV_GPU_CLIENT_ILLUM_ZONE_LOCATION_INVALID     = 0xFFFFFFFF,
} NV_GPU_CLIENT_ILLUM_ZONE_LOCATION;
 
typedef enum
{
    NV_GPU_CLIENT_ILLUM_DEVICE_TYPE_INVALID = 0,
    NV_GPU_CLIENT_ILLUM_DEVICE_TYPE_MCUV10,
    NV_GPU_CLIENT_ILLUM_DEVICE_TYPE_GPIO_PWM_RGBW_V10,
    NV_GPU_CLIENT_ILLUM_DEVICE_TYPE_GPIO_PWM_SINGLE_COLOR_V10,
} NV_GPU_CLIENT_ILLUM_DEVICE_TYPE;
 
typedef enum
{
    NV_GPU_CLIENT_ILLUM_ZONE_TYPE_INVALID = 0,
    NV_GPU_CLIENT_ILLUM_ZONE_TYPE_RGB,
    NV_GPU_CLIENT_ILLUM_ZONE_TYPE_COLOR_FIXED,
    NV_GPU_CLIENT_ILLUM_ZONE_TYPE_RGBW,
    NV_GPU_CLIENT_ILLUM_ZONE_TYPE_SINGLE_COLOR,
} NV_GPU_CLIENT_ILLUM_ZONE_TYPE;
 
#define NV_GPU_CLIENT_ILLUM_CTRL_MODE_PIECEWISE_LINEAR_COLOR_ENDPOINTS           2
 
typedef enum
{
    NV_GPU_CLIENT_ILLUM_PIECEWISE_LINEAR_CYCLE_HALF_HALT = 0,
    NV_GPU_CLIENT_ILLUM_PIECEWISE_LINEAR_CYCLE_FULL_HALT,
    NV_GPU_CLIENT_ILLUM_PIECEWISE_LINEAR_CYCLE_FULL_REPEAT,
    NV_GPU_CLIENT_ILLUM_PIECEWISE_LINEAR_CYCLE_INVALID = 0xFF,
} NV_GPU_CLIENT_ILLUM_PIECEWISE_LINEAR_CYCLE_TYPE;
 
#define NV_GPU_CLIENT_ILLUM_DEVICE_NUM_DEVICES_MAX 32
 
typedef struct _NV_GPU_CLIENT_ILLUM_DEVICE_INFO_DATA_MCUV10
{
    NvU8 i2cDevIdx;
} NV_GPU_CLIENT_ILLUM_DEVICE_INFO_DATA_MCUV10;
 
typedef struct _NV_GPU_CLIENT_ILLUM_DEVICE_INFO_DATA_GPIO_PWM_RGBW
{
    NvU8 gpioPinRed;
 
    NvU8 gpioPinGreen;
 
    NvU8 gpioPinBlue;
 
    NvU8 gpioPinWhite;
} NV_GPU_CLIENT_ILLUM_DEVICE_INFO_DATA_GPIO_PWM_RGBW;
typedef struct _NV_GPU_CLIENT_ILLUM_DEVICE_INFO_DATA_GPIO_PWM_SINGLE_COLOR
{
    NvU8 gpioPinSingleColor;
} NV_GPU_CLIENT_ILLUM_DEVICE_INFO_DATA_GPIO_PWM_SINGLE_COLOR;
 
typedef struct _NV_GPU_CLIENT_ILLUM_DEVICE_INFO_V1
{
    NV_GPU_CLIENT_ILLUM_DEVICE_TYPE    type;
 
    NvU32                              ctrlModeMask;
 
    union
    {
        //
        // Need to be careful when add/expanding types in this union. If any type
        // exceeds sizeof(rsvd) then rsvd has failed its purpose.
        //
        NV_GPU_CLIENT_ILLUM_DEVICE_INFO_DATA_MCUV10                 mcuv10;
        NV_GPU_CLIENT_ILLUM_DEVICE_INFO_DATA_GPIO_PWM_RGBW          gpioPwmRgbwv10;
        NV_GPU_CLIENT_ILLUM_DEVICE_INFO_DATA_GPIO_PWM_SINGLE_COLOR  gpioPwmSingleColorv10;
 
        NvU8                                           rsvd[64];
    } data;
 
    NvU8    rsvd[64];
} NV_GPU_CLIENT_ILLUM_DEVICE_INFO_V1;
 
typedef struct _NV_GPU_CLIENT_ILLUM_DEVICE_INFO_PARAMS_V1
{
    NvU32       version;
 
    NvU32       numIllumDevices;
 
    NvU8        rsvd[64];
 
    NV_GPU_CLIENT_ILLUM_DEVICE_INFO_V1 devices[NV_GPU_CLIENT_ILLUM_DEVICE_NUM_DEVICES_MAX];
} NV_GPU_CLIENT_ILLUM_DEVICE_INFO_PARAMS_V1;
 
#define NV_GPU_CLIENT_ILLUM_DEVICE_INFO_PARAMS_VER_1 MAKE_NVAPI_VERSION(NV_GPU_CLIENT_ILLUM_DEVICE_INFO_PARAMS_V1, 1)
#define NV_GPU_CLIENT_ILLUM_DEVICE_INFO_PARAMS_VER   NV_GPU_CLIENT_ILLUM_DEVICE_INFO_PARAMS_VER_1
typedef NV_GPU_CLIENT_ILLUM_DEVICE_INFO_PARAMS_V1    NV_GPU_CLIENT_ILLUM_DEVICE_INFO_PARAMS;
 
//
NVAPI_INTERFACE NvAPI_GPU_ClientIllumDevicesGetInfo(__in NvPhysicalGpuHandle hPhysicalGpu, __inout NV_GPU_CLIENT_ILLUM_DEVICE_INFO_PARAMS *pIllumDevicesInfo);
 
 
typedef struct
{
    NvBool bSync;
 
    NvU64  timeStampms;
 
    NvU8    rsvd[64];
} NV_GPU_CLIENT_ILLUM_DEVICE_SYNC_V1;
 
typedef struct
{
    NV_GPU_CLIENT_ILLUM_DEVICE_TYPE    type;
 
    NV_GPU_CLIENT_ILLUM_DEVICE_SYNC_V1    syncData;
 
    NvU8    rsvd[64];
} NV_GPU_CLIENT_ILLUM_DEVICE_CONTROL_V1;
 
typedef NV_GPU_CLIENT_ILLUM_DEVICE_CONTROL_V1    NV_GPU_CLIENT_ILLUM_DEVICE_CONTROL;
 
typedef struct
{
    NvU32   version;
 
    NvU32   numIllumDevices;
 
    NvU8    rsvd[64];
 
    NV_GPU_CLIENT_ILLUM_DEVICE_CONTROL_V1 devices[NV_GPU_CLIENT_ILLUM_DEVICE_NUM_DEVICES_MAX];
} NV_GPU_CLIENT_ILLUM_DEVICE_CONTROL_PARAMS_V1;
 
#define NV_GPU_CLIENT_ILLUM_DEVICE_CONTROL_PARAMS_VER_1 MAKE_NVAPI_VERSION(NV_GPU_CLIENT_ILLUM_DEVICE_CONTROL_PARAMS_V1, 1)
#define NV_GPU_CLIENT_ILLUM_DEVICE_CONTROL_PARAMS_VER   NV_GPU_CLIENT_ILLUM_DEVICE_CONTROL_PARAMS_VER_1
typedef NV_GPU_CLIENT_ILLUM_DEVICE_CONTROL_PARAMS_V1    NV_GPU_CLIENT_ILLUM_DEVICE_CONTROL_PARAMS;
 
//
NVAPI_INTERFACE NvAPI_GPU_ClientIllumDevicesGetControl(__in NvPhysicalGpuHandle hPhysicalGpu, __inout NV_GPU_CLIENT_ILLUM_DEVICE_CONTROL_PARAMS *pClientIllumDevicesControl);
 
//
NVAPI_INTERFACE NvAPI_GPU_ClientIllumDevicesSetControl(__in NvPhysicalGpuHandle hPhysicalGpu, __inout NV_GPU_CLIENT_ILLUM_DEVICE_CONTROL_PARAMS *pClientIllumDevicesControl);
 
 
#define NV_GPU_CLIENT_ILLUM_ZONE_NUM_ZONES_MAX 32
 
typedef struct _NV_GPU_CLIENT_ILLUM_ZONE_INFO_DATA_RGB
{
    NvU8 rsvd;
} NV_GPU_CLIENT_ILLUM_ZONE_INFO_DATA_RGB;
 
typedef struct _NV_GPU_CLIENT_ILLUM_ZONE_INFO_DATA_RGBW
{
    NvU8 rsvd;
} NV_GPU_CLIENT_ILLUM_ZONE_INFO_DATA_RGBW;
 
typedef struct _NV_GPU_CLIENT_ILLUM_ZONE_INFO_DATA_SINGLE_COLOR
{
    NvU8 rsvd;
} NV_GPU_CLIENT_ILLUM_ZONE_INFO_DATA_SINGLE_COLOR;
 
typedef struct _NV_GPU_CLIENT_ILLUM_ZONE_INFO_V1
{
    NV_GPU_CLIENT_ILLUM_ZONE_TYPE      type;
 
    NvU8                               illumDeviceIdx;
 
    NvU8                                provIdx;
 
    NV_GPU_CLIENT_ILLUM_ZONE_LOCATION  zoneLocation;
 
    union
    {
        //
        // Need to be careful when add/expanding types in this union. If any type
        // exceeds sizeof(rsvd) then rsvd has failed its purpose.
        //
        NV_GPU_CLIENT_ILLUM_ZONE_INFO_DATA_RGB          rgb;
        NV_GPU_CLIENT_ILLUM_ZONE_INFO_DATA_RGBW         rgbw;
        NV_GPU_CLIENT_ILLUM_ZONE_INFO_DATA_SINGLE_COLOR singleColor;
 
        NvU8                                      rsvd[64];
    } data;
 
    NvU8    rsvd[64];
} NV_GPU_CLIENT_ILLUM_ZONE_INFO_V1;
 
typedef struct _NV_GPU_CLIENT_ILLUM_ZONE_INFO_PARAMS_V1
{
    NvU32   version;
 
    NvU32   numIllumZones;
 
    NvU8    rsvd[64];
    NV_GPU_CLIENT_ILLUM_ZONE_INFO_V1 zones[NV_GPU_CLIENT_ILLUM_ZONE_NUM_ZONES_MAX];
} NV_GPU_CLIENT_ILLUM_ZONE_INFO_PARAMS_V1;
 
#define NV_GPU_CLIENT_ILLUM_ZONE_INFO_PARAMS_VER_1 MAKE_NVAPI_VERSION(NV_GPU_CLIENT_ILLUM_ZONE_INFO_PARAMS_V1, 1)
#define NV_GPU_CLIENT_ILLUM_ZONE_INFO_PARAMS_VER   NV_GPU_CLIENT_ILLUM_ZONE_INFO_PARAMS_VER_1
typedef NV_GPU_CLIENT_ILLUM_ZONE_INFO_PARAMS_V1    NV_GPU_CLIENT_ILLUM_ZONE_INFO_PARAMS;
 
//
NVAPI_INTERFACE NvAPI_GPU_ClientIllumZonesGetInfo(__in NvPhysicalGpuHandle hPhysicalGpu, __inout NV_GPU_CLIENT_ILLUM_ZONE_INFO_PARAMS *pIllumZonesInfo);
 
 
typedef struct _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_RGB_PARAMS
{
    NvU8 colorR;
 
    NvU8 colorG;
 
    NvU8 colorB;
 
    NvU8 brightnessPct;
} NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_RGB_PARAMS;
 
typedef struct _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_RGB
{
    NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_RGB_PARAMS rgbParams;
} NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_RGB;
 
typedef struct _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR
{
    NV_GPU_CLIENT_ILLUM_PIECEWISE_LINEAR_CYCLE_TYPE    cycleType;
 
    NvU8    grpCount;
 
    NvU16   riseTimems;
 
    NvU16   fallTimems;
 
    NvU16   ATimems;
 
    NvU16   BTimems;
 
    NvU16   grpIdleTimems;
 
    NvU16   phaseOffsetms;
} NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR;
 
typedef struct _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR_RGB
{
    NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_RGB_PARAMS rgbParams[NV_GPU_CLIENT_ILLUM_CTRL_MODE_PIECEWISE_LINEAR_COLOR_ENDPOINTS];
 
    NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR  piecewiseLinearData;
} NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR_RGB;
 
typedef struct _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_RGB
{
    union
    {
        //
        // Need to be careful when add/expanding types in this union. If any type
        // exceeds sizeof(rsvd) then rsvd has failed its purpose.
        //
        NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_RGB            manualRGB;
        NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR_RGB  piecewiseLinearRGB;
 
        NvU8                                         rsvd[64];
    } data;
 
    NvU8    rsvd[64];
} NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_RGB;
 
typedef struct _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_COLOR_FIXED_PARAMS
{
    NvU8 brightnessPct;
} NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_COLOR_FIXED_PARAMS;
 
typedef struct _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_COLOR_FIXED
{
    NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_COLOR_FIXED_PARAMS colorFixedParams;
} NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_COLOR_FIXED;
 
typedef struct _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR_COLOR_FIXED
{
    NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_COLOR_FIXED_PARAMS colorFixedParams[NV_GPU_CLIENT_ILLUM_CTRL_MODE_PIECEWISE_LINEAR_COLOR_ENDPOINTS];
 
    NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR          piecewiseLinearData;
} NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR_COLOR_FIXED;
 
typedef struct _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_COLOR_FIXED
{
    union
    {
        //
        // Need to be careful when add/expanding types in this union. If any type
        // exceeds sizeof(rsvd) then rsvd has failed its purpose.
        //
        NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_COLOR_FIXED           manualColorFixed;
        NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR_COLOR_FIXED piecewiseLinearColorFixed;
        NvU8                                         rsvd[64];
    } data;
 
    NvU8    rsvd[64];
} NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_COLOR_FIXED;
 
typedef struct _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_RGBW_PARAMS
{
    NvU8 colorR;
  
    NvU8 colorG;
  
    NvU8 colorB;
  
    NvU8 colorW;
  
    NvU8 brightnessPct;
} NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_RGBW_PARAMS;
 
typedef struct _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_RGBW
{
    NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_RGBW_PARAMS rgbwParams;
} NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_RGBW;
 
typedef struct _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR_RGBW
{
    NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_RGBW_PARAMS rgbwParams[NV_GPU_CLIENT_ILLUM_CTRL_MODE_PIECEWISE_LINEAR_COLOR_ENDPOINTS];
  
    NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR  piecewiseLinearData;
} NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR_RGBW;
 
typedef struct _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_RGBW
{
    union
    {
        //
        // Need to be careful when add/expanding types in this union. If any type
        // exceeds sizeof(rsvd) then rsvd has failed its purpose.
        //
        NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_RGBW           manualRGBW;
        NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR_RGBW piecewiseLinearRGBW;
        NvU8                                         rsvd[64];
    } data;
  
    NvU8    rsvd[64];
} NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_RGBW;
 
typedef struct _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_SINGLE_COLOR_PARAMS
{
    NvU8 brightnessPct;
} NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_SINGLE_COLOR_PARAMS;
 
typedef struct _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_SINGLE_COLOR
{
    NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_SINGLE_COLOR_PARAMS singleColorParams;
} NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_SINGLE_COLOR;
 
typedef struct _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR_SINGLE_COLOR
{
    NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_SINGLE_COLOR_PARAMS singleColorParams[NV_GPU_CLIENT_ILLUM_CTRL_MODE_PIECEWISE_LINEAR_COLOR_ENDPOINTS];
  
    NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR  piecewiseLinearData;
} NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR_SINGLE_COLOR;
 
typedef struct _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_SINGLE_COLOR
{
    union
    {
        //
        // Need to be careful when add/expanding types in this union. If any type
        // exceeds sizeof(rsvd) then rsvd has failed its purpose.
        //
        NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_MANUAL_SINGLE_COLOR           manualSingleColor;
        NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_PIECEWISE_LINEAR_SINGLE_COLOR piecewiseLinearSingleColor;
        NvU8                                         rsvd[64];
    } data;
  
    NvU8    rsvd[64];
} NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_SINGLE_COLOR;
 
typedef struct _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_V1
{
    NV_GPU_CLIENT_ILLUM_ZONE_TYPE  type;
    NV_GPU_CLIENT_ILLUM_CTRL_MODE  ctrlMode;
    union
    {
        NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_RGB           rgb;
        NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_COLOR_FIXED   colorFixed;
        NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_RGBW          rgbw;
        NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_DATA_SINGLE_COLOR  singleColor;        
        NvU8                                                rsvd[64];
    } data;
    NvU8    rsvd[64];
} NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_V1;
 
typedef struct _NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_PARAMS_V1
{
    NvU32                          version;
 
    NvU32                          bDefault : 1;
    NvU32                          rsvdField : 31;
 
    NvU32   numIllumZonesControl;
 
    NvU8                           rsvd[64];
  
    NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_V1 zones[NV_GPU_CLIENT_ILLUM_ZONE_NUM_ZONES_MAX];
} NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_PARAMS_V1;
 
#define NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_PARAMS_VER_1 MAKE_NVAPI_VERSION(NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_PARAMS_V1, 1)
#define NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_PARAMS_VER   NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_PARAMS_VER_1
typedef NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_PARAMS_V1    NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_PARAMS;
 
//
NVAPI_INTERFACE NvAPI_GPU_ClientIllumZonesGetControl(__in NvPhysicalGpuHandle hPhysicalGpu, __inout NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_PARAMS *pIllumZonesControl);
 
//
NVAPI_INTERFACE NvAPI_GPU_ClientIllumZonesSetControl(__in NvPhysicalGpuHandle hPhysicalGpu, __inout NV_GPU_CLIENT_ILLUM_ZONE_CONTROL_PARAMS *pIllumZonesControl);
 
//
// FUNCTION NAME: NvAPI_Event_RegisterCallback
//
NVAPI_INTERFACE NvAPI_Event_RegisterCallback(PNV_EVENT_REGISTER_CALLBACK eventCallback,
                                             NvEventHandle* phClient);
 
//
// FUNCTION NAME: NvAPI_Event_UnregisterCallback
//
NVAPI_INTERFACE NvAPI_Event_UnregisterCallback(NvEventHandle hClient);
//
// FUNCTION NAME: NvAPI_EnumNvidiaDisplayHandle
//
NVAPI_INTERFACE NvAPI_EnumNvidiaDisplayHandle(NvU32 thisEnum, NvDisplayHandle *pNvDispHandle);
 
 
 
 
 
//
// FUNCTION NAME: NvAPI_EnumNvidiaUnAttachedDisplayHandle
//
NVAPI_INTERFACE NvAPI_EnumNvidiaUnAttachedDisplayHandle(NvU32 thisEnum, NvUnAttachedDisplayHandle *pNvUnAttachedDispHandle);
 
 
 
//
// FUNCTION NAME: NvAPI_CreateDisplayFromUnAttachedDisplay
//
NVAPI_INTERFACE NvAPI_CreateDisplayFromUnAttachedDisplay(NvUnAttachedDisplayHandle hNvUnAttachedDisp, NvDisplayHandle *pNvDisplay);
 
//
// FUNCTION NAME: NvAPI_GetAssociatedNVidiaDisplayHandle
//
NVAPI_INTERFACE NvAPI_GetAssociatedNvidiaDisplayHandle(const char *szDisplayName, NvDisplayHandle *pNvDispHandle);
 
 
//
// FUNCTION NAME: NvAPI_DISP_GetAssociatedUnAttachedNvidiaDisplayHandle
//
NVAPI_INTERFACE NvAPI_DISP_GetAssociatedUnAttachedNvidiaDisplayHandle(const char *szDisplayName, NvUnAttachedDisplayHandle *pNvUnAttachedDispHandle);
 
 
 
//
// FUNCTION NAME: NvAPI_GetAssociatedNVidiaDisplayName
//
NVAPI_INTERFACE NvAPI_GetAssociatedNvidiaDisplayName(NvDisplayHandle NvDispHandle, NvAPI_ShortString szDisplayName);
 
//
// FUNCTION NAME: NvAPI_GetUnAttachedAssociatedDisplayName
//
NVAPI_INTERFACE NvAPI_GetUnAttachedAssociatedDisplayName(NvUnAttachedDisplayHandle hNvUnAttachedDisp, NvAPI_ShortString szDisplayName);
 
 
//
// FUNCTION NAME: NvAPI_EnableHWCursor
//
NVAPI_INTERFACE NvAPI_EnableHWCursor(NvDisplayHandle hNvDisplay);
 
//
// FUNCTION NAME: NvAPI_DisableHWCursor
//
NVAPI_INTERFACE NvAPI_DisableHWCursor(NvDisplayHandle hNvDisplay);
 
//
// FUNCTION NAME: NvAPI_GetVBlankCounter
//
NVAPI_INTERFACE NvAPI_GetVBlankCounter(NvDisplayHandle hNvDisplay, NvU32 *pCounter);
 
// FUNCTION NAME:  NvAPI_SetRefreshRateOverride
//
NVAPI_INTERFACE NvAPI_SetRefreshRateOverride(NvDisplayHandle hNvDisplay, NvU32 outputsMask, float refreshRate, NvU32 bSetDeferred);
 
//
// FUNCTION NAME: NvAPI_GetAssociatedDisplayOutputId
//
NVAPI_INTERFACE NvAPI_GetAssociatedDisplayOutputId(NvDisplayHandle hNvDisplay, NvU32 *pOutputId);
 
 
typedef struct _NV_DISPLAY_PORT_INFO_V1
{
    NvU32               version;                                  
    NvU32               dpcd_ver;                                 
    NV_DP_LINK_RATE     maxLinkRate;                              
    NV_DP_LANE_COUNT    maxLaneCount;                             
    NV_DP_LINK_RATE     curLinkRate;                              
    NV_DP_LANE_COUNT    curLaneCount;                             
    NV_DP_COLOR_FORMAT  colorFormat;                              
    NV_DP_DYNAMIC_RANGE dynamicRange;                             
    NV_DP_COLORIMETRY   colorimetry;                              
    NV_DP_BPC           bpc;                                      
    NvU32               isDp                                : 1;  
    NvU32               isInternalDp                        : 1;  
    NvU32               isColorCtrlSupported                : 1;  
    NvU32               is6BPCSupported                     : 1;  
    NvU32               is8BPCSupported                     : 1;  
    NvU32               is10BPCSupported                    : 1;  
    NvU32               is12BPCSupported                    : 1;  
    NvU32               is16BPCSupported                    : 1;  
    NvU32               isYCrCb420Supported                 : 1;  
    NvU32               isYCrCb422Supported                 : 1;  
    NvU32               isYCrCb444Supported                 : 1;  
    NvU32               isRgb444SupportedOnCurrentMode      : 1;  
    NvU32               isYCbCr444SupportedOnCurrentMode    : 1;  
    NvU32               isYCbCr422SupportedOnCurrentMode    : 1;  
    NvU32               isYCbCr420SupportedOnCurrentMode    : 1;  
    NvU32               is6BPCSupportedOnCurrentMode        : 1;  // if 6 bpc is supported On Current Mode
    NvU32               is8BPCSupportedOnCurrentMode        : 1;  // if 8 bpc is supported On Current Mode
    NvU32               is10BPCSupportedOnCurrentMode       : 1;  // if 10 bpc is supported On Current Mode
    NvU32               is12BPCSupportedOnCurrentMode       : 1;  // if 12 bpc is supported On Current Mode
    NvU32               is16BPCSupportedOnCurrentMode       : 1;  // if 16 bpc is supported On Current Mode
    NvU32               isMonxvYCC601Capable                : 1;  // if xvYCC 601 extended colorimetry is supported
    NvU32               isMonxvYCC709Capable                : 1;  // if xvYCC 709 extended colorimetry is supported
    NvU32               isMonsYCC601Capable                 : 1;  // if sYCC601 extended colorimetry is supported
    NvU32               isMonAdobeYCC601Capable             : 1;  // if AdobeYCC601 extended colorimetry is supported
    NvU32               isMonAdobeRGBCapable                : 1;  // if AdobeRGB extended colorimetry is supported
    NvU32               isMonBT2020RGBCapable               : 1;  // if BT2020 RGB extended colorimetry is supported
    NvU32               isMonBT2020YCCCapable               : 1;  // if BT2020 Y'CbCr extended colorimetry is supported
    NvU32               isMonBT2020cYCCCapable              : 1;  // if BT2020 cYCbCr (constant luminance) extended colorimetry is supported
 
    NvU32               reserved                            : 4;  
 } NV_DISPLAY_PORT_INFO_V1;
 
 typedef NV_DISPLAY_PORT_INFO_V1 NV_DISPLAY_PORT_INFO;
 
#define NV_DISPLAY_PORT_INFO_VER1  MAKE_NVAPI_VERSION(NV_DISPLAY_PORT_INFO,1)
#define NV_DISPLAY_PORT_INFO_VER2  MAKE_NVAPI_VERSION(NV_DISPLAY_PORT_INFO,2)
#define NV_DISPLAY_PORT_INFO_VER   NV_DISPLAY_PORT_INFO_VER2
 
// FUNCTION NAME:   NvAPI_GetDisplayPortInfo
//
//
NVAPI_INTERFACE NvAPI_GetDisplayPortInfo(__in_opt NvDisplayHandle hNvDisplay, __in NvU32 outputId, __inout NV_DISPLAY_PORT_INFO *pInfo);
 
// FUNCTION NAME:   NvAPI_SetDisplayPort
//
 
 
typedef struct
{
    NvU32               version;                     
    NV_DP_LINK_RATE     linkRate;                    
    NV_DP_LANE_COUNT    laneCount;                   
    NV_DP_COLOR_FORMAT  colorFormat;                 
    NV_DP_DYNAMIC_RANGE dynamicRange;                
    NV_DP_COLORIMETRY   colorimetry;                 
    NV_DP_BPC           bpc;                         
    NvU32               isHPD               : 1;     
    NvU32               isSetDeferred       : 1;     
    NvU32               isChromaLpfOff      : 1;     
    NvU32               isDitherOff         : 1;     
    NvU32               testLinkTrain       : 1;     
    NvU32               testColorChange     : 1;     
 
} NV_DISPLAY_PORT_CONFIG;
 
#define NV_DISPLAY_PORT_CONFIG_VER   MAKE_NVAPI_VERSION(NV_DISPLAY_PORT_CONFIG,2)
#define NV_DISPLAY_PORT_CONFIG_VER_1 MAKE_NVAPI_VERSION(NV_DISPLAY_PORT_CONFIG,1)
#define NV_DISPLAY_PORT_CONFIG_VER_2 MAKE_NVAPI_VERSION(NV_DISPLAY_PORT_CONFIG,2)
 
 
NVAPI_INTERFACE NvAPI_SetDisplayPort(NvDisplayHandle hNvDisplay, NvU32 outputId, NV_DISPLAY_PORT_CONFIG *pCfg);
 
 
 
 
typedef struct _NV_HDMI_SUPPORT_INFO_V1
{
    NvU32      version;                     
 
    NvU32      isGpuHDMICapable       : 1;  
    NvU32      isMonUnderscanCapable  : 1;  
    NvU32      isMonBasicAudioCapable : 1;  
    NvU32      isMonYCbCr444Capable   : 1;  
    NvU32      isMonYCbCr422Capable   : 1;  
    NvU32      isMonxvYCC601Capable   : 1;  
    NvU32      isMonxvYCC709Capable   : 1;  
    NvU32      isMonHDMI              : 1;  
    NvU32      reserved               : 24; 
 
    NvU32      EDID861ExtRev;               
 } NV_HDMI_SUPPORT_INFO_V1;
 
typedef struct _NV_HDMI_SUPPORT_INFO_V2
{
    NvU32      version;                      
 
    NvU32      isGpuHDMICapable        : 1;  
    NvU32      isMonUnderscanCapable   : 1;  
    NvU32      isMonBasicAudioCapable  : 1;  
    NvU32      isMonYCbCr444Capable    : 1;  
    NvU32      isMonYCbCr422Capable    : 1;  
    NvU32      isMonxvYCC601Capable    : 1;  
    NvU32      isMonxvYCC709Capable    : 1;  
    NvU32      isMonHDMI               : 1;  
    NvU32      isMonsYCC601Capable     : 1;  
    NvU32      isMonAdobeYCC601Capable : 1;  
    NvU32      isMonAdobeRGBCapable    : 1;  
    NvU32      reserved                : 21; 
 
    NvU32      EDID861ExtRev;                
 } NV_HDMI_SUPPORT_INFO_V2;
 
#define NV_HDMI_SUPPORT_INFO_VER1  MAKE_NVAPI_VERSION(NV_HDMI_SUPPORT_INFO_V1, 1)
#define NV_HDMI_SUPPORT_INFO_VER2  MAKE_NVAPI_VERSION(NV_HDMI_SUPPORT_INFO_V2, 2)
 
 
 
#ifndef NV_HDMI_SUPPORT_INFO_VER
 
typedef NV_HDMI_SUPPORT_INFO_V2    NV_HDMI_SUPPORT_INFO;
#define NV_HDMI_SUPPORT_INFO_VER   NV_HDMI_SUPPORT_INFO_VER2
 
#endif
 
 
// FUNCTION NAME:   NvAPI_GetHDMISupportInfo
//
 
 
NVAPI_INTERFACE NvAPI_GetHDMISupportInfo(__in_opt NvDisplayHandle hNvDisplay, __in NvU32 outputId, __inout NV_HDMI_SUPPORT_INFO *pInfo);
 
 
 
typedef enum
{
    NV_INFOFRAME_CMD_GET_DEFAULT = 0,     
    NV_INFOFRAME_CMD_RESET,               
    NV_INFOFRAME_CMD_GET,                 
    NV_INFOFRAME_CMD_SET,                 
    NV_INFOFRAME_CMD_GET_OVERRIDE,        
    NV_INFOFRAME_CMD_SET_OVERRIDE,        
    NV_INFOFRAME_CMD_GET_PROPERTY,        
    NV_INFOFRAME_CMD_SET_PROPERTY,        
} NV_INFOFRAME_CMD;
 
 
typedef enum
{
    NV_INFOFRAME_PROPERTY_MODE_AUTO           = 0, 
    NV_INFOFRAME_PROPERTY_MODE_ENABLE,             
    NV_INFOFRAME_PROPERTY_MODE_DISABLE,            
    NV_INFOFRAME_PROPERTY_MODE_ALLOW_OVERRIDE,     
} NV_INFOFRAME_PROPERTY_MODE;
 
 
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;
 
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;
 
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;
 
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;
 
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;
 
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;
 
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;
 
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;
 
 
 
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;
 
 
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;
 
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; 
    NvU16 size;    
    NvU8  cmd;     
    NvU8  type;    
 
    union
    {
        NV_INFOFRAME_PROPERTY     property;  
        NV_INFOFRAME_AUDIO        audio;
        NV_INFOFRAME_VIDEO        video;
    } infoframe;
} NV_INFOFRAME_DATA;
 
#define NV_INFOFRAME_DATA_VER   MAKE_NVAPI_VERSION(NV_INFOFRAME_DATA,1)
 
// FUNCTION NAME:   NvAPI_Disp_InfoFrameControl
//
NVAPI_INTERFACE NvAPI_Disp_InfoFrameControl(__in NvU32 displayId, __inout NV_INFOFRAME_DATA *pInfoframeData);
 
 
 
 
 
 
// FUNCTION NAME:   NvAPI_Disp_ColorControl
//
//
 
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;
 
typedef enum
{
    NV_COLOR_FORMAT_RGB             = 0,
    NV_COLOR_FORMAT_YUV422,
    NV_COLOR_FORMAT_YUV444,
    NV_COLOR_FORMAT_YUV420,
 
    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_BT2020RGB,
    NV_COLOR_COLORIMETRY_BT2020YCC,
    NV_COLOR_COLORIMETRY_BT2020cYCC,
 
    NV_COLOR_COLORIMETRY_DEFAULT         = 0xFE,
    NV_COLOR_COLORIMETRY_AUTO            = 0xFF
} NV_COLOR_COLORIMETRY;
 
typedef enum _NV_DYNAMIC_RANGE
{
    NV_DYNAMIC_RANGE_VESA     = 0x0,
    NV_DYNAMIC_RANGE_CEA      = 0x1,
 
    NV_DYNAMIC_RANGE_AUTO     = 0xFF
} NV_DYNAMIC_RANGE;
 
typedef enum _NV_BPC
{
    NV_BPC_DEFAULT         = 0,
    NV_BPC_6               = 1,
    NV_BPC_8               = 2,
    NV_BPC_10              = 3,
    NV_BPC_12              = 4,
    NV_BPC_16              = 5,
} NV_BPC;
 
typedef enum _NV_COLOR_SELECTION_POLICY
{
     NV_COLOR_SELECTION_POLICY_USER     = 0,     
     NV_COLOR_SELECTION_POLICY_BEST_QUALITY = 1, 
     NV_COLOR_SELECTION_POLICY_DEFAULT = NV_COLOR_SELECTION_POLICY_BEST_QUALITY,
     NV_COLOR_SELECTION_POLICY_UNKNOWN = 0xFF,
} NV_COLOR_SELECTION_POLICY;
 
typedef enum _NV_DESKTOP_COLOR_DEPTH
{
  NV_DESKTOP_COLOR_DEPTH_DEFAULT         = 0x0,                                    // set if the current setting should be kept
  NV_DESKTOP_COLOR_DEPTH_8BPC            = 0x1,                                    //8 bit int per color component (8 bit int alpha)
  NV_DESKTOP_COLOR_DEPTH_10BPC           = 0x2,                                    //10 bit int per color component (2 bit int alpha)
  NV_DESKTOP_COLOR_DEPTH_16BPC_FLOAT     = 0x3,                                    //16 bit float per color component (16 bit float alpha)
  NV_DESKTOP_COLOR_DEPTH_16BPC_FLOAT_WCG = 0x4,                                    //16 bit float per color component (16 bit float alpha) wide color gamut
  NV_DESKTOP_COLOR_DEPTH_16BPC_FLOAT_HDR = 0x5,                                    //16 bit float per color component (16 bit float alpha) HDR
  NV_DESKTOP_COLOR_DEPTH_MAX_VALUE       = NV_DESKTOP_COLOR_DEPTH_16BPC_FLOAT_HDR, // must be set to highest enum value
} NV_DESKTOP_COLOR_DEPTH;
 
typedef struct _NV_COLOR_DATA_V1
{
    NvU32 version; 
    NvU16 size;    
    NvU8  cmd;
    struct
    {
        NvU8  colorFormat;    
        NvU8  colorimetry;    
    } data;
} NV_COLOR_DATA_V1;
 
typedef struct _NV_COLOR_DATA_V2
{
    NvU32 version; 
    NvU16 size;    
    NvU8  cmd;
    struct
    {
        NvU8  colorFormat;    
        NvU8  colorimetry;    
        NvU8  dynamicRange;   
    } data;
} NV_COLOR_DATA_V2;
 
typedef struct _NV_COLOR_DATA_V3
{
    NvU32 version; 
    NvU16 size;    
    NvU8  cmd;
    struct
    {
        NvU8     colorFormat;    
        NvU8     colorimetry;    
        NvU8     dynamicRange;   
        NV_BPC   bpc;            
    } data;
} NV_COLOR_DATA_V3;
 
typedef struct _NV_COLOR_DATA_V4
{
    NvU32 version; 
    NvU16 size;    
    NvU8  cmd;
    struct
    {
        NvU8     colorFormat;     
        NvU8     colorimetry;     
        NvU8     dynamicRange;    
        NV_BPC   bpc;             
        NV_COLOR_SELECTION_POLICY colorSelectionPolicy; 
    } data;
} NV_COLOR_DATA_V4;
 
typedef struct _NV_COLOR_DATA_V5
{
    NvU32 version; 
    NvU16 size;    
    NvU8  cmd;
    struct
    {
        NvU8                      colorFormat;          
        NvU8                      colorimetry;          
        NvU8                      dynamicRange;         
        NV_BPC                    bpc;                  
        NV_COLOR_SELECTION_POLICY colorSelectionPolicy; 
        NV_DESKTOP_COLOR_DEPTH    depth;                
    } data;
} NV_COLOR_DATA_V5;
 
typedef NV_COLOR_DATA_V5    NV_COLOR_DATA;
 
#define NV_COLOR_DATA_VER1  MAKE_NVAPI_VERSION(NV_COLOR_DATA_V1, 1)
#define NV_COLOR_DATA_VER2  MAKE_NVAPI_VERSION(NV_COLOR_DATA_V2, 2)
#define NV_COLOR_DATA_VER3  MAKE_NVAPI_VERSION(NV_COLOR_DATA_V3, 3)
#define NV_COLOR_DATA_VER4  MAKE_NVAPI_VERSION(NV_COLOR_DATA_V4, 4)
#define NV_COLOR_DATA_VER5  MAKE_NVAPI_VERSION(NV_COLOR_DATA_V5, 5)
#define NV_COLOR_DATA_VER   NV_COLOR_DATA_VER5
 
NVAPI_INTERFACE NvAPI_Disp_ColorControl(NvU32 displayId, NV_COLOR_DATA *pColorData);
 
 
 
typedef enum
{
    NV_STATIC_METADATA_TYPE_1 = 0                   
}NV_STATIC_METADATA_DESCRIPTOR_ID;
 
typedef struct _NV_HDR_CAPABILITIES_V1
{
    NvU32 version;                                                  
 
    NvU32 isST2084EotfSupported                 :1;                 
    NvU32 isTraditionalHdrGammaSupported        :1;                 
    NvU32 isEdrSupported                        :1;                 
    NvU32 driverExpandDefaultHdrParameters      :1;                 
    NvU32 isTraditionalSdrGammaSupported        :1;                 
    NvU32 reserved                              :27;
 
    NV_STATIC_METADATA_DESCRIPTOR_ID static_metadata_descriptor_id; 
 
    struct                                                          
    {
        NvU16    displayPrimary_x0;                                 
        NvU16    displayPrimary_y0;                                 
 
        NvU16    displayPrimary_x1;                                 
        NvU16    displayPrimary_y1;                                 
 
        NvU16    displayPrimary_x2;                                 
        NvU16    displayPrimary_y2;                                 
 
        NvU16    displayWhitePoint_x;                               
        NvU16    displayWhitePoint_y;                               
 
        NvU16    desired_content_max_luminance;                     
        NvU16    desired_content_min_luminance;                     
        NvU16    desired_content_max_frame_average_luminance;       
    }display_data;
} NV_HDR_CAPABILITIES_V1;
 
typedef struct _NV_HDR_CAPABILITIES_V2
{
    NvU32 version;                                                  
 
    NvU32 isST2084EotfSupported                 :1;                 
    NvU32 isTraditionalHdrGammaSupported        :1;                 
    NvU32 isEdrSupported                        :1;                 
    NvU32 driverExpandDefaultHdrParameters      :1;                 
    NvU32 isTraditionalSdrGammaSupported        :1;                 
    NvU32 isDolbyVisionSupported                :1;                 
    NvU32 reserved                              :26;
 
    NV_STATIC_METADATA_DESCRIPTOR_ID static_metadata_descriptor_id; 
 
    struct                                                          
    {
        NvU16    displayPrimary_x0;                                 
        NvU16    displayPrimary_y0;                                 
 
        NvU16    displayPrimary_x1;                                 
        NvU16    displayPrimary_y1;                                 
 
        NvU16    displayPrimary_x2;                                 
        NvU16    displayPrimary_y2;                                 
 
        NvU16    displayWhitePoint_x;                               
        NvU16    displayWhitePoint_y;                               
 
        NvU16    desired_content_max_luminance;                     
        NvU16    desired_content_min_luminance;                     
        NvU16    desired_content_max_frame_average_luminance;       
    }display_data;
 
    struct
    {
        NvU32 VSVDB_version               : 3;                
        NvU32 dm_version                  : 8;                
        NvU32 supports_2160p60hz          : 1;                
        NvU32 supports_YUV422_12bit       : 1;                
        NvU32 supports_global_dimming     : 1;                
        NvU32 colorimetry                 : 1;                
        NvU32 supports_backlight_control  : 2;                
        NvU32 backlt_min_luma             : 2;                
        NvU32 interface_supported_by_sink : 2;                
        NvU32 supports_10b_12b_444        : 2;                
        NvU32 reserved                    : 9;                
        NvU16 target_min_luminance;                           
        NvU16 target_max_luminance;                           
        NvU16 cc_red_x;                                       
        NvU16 cc_red_y;                                       
        NvU16 cc_green_x;                                     
        NvU16 cc_green_y;                                     
        NvU16 cc_blue_x;                                      
        NvU16 cc_blue_y;                                      
        NvU16 cc_white_x;                                     
        NvU16 cc_white_y;                                     
    }dv_static_metadata;
 
} NV_HDR_CAPABILITIES_V2;
 
typedef struct _NV_HDR_CAPABILITIES_V3
{
    NvU32 version;                                                  
 
    NvU32 isST2084EotfSupported                 :1;                 
    NvU32 isTraditionalHdrGammaSupported        :1;                 
    NvU32 isEdrSupported                        :1;                 
    NvU32 driverExpandDefaultHdrParameters      :1;                 
    NvU32 isTraditionalSdrGammaSupported        :1;                 
    NvU32 isDolbyVisionSupported                :1;                 
    NvU32 isHdr10PlusSupported                  :1;                 
    NvU32 isHdr10PlusGamingSupported            :1;                 
    NvU32 reserved                              :24;
 
    NV_STATIC_METADATA_DESCRIPTOR_ID static_metadata_descriptor_id; 
 
    struct                                                          
    {
        NvU16    displayPrimary_x0;                                 
        NvU16    displayPrimary_y0;                                 
 
        NvU16    displayPrimary_x1;                                 
        NvU16    displayPrimary_y1;                                 
 
        NvU16    displayPrimary_x2;                                 
        NvU16    displayPrimary_y2;                                 
 
        NvU16    displayWhitePoint_x;                               
        NvU16    displayWhitePoint_y;                               
 
        NvU16    desired_content_max_luminance;                     
        NvU16    desired_content_min_luminance;                     
        NvU16    desired_content_max_frame_average_luminance;       
    }display_data;
 
    struct
    {
        NvU32 VSVDB_version               : 3;                
        NvU32 dm_version                  : 8;                
        NvU32 supports_2160p60hz          : 1;                
        NvU32 supports_YUV422_12bit       : 1;                
        NvU32 supports_global_dimming     : 1;                
        NvU32 colorimetry                 : 1;                
        NvU32 supports_backlight_control  : 2;                
        NvU32 backlt_min_luma             : 2;                
        NvU32 interface_supported_by_sink : 2;                
        NvU32 supports_10b_12b_444        : 2;                
        NvU32 parity                      : 1;                
        NvU32 reserved                    : 8;                
 
        NvU16 target_min_luminance;                           
        NvU16 target_max_luminance;                           
        NvU16 cc_red_x;                                       
        NvU16 cc_red_y;                                       
        NvU16 cc_green_x;                                     
        NvU16 cc_green_y;                                     
        NvU16 cc_blue_x;                                      
        NvU16 cc_blue_y;                                      
        NvU16 cc_white_x;                                     
        NvU16 cc_white_y;                                     
    }dv_static_metadata;
 
    struct
    {
        NvU16 application_version               : 2;          
        NvU16 full_frame_peak_luminance_index   : 2;          
        NvU16 peak_luminance_index              : 4;          
        NvU16 reserved                          : 8;
    }hdr10plus_vsvdb;
 
} NV_HDR_CAPABILITIES_V3;
 
#define NV_HDR_CAPABILITIES_VER1  MAKE_NVAPI_VERSION(NV_HDR_CAPABILITIES_V1, 1)
#define NV_HDR_CAPABILITIES_VER2  MAKE_NVAPI_VERSION(NV_HDR_CAPABILITIES_V2, 2)
#define NV_HDR_CAPABILITIES_VER3  MAKE_NVAPI_VERSION(NV_HDR_CAPABILITIES_V3, 3)
#define NV_HDR_CAPABILITIES_VER   NV_HDR_CAPABILITIES_VER3
typedef NV_HDR_CAPABILITIES_V3    NV_HDR_CAPABILITIES;
 
// FUNCTION NAME:   NvAPI_Disp_GetHdrCapabilities
//
//
NVAPI_INTERFACE NvAPI_Disp_GetHdrCapabilities(__in NvU32 displayId, __inout NV_HDR_CAPABILITIES *pHdrCapabilities);
 
 
 
typedef enum
{
    NV_HDR_CMD_GET = 0,                             
    NV_HDR_CMD_SET = 1                              
} NV_HDR_CMD;
 
typedef enum
{
    // Official production-ready HDR modes
    NV_HDR_MODE_OFF                 = 0,            
    NV_HDR_MODE_UHDA                = 2,            
 
    // Experimental
    NV_HDR_MODE_UHDA_PASSTHROUGH    = 5,            
    NV_HDR_MODE_DOLBY_VISION        = 7,            
 
    // Unsupported/obsolete HDR modes
    NV_HDR_MODE_EDR                 = 3,            
    NV_HDR_MODE_SDR                 = 4,            
    NV_HDR_MODE_UHDA_NB             = 6,            
    NV_HDR_MODE_UHDBD               = 2             
 
} NV_HDR_MODE;
 
typedef struct _NV_HDR_COLOR_DATA_V1
{
    NvU32                             version;                                 
    NV_HDR_CMD                        cmd;                                     
    NV_HDR_MODE                       hdrMode;                                 
    NV_STATIC_METADATA_DESCRIPTOR_ID  static_metadata_descriptor_id;           
 
    struct                                                                    
    {
        NvU16    displayPrimary_x0;                                           
        NvU16    displayPrimary_y0;                                           
 
        NvU16    displayPrimary_x1;                                           
        NvU16    displayPrimary_y1;                                           
 
        NvU16    displayPrimary_x2;                                           
        NvU16    displayPrimary_y2;                                           
 
        NvU16    displayWhitePoint_x;                                         
        NvU16    displayWhitePoint_y;                                         
 
        NvU16    max_display_mastering_luminance;                             
        NvU16    min_display_mastering_luminance;                             
 
        NvU16    max_content_light_level;                                     
        NvU16    max_frame_average_light_level;                               
    } mastering_display_data;
} NV_HDR_COLOR_DATA_V1;
 
typedef struct _NV_HDR_COLOR_DATA_V2
{
    NvU32                             version;                                 
    NV_HDR_CMD                        cmd;                                     
    NV_HDR_MODE                       hdrMode;                                 
    NV_STATIC_METADATA_DESCRIPTOR_ID  static_metadata_descriptor_id;           
 
    struct                                                                    
    {
        NvU16    displayPrimary_x0;                                           
        NvU16    displayPrimary_y0;                                           
 
        NvU16    displayPrimary_x1;                                           
        NvU16    displayPrimary_y1;                                           
 
        NvU16    displayPrimary_x2;                                           
        NvU16    displayPrimary_y2;                                           
 
        NvU16    displayWhitePoint_x;                                         
        NvU16    displayWhitePoint_y;                                         
 
        NvU16    max_display_mastering_luminance;                             
        NvU16    min_display_mastering_luminance;                             
 
        NvU16    max_content_light_level;                                     
        NvU16    max_frame_average_light_level;                               
    } mastering_display_data;
 
    NV_COLOR_FORMAT          hdrColorFormat;                                     
    NV_DYNAMIC_RANGE         hdrDynamicRange;                                    
    NV_BPC                   hdrBpc;                                             
} NV_HDR_COLOR_DATA_V2;
 
#define NV_HDR_COLOR_DATA_VER1  MAKE_NVAPI_VERSION(NV_HDR_COLOR_DATA_V1, 1)
#define NV_HDR_COLOR_DATA_VER2  MAKE_NVAPI_VERSION(NV_HDR_COLOR_DATA_V2, 2)
 
#ifndef NV_HDR_COLOR_DATA_VER
#define NV_HDR_COLOR_DATA_VER   NV_HDR_COLOR_DATA_VER2
typedef NV_HDR_COLOR_DATA_V2    NV_HDR_COLOR_DATA;
#endif
 
// FUNCTION NAME:   NvAPI_Disp_HdrColorControl
//
//
NVAPI_INTERFACE NvAPI_Disp_HdrColorControl(__in NvU32 displayId, __inout NV_HDR_COLOR_DATA *pHdrColorData);
 
typedef enum _NV_COLORSPACE_TYPE
{
    NV_COLORSPACE_sRGB      = 0,    
    NV_COLORSPACE_xRGB      = 1,    
    NV_COLORSPACE_REC2100   = 12,   
} NV_COLORSPACE_TYPE;
 
// FUNCTION NAME:   NvAPI_Disp_SetSourceColorSpace
//
//
NVAPI_INTERFACE NvAPI_Disp_SetSourceColorSpace(__in NvU32 displayId, __in NV_COLORSPACE_TYPE colorSpaceType);
 
#define NV_SOURCE_PID_CURRENT 0
 
// FUNCTION NAME:   NvAPI_Disp_GetSourceColorSpace
//
//
NVAPI_INTERFACE NvAPI_Disp_GetSourceColorSpace(__in NvU32 displayId, __inout NV_COLORSPACE_TYPE* pColorSpaceType, NvU64 sourcePID);
 
typedef struct _NV_HDR_METADATA_V1
{
    NvU32    version;                                          
 
    NvU16    displayPrimary_x0;                                
    NvU16    displayPrimary_y0;                                
 
    NvU16    displayPrimary_x1;                                
    NvU16    displayPrimary_y1;                                
 
    NvU16    displayPrimary_x2;                                
    NvU16    displayPrimary_y2;                                
 
    NvU16    displayWhitePoint_x;                              
    NvU16    displayWhitePoint_y;                              
 
    NvU16    max_display_mastering_luminance;                  
    NvU16    min_display_mastering_luminance;                  
 
    NvU16    max_content_light_level;                          
    NvU16    max_frame_average_light_level;                    
} NV_HDR_METADATA_V1;
 
#define NV_HDR_METADATA_VER1 MAKE_NVAPI_VERSION(NV_HDR_METADATA_V1, 1)
#define NV_HDR_METADATA_VER NV_HDR_METADATA_VER1
typedef NV_HDR_METADATA_V1 NV_HDR_METADATA;
 
// FUNCTION NAME:   NvAPI_Disp_SetSourceHdrMetadata
//
//
NVAPI_INTERFACE NvAPI_Disp_SetSourceHdrMetadata(__in NvU32 displayId, __in NV_HDR_METADATA* pMetadata);
 
// FUNCTION NAME:   NvAPI_Disp_GetSourceHdrMetadata
//
//
NVAPI_INTERFACE NvAPI_Disp_GetSourceHdrMetadata(__in NvU32 displayId, __inout NV_HDR_METADATA* pMetadata, NvU64 sourcePID);
 
typedef enum _NV_DISPLAY_OUTPUT_MODE
{
    NV_DISPLAY_OUTPUT_MODE_SDR              = 0,
    NV_DISPLAY_OUTPUT_MODE_HDR10            = 1,
    NV_DISPLAY_OUTPUT_MODE_HDR10PLUS_GAMING = 2
} NV_DISPLAY_OUTPUT_MODE;
 
// FUNCTION NAME:   NvAPI_Disp_SetOutputMode
//
//
NVAPI_INTERFACE NvAPI_Disp_SetOutputMode(__in NvU32 displayId, __inout NV_DISPLAY_OUTPUT_MODE* pDisplayMode);
 
// FUNCTION NAME:   NvAPI_Disp_GetOutputMode
//
//
NVAPI_INTERFACE NvAPI_Disp_GetOutputMode(__in NvU32 displayId, __inout NV_DISPLAY_OUTPUT_MODE* pDisplayMode);
 
typedef enum _NV_HDR_TONEMAPPING_METHOD
{
    NV_HDR_TONEMAPPING_APP  = 0,
    NV_HDR_TONEMAPPING_GPU  = 1
} NV_HDR_TONEMAPPING_METHOD;
 
// FUNCTION NAME:   NvAPI_Disp_SetHdrToneMapping
//
//
NVAPI_INTERFACE NvAPI_Disp_SetHdrToneMapping(__in NvU32 displayId, __in NV_HDR_TONEMAPPING_METHOD hdrTonemapping);
 
// FUNCTION NAME:   NvAPI_Disp_GetHdrToneMapping
//
//
NVAPI_INTERFACE NvAPI_Disp_GetHdrToneMapping(__in NvU32 displayId, __inout NV_HDR_TONEMAPPING_METHOD* pHdrTonemapping);
 
typedef struct
{
    NvU32                   isInterlaced   : 4;  
    NvU32                   reserved0      : 12;
    union
    {
        NvU32               tvFormat       : 8;  
        NvU32               ceaId          : 8;  
        NvU32               nvPsfId        : 8;  
    };
    NvU32                   scaling        : 8;  
}NV_TIMING_FLAG;
 
typedef struct _NV_TIMING_INPUT
{
    NvU32 version;                      
 
    NvU32 width;                        
    NvU32 height;                       
    float rr;                           
 
    NV_TIMING_FLAG flag;                
 
    NV_TIMING_OVERRIDE type;            
}NV_TIMING_INPUT;
 
#define NV_TIMING_INPUT_VER   MAKE_NVAPI_VERSION(NV_TIMING_INPUT,1)
 
// FUNCTION NAME:   NvAPI_DISP_GetTiming
//
NVAPI_INTERFACE NvAPI_DISP_GetTiming( __in NvU32 displayId,__in NV_TIMING_INPUT *timingInput, __out NV_TIMING *pTiming);
 
 
 
// FUNCTION NAME:   NvAPI_DISP_GetMonitorCapabilities
//
//
 
 
 
typedef enum
{
    // hdmi related caps
    NV_MONITOR_CAPS_TYPE_HDMI_VSDB = 0x1000,
    NV_MONITOR_CAPS_TYPE_HDMI_VCDB = 0x1001,
    // backend caps
    NV_MONITOR_CAPS_TYPE_GENERIC   = 0x1002,
} 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;
 
 
typedef struct _NV_MONITOR_CAPS_VSDB
{
    // byte 1
    NvU8    sourcePhysicalAddressB         : 4; 
    NvU8    sourcePhysicalAddressA         : 4; 
    // byte 2
    NvU8    sourcePhysicalAddressD         : 4; 
    NvU8    sourcePhysicalAddressC         : 4; 
    // byte 3
    NvU8    supportDualDviOperation        : 1; 
    NvU8    reserved6                      : 2; 
    NvU8    supportDeepColorYCbCr444       : 1; 
    NvU8    supportDeepColor30bits         : 1; 
    NvU8    supportDeepColor36bits         : 1; 
    NvU8    supportDeepColor48bits         : 1; 
    NvU8    supportAI                      : 1; 
    // byte 4
    NvU8    maxTmdsClock;  
    // byte 5
    NvU8    cnc0SupportGraphicsTextContent : 1; 
    NvU8    cnc1SupportPhotoContent        : 1; 
    NvU8    cnc2SupportCinemaContent       : 1; 
    NvU8    cnc3SupportGameContent         : 1; 
    NvU8    reserved8                      : 1; 
    NvU8    hasVicEntries                  : 1; 
    NvU8    hasInterlacedLatencyField      : 1; 
    NvU8    hasLatencyField                : 1; 
    // byte 6
    NvU8    videoLatency; 
    // byte 7
    NvU8    audioLatency; 
    // byte 8
    NvU8    interlacedVideoLatency; 
    // byte 9
    NvU8    interlacedAudioLatency; 
    // byte 10
    NvU8    reserved13                     : 7; 
    NvU8    has3dEntries                   : 1; 
    // byte 11
    NvU8    hdmi3dLength                   : 5; 
    NvU8    hdmiVicLength                  : 3; 
    // Remaining bytes
    NvU8    hdmi_vic[7];  
    NvU8    hdmi_3d[31];  
} NV_MONITOR_CAPS_VSDB;
 
typedef struct _NV_MONITOR_CAPS_GENERIC
{
    NvU8    supportVRR                   : 1;  
    NvU8    supportULMB                  : 1;  
    NvU8    isTrueGsync                  : 1;  
    NvU8    isRLACapable                 : 1;  
    NvU8    currentlyCapableOfVRR        : 1;  
    NvU8    reserved                     : 3;
} NV_MONITOR_CAPS_GENERIC;
 
typedef struct _NV_MONITOR_CAPABILITIES_V1
{
    NvU32    version;
    NvU16    size;
    NvU32    infoType;
    NvU32    connectorType;        
    NvU8     bIsValidInfo : 1;     
    union {
        NV_MONITOR_CAPS_VSDB  vsdb;
        NV_MONITOR_CAPS_VCDB  vcdb;
        NV_MONITOR_CAPS_GENERIC caps;
    } data;
} NV_MONITOR_CAPABILITIES_V1;
 
typedef NV_MONITOR_CAPABILITIES_V1 NV_MONITOR_CAPABILITIES;
 
#define NV_MONITOR_CAPABILITIES_VER1   MAKE_NVAPI_VERSION(NV_MONITOR_CAPABILITIES_V1,1)
#define NV_MONITOR_CAPABILITIES_VER    NV_MONITOR_CAPABILITIES_VER1
 
 
NVAPI_INTERFACE NvAPI_DISP_GetMonitorCapabilities(__in NvU32 displayId, __inout NV_MONITOR_CAPABILITIES *pMonitorCapabilities);
 
typedef struct _NV_MONITOR_COLOR_DATA
{
    NvU32                   version;
// We are only supporting DP monitors for now. We need to extend this to HDMI panels as well
    NV_DP_COLOR_FORMAT      colorFormat;        
    NV_DP_BPC               backendBitDepths;   
} NV_MONITOR_COLOR_CAPS_V1;
 
typedef NV_MONITOR_COLOR_CAPS_V1 NV_MONITOR_COLOR_CAPS;
 
#define NV_MONITOR_COLOR_CAPS_VER1   MAKE_NVAPI_VERSION(NV_MONITOR_COLOR_CAPS_V1,1)
#define NV_MONITOR_COLOR_CAPS_VER    NV_MONITOR_COLOR_CAPS_VER1
 
// FUNCTION NAME:   NvAPI_DISP_GetMonitorColorCapabilities
//
NVAPI_INTERFACE NvAPI_DISP_GetMonitorColorCapabilities(__in NvU32 displayId, __inout_ecount_part_opt(*pColorCapsCount, *pColorCapsCount) NV_MONITOR_COLOR_CAPS *pMonitorColorCapabilities, __inout NvU32 *pColorCapsCount);
 
typedef struct
{
    NvU32                   version;
 
    // the source mode information
    NvU32                   width;             
    NvU32                   height;            
    NvU32                   depth;             
    NV_FORMAT               colorFormat;       
 
    NV_VIEWPORTF            srcPartition;      
 
    float                   xRatio;            
    float                   yRatio;            
 
    NV_TIMING               timing;            
    NvU32                   hwModeSetOnly : 1; 
 
}NV_CUSTOM_DISPLAY;
 
#define NV_CUSTOM_DISPLAY_VER  MAKE_NVAPI_VERSION(NV_CUSTOM_DISPLAY,1)
 
// FUNCTION NAME:   NvAPI_DISP_EnumCustomDisplay
//
NVAPI_INTERFACE NvAPI_DISP_EnumCustomDisplay( __in NvU32 displayId, __in NvU32 index, __inout NV_CUSTOM_DISPLAY *pCustDisp);
 
// FUNCTION NAME:   NvAPI_DISP_TryCustomDisplay
//
NVAPI_INTERFACE NvAPI_DISP_TryCustomDisplay( __in_ecount(count) NvU32 *pDisplayIds, __in NvU32 count, __in_ecount(count) NV_CUSTOM_DISPLAY *pCustDisp);
 
// FUNCTION NAME:   NvAPI_DISP_DeleteCustomDisplay
//
NVAPI_INTERFACE NvAPI_DISP_DeleteCustomDisplay( __in_ecount(count) NvU32 *pDisplayIds, __in NvU32 count, __in NV_CUSTOM_DISPLAY *pCustDisp);
 
// FUNCTION NAME:   NvAPI_DISP_SaveCustomDisplay
//
NVAPI_INTERFACE NvAPI_DISP_SaveCustomDisplay( __in_ecount(count) NvU32 *pDisplayIds, __in NvU32 count, __in NvU32 isThisOutputIdOnly, __in NvU32 isThisMonitorIdOnly);
 
// FUNCTION NAME:   NvAPI_DISP_RevertCustomDisplayTrial
//
NVAPI_INTERFACE NvAPI_DISP_RevertCustomDisplayTrial( __in_ecount(count) NvU32* pDisplayIds, __in NvU32 count);
 
// FUNCTION NAME:   NvAPI_GetView
//
__nvapi_deprecated_function("Do not use this function - it is deprecated in release 290. Instead, use NvAPI_DISP_GetDisplayConfig.")
NVAPI_INTERFACE NvAPI_GetView(NvDisplayHandle hNvDisplay, NV_VIEW_TARGET_INFO *pTargets, NvU32 *pTargetMaskCount, NV_TARGET_VIEW_MODE *pTargetView);
 
 
 
 
 
 
 
// FUNCTION NAME:   NvAPI_GetViewEx
//
__nvapi_deprecated_function("Do not use this function - it is deprecated in release 290. Instead, use NvAPI_DISP_GetDisplayConfig.")
NVAPI_INTERFACE NvAPI_GetViewEx(NvDisplayHandle hNvDisplay, NV_DISPLAY_PATH_INFO *pPathInfo, NvU32 *pPathCount, NV_TARGET_VIEW_MODE *pTargetViewMode);
 
// FUNCTION NAME:   NvAPI_GetSupportedViews
//
NVAPI_INTERFACE NvAPI_GetSupportedViews(NvDisplayHandle hNvDisplay, NV_TARGET_VIEW_MODE *pTargetViews, NvU32 *pViewCount);
 
 
//
// FUNCTION NAME:   NvAPI_DISP_GetDisplayIdByDisplayName
//
NVAPI_INTERFACE NvAPI_DISP_GetDisplayIdByDisplayName(const char *displayName, NvU32* displayId);
 
 
 
 
// FUNCTION NAME:   NvAPI_DISP_GetDisplayConfig
//
NVAPI_INTERFACE NvAPI_DISP_GetDisplayConfig(__inout NvU32 *pathInfoCount, __out_ecount_full_opt(*pathInfoCount) NV_DISPLAYCONFIG_PATH_INFO *pathInfo);
 
 
 
 
// FUNCTION NAME:   NvAPI_DISP_SetDisplayConfig
//
//
NVAPI_INTERFACE NvAPI_DISP_SetDisplayConfig(__in NvU32 pathInfoCount, __in_ecount(pathInfoCount) NV_DISPLAYCONFIG_PATH_INFO* pathInfo, __in NvU32 flags);
 
 
 
typedef struct _NV_EDID_DATA_V1
{
    NvU32 version;      
    NvU8 *pEDID;        
    NvU32 sizeOfEDID;   
} NV_EDID_DATA_V1;
 
typedef struct _NV_EDID_DATA_V2
{
    NvU32 version;      
    NvU8 *pEDID;        
    NvU32 sizeOfEDID;   
    NvU32 reserved[8];  
} NV_EDID_DATA_V2;
 
typedef NV_EDID_DATA_V2 NV_EDID_DATA;
#define NV_EDID_DATA_VER1 MAKE_NVAPI_VERSION(NV_EDID_DATA_V1, 1)
#define NV_EDID_DATA_VER2 MAKE_NVAPI_VERSION(NV_EDID_DATA_V2, 2)
 
#define NV_EDID_DATA_VER NV_EDID_DATA_VER2
//
// FUNCTION NAME: NvAPI_DISP_GetEdidData
//
NVAPI_INTERFACE NvAPI_DISP_GetEdidData(__in NvU32 displayId, __inout NV_EDID_DATA *pEdidParams, __inout NV_EDID_FLAG *pFlag);
 
typedef struct _NV_GET_ADAPTIVE_SYNC_DATA_V1
{
    NvU32  version ;                      
    NvU32  maxFrameInterval;              
    NvU32  bDisableAdaptiveSync : 1;      
    NvU32  bDisableFrameSplitting : 1;    
    NvU32  reserved : 30;                 
    NvU32  lastFlipRefreshCount;          
    NvU64  lastFlipTimeStamp;             
    NvU32  reservedEx[4];                 
} NV_GET_ADAPTIVE_SYNC_DATA_V1;
 
#define NV_GET_ADAPTIVE_SYNC_DATA_VER1  MAKE_NVAPI_VERSION(NV_GET_ADAPTIVE_SYNC_DATA_V1,1)
#define NV_GET_ADAPTIVE_SYNC_DATA_VER   NV_GET_ADAPTIVE_SYNC_DATA_VER1
 
typedef NV_GET_ADAPTIVE_SYNC_DATA_V1  NV_GET_ADAPTIVE_SYNC_DATA;
 
//
NVAPI_INTERFACE NvAPI_DISP_GetAdaptiveSyncData(__in NvU32 displayId, __inout NV_GET_ADAPTIVE_SYNC_DATA *pAdaptiveSyncData);
 
typedef struct _NV_SET_ADAPTIVE_SYNC_DATA_V1
{
    NvU32  version ;                      
    NvU32  maxFrameInterval;              
    NvU32  bDisableAdaptiveSync : 1;      
    NvU32  bDisableFrameSplitting : 1;    
    NvU32  reserved : 30;                 
    NvU32  reservedEx[7];                 
} NV_SET_ADAPTIVE_SYNC_DATA_V1;
 
#define NV_SET_ADAPTIVE_SYNC_DATA_VER1  MAKE_NVAPI_VERSION(NV_SET_ADAPTIVE_SYNC_DATA_V1,1)
#define NV_SET_ADAPTIVE_SYNC_DATA_VER   NV_SET_ADAPTIVE_SYNC_DATA_VER1
 
typedef NV_SET_ADAPTIVE_SYNC_DATA_V1  NV_SET_ADAPTIVE_SYNC_DATA;
 
//
NVAPI_INTERFACE NvAPI_DISP_SetAdaptiveSyncData(__in NvU32 displayId, __in NV_SET_ADAPTIVE_SYNC_DATA *pAdaptiveSyncData);
 
 
typedef struct _NV_GET_VIRTUAL_REFRESH_RATE_DATA_V1
{
    NvU32  version ;                      
    NvU32  frameIntervalUs;               
    NvU32  reservedEx[8];                 
} NV_GET_VIRTUAL_REFRESH_RATE_DATA_V1;
 
#define NV_GET_VIRTUAL_REFRESH_RATE_DATA_VER1  MAKE_NVAPI_VERSION(_NV_GET_VIRTUAL_REFRESH_RATE_DATA_V1,1)
#define NV_GET_VIRTUAL_REFRESH_RATE_DATA_VER   NV_GET_VIRTUAL_REFRESH_RATE_DATA_VER1
 
typedef NV_GET_VIRTUAL_REFRESH_RATE_DATA_V1  NV_GET_VIRTUAL_REFRESH_RATE_DATA;
 
//
NVAPI_INTERFACE NvAPI_DISP_GetVirtualRefreshRateData(__in NvU32 displayId, __inout NV_GET_VIRTUAL_REFRESH_RATE_DATA *pVirtualRefreshRateData);
 
typedef struct _NV_SET_VIRTUAL_REFRESH_RATE_DATA_V1
{
    NvU32  version ;                      
    NvU32  frameIntervalUs;               
    NvU32  reservedEx[8];                 
} NV_SET_VIRTUAL_REFRESH_RATE_DATA_V1;
 
#define NV_SET_VIRTUAL_REFRESH_RATE_DATA_VER1  MAKE_NVAPI_VERSION(_NV_SET_VIRTUAL_REFRESH_RATE_DATA_V1,1)
#define NV_SET_VIRTUAL_REFRESH_RATE_DATA_VER   NV_SET_VIRTUAL_REFRESH_RATE_DATA_VER1
 
typedef NV_SET_VIRTUAL_REFRESH_RATE_DATA_V1  NV_SET_VIRTUAL_REFRESH_RATE_DATA;
 
//
NVAPI_INTERFACE NvAPI_DISP_SetVirtualRefreshRateData(__in NvU32 displayId, __in NV_SET_VIRTUAL_REFRESH_RATE_DATA *pVirtualRefreshRateData);
 
typedef struct
{
    NvU32    version;            
    NvU32    displayId;          
    NvU32    reserved;           
} NV_SET_PREFERRED_STEREO_DISPLAY_V1;
 
typedef NV_SET_PREFERRED_STEREO_DISPLAY_V1     NV_SET_PREFERRED_STEREO_DISPLAY;
 
#define NV_SET_PREFERRED_STEREO_DISPLAY_VER1   MAKE_NVAPI_VERSION(NV_SET_PREFERRED_STEREO_DISPLAY_V1,1)
 
#define NV_SET_PREFERRED_STEREO_DISPLAY_VER    NV_SET_PREFERRED_STEREO_DISPLAY_VER1
 
// FUNCTION NAME:   NvAPI_DISP_SetPreferredStereoDisplay
//
NVAPI_INTERFACE NvAPI_DISP_SetPreferredStereoDisplay(__in NV_SET_PREFERRED_STEREO_DISPLAY *pPreferredStereoDisplay);
 
typedef struct
{
    NvU32    version;            
    NvU32    displayId;          
    NvU32    reserved;           
} NV_GET_PREFERRED_STEREO_DISPLAY_V1;
 
typedef NV_GET_PREFERRED_STEREO_DISPLAY_V1     NV_GET_PREFERRED_STEREO_DISPLAY;
 
#define NV_GET_PREFERRED_STEREO_DISPLAY_VER1   MAKE_NVAPI_VERSION(NV_GET_PREFERRED_STEREO_DISPLAY_V1,1)
 
#define NV_GET_PREFERRED_STEREO_DISPLAY_VER    NV_GET_PREFERRED_STEREO_DISPLAY_VER1
 
// FUNCTION NAME:   NvAPI_DISP_GetPreferredStereoDisplay
//
NVAPI_INTERFACE NvAPI_DISP_GetPreferredStereoDisplay(__inout NV_GET_PREFERRED_STEREO_DISPLAY *pPreferredStereoDisplay);
 
#if defined(__cplusplus)
 
typedef struct _NV_MANAGED_DEDICATED_DISPLAY_INFO
{
    NvU32    version;                    
    NvU32    displayId;                  
    NvU32    isAcquired          : 1;    
    NvU32    isMosaic            : 1;    
    NvU32    reserved            : 30;   
} NV_MANAGED_DEDICATED_DISPLAY_INFO_V1;
 
#define NV_MANAGED_DEDICATED_DISPLAY_INFO_VER1  MAKE_NVAPI_VERSION(NV_MANAGED_DEDICATED_DISPLAY_INFO_V1,1)
#define NV_MANAGED_DEDICATED_DISPLAY_INFO_VER   NV_MANAGED_DEDICATED_DISPLAY_INFO_VER1
 
typedef NV_MANAGED_DEDICATED_DISPLAY_INFO_V1    NV_MANAGED_DEDICATED_DISPLAY_INFO;
 
//
// FUNCTION NAME: NvAPI_DISP_GetNvManagedDedicatedDisplays
//
NVAPI_INTERFACE NvAPI_DISP_GetNvManagedDedicatedDisplays(__inout NvU32* pDedicatedDisplayCount, __inout NV_MANAGED_DEDICATED_DISPLAY_INFO* pDedicatedDisplays);
#endif // defined(__cplusplus)
 
#if defined(__cplusplus)
//
// FUNCTION NAME: NvAPI_DISP_AcquireDedicatedDisplay
//
NVAPI_INTERFACE NvAPI_DISP_AcquireDedicatedDisplay(__in NvU32 displayId, __inout NvU64* pDisplaySourceHandle);
#endif // defined(__cplusplus)
 
#if defined(__cplusplus)
//
// FUNCTION NAME: NvAPI_DISP_ReleaseDedicatedDisplay
//
NVAPI_INTERFACE NvAPI_DISP_ReleaseDedicatedDisplay(__in NvU32 displayId);
#endif // defined(__cplusplus)
 
 
#if defined (_WINNT_)
 
 
typedef struct _NV_DISPLAY_ID_INFO_DATA_V1
{
    NvU32  version;      
    LUID   adapterId;    
    NvU32  targetId;     
    NvU32  reserved[4];  
} NV_DISPLAY_ID_INFO_DATA_V1;
 
#define NV_DISPLAY_ID_INFO_DATA_VER1  MAKE_NVAPI_VERSION(NV_DISPLAY_ID_INFO_DATA_V1,1)
#define NV_DISPLAY_ID_INFO_DATA_VER   NV_DISPLAY_ID_INFO_DATA_VER1
 
typedef NV_DISPLAY_ID_INFO_DATA_V1 NV_DISPLAY_ID_INFO_DATA;
 
//
// FUNCTION NAME: NvAPI_Disp_GetDisplayIdInfo
//
NVAPI_INTERFACE NvAPI_Disp_GetDisplayIdInfo(__in NvU32 displayId, __inout NV_DISPLAY_ID_INFO_DATA* pDisplayIdInfoData);
 
#endif
 
 
 
#if defined (_WINNT_)
 
typedef struct _NV_TARGET_INFO_DATA_V1
{
    NvU32  version;                          
    LUID   adapterId;                        
    NvU32  targetId;                         
    NvU32  displayId[NVAPI_MAX_DISPLAYS];    
    NvU32  displayIdCount;                   
    NvU32  reserved[4];                      
} NV_TARGET_INFO_DATA_V1;
 
#define NV_TARGET_INFO_DATA_VER1  MAKE_NVAPI_VERSION(NV_TARGET_INFO_DATA_V1,1)
#define NV_TARGET_INFO_DATA_VER   NV_TARGET_INFO_DATA_VER1
 
typedef NV_TARGET_INFO_DATA_V1 NV_TARGET_INFO_DATA;
 
//
// FUNCTION NAME: NvAPI_Disp_GetDisplayIdsFromTarget
//
NVAPI_INTERFACE NvAPI_Disp_GetDisplayIdsFromTarget(__inout NV_TARGET_INFO_DATA* pTargetInfoData);
 
#endif
 
 
 
typedef struct _NV_GET_VRR_INFO_V1
{
    NvU32               version;                          
    NvU32               bIsVRREnabled : 1;                
    NvU32               reserved      :31;                
    NvU32               reservedEx[4];                    
} NV_GET_VRR_INFO_V1;
 
#define NV_GET_VRR_INFO_VER1  MAKE_NVAPI_VERSION(NV_GET_VRR_INFO_V1,1)
#define NV_GET_VRR_INFO_VER   NV_GET_VRR_INFO_VER1
 
typedef NV_GET_VRR_INFO_V1 NV_GET_VRR_INFO;
 
//
// FUNCTION NAME: NvAPI_Disp_GetVRRInfo
//
NVAPI_INTERFACE NvAPI_Disp_GetVRRInfo(__in NvU32 displayId, __inout NV_GET_VRR_INFO *pVrrInfo);
 
 
 
//
// 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           |
//|                         ||                         ||                         ||                         |
//|                         ||                         ||                         ||                         |
//|                         ||                         ||                         ||                         |
//|                         ||                         ||                         ||                         |
//+-------------------------++-------------------------++-------------------------++-------------------------+
 
 
 
#define NVAPI_MAX_MOSAIC_DISPLAY_ROWS       8
#define NVAPI_MAX_MOSAIC_DISPLAY_COLUMNS    8
//
// These bits are used to describe the validity of a topo.
//
#define NV_MOSAIC_TOPO_VALIDITY_VALID               0x00000000  
#define NV_MOSAIC_TOPO_VALIDITY_MISSING_GPU         0x00000001  
#define NV_MOSAIC_TOPO_VALIDITY_MISSING_DISPLAY     0x00000002  
#define NV_MOSAIC_TOPO_VALIDITY_MIXED_DISPLAY_TYPES 0x00000004  
 
 
//
typedef struct 
{
    NvU32                version;              
    NvLogicalGpuHandle   hLogicalGPU;          
    NvU32                validityMask;         
    NvU32                rowCount;             
    NvU32                colCount;             
 
    struct 
    {
        NvPhysicalGpuHandle hPhysicalGPU;      
        NvU32               displayOutputId;   
        NvS32               overlapX;          
        NvS32               overlapY;          
 
    } gpuLayout[NVAPI_MAX_MOSAIC_DISPLAY_ROWS][NVAPI_MAX_MOSAIC_DISPLAY_COLUMNS];
 
} NV_MOSAIC_TOPO_DETAILS;
 
#define NVAPI_MOSAIC_TOPO_DETAILS_VER         MAKE_NVAPI_VERSION(NV_MOSAIC_TOPO_DETAILS,1)
 
 
//
typedef enum
{
    NV_MOSAIC_TOPO_TYPE_ALL,                          
    NV_MOSAIC_TOPO_TYPE_BASIC,                        
    NV_MOSAIC_TOPO_TYPE_PASSIVE_STEREO,               
    NV_MOSAIC_TOPO_TYPE_SCALED_CLONE,                 
    NV_MOSAIC_TOPO_TYPE_PASSIVE_STEREO_SCALED_CLONE,  
    NV_MOSAIC_TOPO_TYPE_MAX,                          
} NV_MOSAIC_TOPO_TYPE;
 
 
//
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  
 
} NV_MOSAIC_TOPO;
 
 
//
typedef struct 
{
    NvU32                        version;            
    NV_MOSAIC_TOPO               topo;               
    NvU32                        enabled;            
    NvU32                        isPossible;         
 
} NV_MOSAIC_TOPO_BRIEF;
 
#define NVAPI_MOSAIC_TOPO_BRIEF_VER         MAKE_NVAPI_VERSION(NV_MOSAIC_TOPO_BRIEF,1)
 
 
//
typedef struct _NV_MOSAIC_DISPLAY_SETTING_V1
{
    NvU32                        version;            
    NvU32                        width;              
    NvU32                        height;             
    NvU32                        bpp;                
    NvU32                        freq;               
} NV_MOSAIC_DISPLAY_SETTING_V1;
 
typedef struct NV_MOSAIC_DISPLAY_SETTING_V2
{
    NvU32                        version;            
    NvU32                        width;              
    NvU32                        height;             
    NvU32                        bpp;                
    NvU32                        freq;               
    NvU32                        rrx1k;              
} NV_MOSAIC_DISPLAY_SETTING_V2;
 
typedef NV_MOSAIC_DISPLAY_SETTING_V2 NV_MOSAIC_DISPLAY_SETTING;
 
#define NVAPI_MOSAIC_DISPLAY_SETTING_VER1         MAKE_NVAPI_VERSION(NV_MOSAIC_DISPLAY_SETTING_V1,1)
#define NVAPI_MOSAIC_DISPLAY_SETTING_VER2         MAKE_NVAPI_VERSION(NV_MOSAIC_DISPLAY_SETTING_V2,2)
#define NVAPI_MOSAIC_DISPLAY_SETTING_VER          NVAPI_MOSAIC_DISPLAY_SETTING_VER2
 
 
//
// Set a reasonable max number of display settings to support
// so arrays are bound.
//
#define NV_MOSAIC_DISPLAY_SETTINGS_MAX 40  
 
 
//
typedef struct _NV_MOSAIC_SUPPORTED_TOPO_INFO_V1
{
    NvU32                          version;                                         
    NvU32                          topoBriefsCount;                                 
    NV_MOSAIC_TOPO_BRIEF           topoBriefs[NV_MOSAIC_TOPO_MAX];                  
    NvU32                          displaySettingsCount;                            
    NV_MOSAIC_DISPLAY_SETTING_V1   displaySettings[NV_MOSAIC_DISPLAY_SETTINGS_MAX]; 
 
} NV_MOSAIC_SUPPORTED_TOPO_INFO_V1;
 
typedef struct _NV_MOSAIC_SUPPORTED_TOPO_INFO_V2
{
    NvU32                          version;                                         
    NvU32                          topoBriefsCount;                                 
    NV_MOSAIC_TOPO_BRIEF           topoBriefs[NV_MOSAIC_TOPO_MAX];                  
    NvU32                          displaySettingsCount;                            
    NV_MOSAIC_DISPLAY_SETTING_V2   displaySettings[NV_MOSAIC_DISPLAY_SETTINGS_MAX]; 
 
} NV_MOSAIC_SUPPORTED_TOPO_INFO_V2;
 
typedef NV_MOSAIC_SUPPORTED_TOPO_INFO_V2 NV_MOSAIC_SUPPORTED_TOPO_INFO;
 
#define NVAPI_MOSAIC_SUPPORTED_TOPO_INFO_VER1         MAKE_NVAPI_VERSION(NV_MOSAIC_SUPPORTED_TOPO_INFO_V1,1)
#define NVAPI_MOSAIC_SUPPORTED_TOPO_INFO_VER2         MAKE_NVAPI_VERSION(NV_MOSAIC_SUPPORTED_TOPO_INFO_V2,2)
#define NVAPI_MOSAIC_SUPPORTED_TOPO_INFO_VER          NVAPI_MOSAIC_SUPPORTED_TOPO_INFO_VER2
 
 
//
// 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
 
 
//
#define NV_MOSAIC_MAX_TOPO_PER_TOPO_GROUP 2 
 
 
//
typedef struct 
{
    NvU32                      version;              
    NV_MOSAIC_TOPO_BRIEF       brief;                
    NvU32                      count;                
    NV_MOSAIC_TOPO_DETAILS     topos[NV_MOSAIC_MAX_TOPO_PER_TOPO_GROUP];
 
} NV_MOSAIC_TOPO_GROUP;
 
#define NVAPI_MOSAIC_TOPO_GROUP_VER         MAKE_NVAPI_VERSION(NV_MOSAIC_TOPO_GROUP,1)
 
 
 
//
// FUNCTION NAME:   NvAPI_Mosaic_GetSupportedTopoInfo
//
//                                              compatible with this entry point.
NVAPI_INTERFACE NvAPI_Mosaic_GetSupportedTopoInfo(NV_MOSAIC_SUPPORTED_TOPO_INFO *pSupportedTopoInfo, NV_MOSAIC_TOPO_TYPE type);
 
 
//
// FUNCTION NAME:   NvAPI_Mosaic_GetTopoGroup
//
//                                              compatible with this entry point.
NVAPI_INTERFACE NvAPI_Mosaic_GetTopoGroup(NV_MOSAIC_TOPO_BRIEF *pTopoBrief, NV_MOSAIC_TOPO_GROUP *pTopoGroup);
 
 
//
// FUNCTION NAME:   NvAPI_Mosaic_GetOverlapLimits
//
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
//
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
//
NVAPI_INTERFACE NvAPI_Mosaic_GetCurrentTopo(NV_MOSAIC_TOPO_BRIEF *pTopoBrief, NV_MOSAIC_DISPLAY_SETTING *pDisplaySetting, NvS32 *pOverlapX, NvS32 *pOverlapY);
 
 
//
// FUNCTION NAME:   NvAPI_Mosaic_EnableCurrentTopo
//
NVAPI_INTERFACE NvAPI_Mosaic_EnableCurrentTopo(NvU32 enable);
 
typedef struct _NV_MOSAIC_GRID_TOPO_DISPLAY_V1
{
    NvU32                       displayId;              
    NvS32                       overlapX;               
    NvS32                       overlapY;               
    NV_ROTATE                   rotation;               
    NvU32                       cloneGroup;             
} NV_MOSAIC_GRID_TOPO_DISPLAY_V1;
 
typedef enum _NV_PIXEL_SHIFT_TYPE
{
    NV_PIXEL_SHIFT_TYPE_NO_PIXEL_SHIFT            = 0,          
    NV_PIXEL_SHIFT_TYPE_2x2_TOP_LEFT_PIXELS       = 1,          
    NV_PIXEL_SHIFT_TYPE_2x2_BOTTOM_RIGHT_PIXELS   = 2,          
    NV_PIXEL_SHIFT_TYPE_2x2_TOP_RIGHT_PIXELS      = 4,          
    NV_PIXEL_SHIFT_TYPE_2x2_BOTTOM_LEFT_PIXELS    = 8,          
} NV_PIXEL_SHIFT_TYPE;
 
typedef struct _NV_MOSAIC_GRID_TOPO_DISPLAY_V2
{
    NvU32                               version;                
 
    NvU32                               displayId;              
    NvS32                               overlapX;               
    NvS32                               overlapY;               
    NV_ROTATE                           rotation;               
    NvU32                               cloneGroup;             
    NV_PIXEL_SHIFT_TYPE                 pixelShiftType;         
} NV_MOSAIC_GRID_TOPO_DISPLAY_V2;
 
#ifndef NV_MOSAIC_GRID_TOPO_DISPLAY_VER
 
typedef NV_MOSAIC_GRID_TOPO_DISPLAY_V1           NV_MOSAIC_GRID_TOPO_DISPLAY;
 
#endif
 
typedef struct _NV_MOSAIC_GRID_TOPO_V1
{
    NvU32                          version;                            
    NvU32                          rows;                               
    NvU32                          columns;                            
    NvU32                          displayCount;                       
    NvU32                          applyWithBezelCorrect : 1;          
    NvU32                          immersiveGaming : 1;                
    NvU32                          baseMosaic : 1;                     
    NvU32                          driverReloadAllowed : 1;            
    NvU32                          acceleratePrimaryDisplay : 1;       
    NvU32                          reserved : 27;                      
    NV_MOSAIC_GRID_TOPO_DISPLAY_V1 displays[NV_MOSAIC_MAX_DISPLAYS];   
    NV_MOSAIC_DISPLAY_SETTING_V1   displaySettings;                    
} NV_MOSAIC_GRID_TOPO_V1;
 
typedef struct _NV_MOSAIC_GRID_TOPO_V2
{
    NvU32                          version;                            
    NvU32                          rows;                               
    NvU32                          columns;                            
    NvU32                          displayCount;                       
    NvU32                          applyWithBezelCorrect : 1;          
    NvU32                          immersiveGaming : 1;                
    NvU32                          baseMosaic : 1;                     
    NvU32                          driverReloadAllowed : 1;            
    NvU32                          acceleratePrimaryDisplay : 1;       
    NvU32                          pixelShift : 1;                     
    NvU32                          reserved : 26;                      
    NV_MOSAIC_GRID_TOPO_DISPLAY_V2 displays[NV_MOSAIC_MAX_DISPLAYS];   
    NV_MOSAIC_DISPLAY_SETTING_V1   displaySettings;                    
} NV_MOSAIC_GRID_TOPO_V2;
 
#define NV_MOSAIC_GRID_TOPO_VER1         MAKE_NVAPI_VERSION(NV_MOSAIC_GRID_TOPO_V1,1)
#define NV_MOSAIC_GRID_TOPO_VER2         MAKE_NVAPI_VERSION(NV_MOSAIC_GRID_TOPO_V2,2)
#ifndef NV_MOSAIC_GRID_TOPO_VER
 
typedef NV_MOSAIC_GRID_TOPO_V2           NV_MOSAIC_GRID_TOPO;
 
#define NV_MOSAIC_GRID_TOPO_VER          NV_MOSAIC_GRID_TOPO_VER2
 
#endif
 
 
 
#define NV_MOSAIC_DISPLAYCAPS_PROBLEM_DISPLAY_ON_INVALID_GPU        NV_BIT(0)
#define NV_MOSAIC_DISPLAYCAPS_PROBLEM_DISPLAY_ON_WRONG_CONNECTOR    NV_BIT(1)
#define NV_MOSAIC_DISPLAYCAPS_PROBLEM_NO_COMMON_TIMINGS             NV_BIT(2)
#define NV_MOSAIC_DISPLAYCAPS_PROBLEM_NO_EDID_AVAILABLE             NV_BIT(3)
#define NV_MOSAIC_DISPLAYCAPS_PROBLEM_MISMATCHED_OUTPUT_TYPE        NV_BIT(4)
#define NV_MOSAIC_DISPLAYCAPS_PROBLEM_NO_DISPLAY_CONNECTED          NV_BIT(5)
#define NV_MOSAIC_DISPLAYCAPS_PROBLEM_NO_GPU_TOPOLOGY               NV_BIT(6)
#define NV_MOSAIC_DISPLAYCAPS_PROBLEM_NOT_SUPPORTED                 NV_BIT(7)
#define NV_MOSAIC_DISPLAYCAPS_PROBLEM_NO_SLI_BRIDGE                 NV_BIT(8)
#define NV_MOSAIC_DISPLAYCAPS_PROBLEM_ECC_ENABLED                   NV_BIT(9)
#define NV_MOSAIC_DISPLAYCAPS_PROBLEM_GPU_TOPOLOGY_NOT_SUPPORTED    NV_BIT(10)
 
 
 
 
 
 
 
#define NV_MOSAIC_SETDISPLAYTOPO_FLAG_CURRENT_GPU_TOPOLOGY NV_BIT(0)
 
#define NV_MOSAIC_SETDISPLAYTOPO_FLAG_NO_DRIVER_RELOAD     NV_BIT(1)
 
#define NV_MOSAIC_SETDISPLAYTOPO_FLAG_MAXIMIZE_PERFORMANCE NV_BIT(2)
 
#define NV_MOSAIC_SETDISPLAYTOPO_FLAG_ALLOW_INVALID        NV_BIT(3)
 
//
// FUNCTION NAME:   NvAPI_Mosaic_SetDisplayGrids
//
NVAPI_INTERFACE NvAPI_Mosaic_SetDisplayGrids(__in_ecount(gridCount) NV_MOSAIC_GRID_TOPO *pGridTopologies, __in NvU32 gridCount, __in NvU32 setTopoFlags);
 
 
#define NV_MOSAIC_DISPLAYTOPO_WARNING_DISPLAY_POSITION            NV_BIT(0)
 
#define NV_MOSAIC_DISPLAYTOPO_WARNING_DRIVER_RELOAD_REQUIRED      NV_BIT(1)
 
typedef struct
{
    NvU32 version;
    NvU32 errorFlags;            
    NvU32 warningFlags;          
 
    NvU32 displayCount;          
    struct
    {
        NvU32 displayId;             
        NvU32 errorFlags;            
        NvU32 warningFlags;          
 
        NvU32  supportsRotation : 1; 
        NvU32  reserved : 31;        
    } displays[NVAPI_MAX_DISPLAYS];
} NV_MOSAIC_DISPLAY_TOPO_STATUS;
 
#define NV_MOSAIC_DISPLAY_TOPO_STATUS_VER         MAKE_NVAPI_VERSION(NV_MOSAIC_DISPLAY_TOPO_STATUS,1)
 
 
//
// FUNCTION NAME:   NvAPI_Mosaic_ValidateDisplayGrids
//
NVAPI_INTERFACE NvAPI_Mosaic_ValidateDisplayGrids(__in NvU32 setTopoFlags,
        __in_ecount(gridCount) NV_MOSAIC_GRID_TOPO *pGridTopologies,
        __inout_ecount_full(gridCount) NV_MOSAIC_DISPLAY_TOPO_STATUS *pTopoStatus,
        __in NvU32 gridCount);
 
 
 
//
// FUNCTION NAME:   NvAPI_Mosaic_EnumDisplayModes
//
NVAPI_INTERFACE NvAPI_Mosaic_EnumDisplayModes(__in NV_MOSAIC_GRID_TOPO *pGridTopology,
        __inout_ecount_part_opt(*pDisplayCount, *pDisplayCount) NV_MOSAIC_DISPLAY_SETTING *pDisplaySettings,
        __inout NvU32 *pDisplayCount);
 
 
//
// FUNCTION NAME:   NvAPI_Mosaic_EnumDisplayGrids
//
NVAPI_INTERFACE NvAPI_Mosaic_EnumDisplayGrids(__inout_ecount_part_opt(*pGridCount, *pGridCount) NV_MOSAIC_GRID_TOPO *pGridTopologies,
        __inout NvU32 *pGridCount);
 
 
//
// ###########################################################################
// 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           |
//|                         ||                         ||                         ||                         |
//|                         ||                         ||                         ||                         |
//|                         ||                         ||                         ||                         |
//|                         ||                         ||                         ||                         |
//+-------------------------++-------------------------++-------------------------++-------------------------+
 
 
 
#define NVAPI_MAX_MOSAIC_DISPLAY_ROWS       8
 
#define NVAPI_MAX_MOSAIC_DISPLAY_COLUMNS    8 
 
#define NVAPI_MAX_MOSAIC_TOPOS              16
 
typedef struct 
{
    NvU32 version;                             
    NvU32 rowCount;                            
    NvU32 colCount;                            
 
    struct 
    {
        NvPhysicalGpuHandle hPhysicalGPU;      
        NvU32               displayOutputId;   
        NvS32               overlapX;          
        NvS32               overlapY;          
 
    } gpuLayout[NVAPI_MAX_MOSAIC_DISPLAY_ROWS][NVAPI_MAX_MOSAIC_DISPLAY_COLUMNS];
 
} NV_MOSAIC_TOPOLOGY;
 
#define NVAPI_MOSAIC_TOPOLOGY_VER         MAKE_NVAPI_VERSION(NV_MOSAIC_TOPOLOGY,1)
 
typedef struct 
{
    NvU32                   version;                                    
    NvU32                   totalCount;                     
    NV_MOSAIC_TOPOLOGY      topos[NVAPI_MAX_MOSAIC_TOPOS];  
 
} NV_MOSAIC_SUPPORTED_TOPOLOGIES;
 
#define NVAPI_MOSAIC_SUPPORTED_TOPOLOGIES_VER         MAKE_NVAPI_VERSION(NV_MOSAIC_SUPPORTED_TOPOLOGIES,1)
 
 
 
//
// FUNCTION NAME:   NvAPI_GetSupportedMosaicTopologies
//
NVAPI_INTERFACE NvAPI_GetSupportedMosaicTopologies(NV_MOSAIC_SUPPORTED_TOPOLOGIES *pMosaicTopos);
 
//
// FUNCTION NAME:   NvAPI_GetCurrentMosaicTopology
//
NVAPI_INTERFACE NvAPI_GetCurrentMosaicTopology(NV_MOSAIC_TOPOLOGY *pMosaicTopo, NvU32 *pEnabled);
 
 
//
// FUNCTION NAME:   NvAPI_SetCurrentMosaicTopology
//
NVAPI_INTERFACE NvAPI_SetCurrentMosaicTopology(NV_MOSAIC_TOPOLOGY *pMosaicTopo);
 
//
// FUNCTION NAME:   NvAPI_EnableCurrentMosaicTopology
//
NVAPI_INTERFACE NvAPI_EnableCurrentMosaicTopology(NvU32 enable);
 
 
#define NVAPI_MAX_GSYNC_DEVICES                       4
 
 
// Sync Display APIs
 
//
// FUNCTION NAME: NvAPI_GSync_EnumSyncDevices
//
NVAPI_INTERFACE NvAPI_GSync_EnumSyncDevices(__out NvGSyncDeviceHandle nvGSyncHandles[NVAPI_MAX_GSYNC_DEVICES], __out NvU32 *gsyncCount);
 
 
// GSync boardId values
#define NVAPI_GSYNC_BOARD_ID_P358 856       
#define NVAPI_GSYNC_BOARD_ID_P2060 8288     
 
#define NVAPI_GSYNC_BOARD_ID_P2061 8289     
 
 
typedef struct _NV_GSYNC_CAPABILITIES_V1
{
    NvU32   version;                        
    NvU32   boardId;                        
    NvU32   revision;                       
    NvU32   capFlags;                       
} NV_GSYNC_CAPABILITIES_V1;
 
typedef struct _NV_GSYNC_CAPABILITIES_V2
{
    NvU32   version;                        
    NvU32   boardId;                        
    NvU32   revision;                       
    NvU32   capFlags;                       
    NvU32   extendedRevision;               
} NV_GSYNC_CAPABILITIES_V2;
 
typedef struct _NV_GSYNC_CAPABILITIES_V3
{
    NvU32   version;                        
    NvU32   boardId;                        
    NvU32   revision;                       
    NvU32   capFlags;                       
    NvU32   extendedRevision;               
    NvU32   bIsMulDivSupported : 1;         
    NvU32   reserved           : 31;        
    NvU32   maxMulDivValue;                 
} NV_GSYNC_CAPABILITIES_V3;
 
typedef NV_GSYNC_CAPABILITIES_V3 NV_GSYNC_CAPABILITIES;
 
 
#define NV_GSYNC_CAPABILITIES_VER1  MAKE_NVAPI_VERSION(NV_GSYNC_CAPABILITIES_V1,1)
#define NV_GSYNC_CAPABILITIES_VER2  MAKE_NVAPI_VERSION(NV_GSYNC_CAPABILITIES_V2,2)
#define NV_GSYNC_CAPABILITIES_VER3  MAKE_NVAPI_VERSION(NV_GSYNC_CAPABILITIES_V3,3)
#define NV_GSYNC_CAPABILITIES_VER NV_GSYNC_CAPABILITIES_VER3
 
 
//
// FUNCTION NAME: NvAPI_GSync_QueryCapabilities
//
NVAPI_INTERFACE NvAPI_GSync_QueryCapabilities(__in NvGSyncDeviceHandle hNvGSyncDevice, __inout NV_GSYNC_CAPABILITIES *pNvGSyncCapabilities);
 
 
 
typedef enum _NVAPI_GSYNC_GPU_TOPOLOGY_CONNECTOR
{
    NVAPI_GSYNC_GPU_TOPOLOGY_CONNECTOR_NONE         = 0,
    NVAPI_GSYNC_GPU_TOPOLOGY_CONNECTOR_PRIMARY      = 1,
    NVAPI_GSYNC_GPU_TOPOLOGY_CONNECTOR_SECONDARY    = 2,
    NVAPI_GSYNC_GPU_TOPOLOGY_CONNECTOR_TERTIARY     = 3,
    NVAPI_GSYNC_GPU_TOPOLOGY_CONNECTOR_QUARTERNARY  = 4,
} NVAPI_GSYNC_GPU_TOPOLOGY_CONNECTOR;
 
typedef enum _NVAPI_GSYNC_DISPLAY_SYNC_STATE
{
    NVAPI_GSYNC_DISPLAY_SYNC_STATE_UNSYNCED         = 0,
    NVAPI_GSYNC_DISPLAY_SYNC_STATE_SLAVE            = 1,
    NVAPI_GSYNC_DISPLAY_SYNC_STATE_MASTER           = 2,
} NVAPI_GSYNC_DISPLAY_SYNC_STATE;
 
typedef struct _NV_GSYNC_GPU
{
    NvU32                               version;            
    NvPhysicalGpuHandle                 hPhysicalGpu;       
    NVAPI_GSYNC_GPU_TOPOLOGY_CONNECTOR  connector;          
    NvPhysicalGpuHandle                 hProxyPhysicalGpu;  
    NvU32                               isSynced : 1;       
    NvU32                               reserved : 31;      
} NV_GSYNC_GPU;
 
typedef struct _NV_GSYNC_DISPLAY
{
    NvU32                               version;            
    NvU32                               displayId;          
    NvU32                               isMasterable : 1;   
    NvU32                               reserved : 31;      
    NVAPI_GSYNC_DISPLAY_SYNC_STATE      syncState;          
} NV_GSYNC_DISPLAY;
 
#define NV_GSYNC_DISPLAY_VER  MAKE_NVAPI_VERSION(NV_GSYNC_DISPLAY,1)
#define NV_GSYNC_GPU_VER      MAKE_NVAPI_VERSION(NV_GSYNC_GPU,1)
 
 
//
// FUNCTION NAME: NvAPI_GSync_GetTopology
//
NVAPI_INTERFACE NvAPI_GSync_GetTopology(__in NvGSyncDeviceHandle hNvGSyncDevice, __inout_opt NvU32 *gsyncGpuCount,  __inout_ecount_part_opt(*gsyncGpuCount, *gsyncGpuCount) NV_GSYNC_GPU *gsyncGPUs,
                                        __inout_opt NvU32 *gsyncDisplayCount, __inout_ecount_part_opt(*gsyncDisplayCount, *gsyncDisplayCount) NV_GSYNC_DISPLAY *gsyncDisplays);
 
//
// FUNCTION NAME: NvAPI_GSync_SetSyncStateSettings
//
NVAPI_INTERFACE NvAPI_GSync_SetSyncStateSettings(__in NvU32 gsyncDisplayCount, __in_ecount(gsyncDisplayCount) NV_GSYNC_DISPLAY *pGsyncDisplays, __in NvU32 flags);
 
 
 
typedef enum _NVAPI_GSYNC_POLARITY
{
    NVAPI_GSYNC_POLARITY_RISING_EDGE     = 0,
    NVAPI_GSYNC_POLARITY_FALLING_EDGE    = 1,
    NVAPI_GSYNC_POLARITY_BOTH_EDGES      = 2,
} NVAPI_GSYNC_POLARITY;
 
typedef enum _NVAPI_GSYNC_VIDEO_MODE
{
    NVAPI_GSYNC_VIDEO_MODE_NONE          = 0,
    NVAPI_GSYNC_VIDEO_MODE_TTL           = 1,
    NVAPI_GSYNC_VIDEO_MODE_NTSCPALSECAM  = 2,
    NVAPI_GSYNC_VIDEO_MODE_HDTV          = 3,
    NVAPI_GSYNC_VIDEO_MODE_COMPOSITE     = 4,
} NVAPI_GSYNC_VIDEO_MODE;
 
typedef enum _NVAPI_GSYNC_SYNC_SOURCE
{
    NVAPI_GSYNC_SYNC_SOURCE_VSYNC        = 0,
    NVAPI_GSYNC_SYNC_SOURCE_HOUSESYNC    = 1,
} NVAPI_GSYNC_SYNC_SOURCE;
 
typedef struct _NV_GSYNC_DELAY
{
    NvU32        version;          
    NvU32        numLines;         
    NvU32        numPixels;        
    NvU32        maxLines;         
    NvU32        minPixels;        
} NV_GSYNC_DELAY;
 
#define NV_GSYNC_DELAY_VER  MAKE_NVAPI_VERSION(NV_GSYNC_DELAY,1)
 
typedef struct _NV_GSYNC_CONTROL_PARAMS_V1
{
    NvU32                       version;            
    NVAPI_GSYNC_POLARITY        polarity;           
    NVAPI_GSYNC_VIDEO_MODE      vmode;              
    NvU32                       interval;           
    NVAPI_GSYNC_SYNC_SOURCE     source;             
    NvU32                       interlaceMode:1;    
    NvU32                       syncSourceIsOutput:1; 
    NvU32                       reserved:30;        
    NV_GSYNC_DELAY              syncSkew;           
    NV_GSYNC_DELAY              startupDelay;       
} NV_GSYNC_CONTROL_PARAMS_V1;
 
typedef enum _NVAPI_GSYNC_MULTIPLY_DIVIDE_MODE
{
    NVAPI_GSYNC_UNDEFINED_MODE = 0,
    NVAPI_GSYNC_MULTIPLY_MODE  = 1,
    NVAPI_GSYNC_DIVIDE_MODE    = 2,
} NVAPI_GSYNC_MULTIPLY_DIVIDE_MODE;
 
typedef struct _NV_GSYNC_CONTROL_PARAMS_V2
{
    NvU32                              version;                
    NVAPI_GSYNC_POLARITY               polarity;               
    NVAPI_GSYNC_VIDEO_MODE             vmode;                  
    NvU32                              interval;               
    NVAPI_GSYNC_SYNC_SOURCE            source;                 
    NvU32                              interlaceMode:1;        
    NvU32                              syncSourceIsOutput:1;   
    NvU32                              reserved:30;            
    NV_GSYNC_DELAY                     syncSkew;               
    NV_GSYNC_DELAY                     startupDelay;           
    NVAPI_GSYNC_MULTIPLY_DIVIDE_MODE   multiplyDivideMode;     
    NvU8                               multiplyDivideValue;    
} NV_GSYNC_CONTROL_PARAMS_V2;
 
typedef NV_GSYNC_CONTROL_PARAMS_V2 NV_GSYNC_CONTROL_PARAMS;
#define NV_GSYNC_CONTROL_PARAMS_VER1  MAKE_NVAPI_VERSION(NV_GSYNC_CONTROL_PARAMS_V1,1)
#define NV_GSYNC_CONTROL_PARAMS_VER2  MAKE_NVAPI_VERSION(NV_GSYNC_CONTROL_PARAMS_V2,2)
#define NV_GSYNC_CONTROL_PARAMS_VER   NV_GSYNC_CONTROL_PARAMS_VER2
 
 
//
// FUNCTION NAME: NvAPI_GSync_GetControlParameters
//
NVAPI_INTERFACE NvAPI_GSync_GetControlParameters(__in NvGSyncDeviceHandle hNvGSyncDevice, __inout NV_GSYNC_CONTROL_PARAMS *pGsyncControls);
 
 
 
//
// FUNCTION NAME: NvAPI_GSync_SetControlParameters
//
NVAPI_INTERFACE NvAPI_GSync_SetControlParameters(__in NvGSyncDeviceHandle hNvGSyncDevice, __inout NV_GSYNC_CONTROL_PARAMS *pGsyncControls);
 
 
 
 
typedef enum _NVAPI_GSYNC_DELAY_TYPE
{
    NVAPI_GSYNC_DELAY_TYPE_UNKNOWN          = 0,
    NVAPI_GSYNC_DELAY_TYPE_SYNC_SKEW        = 1,
    NVAPI_GSYNC_DELAY_TYPE_STARTUP          = 2
} NVAPI_GSYNC_DELAY_TYPE;
 
//
// FUNCTION NAME: NvAPI_GSync_AdjustSyncDelay
//
NVAPI_INTERFACE NvAPI_GSync_AdjustSyncDelay(__in NvGSyncDeviceHandle hNvGSyncDevice, __in NVAPI_GSYNC_DELAY_TYPE delayType, __inout NV_GSYNC_DELAY *pGsyncDelay, __out_opt NvU32* syncSteps);
 
 
 
typedef struct _NV_GSYNC_STATUS
{
    NvU32 version;                          
    NvU32 bIsSynced;                        
    NvU32 bIsStereoSynced;                  
    NvU32 bIsSyncSignalAvailable;           
} NV_GSYNC_STATUS;
 
#define NV_GSYNC_STATUS_VER  MAKE_NVAPI_VERSION(NV_GSYNC_STATUS,1)
 
//
// FUNCTION NAME: NvAPI_GSync_GetSyncStatus
//
NVAPI_INTERFACE NvAPI_GSync_GetSyncStatus(__in NvGSyncDeviceHandle hNvGSyncDevice, __in NvPhysicalGpuHandle hPhysicalGpu, __inout NV_GSYNC_STATUS *status);
 
 
 
#define NVAPI_MAX_RJ45_PER_GSYNC    2
 
typedef enum _NVAPI_GSYNC_RJ45_IO
{
    NVAPI_GSYNC_RJ45_OUTPUT     = 0,
    NVAPI_GSYNC_RJ45_INPUT      = 1,
    NVAPI_GSYNC_RJ45_UNUSED     = 2 
 
} NVAPI_GSYNC_RJ45_IO;
 
typedef struct _NV_GSYNC_STATUS_PARAMS_V1
{
    NvU32                       version;
    NvU32                       refreshRate;                                
    NVAPI_GSYNC_RJ45_IO         RJ45_IO[NVAPI_MAX_RJ45_PER_GSYNC];          
    NvU32                       RJ45_Ethernet[NVAPI_MAX_RJ45_PER_GSYNC];    
    NvU32                       houseSyncIncoming;                          
    NvU32                       bHouseSync;                                 
} NV_GSYNC_STATUS_PARAMS_V1;
 
typedef struct _NV_GSYNC_STATUS_PARAMS_V2
{
    NvU32                       version;
    NvU32                       refreshRate;                                
    NVAPI_GSYNC_RJ45_IO         RJ45_IO[NVAPI_MAX_RJ45_PER_GSYNC];          
    NvU32                       RJ45_Ethernet[NVAPI_MAX_RJ45_PER_GSYNC];    
    NvU32                       houseSyncIncoming;                          
    NvU32                       bHouseSync;                                 
    NvU32                       bInternalSlave : 1;                         
    NvU32                       reserved : 31;                              
} NV_GSYNC_STATUS_PARAMS_V2;
 
 
typedef NV_GSYNC_STATUS_PARAMS_V2 NV_GSYNC_STATUS_PARAMS;
 
#define NV_GSYNC_STATUS_PARAMS_VER1  MAKE_NVAPI_VERSION(NV_GSYNC_STATUS_PARAMS_V1,1)
#define NV_GSYNC_STATUS_PARAMS_VER2  MAKE_NVAPI_VERSION(NV_GSYNC_STATUS_PARAMS_V2,2)
#define NV_GSYNC_STATUS_PARAMS_VER   NV_GSYNC_STATUS_PARAMS_VER2
 
//
// FUNCTION NAME: NvAPI_GSync_GetStatusParameters
//
NVAPI_INTERFACE NvAPI_GSync_GetStatusParameters(NvGSyncDeviceHandle hNvGSyncDevice, NV_GSYNC_STATUS_PARAMS *pStatusParams);
 
 
 
 
 
 
 
 
 
#if defined(_D3D9_H_)
//
// FUNCTION NAME:   NvAPI_D3D9_RegisterResource
//
NVAPI_INTERFACE NvAPI_D3D9_RegisterResource(IDirect3DResource9* pResource);
#endif //defined(_D3D9_H_)
 
#if defined(_D3D9_H_)
//
// FUNCTION NAME:   NvAPI_D3D9_UnregisterResource
//
NVAPI_INTERFACE NvAPI_D3D9_UnregisterResource(IDirect3DResource9* pResource);
 
#endif //defined(_D3D9_H_)
 
 
 
 
#if defined(_D3D9_H_)
//
// FUNCTION NAME: NvAPI_D3D9_AliasSurfaceAsTexture
//
//
 
 
typedef enum {
    NVAPI_ALIAS_SURFACE_FLAG_NONE                     = 0x00000000,
    NVAPI_ALIAS_SURFACE_FLAG_USE_SUPER                = 0x00000001,  
    NVAPI_ALIAS_SURFACE_FLAG_MASK                     = 0x00000001
} NVAPI_ALIAS_SURFACE_FLAG;
 
 
NVAPI_INTERFACE NvAPI_D3D9_AliasSurfaceAsTexture(IDirect3DDevice9* pDev,
                                                 IDirect3DSurface9* pSurface,
                                                 IDirect3DTexture9 **ppTexture,
                                                 DWORD dwFlag);
#endif //defined(_D3D9_H_)
 
#if defined(_D3D9_H_)
//
// FUNCTION NAME:   NvAPI_D3D9_StretchRectEx
//
NVAPI_INTERFACE NvAPI_D3D9_StretchRectEx(IDirect3DDevice9 * pDevice,
                                         IDirect3DResource9 * pSourceResource,
                                         CONST RECT * pSourceRect,
                                         IDirect3DResource9 * pDestResource,
                                         CONST RECT * pDestRect,
                                         D3DTEXTUREFILTERTYPE Filter);
 
#endif //defined(_D3D9_H_)
 
#if defined(_D3D9_H_)
//
// FUNCTION NAME:   NvAPI_D3D9_ClearRT
//
NVAPI_INTERFACE NvAPI_D3D9_ClearRT(IDirect3DDevice9 * pDevice,
                                   NvU32 dwNumRects,
                                   CONST RECT * pRects,
                                   float r, float g, float b, float a);
#endif //if defined(_D3D9_H_)
 
 
 
 
 
 
 
 
 
 
#if defined(_D3D9_H_) && defined(__cplusplus)
 
//
// FUNCTION NAME: NvAPI_D3D9_GetSurfaceHandle
//
NVAPI_INTERFACE NvAPI_D3D9_GetSurfaceHandle(IDirect3DSurface9 *pSurface, 
                                        NVDX_ObjectHandle *pHandle);
 
#endif //defined(_D3D9_H_) && defined(__cplusplus)
 
#if defined(_D3D9_H_) && defined(__cplusplus)
 
//
// FUNCTION_NAME: NvAPI_D3D9_VideoSetStereoInfo
//
 
#ifndef NV_STEREO_VIDEO_FORMAT_DEFINE
#define NV_STEREO_VIDEO_FORMAT_DEFINE
 
 
typedef enum _NV_STEREO_VIDEO_FORMAT
{
    NV_STEREO_VIDEO_FORMAT_NOT_STEREO         = 0,
 
    NV_STEREO_VIDEO_FORMAT_SIDE_BY_SIDE_LR    = 1,
    NV_STEREO_VIDEO_FORMAT_SIDE_BY_SIDE_RL    = 2,
    NV_STEREO_VIDEO_FORMAT_TOP_BOTTOM_LR      = 3,
    NV_STEREO_VIDEO_FORMAT_TOP_BOTTOM_RL      = 4,
    NV_STEREO_VIDEO_FORMAT_ROW_INTERLEAVE_LR  = 5,
    NV_STEREO_VIDEO_FORMAT_ROW_INTERLEAVE_RL  = 6,
    NV_STEREO_VIDEO_FORMAT_TWO_FRAMES_LR      = 7,
    NV_STEREO_VIDEO_FORMAT_MONO_PLUS_OFFSET   = 8,
 
    NV_STEREO_VIDEO_FORMAT_LAST               = 9,
} NV_STEREO_VIDEO_FORMAT;
 
#endif // NV_STEREO_VIDEO_FORMAT_DEFINE
 
 
typedef struct _NV_DX_VIDEO_STEREO_INFO {
    NvU32                     dwVersion;         
    NVDX_ObjectHandle         hSurface;          
    NVDX_ObjectHandle         hLinkedSurface;    
    NV_STEREO_VIDEO_FORMAT    eFormat;           
    NvS32                     sViewOffset;       
    BOOL                      bStereoEnable;     
} NV_DX_VIDEO_STEREO_INFO;
 
#define NV_DX_VIDEO_STEREO_INFO_VER  MAKE_NVAPI_VERSION(NV_DX_VIDEO_STEREO_INFO,1)
 
NVAPI_INTERFACE NvAPI_D3D9_VideoSetStereoInfo(IDirect3DDevice9 *pDev,
                                              NV_DX_VIDEO_STEREO_INFO *pStereoInfo);
 
#endif //defined(_D3D9_H_) && defined(__cplusplus)
 
 
#if defined(__cplusplus) && defined(__d3d10_h__)
//
// FUNCTION NAME: NvAPI_D3D10_SetDepthBoundsTest
//
NVAPI_INTERFACE NvAPI_D3D10_SetDepthBoundsTest(ID3D10Device *pDev,
                                               NvU32 bEnable,
                                               float fMinDepth,
                                               float fMaxDepth);
 
#endif //defined(__cplusplus) && defined(__d3d10_h__)
 
 
 
 
 
#if defined (__cplusplus) && (defined(__d3d11_h__) || defined(__d3d11_1_h__))
 
//
// FUNCTION NAME: NvAPI_D3D11_IsNvShaderExtnOpCodeSupported
//
NVAPI_INTERFACE NvAPI_D3D11_IsNvShaderExtnOpCodeSupported(__in  IUnknown *pDev,
                                                          __in  NvU32 opCode,
                                                          __out bool *pSupported);
 
#endif //defined (__cplusplus) && (defined(__d3d11_h__) || defined(__d3d11_1_h__))
 
#if defined (__cplusplus) && (defined(__d3d11_h__) || defined(__d3d11_1_h__))
 
//
// FUNCTION NAME: NvAPI_D3D11_SetNvShaderExtnSlot
//
NVAPI_INTERFACE NvAPI_D3D11_SetNvShaderExtnSlot(__in IUnknown *pDev,
                                                __in NvU32 uavSlot);
 
#endif //defined (__cplusplus) && (defined(__d3d11_h__) || defined(__d3d11_1_h__))
 
#if defined (__cplusplus) && defined (__d3d12_h__)
 
//
// FUNCTION NAME: NvAPI_D3D12_SetNvShaderExtnSlotSpace
//
NVAPI_INTERFACE NvAPI_D3D12_SetNvShaderExtnSlotSpace(__in IUnknown *pDev,
                                                __in NvU32 uavSlot,
                                                __in NvU32 uavSpace);
 
//
// FUNCTION NAME: NvAPI_D3D12_SetNvShaderExtnSlotSpaceLocalThread
//
NVAPI_INTERFACE NvAPI_D3D12_SetNvShaderExtnSlotSpaceLocalThread(__in IUnknown *pDev,
                                                                __in NvU32 uavSlot,
                                                                __in NvU32 uavSpace);
 
#endif //defined (__cplusplus) && defined (__d3d12_h__)
 
#if defined (__cplusplus) && (defined(__d3d11_h__) || defined(__d3d11_1_h__))
 
//
// FUNCTION NAME: NvAPI_D3D11_SetNvShaderExtnSlotLocalThread
//
NVAPI_INTERFACE NvAPI_D3D11_SetNvShaderExtnSlotLocalThread(__in IUnknown *pDev,
                                                           __in NvU32 uavSlot);
 
#endif //defined (__cplusplus) && (defined(__d3d11_h__) || defined(__d3d11_1_h__))
 
#if defined (__cplusplus) && (defined(__d3d11_h__) || defined(__d3d11_1_h__))
 
//
// FUNCTION NAME: NvAPI_D3D11_BeginUAVOverlapEx
//
typedef enum _NVAPI_D3D11_INSERTWFI_FLAG
{
    NVAPI_D3D_BEGIN_UAV_OVERLAP_NO_WFI      = 0x00000000,   
    NVAPI_D3D_BEGIN_UAV_OVERLAP_GFX_WFI     = 0x00000001,   
    NVAPI_D3D_BEGIN_UAV_OVERLAP_COMP_WFI    = 0x00000002,   
} NVAPI_D3D11_INSERTWFI_FLAG;
 
NVAPI_INTERFACE NvAPI_D3D11_BeginUAVOverlapEx(__in  IUnknown *pDeviceOrContext, __in NvU32 insertWFIFlags);
 
#endif //defined (__cplusplus) && (defined(__d3d11_h__) || defined(__d3d11_1_h__))
 
#if defined (__cplusplus) && (defined(__d3d11_h__) || defined(__d3d11_1_h__))
 
//
// FUNCTION NAME: NvAPI_D3D11_BeginUAVOverlap
//
NVAPI_INTERFACE NvAPI_D3D11_BeginUAVOverlap(__in  IUnknown *pDeviceOrContext);
 
#endif //defined (__cplusplus) && (defined(__d3d11_h__) || defined(__d3d11_1_h__))
 
#if defined (__cplusplus) && (defined(__d3d11_h__) || defined(__d3d11_1_h__))
 
//
// FUNCTION NAME: NvAPI_D3D11_EndUAVOverlap
//
NVAPI_INTERFACE NvAPI_D3D11_EndUAVOverlap(__in  IUnknown *pDeviceOrContext);
 
#endif //defined (__cplusplus) && (defined(__d3d11_h__) || defined(__d3d11_1_h__))
 
#if defined(__cplusplus) && defined(__d3d11_h__)
//
// FUNCTION NAME: NvAPI_D3D11_GetResourceHandle
//
NVAPI_INTERFACE NvAPI_D3D11_GetResourceHandle(ID3D11Device *pDev,
                                              ID3D11Resource* pResource,
                                              NVDX_ObjectHandle* phObject);
 
#endif //defined(__cplusplus) && defined(__d3d11_h__)
 
#if defined(_D3D9_H_) || defined(__d3d10_h__) || defined(__d3d10_1_h__) || defined(__d3d11_h__)
//
// FUNCTION NAME: NvAPI_D3D_SetFPSIndicatorState
//
NVAPI_INTERFACE NvAPI_D3D_SetFPSIndicatorState(IUnknown *pDev, NvU8 doEnable);
 
#endif //if defined(_D3D9_H_) || defined(__d3d10_h__) || defined(__d3d10_1_h__) || defined(__d3d11_h__)
 
#if defined(_D3D9_H_)
//
// FUNCTION NAME: NvAPI_D3D9_Present
//
NVAPI_INTERFACE NvAPI_D3D9_Present(IDirect3DDevice9 *pDevice,
                                   IDirect3DSwapChain9 *pSwapChain,
                                   const RECT *pSourceRect,
                                   const RECT *pDestRect,
                                   HWND hDestWindowOverride,
                                   const RGNDATA *pDirtyRegion);
#endif //if defined(_D3D9_H_)
 
#if defined(_D3D9_H_)
//
// FUNCTION NAME: NvAPI_D3D9_QueryFrameCount
//
NVAPI_INTERFACE NvAPI_D3D9_QueryFrameCount(IDirect3DDevice9 *pDevice,
                                           NvU32 *pFrameCount);
#endif //if defined(_D3D9_H_)
 
#if defined(_D3D9_H_)
//
// FUNCTION NAME: NvAPI_D3D9_ResetFrameCount
//
NVAPI_INTERFACE NvAPI_D3D9_ResetFrameCount(IDirect3DDevice9 *pDevice);
#endif //if defined(_D3D9_H_)
 
#if defined(_D3D9_H_)
//
// FUNCTION NAME: NvAPI_D3D9_QueryMaxSwapGroup
//
NVAPI_INTERFACE NvAPI_D3D9_QueryMaxSwapGroup(IDirect3DDevice9 *pDevice, 
                                             NvU32 *pMaxGroups, 
                                             NvU32 *pMaxBarriers); 
#endif //if defined(_D3D9_H_)
 
#if defined(_D3D9_H_)
//
// FUNCTION NAME: NvAPI_D3D9_QuerySwapGroup
//
NVAPI_INTERFACE NvAPI_D3D9_QuerySwapGroup(IDirect3DDevice9 *pDevice, 
                                          IDirect3DSwapChain9 *pSwapChain, 
                                          NvU32 *pSwapGroup, 
                                          NvU32 *pSwapBarrier); 
#endif //if defined(_D3D9_H_)
 
#if defined(_D3D9_H_)
//
// FUNCTION NAME: NvAPI_D3D9_JoinSwapGroup
//
NVAPI_INTERFACE NvAPI_D3D9_JoinSwapGroup(IDirect3DDevice9 *pDevice, 
                                         IDirect3DSwapChain9 *pSwapChain, 
                                         NvU32 group,
                                         BOOL blocking); 
#endif //if defined(_D3D9_H_)
 
#if defined(_D3D9_H_)
//
// FUNCTION NAME: NvAPI_D3D9_BindSwapBarrier
//
NVAPI_INTERFACE NvAPI_D3D9_BindSwapBarrier(IDirect3DDevice9 *pDevice, 
                                           NvU32 group, 
                                           NvU32 barrier); 
#endif //if defined(_D3D9_H_)
 
typedef enum
{
    NVAPI_VSYNC_DEFAULT,                    
    NVAPI_VSYNC_OFF,                        
    NVAPI_VSYNC_ON,                         
    NVAPI_VSYNC_ADAPTIVE,                   
    NVAPI_VSYNC_ADAPTIVE_HALF_REFRESH_RATE  
 
} NVAPI_VSYNC_MODE;
 
 
#if defined(_D3D9_H_) || defined(__d3d10_h__) || defined(__d3d10_1_h__) || defined(__d3d11_h__) || defined(__d3d12_h__)
//
// FUNCTION NAME: NvAPI_D3D_SetVerticalSyncMode
//
NVAPI_INTERFACE NvAPI_D3D_SetVerticalSyncMode(__in IUnknown *pDevice, __in NVAPI_VSYNC_MODE vsyncMode); 
 
#endif //if defined(_D3D9_H_) || defined(__d3d10_h__) || defined(__d3d10_1_h__) || defined(__d3d11_h__) || defined(__d3d12_h__)
 
#if defined(__d3d10_h__) || defined(__d3d10_1_h__) || defined(__d3d11_h__) || defined(__d3d12_h__)
//
// FUNCTION NAME: NvAPI_D3D1x_Present
//
//                                     DXGI_STATUS_OCCLUDED, or D3DDDIERR_DEVICEREMOVED. 
NVAPI_INTERFACE NvAPI_D3D1x_Present(IUnknown *pDevice,
                                    IDXGISwapChain *pSwapChain,
                                    UINT SyncInterval,
                                    UINT Flags);
#endif // defined(__d3d10_h__) || defined(__d3d10_1_h__) || defined(__d3d11_h__) || defined(__d3d12_h__)
 
#if defined(__d3d10_h__) || defined(__d3d10_1_h__) || defined(__d3d11_h__) || defined(__d3d12_h__)
//
// FUNCTION NAME: NvAPI_D3D1x_QueryFrameCount
//
NVAPI_INTERFACE NvAPI_D3D1x_QueryFrameCount(IUnknown *pDevice,
                                            NvU32 *pFrameCount);
#endif // defined(__d3d10_h__) || defined(__d3d10_1_h__) || defined(__d3d11_h__) || defined(__d3d12_h__)
 
#if defined(__d3d10_h__) || defined(__d3d10_1_h__) || defined(__d3d11_h__) || defined(__d3d12_h__)
//
// FUNCTION NAME: NvAPI_D3D1x_ResetFrameCount
//
NVAPI_INTERFACE NvAPI_D3D1x_ResetFrameCount(IUnknown *pDevice);
#endif // defined(__d3d10_h__) || defined(__d3d10_1_h__) || defined(__d3d11_h__) || defined(__d3d12_h__)
 
#if defined(__d3d10_h__) || defined(__d3d10_1_h__) || defined(__d3d11_h__) || defined(__d3d12_h__)
//
// FUNCTION NAME: NvAPI_D3D1x_QueryMaxSwapGroup
//
NVAPI_INTERFACE NvAPI_D3D1x_QueryMaxSwapGroup(IUnknown *pDevice, 
                                              NvU32 *pMaxGroups, 
                                              NvU32 *pMaxBarriers); 
#endif // defined(__d3d10_h__) || defined(__d3d10_1_h__) || defined(__d3d11_h__) || defined(__d3d12_h__)
 
#if defined(__d3d10_h__) || defined(__d3d10_1_h__) || defined(__d3d11_h__) || defined(__d3d12_h__)
//
// FUNCTION NAME: NvAPI_D3D1x_QuerySwapGroup
//
NVAPI_INTERFACE NvAPI_D3D1x_QuerySwapGroup(IUnknown *pDevice, 
                                           IDXGISwapChain  *pSwapChain, 
                                           NvU32 *pSwapGroup, 
                                           NvU32 *pSwapBarrier); 
#endif // defined(__d3d10_h__) || defined(__d3d10_1_h__) || defined(__d3d11_h__) || defined(__d3d12_h__)
 
#if defined(__d3d10_h__) || defined(__d3d10_1_h__) || defined(__d3d11_h__) || defined(__d3d12_h__)
//
// FUNCTION NAME: NvAPI_D3D1x_JoinSwapGroup
//
NVAPI_INTERFACE NvAPI_D3D1x_JoinSwapGroup(IUnknown *pDevice, 
                                          IDXGISwapChain  *pSwapChain, 
                                          NvU32 group,
                                          BOOL blocking);
#endif // defined(__d3d10_h__) || defined(__d3d10_1_h__) || defined(__d3d11_h__) || defined(__d3d12_h__)
 
#if defined(__d3d10_h__) || defined(__d3d10_1_h__) || defined(__d3d11_h__) || defined(__d3d12_h__)
//
// FUNCTION NAME: NvAPI_D3D1x_BindSwapBarrier
//
NVAPI_INTERFACE NvAPI_D3D1x_BindSwapBarrier(IUnknown *pDevice, 
                                            NvU32 group, 
                                            NvU32 barrier); 
#endif // defined(__d3d10_h__) || defined(__d3d10_1_h__) || defined(__d3d11_h__) || defined(__d3d12_h__)
 
#if defined(__cplusplus) && defined(__d3d12_h__)
//
// FUNCTION NAME: NvAPI_D3D12_QueryPresentBarrierSupport
//
NVAPI_INTERFACE NvAPI_D3D12_QueryPresentBarrierSupport(__in ID3D12Device *pDevice, __out bool *pSupported);
#endif // defined(__cplusplus) && defined(__d3d12_h__)
 
#if defined(__cplusplus) && defined(__d3d12_h__)
//
// FUNCTION NAME: NvAPI_D3D12_CreatePresentBarrierClient
//
NVAPI_INTERFACE NvAPI_D3D12_CreatePresentBarrierClient(__in ID3D12Device *pDevice,
                                                       __in IDXGISwapChain *pSwapChain,
                                                       __out NvPresentBarrierClientHandle *pPresentBarrierClient);
#endif // defined(__cplusplus) && defined(__d3d12_h__)
 
#if defined(__cplusplus) && defined(__d3d12_h__)
//
// FUNCTION NAME: NvAPI_D3D12_RegisterPresentBarrierResources
//
NVAPI_INTERFACE NvAPI_D3D12_RegisterPresentBarrierResources(__in NvPresentBarrierClientHandle presentBarrierClient,
                                                            __in ID3D12Fence                  *pFence,
                                                            __in ID3D12Resource               **ppResources,
                                                            __in NvU32                        numResources);
#endif // defined(__cplusplus) && defined(__d3d12_h__)
 
#if defined(__cplusplus)
//
// FUNCTION NAME: NvAPI_DestroyPresentBarrierClient
//
NVAPI_INTERFACE NvAPI_DestroyPresentBarrierClient(__in NvPresentBarrierClientHandle presentBarrierClient);
#endif // defined(__cplusplus)
 
#if defined(__cplusplus)
typedef struct _NV_JOIN_PRESENT_BARRIER_PARAMS
{
    NvU32                     dwVersion;            
} NV_JOIN_PRESENT_BARRIER_PARAMS;
 
#define NV_JOIN_PRESENT_BARRIER_PARAMS_VER1  MAKE_NVAPI_VERSION(NV_JOIN_PRESENT_BARRIER_PARAMS, 1)
//
// FUNCTION NAME: NvAPI_JoinPresentBarrier
//
NVAPI_INTERFACE NvAPI_JoinPresentBarrier(__in NvPresentBarrierClientHandle presentBarrierClient, __in NV_JOIN_PRESENT_BARRIER_PARAMS *pParams);
#endif // defined(__cplusplus)
 
#if defined(__cplusplus)
//
// FUNCTION NAME: NvAPI_LeavePresentBarrier
//
NVAPI_INTERFACE NvAPI_LeavePresentBarrier(__in NvPresentBarrierClientHandle presentBarrierClient);
#endif // defined(__cplusplus)
 
#if defined(__cplusplus)
 
#define NV_PRESENT_BARRIER_FRAME_STATICS_VER1  MAKE_NVAPI_VERSION(NV_PRESENT_BARRIER_FRAME_STATISTICS,1)
 
typedef enum _NV_PRESENT_BARRIER_SYNC_MODE
{
    PRESENT_BARRIER_NOT_JOINED       = 0x00000000,    
    PRESENT_BARRIER_SYNC_CLIENT      = 0x00000001,    
    PRESENT_BARRIER_SYNC_SYSTEM      = 0x00000002,    
    PRESENT_BARRIER_SYNC_CLUSTER     = 0x00000003,    
} NV_PRESENT_BARRIER_SYNC_MODE;
 
typedef struct _NV_PRESENT_BARRIER_FRAME_STATISTICS
{
    NvU32                           dwVersion;            
    NV_PRESENT_BARRIER_SYNC_MODE    SyncMode;             
    NvU32                           PresentCount;         
    NvU32                           PresentInSyncCount;   
    NvU32                           FlipInSyncCount;      
    NvU32                           RefreshCount;         
} NV_PRESENT_BARRIER_FRAME_STATISTICS;
 
//
// FUNCTION NAME: NvAPI_QueryPresentBarrierFrameStatistics
//
NVAPI_INTERFACE NvAPI_QueryPresentBarrierFrameStatistics(__in NvPresentBarrierClientHandle presentBarrierClient,
                                                         __out NV_PRESENT_BARRIER_FRAME_STATISTICS *pFrameStats);
#endif // defined(__cplusplus)
 
#if defined(__cplusplus) && defined(__d3d12_h__)
//
// FUNCTION NAME: NvAPI_D3D12_CreateDDisplayPresentBarrierClient
//
NVAPI_INTERFACE NvAPI_D3D12_CreateDDisplayPresentBarrierClient(__in ID3D12Device *pDevice, __in NvU32 sourceId, __out NvPresentBarrierClientHandle *pPresentBarrierClient);
#endif // defined(__cplusplus) && defined(__d3d12_h__)
 
#if defined (__cplusplus) && (defined(__d3d11_h__) || defined(__d3d11_1_h__) || defined(__d3d12_h__))
 
enum NVAPI_QUAD_FILLMODE
{
    NVAPI_QUAD_FILLMODE_DISABLED = 0,
    NVAPI_QUAD_FILLMODE_BBOX = 1,
    NVAPI_QUAD_FILLMODE_FULL_VIEWPORT = 2,
};
 
#endif //defined(__cplusplus) && (defined(__d3d11_h__) || defined(__d3d11_1_h__) || defined(__d3d12_h__))
 
#if defined (__cplusplus) && (defined(__d3d11_h__) || defined(__d3d11_1_h__))
 
typedef struct NvAPI_D3D11_RASTERIZER_DESC_EX
{
    // D3D11_RASTERIZER_DESC member variables
    D3D11_FILL_MODE FillMode;
    D3D11_CULL_MODE CullMode;
    BOOL FrontCounterClockwise;
    INT DepthBias;
    FLOAT DepthBiasClamp;
    FLOAT SlopeScaledDepthBias;
    BOOL DepthClipEnable;
    BOOL ScissorEnable;
    BOOL MultisampleEnable;
    BOOL AntialiasedLineEnable;
 
    // NvAPI_D3D11_RASTERIZER_DESC_EX specific member variables
    NvU32 ForcedSampleCount;                 //<! Added DX 11.1, part of _DESC1 version of this struct.
    bool ProgrammableSamplePositionsEnable;  //<! enable Programmable Samples feature
    bool InterleavedSamplingEnable;          //<! when jitter is enabled, an app need to fill the whole arrays below, otherwise only as much entries as samples
    NvU8 SampleCount;                        //<! number of samples. In TIR N->1 it needs to match N, in non-TIR it needs to match RT sample count. Ignored if ForcePerSampleInterlock is set
    NvU8 SamplePositionsX[16];               //<! x positions in API sample order
    NvU8 SamplePositionsY[16];               //<! y positions in API sample order
    bool ConservativeRasterEnable;           //<! rasterize all pixels a primitive touches in any way instead of just those with the centroid covered. 
    NVAPI_QUAD_FILLMODE QuadFillMode;        //<! Fill a triangle outside its bounds as a screen-aligned quad, matching the tri's bounding-box or filling the full viewport.
    bool PostZCoverageEnable;                //<! Enable pixel-shader input SV_COVERAGE to account for z-test in early-z mode.
    bool CoverageToColorEnable;              //<! Enable output of coverage to a color render-target.
    NvU8 CoverageToColorRTIndex;             //<! Index of RT for coverage-to-color.
    bool TargetIndepentRasterWithDepth;      //<! TargetIndepentRasterWithDepth = TRUE enables rasterezation mode where sample count of both raster and depth-stencil buffer are equal and do not match RT sample count.
    NvU8 reserved[63];                       //<! reserved for expansion, set to zero.
} NvAPI_D3D11_RASTERIZER_DESC_EX;
 
//
// FUNCTION NAME: NvAPI_D3D11_CreateRasterizerState
//
NVAPI_INTERFACE NvAPI_D3D11_CreateRasterizerState(__in ID3D11Device *pDevice,
                                                  __in const NvAPI_D3D11_RASTERIZER_DESC_EX *pRasterizerDesc,
                                                  __out ID3D11RasterizerState **ppRasterizerState);
 
#endif //defined(__cplusplus) && defined(__d3d11_h__)
 
 
#if defined (__cplusplus) && (defined(_D3D9_H_) || defined(__d3d11_h__) || defined(__d3d11_1_h__) || defined(__d3d12_h__))
 
//
// FUNCTION NAME: NvAPI_D3D_ConfigureAnsel
//
 
typedef enum _NVAPI_ANSEL_FEATURE
{
    NVAPI_ANSEL_FEATURE_UNKNOWN         = 0,
    NVAPI_ANSEL_FEATURE_BLACK_AND_WHITE = 1,
    NVAPI_ANSEL_FEATURE_HUDLESS         = 2
} NVAPI_ANSEL_FEATURE;
 
typedef enum _NVAPI_ANSEL_FEATURE_STATE
{
    NVAPI_ANSEL_FEATURE_STATE_UNKNOWN   = 0,
    NVAPI_ANSEL_FEATURE_STATE_ENABLE    = 1,    
    NVAPI_ANSEL_FEATURE_STATE_DISABLE   = 2     
} NVAPI_ANSEL_FEATURE_STATE;
 
typedef enum _NVAPI_ANSEL_HOTKEY_MODIFIER
{
    NVAPI_ANSEL_HOTKEY_MODIFIER_UNKNOWN = 0,
    NVAPI_ANSEL_HOTKEY_MODIFIER_CTRL    = 1,    
    NVAPI_ANSEL_HOTKEY_MODIFIER_SHIFT   = 2,    
    NVAPI_ANSEL_HOTKEY_MODIFIER_ALT     = 3     
} NVAPI_ANSEL_HOTKEY_MODIFIER;
 
typedef struct NVAPI_ANSEL_FEATURE_CONFIGURATION_STRUCT {
    NVAPI_ANSEL_FEATURE featureId;              
    NVAPI_ANSEL_FEATURE_STATE featureState;     
    UINT hotkey;                                
} NVAPI_ANSEL_FEATURE_CONFIGURATION_STRUCT;
 
typedef struct NVAPI_ANSEL_CONFIGURATION_STRUCT_V1 {
    NvU32 version;                                                
    NVAPI_ANSEL_HOTKEY_MODIFIER hotkeyModifier;                   
    UINT keyEnable;                                               
    UINT numAnselFeatures;                                        
    NVAPI_ANSEL_FEATURE_CONFIGURATION_STRUCT * pAnselFeatures; 
} NVAPI_ANSEL_CONFIGURATION_STRUCT_V1;
 
typedef NVAPI_ANSEL_CONFIGURATION_STRUCT_V1 NVAPI_ANSEL_CONFIGURATION_STRUCT;
 
#define NVAPI_ANSEL_CONFIGURATION_STRUCT_VER1  MAKE_NVAPI_VERSION(NVAPI_ANSEL_CONFIGURATION_STRUCT_V1,1)
#define NVAPI_ANSEL_CONFIGURATION_STRUCT_VER NVAPI_ANSEL_CONFIGURATION_STRUCT_VER1
 
NVAPI_INTERFACE NvAPI_D3D_ConfigureAnsel(__in IUnknown *pDevice,
                                         __in NVAPI_ANSEL_CONFIGURATION_STRUCT *pNLSConfig);
 
#endif //defined (__cplusplus) && (defined(_D3D9_H_) || defined(__d3d11_h__) || defined(__d3d11_1_h__) || defined(__d3d12_h__))
 
 
#if defined (__cplusplus) && defined(__d3d11_2_h__)
 
//
// FUNCTION NAME: NvAPI_D3D11_CreateTiledTexture2DArray
//
//
 
NVAPI_INTERFACE NvAPI_D3D11_CreateTiledTexture2DArray(__in       ID3D11Device           *pDevice,
                                                      __in const D3D11_TEXTURE2D_DESC   *pDesc,
                                                      __in const D3D11_SUBRESOURCE_DATA *pInitialData,
                                                      __out      ID3D11Texture2D        **ppTexture2D);
 
#endif //defined(__cplusplus) && defined(__d3d11_2_h__)
 
 
#if defined (__cplusplus) && defined(__d3d11_h__)
 
typedef enum _NV_D3D11_FEATURE
{
    NV_D3D11_FEATURE_RASTERIZER,
} NV_D3D11_FEATURE;
 
typedef struct _NV_D3D11_FEATURE_DATA_RASTERIZER_SUPPORT
{
    BOOL TargetIndependentRasterWithDepth;
    BOOL ProgrammableSamplePositions;
    BOOL InterleavedSampling;
    BOOL ConservativeRaster;
    BOOL PostZCoverage;
    BOOL CoverageToColor;
} NV_D3D11_FEATURE_DATA_RASTERIZER_SUPPORT;
 
//
// FUNCTION NAME: NvAPI_D3D11_CheckFeatureSupport
//
NVAPI_INTERFACE NvAPI_D3D11_CheckFeatureSupport(__in  ID3D11Device        *pDevice,
                                                __in  NV_D3D11_FEATURE    Feature,
                                                __out void                *pFeatureSupportData,
                                                __in  UINT                FeatureSupportDataSize);
 
#endif //defined(__cplusplus) && defined(__d3d11_h__)
 
 
#if defined (__cplusplus) && defined(__d3d11_h__)
 
//
// FUNCTION NAME: NvAPI_D3D11_CreateImplicitMSAATexture2D
//
//
NVAPI_INTERFACE NvAPI_D3D11_CreateImplicitMSAATexture2D(__in  ID3D11Device                 *pDevice,
                                                        __in  const D3D11_TEXTURE2D_DESC   *pDesc,
                                                        __out ID3D11Texture2D              **ppTexture2D);
 
#endif //defined(__cplusplus) && defined(__d3d11_h__)
 
 
#if defined (__cplusplus) && defined(__d3d12_h__)
 
//
// FUNCTION NAME: NvAPI_D3D12_CreateImplicitMSAATexture2D
//
//
NVAPI_INTERFACE NvAPI_D3D12_CreateCommittedImplicitMSAATexture2D(
        __in  ID3D12Device* pDevice,
        __in  const D3D12_HEAP_PROPERTIES *pHeapProperties,
        D3D12_HEAP_FLAGS HeapFlags,
        __in  const D3D12_RESOURCE_DESC *pDesc,
        D3D12_RESOURCE_STATES InitialResourceState,
        __in_opt  const D3D12_CLEAR_VALUE *pOptimizedClearValue,
        REFIID riidResource,
        __out void **ppvResource);
 
#endif //defined(__cplusplus) && defined(__d3d12_h__)
 
 
 
typedef enum _NV_RESOLVE_MODE {
    NV_RESOLVE_MODE_SAMPLE_0,
} NV_RESOLVE_MODE;
 
#if defined (__cplusplus) && defined(__d3d11_h__)
 
//
// FUNCTION NAME: NvAPI_D3D11_ResolveSubresourceRegion
//
//
NVAPI_INTERFACE NvAPI_D3D11_ResolveSubresourceRegion(
    __in  ID3D11Device     *pDevice,
    __in  ID3D11Texture2D  *pDstResource,
    __in  UINT              DstSubresource,
    __in  UINT              DstX,
    __in  UINT              DstY,
    __in  ID3D11Texture2D  *pSrcResource,
    __in  UINT              SrcSubresource,
    __in_opt const RECT    *pSrcRect,
    __in  DXGI_FORMAT       Format,
    __in  NV_RESOLVE_MODE   ResolveMode);
 
#endif //defined(__cplusplus) && defined(__d3d11_h__)
 
 
#if defined (__cplusplus) && defined(__d3d12_h__)
 
//
// FUNCTION NAME: NvAPI_D3D12_ResolveSubresourceRegion
//
//
NVAPI_INTERFACE NvAPI_D3D12_ResolveSubresourceRegion(
    __in     ID3D12GraphicsCommandList1*pCommandList,
    __in     ID3D12Resource            *pDstResource,
    __in     UINT                       DstSubresource,
    __in     UINT                       DstX,
    __in     UINT                       DstY,
    __in     ID3D12Resource            *pSrcResource,
    __in     UINT                       SrcSubresource,
    __in_opt RECT                      *pSrcRect,
    __in     DXGI_FORMAT                Format,
    __in     NV_RESOLVE_MODE            ResolveMode);
 
#endif //defined(__cplusplus) && defined(__d3d12_h__)
 
 
#if defined (__cplusplus) && defined(__d3d11_2_h__)
 
//
// FUNCTION NAME: NvAPI_D3D11_TiledTexture2DArrayGetDesc
//
//
 
NVAPI_INTERFACE NvAPI_D3D11_TiledTexture2DArrayGetDesc(__in  ID3D11Texture2D      *pTiledTexture2DArray,
                                                       __out D3D11_TEXTURE2D_DESC *pDesc);
 
#endif //defined(__cplusplus) && defined(__d3d11_2_h__)
 
 
#if defined (__cplusplus) && defined(__d3d11_2_h__)
 
//
// FUNCTION NAME: NvAPI_D3D11_UpdateTileMappings
//
//
 
NVAPI_INTERFACE NvAPI_D3D11_UpdateTileMappings(
    __in       ID3D11DeviceContext2            *pDeviceContext,
    __in       ID3D11Resource                  *pTiledResource,
    __in       UINT                             NumTiledResourceRegions,
    __in const D3D11_TILED_RESOURCE_COORDINATE *pTiledResourceRegionStartCoordinates,
    __in const D3D11_TILE_REGION_SIZE          *pTiledResourceRegionSizes,
    __in       ID3D11Buffer                    *pTilePool,
    __in       UINT                             NumRanges,
    __in const UINT                            *pRangeFlags,
    __in const UINT                            *pTilePoolStartOffsets,
    __in const UINT                            *pRangeTileCounts,
    __in       UINT                             Flags);
 
#endif //defined(__cplusplus) && defined(__d3d11_2_h__)
 
 
#if defined (__cplusplus) && defined(__d3d11_2_h__)
 
//
// FUNCTION NAME: NvAPI_D3D11_CopyTileMappings
//
//
 
NVAPI_INTERFACE NvAPI_D3D11_CopyTileMappings(
    __in       ID3D11DeviceContext             *pDeviceContext,
    __in       ID3D11Resource                  *pDestTiledResource,
    __in const D3D11_TILED_RESOURCE_COORDINATE *pDestRegionStartCoordinate,
    __in       ID3D11Resource                  *pSourceTiledResource,
    __in const D3D11_TILED_RESOURCE_COORDINATE *pSourceRegionStartCoordinate,
    __in const D3D11_TILE_REGION_SIZE          *pTileRegionSize,
    __in       UINT                             Flags);
 
#endif //defined(__cplusplus) && defined(__d3d11_2_h__)
 
 
#if defined (__cplusplus) && defined(__d3d11_2_h__)
 
//
// FUNCTION NAME: NvAPI_D3D11_TiledResourceBarrier
//
//
 
NVAPI_INTERFACE NvAPI_D3D11_TiledResourceBarrier(
    __in       ID3D11DeviceContext             *pDeviceContext,
    __in       ID3D11Resource                  *pTiledResourceAccessBeforeBarrier,
    __in       ID3D11Resource                  *pTiledResourceAccessAfterBarrier);
 
#endif //defined(__cplusplus) && defined(__d3d11_2_h__)
 
 
#if defined (__cplusplus) && (defined(__d3d11_h__) || defined(__d3d11_1_h__))
 
//
// FUNCTION NAME: NvAPI_D3D11_AliasMSAATexture2DAsNonMSAA
//
NVAPI_INTERFACE NvAPI_D3D11_AliasMSAATexture2DAsNonMSAA(__in ID3D11Device *pDevice,
                                                        __in ID3D11Texture2D *pInputTex,
                                                        __out ID3D11Texture2D **ppOutTex);
 
#endif //defined(__cplusplus) && defined(__d3d11_h__)
 
#if defined (__cplusplus) && (defined(__d3d11_h__) || defined(__d3d12_h__)) && (!defined(CINTERFACE))
typedef UINT NvAPI_D3D11_SWIZZLE_MODE;
 
typedef enum _NV_SWIZZLE_MODE
{
    NV_SWIZZLE_POS_X = 0,
    NV_SWIZZLE_NEG_X = 1,
    NV_SWIZZLE_POS_Y = 2,
    NV_SWIZZLE_NEG_Y = 3,
    NV_SWIZZLE_POS_Z = 4,
    NV_SWIZZLE_NEG_Z = 5,
    NV_SWIZZLE_POS_W = 6,
    NV_SWIZZLE_NEG_W = 7
}NV_SWIZZLE_MODE;
 
typedef enum _NV_SWIZZLE_OFFSET
{
    NV_SWIZZLE_OFFSET_X = 0,
    NV_SWIZZLE_OFFSET_Y = 4,
    NV_SWIZZLE_OFFSET_Z = 8,
    NV_SWIZZLE_OFFSET_W = 12
}NV_SWIZZLE_OFFSET;
 
#endif //defined (__cplusplus) && (defined(__d3d11_h__) || defined(__d3d12_h__)) && (!defined(CINTERFACE))
 
 
#if defined (__cplusplus) && (defined(__d3d11_h__) || defined(__d3d12_h__)) && (!defined(CINTERFACE))
#define NV_CUSTOM_SEMANTIC_MAX_LIMIT 32
 
typedef enum NV_CUSTOM_SEMANTIC_TYPE
{
    NV_NONE_SEMANTIC                    = 0,
    NV_X_RIGHT_SEMANTIC                 = 1,
    NV_VIEWPORT_MASK_SEMANTIC           = 2,
    NV_XYZW_RIGHT_SEMANTIC              = 3,
    NV_VIEWPORT_MASK_2_SEMANTIC         = 4,
 
    NV_POSITION_SEMANTIC                = 5,
    NV_CLIP_DISTANCE_0_SEMANTIC         = 6,    // MultiView can accept upto two vec4 values. So the application should not use
    NV_CLIP_DISTANCE_1_SEMANTIC         = 7,    // more than 2 of the below Clip / Cull semantics in a single shader.
    NV_CULL_DISTANCE_0_SEMANTIC         = 8,
    NV_CULL_DISTANCE_1_SEMANTIC         = 9,
    NV_GENERIC_ATTRIBUTE_SEMANTIC       = 10,
 
    NV_PACKED_EYE_INDEX_SEMANTIC        = 17,
    NV_CUSTOM_SEMANTIC_MAX        = NV_CUSTOM_SEMANTIC_MAX_LIMIT,
} NV_CUSTOM_SEMANTIC_TYPE;
 
typedef struct _NV_CUSTOM_SEMANTIC
{
    UINT                        version;                                // NV_CUSTOM_SEMANTIC_VERSION
 
    NV_CUSTOM_SEMANTIC_TYPE     NVCustomSemanticType;                   // type of custom semantic (NV_CUSTOM_SEMANTIC_TYPE)
    NvAPI_LongString            NVCustomSemanticNameString;             // name of custom semantic e.g. "NV_X_RIGHT", "NV_VIEWPORT_MASK"
    BOOL                        RegisterSpecified;                      // (optional) set to TRUE to explicitly provide register number and mask as below
    NvU32                       RegisterNum;                            // (optional) output register which has the custom semantic.
    NvU32                       RegisterMask;                           // (optional) output register component mask which has the custom semantic (X:1, Y:2, Z:4)
    NvU32                       Reserved;                               // reserved
} NV_CUSTOM_SEMANTIC;
 
#define NV_CUSTOM_SEMANTIC_VERSION      MAKE_NVAPI_VERSION(NV_CUSTOM_SEMANTIC, 1)
 
#endif //defined(__cplusplus) && (defined(__d3d11_h__) || defined(__d3d12_h__)) && (!defined(CINTERFACE))
 
#if defined (__cplusplus) && defined(__d3d11_h__) && (!defined(CINTERFACE))
 
typedef struct NvAPI_D3D11_CREATE_GEOMETRY_SHADER_EX_V5
{
    UINT version;
 
    BOOL UseViewportMask;
    BOOL OffsetRtIndexByVpIndex;
    BOOL ForceFastGS;
    BOOL DontUseViewportOrder;
    BOOL UseAttributeSkipMask;
    BOOL UseCoordinateSwizzle;
    NvAPI_D3D11_SWIZZLE_MODE *pCoordinateSwizzling;
 
    NvU32 NumCustomSemantics;                           // Number of custom semantics elements (upto NV_CUSTOM_SEMANTIC_MAX) provided in array pointer pCustomSemantics
    NV_CUSTOM_SEMANTIC *pCustomSemantics;               // pointer to array of NV_CUSTOM_SEMANTIC
    BOOL ConvertToFastGS;                               // reserved
    BOOL UseSpecificShaderExt;                          // TRUE if creating minimal specific shaders with nvapi shader extensions
} NvAPI_D3D11_CREATE_GEOMETRY_SHADER_EX_V5;
 
typedef NvAPI_D3D11_CREATE_GEOMETRY_SHADER_EX_V5        NvAPI_D3D11_CREATE_GEOMETRY_SHADER_EX;
#define NVAPI_D3D11_CREATEGEOMETRYSHADEREX_2_VER_5      MAKE_NVAPI_VERSION(NvAPI_D3D11_CREATE_GEOMETRY_SHADER_EX_V5, 5)
#define NVAPI_D3D11_CREATEGEOMETRYSHADEREX_2_VERSION    NVAPI_D3D11_CREATEGEOMETRYSHADEREX_2_VER_5
 
//
// FUNCTION NAME: NvAPI_D3D11_CreateGeometryShaderEx
//
//
 
NVAPI_INTERFACE NvAPI_D3D11_CreateGeometryShaderEx_2(__in ID3D11Device *pDevice, __in const void *pShaderBytecode, 
                                                     __in SIZE_T BytecodeLength, __in_opt ID3D11ClassLinkage *pClassLinkage, 
                                                     __in const NvAPI_D3D11_CREATE_GEOMETRY_SHADER_EX *pCreateGeometryShaderExArgs,
                                                    __out ID3D11GeometryShader **ppGeometryShader);
 
#endif //defined(__cplusplus) && defined(__d3d11_h__) && (!defined(CINTERFACE))
 
 
#if defined (__cplusplus) && defined(__d3d11_h__) && (!defined(CINTERFACE) ) 
 
typedef struct NvAPI_D3D11_CREATE_VERTEX_SHADER_EX_V1
{
    UINT version;
 
    NvU32 NumCustomSemantics;                           // Number of custom semantics elements (upto NV_CUSTOM_SEMANTIC_MAX) provided in array pointer pCustomSemantics
    NV_CUSTOM_SEMANTIC *pCustomSemantics;               // pointer to array of NV_CUSTOM_SEMANTIC
} NvAPI_D3D11_CREATE_VERTEX_SHADER_EX_V1;
 
typedef struct NvAPI_D3D11_CREATE_VERTEX_SHADER_EX_V2
{
    UINT version;
 
    NvU32 NumCustomSemantics;                           // Number of custom semantics elements (upto NV_CUSTOM_SEMANTIC_MAX) provided in array pointer pCustomSemantics
    NV_CUSTOM_SEMANTIC *pCustomSemantics;               // pointer to array of NV_CUSTOM_SEMANTIC
    BOOL UseWithFastGS;                                 // reserved
} NvAPI_D3D11_CREATE_VERTEX_SHADER_EX_V2;
 
typedef struct NvAPI_D3D11_CREATE_VERTEX_SHADER_EX_V3
{
    UINT version;
 
    NvU32 NumCustomSemantics;                           // Number of custom semantics elements (upto NV_CUSTOM_SEMANTIC_MAX) provided in array pointer pCustomSemantics
    NV_CUSTOM_SEMANTIC *pCustomSemantics;               // pointer to array of NV_CUSTOM_SEMANTIC
    BOOL UseWithFastGS;                                 // reserved
    BOOL UseSpecificShaderExt;                          // TRUE if creating minimal specific shaders with nvapi shader extensions
} NvAPI_D3D11_CREATE_VERTEX_SHADER_EX_V3;
 
typedef NvAPI_D3D11_CREATE_VERTEX_SHADER_EX_V3          NvAPI_D3D11_CREATE_VERTEX_SHADER_EX;
#define NVAPI_D3D11_CREATEVERTEXSHADEREX_VER_1          MAKE_NVAPI_VERSION(NvAPI_D3D11_CREATE_VERTEX_SHADER_EX_V1, 1)
#define NVAPI_D3D11_CREATEVERTEXSHADEREX_VER_2          MAKE_NVAPI_VERSION(NvAPI_D3D11_CREATE_VERTEX_SHADER_EX_V2, 2)
#define NVAPI_D3D11_CREATEVERTEXSHADEREX_VER_3          MAKE_NVAPI_VERSION(NvAPI_D3D11_CREATE_VERTEX_SHADER_EX_V2, 3)
#define NVAPI_D3D11_CREATEVERTEXSHADEREX_VERSION        NVAPI_D3D11_CREATEVERTEXSHADEREX_VER_3
 
//
// FUNCTION NAME: NvAPI_D3D11_CreateVertexShaderEx
//
//
 
NVAPI_INTERFACE NvAPI_D3D11_CreateVertexShaderEx(__in ID3D11Device *pDevice, __in const void *pShaderBytecode, 
                                                 __in SIZE_T BytecodeLength, __in_opt ID3D11ClassLinkage *pClassLinkage, 
                                                 __in const NvAPI_D3D11_CREATE_VERTEX_SHADER_EX *pCreateVertexShaderExArgs,
                                                 __out ID3D11VertexShader **ppVertexShader);
 
#endif //defined(__cplusplus) && defined(__d3d11_h__) && (!defined(CINTERFACE))
 
 
#if defined (__cplusplus) && defined(__d3d11_h__) && (!defined(CINTERFACE) ) 
 
typedef struct NvAPI_D3D11_CREATE_HULL_SHADER_EX_V1
{
    UINT version;
 
    NvU32 NumCustomSemantics;                           // Number of custom semantics elements (upto NV_CUSTOM_SEMANTIC_MAX) provided in array pointer pCustomSemantics
    NV_CUSTOM_SEMANTIC *pCustomSemantics;               // pointer to array of NV_CUSTOM_SEMANTIC
    BOOL UseWithFastGS;                                 // reserved
} NvAPI_D3D11_CREATE_HULL_SHADER_EX_V1;
 
typedef struct NvAPI_D3D11_CREATE_HULL_SHADER_EX_V2
{
    UINT version;
 
    NvU32 NumCustomSemantics;                           // Number of custom semantics elements (upto NV_CUSTOM_SEMANTIC_MAX) provided in array pointer pCustomSemantics
    NV_CUSTOM_SEMANTIC *pCustomSemantics;               // pointer to array of NV_CUSTOM_SEMANTIC
    BOOL UseWithFastGS;                                 // reserved
    BOOL UseSpecificShaderExt;                          // TRUE if creating minimal specific shaders with nvapi shader extensions
} NvAPI_D3D11_CREATE_HULL_SHADER_EX_V2;
 
typedef NvAPI_D3D11_CREATE_HULL_SHADER_EX_V2          NvAPI_D3D11_CREATE_HULL_SHADER_EX;
#define NVAPI_D3D11_CREATEHULLSHADEREX_VER_1          MAKE_NVAPI_VERSION(NvAPI_D3D11_CREATE_HULL_SHADER_EX_V1, 1)
#define NVAPI_D3D11_CREATEHULLSHADEREX_VER_2          MAKE_NVAPI_VERSION(NvAPI_D3D11_CREATE_HULL_SHADER_EX_V1, 2)
#define NVAPI_D3D11_CREATEHULLSHADEREX_VERSION        NVAPI_D3D11_CREATEHULLSHADEREX_VER_2
 
//
// FUNCTION NAME: NvAPI_D3D11_CreateHullShaderEx
//
//
 
NVAPI_INTERFACE NvAPI_D3D11_CreateHullShaderEx(__in ID3D11Device *pDevice, __in const void *pShaderBytecode, 
                                               __in SIZE_T BytecodeLength, __in_opt ID3D11ClassLinkage *pClassLinkage, 
                                               __in const NvAPI_D3D11_CREATE_HULL_SHADER_EX *pCreateHullShaderExArgs,
                                               __out ID3D11HullShader **ppHullShader);
 
#endif //defined(__cplusplus) && defined(__d3d11_h__) && (!defined(CINTERFACE))
 
 
#if defined (__cplusplus) && defined(__d3d11_h__) && (!defined(CINTERFACE) ) 
 
typedef struct NvAPI_D3D11_CREATE_DOMAIN_SHADER_EX_V1
{
    UINT version;
 
    NvU32 NumCustomSemantics;                           // Number of custom semantics elements (upto NV_CUSTOM_SEMANTIC_MAX) provided in array pointer pCustomSemantics
    NV_CUSTOM_SEMANTIC *pCustomSemantics;               // pointer to array of NV_CUSTOM_SEMANTIC
} NvAPI_D3D11_CREATE_DOMAIN_SHADER_EX_V1;
 
typedef struct NvAPI_D3D11_CREATE_DOMAIN_SHADER_EX_V2
{
    UINT version;
 
    NvU32 NumCustomSemantics;                           // Number of custom semantics elements (upto NV_CUSTOM_SEMANTIC_MAX) provided in array pointer pCustomSemantics
    NV_CUSTOM_SEMANTIC *pCustomSemantics;               // pointer to array of NV_CUSTOM_SEMANTIC
    BOOL UseWithFastGS;                                 // reserved
} NvAPI_D3D11_CREATE_DOMAIN_SHADER_EX_V2;
 
typedef struct NvAPI_D3D11_CREATE_DOMAIN_SHADER_EX_V3
{
    UINT version;
 
    NvU32 NumCustomSemantics;                           // Number of custom semantics elements (upto NV_CUSTOM_SEMANTIC_MAX) provided in array pointer pCustomSemantics
    NV_CUSTOM_SEMANTIC *pCustomSemantics;               // pointer to array of NV_CUSTOM_SEMANTIC
    BOOL UseWithFastGS;                                 // reserved
    BOOL UseSpecificShaderExt;                          // TRUE if creating minimal specific shaders with nvapi shader extensions
} NvAPI_D3D11_CREATE_DOMAIN_SHADER_EX_V3;
 
typedef NvAPI_D3D11_CREATE_DOMAIN_SHADER_EX_V3          NvAPI_D3D11_CREATE_DOMAIN_SHADER_EX;
#define NVAPI_D3D11_CREATEDOMAINSHADEREX_VER_1          MAKE_NVAPI_VERSION(NvAPI_D3D11_CREATE_DOMAIN_SHADER_EX_V1, 1)
#define NVAPI_D3D11_CREATEDOMAINSHADEREX_VER_2          MAKE_NVAPI_VERSION(NvAPI_D3D11_CREATE_DOMAIN_SHADER_EX_V2, 2)
#define NVAPI_D3D11_CREATEDOMAINSHADEREX_VER_3          MAKE_NVAPI_VERSION(NvAPI_D3D11_CREATE_DOMAIN_SHADER_EX_V3, 3)
#define NVAPI_D3D11_CREATEDOMAINSHADEREX_VERSION        NVAPI_D3D11_CREATEDOMAINSHADEREX_VER_3
 
//
// FUNCTION NAME: NvAPI_D3D11_CreateDomainShaderEx
//
//
 
NVAPI_INTERFACE NvAPI_D3D11_CreateDomainShaderEx(__in ID3D11Device *pDevice, __in const void *pShaderBytecode, 
                                                 __in SIZE_T BytecodeLength, __in_opt ID3D11ClassLinkage *pClassLinkage, 
                                                 __in const NvAPI_D3D11_CREATE_DOMAIN_SHADER_EX *pCreateDomainShaderExArgs,
                                                 __out ID3D11DomainShader **ppDomainShader);
 
#endif //defined(__cplusplus) && defined(__d3d11_h__) && (!defined(CINTERFACE))
 
 
#if defined (__cplusplus) && defined(__d3d11_h__) && (!defined(CINTERFACE) ) 
 
typedef struct NvAPI_D3D11_CREATE_PIXEL_SHADER_EX_V1
{
    UINT version;
 
    NvU32 NumCustomSemantics;                           // Number of custom semantics elements (upto NV_CUSTOM_SEMANTIC_MAX) provided in array pointer pCustomSemantics
    NV_CUSTOM_SEMANTIC *pCustomSemantics;               // pointer to array of NV_CUSTOM_SEMANTIC
} NvAPI_D3D11_CREATE_PIXEL_SHADER_EX_V1;
 
#define NVAPI_D3D11_CREATEPIXELSHADEREX_VER_1           MAKE_NVAPI_VERSION(NvAPI_D3D11_CREATE_PIXEL_SHADER_EX_V1, 1)
 
typedef struct NvAPI_D3D11_CREATE_PIXEL_SHADER_EX_V2
{
    UINT version;                                                       // Always use NVAPI_D3D11_CREATEPIXELSHADEREX_VERSION
 
    NvU32 NumCustomSemantics;                                           // Number of custom semantics elements (upto NV_CUSTOM_SEMANTIC_MAX) provided in array pointer pCustomSemantics
    NV_CUSTOM_SEMANTIC *pCustomSemantics;                               // pointer to array of NV_CUSTOM_SEMANTIC
    NvU32 bEnableSuperSamplingPredicationForVRS                 : 1;    // This enables sampling within a pixel for SuperSampling mode of Variable Rate Shading for relevant attributes tagged with "sample" modifier
    NvU32 bEnableSuperSamplingPredicationForVRSAllAttributes    : 1;    // This enables sampling within a pixel for SuperSampling mode of Variable Rate Shading for all relevant attributes
    NvU32 reserved : 30;                                                // Reserved for further use
} NvAPI_D3D11_CREATE_PIXEL_SHADER_EX_V2;
 
typedef NvAPI_D3D11_CREATE_PIXEL_SHADER_EX_V2           NvAPI_D3D11_CREATE_PIXEL_SHADER_EX;
#define NVAPI_D3D11_CREATEPIXELSHADEREX_VER_2           MAKE_NVAPI_VERSION(NvAPI_D3D11_CREATE_PIXEL_SHADER_EX_V2, 2)
#define NVAPI_D3D11_CREATEPIXELSHADEREX_VERSION         NVAPI_D3D11_CREATEPIXELSHADEREX_VER_2
 
//
// FUNCTION NAME: NvAPI_D3D11_CreatePixelShaderEx_2
//
//
 
NVAPI_INTERFACE NvAPI_D3D11_CreatePixelShaderEx_2(__in ID3D11Device *pDevice, __in const void *pShaderBytecode, 
                                                 __in SIZE_T BytecodeLength, __in_opt ID3D11ClassLinkage *pClassLinkage, 
                                                 __in const NvAPI_D3D11_CREATE_PIXEL_SHADER_EX *pCreatePixelShaderExArgs,
                                                 __out ID3D11PixelShader **ppPixelShader);
 
#endif //defined(__cplusplus) && defined(__d3d11_h__) && (!defined(CINTERFACE))
 
 
#if defined (__cplusplus) && (defined(__d3d11_h__) || defined(__d3d12_h__)) && (!defined(CINTERFACE))
 
typedef enum _NV_FASTGS_FLAGS
{
    NV_FASTGS_USE_VIEWPORT_MASK             = 0x01,   // Causes SV_ViewportArrayIndex value to be interpreted as a bitmask of viewports to broadcast to.
    NV_FASTGS_OFFSET_RT_INDEX_BY_VP_INDEX   = 0x02,   // Causes SV_RenderTargetArrayIndex value to be offset by the viewport index when broadcasting.
    NV_FASTGS_STRICT_API_ORDER              = 0x04,   // Causes broadcast primitives to be rendered strictly in API order (slow).
                                                      // By default, primitives may be batched per viewport to improve performance.
} NV_FASTGS_FLAGS;
 
#endif //defined(__cplusplus) && (defined(__d3d11_h__) || defined(__d3d12_h__)) && (!defined(CINTERFACE))
 
#if defined (__cplusplus) && defined(__d3d11_h__) && (!defined(CINTERFACE))
 
struct NvAPI_D3D11_CREATE_FASTGS_EXPLICIT_DESC_V1
{
    NvU32 version;                                   // ALWAYS == NVAPI_D3D11_CREATEFASTGSEXPLICIT_VER
    NvU32 flags;                                     // A combination of flags from NV_FASTGS_FLAGS
    NvAPI_D3D11_SWIZZLE_MODE *pCoordinateSwizzling;  // [optional] Array of 16 coordinate swizzle modes, one per viewport. NULL if not used.
                                                     // The output x, y, z, and w coordinates of all vertices can be set to any of the coordinates or their 
                                                     // negated versions i.e. {x, y, z, w, -x, -y, -z, -w}. Coordinates are swizzled before any viewport 
                                                     // operation occurs i.e. before frustum clipping, scaling, and viewport clipping. And after 
                                                     // last of vertex/tesselation/geometry shader stage, stream-out and viewport broadcast expansion (see NV_FASTGS_USE_VIEWPORT_MASK)
                                                     // pCoordinateSwizzling[i] sets the swizzle-mode of each component for viewport i.
                                                     // See NV_SWIZZLE_MODE for values of allowed swizzle modes.
                                                     // See NV_SWIZZLE_OFFSET for bit offset from where NV_SWIZZLE_MODE to be set for each component.
                                                     // For example : 
                                                     // 1. To set swizzle for viewport 0 such that -  w and z are unchanged and values of x and y are swapped : 
                                                     // pCoordinateSwizzling[0] = (NV_SWIZZLE_POS_W << NV_SWIZZLE_OFFSET_W) | 
                                                     //                           (NV_SWIZZLE_POS_Z << NV_SWIZZLE_OFFSET_Z) | 
                                                     //                           (NV_SWIZZLE_POS_X << NV_SWIZZLE_OFFSET_Y) | 
                                                     //                           (NV_SWIZZLE_POS_Y << NV_SWIZZLE_OFFSET_X);
                                                     // 2. To set swizzle for viewport 0 such that -  w, z and y are unchanged and value of x is negated :
                                                     // pCoordinateSwizzling[0] = (NV_SWIZZLE_POS_W << NV_SWIZZLE_OFFSET_W) | 
                                                     //                           (NV_SWIZZLE_POS_Z << NV_SWIZZLE_OFFSET_Z) | 
                                                     //                           (NV_SWIZZLE_POS_Y << NV_SWIZZLE_OFFSET_Y) | 
                                                     //                           (NV_SWIZZLE_NEG_X << NV_SWIZZLE_OFFSET_X);
                                                     // Need to set some valid combination of swizzle-modes for all viewports, irrespective of whether that viewport is set.
                                                     // Invalid swizzle-mode for any viewport (even if that viewport is not set) may result in removal of device.
};
 
#define NVAPI_D3D11_CREATEFASTGSEXPLICIT_VER1 MAKE_NVAPI_VERSION(NvAPI_D3D11_CREATE_FASTGS_EXPLICIT_DESC_V1, 1)
#define NVAPI_D3D11_CREATEFASTGSEXPLICIT_VER  NVAPI_D3D11_CREATEFASTGSEXPLICIT_VER1
 
typedef NvAPI_D3D11_CREATE_FASTGS_EXPLICIT_DESC_V1 NvAPI_D3D11_CREATE_FASTGS_EXPLICIT_DESC;
 
//
// FUNCTION NAME: NvAPI_D3D11_CreateFastGeometryShaderExplicit
//
//
 
NVAPI_INTERFACE NvAPI_D3D11_CreateFastGeometryShaderExplicit(__in ID3D11Device *pDevice, __in const void *pShaderBytecode,
                                                             __in SIZE_T BytecodeLength, __in_opt ID3D11ClassLinkage *pClassLinkage,
                                                             __in const NvAPI_D3D11_CREATE_FASTGS_EXPLICIT_DESC *pCreateFastGSArgs,
                                                             __out ID3D11GeometryShader **ppGeometryShader);
 
#endif //defined(__cplusplus) && defined(__d3d11_h__) && (!defined(CINTERFACE))
 
 
#if defined (__cplusplus) && defined(__d3d11_h__) && (!defined(CINTERFACE) ) 
//
// FUNCTION NAME: NvAPI_D3D11_CreateFastGeometryShader
//
//
 
NVAPI_INTERFACE NvAPI_D3D11_CreateFastGeometryShader(__in ID3D11Device *pDevice, __in const void *pShaderBytecode, 
                                                     __in SIZE_T BytecodeLength, __in_opt ID3D11ClassLinkage *pClassLinkage,
                                                     __out ID3D11GeometryShader **ppGeometryShader);
 
#endif //defined(__cplusplus) && defined(__d3d11_h__) && (!defined(CINTERFACE))
 
 
#if defined (__cplusplus) && defined(__d3d11_h__)
 
//
// FUNCTION NAME: NvAPI_D3D11_DecompressView
//
NVAPI_INTERFACE NvAPI_D3D11_DecompressView(__in ID3D11Device* pDevice, __in ID3D11DeviceContext *pDeviceContext, __in ID3D11View* pView);
 
#endif //defined(__cplusplus) && defined(__d3d11_h__)
 
 
#if defined (__cplusplus) && defined(__d3d12_h__)
 
typedef enum _NV_PSO_EXTENSION
{
    NV_PSO_RASTER_EXTENSION = 0,
    NV_PSO_REQUEST_FASTGS_EXTENSION = 1,
    NV_PSO_GEOMETRY_SHADER_EXTENSION = 2,
    NV_PSO_ENABLE_DEPTH_BOUND_TEST_EXTENSION = 3,
    NV_PSO_EXPLICIT_FASTGS_EXTENSION = 4,
    NV_PSO_SET_SHADER_EXTNENSION_SLOT_AND_SPACE = 5,
    NV_PSO_SET_SHADER_EXTENSION_SLOT_AND_SPACE = 5,
    NV_PSO_VERTEX_SHADER_EXTENSION = 6,
    NV_PSO_DOMAIN_SHADER_EXTENSION = 7,
    NV_PSO_HULL_SHADER_EXTENSION = 9,
}NV_PSO_EXTENSION;
 
struct NVAPI_D3D12_PSO_EXTENSION_DESC_V1 
{
    NvU32            baseVersion;         //<! Always use NV_PSO_EXTENSION_DESC_VER
    NV_PSO_EXTENSION psoExtension;
};
 
#define NV_PSO_EXTENSION_DESC_VER_1   MAKE_NVAPI_VERSION(NVAPI_D3D12_PSO_EXTENSION_DESC_V1, 1)
#define NV_PSO_EXTENSION_DESC_VER     NV_PSO_EXTENSION_DESC_VER_1
 
typedef NVAPI_D3D12_PSO_EXTENSION_DESC_V1   NVAPI_D3D12_PSO_EXTENSION_DESC;
 
 
struct NVAPI_D3D12_PSO_RASTERIZER_STATE_DESC_V1 : public NVAPI_D3D12_PSO_EXTENSION_DESC
{
    NvU32 version;                           //<! Always use NV_RASTERIZER_PSO_EXTENSION_DESC_VER
    // These are additional parameters on the top of D3D12_RASTERIZER_DESC
    bool ProgrammableSamplePositionsEnable;  //<! enable Programmable Samples feature
    bool InterleavedSamplingEnable;          //<! when jitter is enabled, an app need to fill the whole arrays below, otherwise only as much entries as samples
    NvU8 SampleCount;                        //<! number of samples. In TIR N->1 it needs to match N, in non-TIR it needs to match RT sample count. Ignored if ForcePerSampleInterlock is set
    NvU8 SamplePositionsX[16];               //<! x positions in API sample order
    NvU8 SamplePositionsY[16];               //<! y positions in API sample order
    NVAPI_QUAD_FILLMODE QuadFillMode;        //<! Fill a triangle outside its bounds as a screen-aligned quad, matching the tri's bounding-box or filling the full viewport.
    bool PostZCoverageEnable;                //<! Enable pixel-shader input SV_COVERAGE to account for z-test in early-z mode.
    bool CoverageToColorEnable;              //<! Enable output of coverage to a color render-target.
    NvU8 CoverageToColorRTIndex;             //<! Index of RT for coverage-to-color.
    
    //Added with NV_RASTERIZER_PSO_EXTENSION_DESC_VER_2
    bool TargetIndepentRasterWithDepth;      //<! TargetIndepentRasterWithDepth = TRUE enables rasterezation mode where sample count of both raster and depth-stencil buffer are equal and do not match RT sample count.
    NvU8 ForcedSampleCount;                  //<! Must be set when TargetIndepentRasterWithDepth is true - refers to SampleDesc.Count for the DSV
    
    //Reserved
    NvU8 reserved[62];                       //<! reserved for expansion, set to zero.
};
 
#define NV_RASTERIZER_PSO_EXTENSION_DESC_VER_1   MAKE_NVAPI_VERSION(NVAPI_D3D12_PSO_RASTERIZER_STATE_DESC_V1, 1)
#define NV_RASTERIZER_PSO_EXTENSION_DESC_VER_2   MAKE_NVAPI_VERSION(NVAPI_D3D12_PSO_RASTERIZER_STATE_DESC_V1, 2)
#define NV_RASTERIZER_PSO_EXTENSION_DESC_VER     NV_RASTERIZER_PSO_EXTENSION_DESC_VER_2
 
typedef NVAPI_D3D12_PSO_RASTERIZER_STATE_DESC_V1   NVAPI_D3D12_PSO_RASTERIZER_STATE_DESC;
 
struct NVAPI_D3D12_PSO_CREATE_FASTGS_EXPLICIT_DESC_V1 : public NVAPI_D3D12_PSO_EXTENSION_DESC
{
    NvU32 version;                                   // ALWAYS == NV_FASTGS_EXPLICIT_PSO_EXTENSION_VER
    NvU32 flags;                                     // A combination of flags from NV_FASTGS_FLAGS
    NvAPI_D3D11_SWIZZLE_MODE *pCoordinateSwizzling;  // [optional] Array of 16 coordinate swizzle modes, one per viewport. NULL if not used.
                                                     // The output x, y, z, and w coordinates of all vertices can be set to any of the coordinates or their 
                                                     // negated versions i.e. {x, y, z, w, -x, -y, -z, -w}. Coordinates are swizzled before any viewport 
                                                     // operation occurs i.e. before frustum clipping, scaling, and viewport clipping. And after 
                                                     // last of vertex/tesselation/geometry shader stage, stream-out and viewport broadcast expansion (see NV_FASTGS_USE_VIEWPORT_MASK)
                                                     // pCoordinateSwizzling[i] sets the swizzle-mode of each component for viewport i.
                                                     // See NV_SWIZZLE_MODE for values of allowed swizzle modes.
                                                     // See NV_SWIZZLE_OFFSET for bit offset from where NV_SWIZZLE_MODE to be set for each component.
                                                     // For example : 
                                                     // 1. To set swizzle for viewport 0 such that -  w and z are unchanged and values of x and y are swapped : 
                                                     // pCoordinateSwizzling[0] = (NV_SWIZZLE_POS_W << NV_SWIZZLE_OFFSET_W) | 
                                                     //                           (NV_SWIZZLE_POS_Z << NV_SWIZZLE_OFFSET_Z) | 
                                                     //                           (NV_SWIZZLE_POS_X << NV_SWIZZLE_OFFSET_Y) | 
                                                     //                           (NV_SWIZZLE_POS_Y << NV_SWIZZLE_OFFSET_X);
                                                     // 2. To set swizzle for viewport 0 such that -  w, z and y are unchanged and value of x is negated :
                                                     // pCoordinateSwizzling[0] = (NV_SWIZZLE_POS_W << NV_SWIZZLE_OFFSET_W) | 
                                                     //                           (NV_SWIZZLE_POS_Z << NV_SWIZZLE_OFFSET_Z) | 
                                                     //                           (NV_SWIZZLE_POS_Y << NV_SWIZZLE_OFFSET_Y) | 
                                                     //                           (NV_SWIZZLE_NEG_X << NV_SWIZZLE_OFFSET_X);
                                                     // Need to set some valid combination of swizzle-modes for all viewports, irrespective of whether that viewport is set.
                                                     // Invalid swizzle-mode for any viewport (even if that viewport is not set) may result in removal of device.
};
 
#define NV_FASTGS_EXPLICIT_PSO_EXTENSION_VER_1 MAKE_NVAPI_VERSION(NVAPI_D3D12_PSO_CREATE_FASTGS_EXPLICIT_DESC_V1, 1)
#define NV_FASTGS_EXPLICIT_PSO_EXTENSION_VER   NV_FASTGS_EXPLICIT_PSO_EXTENSION_VER_1
 
typedef NVAPI_D3D12_PSO_CREATE_FASTGS_EXPLICIT_DESC_V1   NVAPI_D3D12_PSO_CREATE_FASTGS_EXPLICIT_DESC;
 
 
struct NVAPI_D3D12_PSO_REQUEST_FAST_GEOMETRY_SHADER_DESC_V1 : public NVAPI_D3D12_PSO_EXTENSION_DESC
{
    NvU32 version; //<! Always use NV_FAST_GEOMETRY_SHADER_PSO_EXTENSION_VER
};
 
#define NV_FAST_GEOMETRY_SHADER_PSO_EXTENSION_VER_1   MAKE_NVAPI_VERSION(NVAPI_D3D12_PSO_REQUEST_FAST_GEOMETRY_SHADER_DESC_V1, 1)
#define NV_FAST_GEOMETRY_SHADER_PSO_EXTENSION_VER     NV_FAST_GEOMETRY_SHADER_PSO_EXTENSION_VER_1
 
typedef NVAPI_D3D12_PSO_REQUEST_FAST_GEOMETRY_SHADER_DESC_V1   NVAPI_D3D12_PSO_REQUEST_FAST_GEOMETRY_SHADER_DESC;
 
 
struct NVAPI_D3D12_PSO_GEOMETRY_SHADER_DESC_V5 : public NVAPI_D3D12_PSO_EXTENSION_DESC
{
    NvU32 version; //<! Always use NV_GEOMETRY_SHADER_PSO_EXTENSION_DESC_VER
 
    BOOL UseViewportMask;                               // Set to FALSE for custom semantic shaders. Tell the driver to create a shader that outputs the viewport mask in lieu of the viewport index. See above description.
    BOOL OffsetRtIndexByVpIndex;                        // Set to FALSE for custom semantic shaders. The Rendertarget index is offset by the viewport index
    BOOL ForceFastGS;                                   // If TRUE, GS must be written with maxvertexcount(1) and must pass-through input vertex 0 to the output without modification
    BOOL DontUseViewportOrder;                          // Default FALSE for Primitives batched per viewport to improve performance. Set TRUE for API order (slow).
    BOOL UseAttributeSkipMask;                          // Reserved
    BOOL UseCoordinateSwizzle;                          // Reserved
    NvAPI_D3D11_SWIZZLE_MODE *pCoordinateSwizzling;     // Reserved    
 
    NvU32 NumCustomSemantics;                           // Number of custom semantics elements (upto NV_CUSTOM_SEMANTIC_MAX) provided in array pointer pCustomSemantics
    NV_CUSTOM_SEMANTIC *pCustomSemantics;               // pointer to array of NV_CUSTOM_SEMANTIC
 
    BOOL ConvertToFastGS;                               // Tell the driver to attempt to create a fast geometry shader
 
    BOOL UseSpecificShaderExt;                          // TRUE if creating minimal specific shaders with nvapi shader extensions
};
 
#define NV_GEOMETRY_SHADER_PSO_EXTENSION_DESC_VER_5   MAKE_NVAPI_VERSION(NVAPI_D3D12_PSO_GEOMETRY_SHADER_DESC_V5, 5)
#define NV_GEOMETRY_SHADER_PSO_EXTENSION_DESC_VER     NV_GEOMETRY_SHADER_PSO_EXTENSION_DESC_VER_5
 
typedef NVAPI_D3D12_PSO_GEOMETRY_SHADER_DESC_V5       NVAPI_D3D12_PSO_GEOMETRY_SHADER_DESC;
 
 
struct NVAPI_D3D12_PSO_VERTEX_SHADER_DESC_V1 : public NVAPI_D3D12_PSO_EXTENSION_DESC
{
    NvU32 version; //<! Always use NV_VERTEX_SHADER_PSO_EXTENSION_DESC_VER
 
    NvU32 NumCustomSemantics;                           // Number of custom semantics elements (upto NV_CUSTOM_SEMANTIC_MAX) provided in array pointer pCustomSemantics
    NV_CUSTOM_SEMANTIC *pCustomSemantics;               // Pointer to array of NV_CUSTOM_SEMANTIC
};
 
struct NVAPI_D3D12_PSO_VERTEX_SHADER_DESC_V2 : public NVAPI_D3D12_PSO_VERTEX_SHADER_DESC_V1
{
    BOOL UseWithFastGS;                                 // Reserved
};
 
struct NVAPI_D3D12_PSO_VERTEX_SHADER_DESC_V3 : public NVAPI_D3D12_PSO_VERTEX_SHADER_DESC_V2
{
    BOOL UseSpecificShaderExt;                          // TRUE if creating minimal specific shaders with NvAPI shader extensions
};
 
#define NV_VERTEX_SHADER_PSO_EXTENSION_DESC_VER_1   MAKE_NVAPI_VERSION(NVAPI_D3D12_PSO_VERTEX_SHADER_DESC_V1, 1)
#define NV_VERTEX_SHADER_PSO_EXTENSION_DESC_VER_2   MAKE_NVAPI_VERSION(NVAPI_D3D12_PSO_VERTEX_SHADER_DESC_V2, 2)
#define NV_VERTEX_SHADER_PSO_EXTENSION_DESC_VER_3   MAKE_NVAPI_VERSION(NVAPI_D3D12_PSO_VERTEX_SHADER_DESC_V3, 3)
#define NV_VERTEX_SHADER_PSO_EXTENSION_DESC_VER     NV_VERTEX_SHADER_PSO_EXTENSION_DESC_VER_3
 
typedef NVAPI_D3D12_PSO_VERTEX_SHADER_DESC_V3       NVAPI_D3D12_PSO_VERTEX_SHADER_DESC;
 
 
struct NVAPI_D3D12_PSO_HULL_SHADER_DESC_V1 : public NVAPI_D3D12_PSO_EXTENSION_DESC
{
    NvU32 version; //<! Always use NV_HULL_SHADER_PSO_EXTENSION_DESC_VER
 
    NvU32 NumCustomSemantics;                           // Number of custom semantics elements (upto NV_CUSTOM_SEMANTIC_MAX) provided in array pointer pCustomSemantics
    NV_CUSTOM_SEMANTIC *pCustomSemantics;               // Pointer to array of NV_CUSTOM_SEMANTIC
    BOOL UseWithFastGS;                                 // Reserved
};
 
struct NVAPI_D3D12_PSO_HULL_SHADER_DESC_V2 : public NVAPI_D3D12_PSO_HULL_SHADER_DESC_V1
{
    BOOL UseSpecificShaderExt;                          // TRUE if creating minimal specific shaders with nvapi shader extensions
};
 
#define NV_HULL_SHADER_PSO_EXTENSION_DESC_VER_1   MAKE_NVAPI_VERSION(NVAPI_D3D12_PSO_HULL_SHADER_DESC_V1, 1)
#define NV_HULL_SHADER_PSO_EXTENSION_DESC_VER_2   MAKE_NVAPI_VERSION(NVAPI_D3D12_PSO_HULL_SHADER_DESC_V2, 2)
#define NV_HULL_SHADER_PSO_EXTENSION_DESC_VER     NV_HULL_SHADER_PSO_EXTENSION_DESC_VER_2
 
typedef NVAPI_D3D12_PSO_HULL_SHADER_DESC_V2       NVAPI_D3D12_PSO_HULL_SHADER_DESC;
 
 
struct NVAPI_D3D12_PSO_DOMAIN_SHADER_DESC_V1 : public NVAPI_D3D12_PSO_EXTENSION_DESC
{
    NvU32 version; //<! Always use NV_DOMAIN_SHADER_PSO_EXTENSION_DESC_VER
 
    NvU32 NumCustomSemantics;                           // Number of custom semantics elements (upto NV_CUSTOM_SEMANTIC_MAX) provided in array pointer pCustomSemantics
    NV_CUSTOM_SEMANTIC *pCustomSemantics;               // Pointer to array of NV_CUSTOM_SEMANTIC
};
 
struct NVAPI_D3D12_PSO_DOMAIN_SHADER_DESC_V2 : public NVAPI_D3D12_PSO_DOMAIN_SHADER_DESC_V1
{
    BOOL UseWithFastGS;                                 // Reserved
};
 
struct NVAPI_D3D12_PSO_DOMAIN_SHADER_DESC_V3 : public NVAPI_D3D12_PSO_DOMAIN_SHADER_DESC_V2
{
    BOOL UseSpecificShaderExt;                          // TRUE if creating minimal specific shaders with NvAPI shader extensions
};
 
#define NV_DOMAIN_SHADER_PSO_EXTENSION_DESC_VER_1   MAKE_NVAPI_VERSION(NVAPI_D3D12_PSO_DOMAIN_SHADER_DESC_V1, 1)
#define NV_DOMAIN_SHADER_PSO_EXTENSION_DESC_VER_2   MAKE_NVAPI_VERSION(NVAPI_D3D12_PSO_DOMAIN_SHADER_DESC_V2, 2)
#define NV_DOMAIN_SHADER_PSO_EXTENSION_DESC_VER_3   MAKE_NVAPI_VERSION(NVAPI_D3D12_PSO_DOMAIN_SHADER_DESC_V3, 3)
#define NV_DOMAIN_SHADER_PSO_EXTENSION_DESC_VER     NV_DOMAIN_SHADER_PSO_EXTENSION_DESC_VER_3
 
typedef NVAPI_D3D12_PSO_DOMAIN_SHADER_DESC_V3       NVAPI_D3D12_PSO_DOMAIN_SHADER_DESC;
 
 
struct NVAPI_D3D12_PSO_ENABLE_DEPTH_BOUND_TEST_DESC_V1 : public NVAPI_D3D12_PSO_EXTENSION_DESC
{
    NvU32 version; //<! Always use NV_ENABLE_DEPTH_BOUND_TEST_PSO_EXTENSION_DESC_VER
    bool EnableDBT;
};
 
#define NV_ENABLE_DEPTH_BOUND_TEST_PSO_EXTENSION_DESC_VER_1   MAKE_NVAPI_VERSION(NVAPI_D3D12_PSO_ENABLE_DEPTH_BOUND_TEST_DESC_V1, 1)
#define NV_ENABLE_DEPTH_BOUND_TEST_PSO_EXTENSION_DESC_VER     NV_ENABLE_DEPTH_BOUND_TEST_PSO_EXTENSION_DESC_VER_1
 
typedef NVAPI_D3D12_PSO_ENABLE_DEPTH_BOUND_TEST_DESC_V1       NVAPI_D3D12_PSO_ENABLE_DEPTH_BOUND_TEST_DESC;
 
 
struct NVAPI_D3D12_PSO_SET_SHADER_EXTENSION_SLOT_DESC_V1 : public NVAPI_D3D12_PSO_EXTENSION_DESC
{
    NvU32 version; //<! Always use NV_SET_SHADER_EXTENSION_SLOT_DESC_VER
    NvU32 uavSlot;
    NvU32 registerSpace;
};
 
#define NV_SET_SHADER_EXTENSION_SLOT_DESC_VER_1               MAKE_NVAPI_VERSION(NVAPI_D3D12_PSO_SET_SHADER_EXTENSION_SLOT_DESC_V1, 1)
#define NV_SET_SHADER_EXTENSION_SLOT_DESC_VER                 NV_SET_SHADER_EXTENSION_SLOT_DESC_VER_1
 
typedef NVAPI_D3D12_PSO_SET_SHADER_EXTENSION_SLOT_DESC_V1     NVAPI_D3D12_PSO_SET_SHADER_EXTENSION_SLOT_DESC;
 
 
typedef enum _NV_COMPUTE_SHADER_DERIVATIVES
{
    NV_COMPUTE_SHADER_DERIVATIVE_NONE = 0,                  // No support for compute derivatives
 
    NV_COMPUTE_SHADER_DERIVATIVE_GROUP_LINEAR = 1,          // Compute derivatives supported. Quads are defined as groups of four threads with linear thread IDs of the form 4N..4N + 3
 
    NV_COMPUTE_SHADER_DERIVATIVE_GROUP_QUADS = 2,           // Compute derivatives supported. Quads are defined as group of 2x2 thread IDs in a 2D (or 3D) CTA. In this mode
                                                            // the app must ensure that width and height of the CTA dimension are both multiples of 2
} NV_COMPUTE_SHADER_DERIVATIVES;
 
//
// FUNCTION NAME: NvAPI_D3D12_CreateGraphicsPipelineState
//
 
NVAPI_INTERFACE NvAPI_D3D12_CreateGraphicsPipelineState(__in ID3D12Device *pDevice,
                                                        __in const D3D12_GRAPHICS_PIPELINE_STATE_DESC *pPSODesc,
                                                          NvU32 numExtensions,
                                                        __in const NVAPI_D3D12_PSO_EXTENSION_DESC** ppExtensions,
                                                        __out ID3D12PipelineState **ppPSO);
 
#endif //defined(__cplusplus) && defined(__d3d12_h__)
 
 
#if defined (__cplusplus) && defined(__d3d12_h__)
//
// FUNCTION NAME: NvAPI_D3D12_CreateComputePipelineState
//
 
NVAPI_INTERFACE NvAPI_D3D12_CreateComputePipelineState(__in ID3D12Device *pDevice,
                                                       __in const D3D12_COMPUTE_PIPELINE_STATE_DESC *pPSODesc,
                                                         NvU32 numExtensions,
                                                       __in const NVAPI_D3D12_PSO_EXTENSION_DESC** ppExtensions,
                                                       __out ID3D12PipelineState **ppPSO);
 
#endif //defined(__cplusplus) && defined(__d3d12_h__)
 
 
#if defined (__cplusplus) && defined(__d3d12_h__)
//
// FUNCTION NAME: NvAPI_D3D12_SetDepthBoundsTestValues
//
 
NVAPI_INTERFACE NvAPI_D3D12_SetDepthBoundsTestValues(__in ID3D12GraphicsCommandList *pCommandList,
                                                     __in const float minDepth,
                                                     __in const float maxDepth);
 
#endif //defined(__cplusplus) && defined(__d3d12_h__)
 
 
#if defined (__cplusplus) && defined(__d3d12_h__)
//
// FUNCTION NAME: NvAPI_D3D12_CreateReservedResource
//
//
 
NVAPI_INTERFACE NvAPI_D3D12_CreateReservedResource(__in       ID3D12Device           *pDevice,
                                                   __in const D3D12_RESOURCE_DESC    *pDesc,
                                                   __in       D3D12_RESOURCE_STATES   InitialState,
                                                   __in const D3D12_CLEAR_VALUE      *pOptimizedClearValue,
                                                   __in       REFIID                  riid,
                                                   __out      void                  **ppvResource,
                                                   __in       bool                    bTexture2DArrayMipPack,
                                                   __in       ID3D12Heap             *pHeap);
 
#endif //defined(__cplusplus) && defined(__d3d12_h__)
 
 
#if defined (__cplusplus) && defined(__d3d12_h__)
//
// FUNCTION NAME: NvAPI_D3D12_CreateHeap
//
//
 
NVAPI_INTERFACE NvAPI_D3D12_CreateHeap(__in       ID3D12Device     *pDevice,
                                       __in const D3D12_HEAP_DESC  *pDesc,
                                       __in       REFIID            riid,
                                       __out      void            **ppvHeap);
 
#endif //defined(__cplusplus) && defined(__d3d12_h__)
 
 
#if defined (__cplusplus) && defined(__d3d12_h__)
//
// FUNCTION NAME: NvAPI_D3D12_CreateHeap2
//
//
typedef enum {
    NV_D3D12_HEAP_FLAG_NONE             = 0,
    NV_D3D12_HEAP_FLAG_CPUVISIBLE_VIDMEM= 1,      
} NV_D3D12_HEAP_FLAGS;
 
typedef struct _NV_HEAP_PARAMS_V1
{
    NvU32                     version;          
    NV_D3D12_HEAP_FLAGS       NVHeapFlags;      
} NV_HEAP_PARAMS_V1;
 
#define NV_HEAP_PARAMS_VER_1 MAKE_NVAPI_VERSION(NV_HEAP_PARAMS_V1, 1)
 
#define NV_HEAP_PARAMS_VER   NV_HEAP_PARAMS_VER_1
typedef NV_HEAP_PARAMS_V1    NV_HEAP_PARAMS;
 
NVAPI_INTERFACE NvAPI_D3D12_CreateHeap2(__in       ID3D12Device         *pDevice,
                                        __in const D3D12_HEAP_DESC      *pDesc,
                                        __in const NV_HEAP_PARAMS       *pNVHeapParams,
                                        __in       REFIID               riid,
                                        __out      void                 **ppvHeap);
 
#endif //defined(__cplusplus) && defined(__d3d12_h__)
 
 
#if defined (__cplusplus) && defined(__d3d12_h__)
//
// FUNCTION NAME: NvAPI_D3D12_QueryCpuVisibleVidmem
//
//
NVAPI_INTERFACE NvAPI_D3D12_QueryCpuVisibleVidmem(__in       ID3D12Device  *pDevice,
                                                  __out      NvU64         *pTotalBytes,
                                                  __out      NvU64         *pFreeBytes);
 
#endif //defined(__cplusplus) && defined(__d3d12_h__)
 
 
#if defined (__cplusplus) && defined(__d3d12_h__)
//
// FUNCTION NAME: NvAPI_D3D12_ReservedResourceGetDesc
//
//
NVAPI_INTERFACE NvAPI_D3D12_ReservedResourceGetDesc(__in  ID3D12Resource      *pReservedResource,
                                                    __out D3D12_RESOURCE_DESC *pDesc);
 
#endif //defined(__cplusplus) && defined(__d3d12_h__)
 
 
#if defined (__cplusplus) && defined(__d3d12_h__)
 
//
// FUNCTION NAME: NvAPI_D3D12_UpdateTileMappings
//
//
NVAPI_INTERFACE NvAPI_D3D12_UpdateTileMappings(
    __in       ID3D12CommandQueue              *pCommandQueue,
    __in       ID3D12Resource                  *pResource,
    __in       UINT                             NumResourceRegions,
    __in const D3D12_TILED_RESOURCE_COORDINATE *pResourceRegionStartCoordinates,
    __in const D3D12_TILE_REGION_SIZE          *pResourceRegionSizes,
    __in       ID3D12Heap                      *pHeap,
    __in       UINT                             NumRanges,
    __in const D3D12_TILE_RANGE_FLAGS          *pRangeFlags,
    __in const UINT                            *pHeapRangeStartOffsets,
    __in const UINT                            *pRangeTileCounts,
    __in       D3D12_TILE_MAPPING_FLAGS         Flags);
 
#endif //defined(__cplusplus) && defined(__d3d12_h__)
 
 
#if defined (__cplusplus) && defined(__d3d12_h__)
 
//
// FUNCTION NAME: NvAPI_D3D12_CopyTileMappings
//
//
NVAPI_INTERFACE NvAPI_D3D12_CopyTileMappings(
    __in       ID3D12CommandQueue              *pCommandQueue,
    __in       ID3D12Resource                  *pDstResource,
    __in const D3D12_TILED_RESOURCE_COORDINATE *pDstRegionStartCoordinate,
    __in       ID3D12Resource                  *pSrcResource,
    __in const D3D12_TILED_RESOURCE_COORDINATE *pSrcRegionStartCoordinate,
    __in const D3D12_TILE_REGION_SIZE          *pRegionSize,
    __in       D3D12_TILE_MAPPING_FLAGS         Flags);
 
#endif //defined(__cplusplus) && defined(__d3d12_h__)
 
 
#if defined (__cplusplus) && defined(__d3d12_h__)
 
//
// FUNCTION NAME: NvAPI_D3D12_ResourceAliasingBarrier
//
//
NVAPI_INTERFACE NvAPI_D3D12_ResourceAliasingBarrier(
    __in       ID3D12GraphicsCommandList *pCommandList,
    __in       UINT                       NumBarriers,
    __in const D3D12_RESOURCE_BARRIER    *pBarriers);
 
#endif //defined(__cplusplus) && defined(__d3d12_h__)
 
#if defined(__cplusplus) && defined(__d3d12_h__)
// Experimental API for internal use. DO NOT USE!
 
typedef struct
{
    NvU32 version;                    
    NvU32 surfaceHandle;              
    NvU64 gpuVAStart;                 
    NvU64 gpuVASize;                  
} NVAPI_UAV_INFO_V1;
 
typedef struct
{
    NvU32 version;                    
    NvU32 surfaceHandle;              
    NvU64 gpuVAStart;                 
    NvU64 gpuVASize;                  
    NvU64 outFlags;
} NVAPI_UAV_INFO_V2;
 
#define NVAPI_UAV_INFO_VER1 1
#define NVAPI_UAV_INFO_VER2 MAKE_NVAPI_VERSION(NVAPI_UAV_INFO_V2, 2)
 
#define NVAPI_UAV_INFO_VER NVAPI_UAV_INFO_VER2
typedef NVAPI_UAV_INFO_V2 NVAPI_UAV_INFO;
 
NVAPI_INTERFACE NvAPI_D3D12_CaptureUAVInfo(__in  ID3D12Device*               pDevice,
                                           __out NVAPI_UAV_INFO             *pUAVInfo);
 
#endif //defined(__cplusplus) && defined(__d3d12_h__)
 
 
#if defined(__cplusplus) && defined(__d3d11_h__)
typedef struct
{
    NvU32 version; 
    NVDX_ObjectHandle hResource; 
    NvU64 gpuVAStart; 
    NvU64 gpuVASize;  
} NV_GET_GPU_VIRTUAL_ADDRESS_V1;
 
#define NV_GET_GPU_VIRTUAL_ADDRESS_VER1 MAKE_NVAPI_VERSION(NV_GET_GPU_VIRTUAL_ADDRESS_V1, 1)
#define NV_GET_GPU_VIRTUAL_ADDRESS_VER NV_GET_GPU_VIRTUAL_ADDRESS_VER1
#define NV_GET_GPU_VIRTUAL_ADDRESS NV_GET_GPU_VIRTUAL_ADDRESS_V1
 
// Experimental API for internal use. DO NOT USE!
NVAPI_INTERFACE NvAPI_D3D11_GetResourceGPUVirtualAddressEx(__in  ID3D11Device *pDevice,
                                                           __inout  NV_GET_GPU_VIRTUAL_ADDRESS *pParams);
                                                 
                                              
#endif //defined(__cplusplus) && defined(__d3d11_h__)
 
 
 
#if defined (__cplusplus) && (defined(__d3d11_h__) || defined(__d3d12_h__))
//
// MetaCommands common defines
//
//
#pragma pack(push, 4)
 
enum NV_D3D_GRAPHICS_STATES
{
    NV_D3D_GRAPHICS_STATE_NONE                    =        0 ,
    NV_D3D_GRAPHICS_STATE_IA_VERTEX_BUFFERS       = (1 <<  0),
    NV_D3D_GRAPHICS_STATE_IA_INDEX_BUFFER         = (1 <<  1),
    NV_D3D_GRAPHICS_STATE_IA_PRIMITIVE_TOPOLOGY   = (1 <<  2),
    NV_D3D_GRAPHICS_STATE_DESCRIPTOR_HEAP         = (1 <<  3),
    NV_D3D_GRAPHICS_STATE_GRAPHICS_ROOT_SIGNATURE = (1 <<  4),
    NV_D3D_GRAPHICS_STATE_COMPUTE_ROOT_SIGNATURE  = (1 <<  5),
    NV_D3D_GRAPHICS_STATE_RS_VIEWPORTS            = (1 <<  6),
    NV_D3D_GRAPHICS_STATE_RS_SCISSOR_RECTS        = (1 <<  7),
    NV_D3D_GRAPHICS_STATE_PREDICATION             = (1 <<  8),
    NV_D3D_GRAPHICS_STATE_OM_RENDER_TARGETS       = (1 <<  9),
    NV_D3D_GRAPHICS_STATE_OM_STENCIL_REF          = (1 << 10),
    NV_D3D_GRAPHICS_STATE_OM_BLEND_FACTOR         = (1 << 11),
    NV_D3D_GRAPHICS_STATE_PIPELINE_STATE          = (1 << 12),
    NV_D3D_GRAPHICS_STATE_SO_TARGETS              = (1 << 13),
    NV_D3D_GRAPHICS_STATE_OM_DEPTH_BOUNDS         = (1 << 14),
    NV_D3D_GRAPHICS_STATE_SAMPLE_POSITIONS        = (1 << 15),
    NV_D3D_GRAPHICS_STATE_VIEW_INSTANCE_MASK      = (1 << 16),
};
 
struct NVAPI_META_COMMAND_DESC
{
    GUID Id;
    LPCWSTR Name;
 
    // states that the initialization and execution of the metacommand will dirty
    NV_D3D_GRAPHICS_STATES InitializationDirtyState;
    NV_D3D_GRAPHICS_STATES ExecutionDirtyState;
};
 
typedef NvU64 NV_META_COMMAND_BOOL;
 
#define NV_META_COMMAND_MAX_TENSOR_DIM 5
// dimensions (Size and Stride) are always indexed this way, irrespective of NV_META_COMMAND_LAYOUT
// For DimensionCount = 5: N, C, D, H, W
// For DimensionCount = 4: N, C, H, W
 
 
#define NV_META_COMMAND_ACTIVATION_MAX_PARAMS 2
 
#if __cplusplus >= 201103L
 
#define compile_time_assert(b)  static_assert((b), "Compile time assertion failed: "#b)
 
enum NV_META_COMMAND_TENSOR_DATA_TYPE : NvU64
{
    NV_META_COMMAND_TENSOR_DATA_TYPE_FLOAT32,
    NV_META_COMMAND_TENSOR_DATA_TYPE_FLOAT16,
    NV_META_COMMAND_TENSOR_DATA_TYPE_UINT32,
 
    NV_META_COMMAND_TENSOR_DATA_TYPE_COUNT,
};
 
 
enum NV_META_COMMAND_TENSOR_LAYOUT : NvU64
{
    NV_META_COMMAND_TENSOR_LAYOUT_UNKNOWN,             // opaque HW-native layout
    NV_META_COMMAND_TENSOR_LAYOUT_STANDARD,            // NCDHW - planar / row major layout (width is inner-most dimension, batch-size N is the outermost)
    NV_META_COMMAND_TENSOR_LAYOUT_COUNT,
};
 
enum NV_META_COMMAND_TENSOR_FLAGS : NvU64
{
    NV_META_COMMAND_TENSOR_FLAG_NONE = 0,
    NV_META_COMMAND_TENSOR_FLAG_DATA_STATIC = 0x1,    // data pointed by the tensor is static (i.e, won't be modified after command list recording)
};
 
enum NV_META_COMMAND_PRECISION : NvU64
{
    NV_META_COMMAND_PRECISION_FLOAT32,
    NV_META_COMMAND_PRECISION_FLOAT16,
    NV_META_COMMAND_PRECISION_MUL_FLOAT16_ADD_FLOAT32,
 
    NV_META_COMMAND_PRECISION_COUNT,
};
 
struct NV_META_COMMAND_TENSOR_DESC
{
    NV_META_COMMAND_TENSOR_DATA_TYPE DataType;
    NV_META_COMMAND_TENSOR_LAYOUT Layout;
    NV_META_COMMAND_TENSOR_FLAGS Flags;
    NvU64 DimensionCount;       // 4 or 5
    NvU64 Size[NV_META_COMMAND_MAX_TENSOR_DIM];
    NvU64 Stride[NV_META_COMMAND_MAX_TENSOR_DIM];    // only used with NV_META_COMMAND_TENSOR_LAYOUT_STANDARD 
};
 
enum NV_META_COMMAND_ACTIVATION_FUNCTION : NvU64
{
    NV_META_COMMAND_ACTIVATION_FUNCTION_ELU,
    NV_META_COMMAND_ACTIVATION_FUNCTION_HARDMAX,
    NV_META_COMMAND_ACTIVATION_FUNCTION_HARD_SIGMOID,
    NV_META_COMMAND_ACTIVATION_FUNCTION_IDENTITY,
    NV_META_COMMAND_ACTIVATION_FUNCTION_LEAKY_RELU,
    NV_META_COMMAND_ACTIVATION_FUNCTION_LINEAR,
    NV_META_COMMAND_ACTIVATION_FUNCTION_LOG_SOFTMAX,
    NV_META_COMMAND_ACTIVATION_FUNCTION_PARAMETERIZED_RELU,
    NV_META_COMMAND_ACTIVATION_FUNCTION_PARAMETRIC_SOFTPLUS,
    NV_META_COMMAND_ACTIVATION_FUNCTION_RELU,
    NV_META_COMMAND_ACTIVATION_FUNCTION_SCALED_ELU,
    NV_META_COMMAND_ACTIVATION_FUNCTION_SCALED_TANH,
    NV_META_COMMAND_ACTIVATION_FUNCTION_SIGMOID,
    NV_META_COMMAND_ACTIVATION_FUNCTION_SOFTMAX,
    NV_META_COMMAND_ACTIVATION_FUNCTION_SOFTPLUS,
    NV_META_COMMAND_ACTIVATION_FUNCTION_SOFTSIGN,
    NV_META_COMMAND_ACTIVATION_FUNCTION_TANH,
    NV_META_COMMAND_ACTIVATION_FUNCTION_THRESHOLDED_RELU,
 
    NV_META_COMMAND_ACTIVATION_FUNCTION_COUNT,
};
 
struct NV_META_COMMAND_ACTIVATION_DESC
{
    NV_META_COMMAND_ACTIVATION_FUNCTION Function;
    float Params[NV_META_COMMAND_ACTIVATION_MAX_PARAMS];
};
 
#else
 
#define compile_time_assert(b)  typedef char compile_time_assertion_failed_in_line_##__LINE__[(b)?1:-1]
 
enum NV_META_COMMAND_TENSOR_DATA_TYPE
{
    NV_META_COMMAND_TENSOR_DATA_TYPE_FLOAT32,
    NV_META_COMMAND_TENSOR_DATA_TYPE_FLOAT16,
    NV_META_COMMAND_TENSOR_DATA_TYPE_UINT32,
 
    NV_META_COMMAND_TENSOR_DATA_TYPE_COUNT,
};
 
 
enum NV_META_COMMAND_TENSOR_LAYOUT
{
    NV_META_COMMAND_TENSOR_LAYOUT_UNKNOWN,             // opaque HW-native layout
    NV_META_COMMAND_TENSOR_LAYOUT_STANDARD,            // NCDHW - planar / row major layout (width is inner-most dimension, batch-size N is the outermost)
    NV_META_COMMAND_TENSOR_LAYOUT_COUNT,
};
 
enum NV_META_COMMAND_TENSOR_FLAGS
{
    NV_META_COMMAND_TENSOR_FLAG_NONE = 0,
    NV_META_COMMAND_TENSOR_FLAG_DATA_STATIC = 0x1,    // data pointed by the tensor is static (i.e, won't be modified after command list recording)
};
 
enum NV_META_COMMAND_PRECISION
{
    NV_META_COMMAND_PRECISION_FLOAT32,
    NV_META_COMMAND_PRECISION_FLOAT16,
    NV_META_COMMAND_PRECISION_MUL_FLOAT16_ADD_FLOAT32,
 
    NV_META_COMMAND_PRECISION_COUNT,
};
 
struct NV_META_COMMAND_TENSOR_DESC
{
    NvU64 DataType;             // NV_META_COMMAND_TENSOR_DATA_TYPE
    NvU64 Layout;               // NV_META_COMMAND_TENSOR_LAYOUT
    NvU64 Flags;                // NV_META_COMMAND_TENSOR_FLAGS
    NvU64 DimensionCount;       // 4 or 5
    NvU64 Size[NV_META_COMMAND_MAX_TENSOR_DIM];
    NvU64 Stride[NV_META_COMMAND_MAX_TENSOR_DIM];    // only used with NV_META_COMMAND_TENSOR_LAYOUT_STANDARD 
};
 
enum NV_META_COMMAND_ACTIVATION_FUNCTION
{
    NV_META_COMMAND_ACTIVATION_FUNCTION_ELU,
    NV_META_COMMAND_ACTIVATION_FUNCTION_HARDMAX,
    NV_META_COMMAND_ACTIVATION_FUNCTION_HARD_SIGMOID,
    NV_META_COMMAND_ACTIVATION_FUNCTION_IDENTITY,
    NV_META_COMMAND_ACTIVATION_FUNCTION_LEAKY_RELU,
    NV_META_COMMAND_ACTIVATION_FUNCTION_LINEAR,
    NV_META_COMMAND_ACTIVATION_FUNCTION_LOG_SOFTMAX,
    NV_META_COMMAND_ACTIVATION_FUNCTION_PARAMETERIZED_RELU,
    NV_META_COMMAND_ACTIVATION_FUNCTION_PARAMETRIC_SOFTPLUS,
    NV_META_COMMAND_ACTIVATION_FUNCTION_RELU,
    NV_META_COMMAND_ACTIVATION_FUNCTION_SCALED_ELU,
    NV_META_COMMAND_ACTIVATION_FUNCTION_SCALED_TANH,
    NV_META_COMMAND_ACTIVATION_FUNCTION_SIGMOID,
    NV_META_COMMAND_ACTIVATION_FUNCTION_SOFTMAX,
    NV_META_COMMAND_ACTIVATION_FUNCTION_SOFTPLUS,
    NV_META_COMMAND_ACTIVATION_FUNCTION_SOFTSIGN,
    NV_META_COMMAND_ACTIVATION_FUNCTION_TANH,
    NV_META_COMMAND_ACTIVATION_FUNCTION_THRESHOLDED_RELU,
 
    NV_META_COMMAND_ACTIVATION_FUNCTION_COUNT,
};
 
struct NV_META_COMMAND_ACTIVATION_DESC
{
    NvU64 Function;     // NV_META_COMMAND_ACTIVATION_FUNCTION
    float Params[NV_META_COMMAND_ACTIVATION_MAX_PARAMS];
};
 
#endif
 
struct NV_META_COMMAND_OPTIONAL_TENSOR_DESC : NV_META_COMMAND_TENSOR_DESC
{
    // true when the tensor isn't needed (e.g, bias is optional)
    NV_META_COMMAND_BOOL IsNull;
};
 
 
struct NV_META_COMMAND_OPTIONAL_ACTIVATION_DESC : NV_META_COMMAND_ACTIVATION_DESC
{
    // true when activation isn't needed
    NV_META_COMMAND_BOOL IsNull;
};
 
 
enum NV_META_COMMAND_PADDING_MODE
{
    NV_META_COMMAND_PADDING_ZEROS,
    NV_META_COMMAND_PADDING_MIRROR,
    NV_META_COMMAND_PADDING_CLAMP,
    NV_META_COMMAND_PADDING_CONSTANT,
 
    NV_META_COMMAND_PADDING_COUNT,
};
 
struct NV_META_COMMAND_PADDING_DESC
{
    NV_META_COMMAND_PADDING_MODE Mode;
 
    // used with NV_META_COMMAND_PADDING_CONSTANT
    float ConstantPadVal;
};
 
// use this enum to query resource sizes using GetRequiredParameterResourceSize() call
enum NV_META_COMMAND_RESOURCE_TYPE
{
    NV_META_COMMAND_RESOURCE_TYPE_INPUT = 0,
    NV_META_COMMAND_RESOURCE_TYPE_OUTPUT = 1,
    
    NV_META_COMMAND_RESOURCE_TYPE_FILTER = 2,
    NV_META_COMMAND_RESOURCE_TYPE_WEIGHT = 2,
    NV_META_COMMAND_RESOURCE_TYPE_BIAS = 3,
    
    NV_META_COMMAND_RESOURCE_TYPE_MATRIX_A = 0,
    NV_META_COMMAND_RESOURCE_TYPE_MATRIX_B = 2,
    NV_META_COMMAND_RESOURCE_TYPE_MATRIX_C = 3,
    
    NV_META_COMMAND_RESOURCE_TYPE_PERSISTENT = 4,
    NV_META_COMMAND_RESOURCE_TYPE_TEMPORARY = 5,
};
 
 
// Extended version of convolution operation that performs:
//
// y = act ( alpha1 * conv(x) + alpha2 * z + bias )
//
// alpha1 and alpha2 are either scalars or if PerChannelScaling is TRUE, they are vectors of
// same dimension as the bias tensor (vector of size equal to number of output channels)
//
// z (SkipConnectionResource) has same dimension as output tensor y (OutputResource).
 
static const GUID MetaCommand_ConvolutionEx = 
{ 0xa7666f1e, 0x9c55, 0x47ee, { 0x9e, 0xb3, 0xe1, 0x62, 0x0, 0x92, 0xd1, 0xe9 } };
 
#define NV_META_COMMAND_NUM_SPATIAL_DIM 3
// D, H, W when DimensionCount is 3
// H, W when DimensionCount is 2
 
 
#if __cplusplus >= 201103L
enum NV_META_COMMAND_CONVOLUTION_DIRECTION : NvU64
{
    NV_META_COMMAND_CONVOLUTION_DIRECTION_FORWARD,  // Corresponds to regular Convolution
    NV_META_COMMAND_CONVOLUTION_DIRECTION_BACKWARD, // Corresponds to ConvolutionTranspose
    
    NV_META_COMMAND_CONVOLUTION_DIRECTION_COUNT,
};
 
enum NV_META_COMMAND_CONVOLUTION_MODE : NvU64
{
    NV_META_COMMAND_CONVOLUTION_MODE_CONVOLUTION,
    NV_META_COMMAND_CONVOLUTION_MODE_CROSS_CORRELATION,
    
    NV_META_COMMAND_CONVOLUTION_MODE_COUNT,
};
 
struct NV_META_COMMAND_CREATE_CONVOLUTION_EX_DESC
{
    // Descriptor of the input tensor
    NV_META_COMMAND_TENSOR_DESC DescIn;
    
    // Descriptor of the tensor acting as the filter kernel
    NV_META_COMMAND_TENSOR_DESC DescFilter;
    
    // Descriptor of the optional bias tensor
    NV_META_COMMAND_OPTIONAL_TENSOR_DESC DescBias;
    
    // Descriptor of the output tensor
    NV_META_COMMAND_TENSOR_DESC DescOut;
    
    // Convolution mode (CROSS_CORRELATION or CONVOLUTION)
    NV_META_COMMAND_CONVOLUTION_MODE Mode;
    
    // Convolution direction (FORWARD or BACKWARD)
    NV_META_COMMAND_CONVOLUTION_DIRECTION Direction;
    
    // Precision at which convolution is done
    NV_META_COMMAND_PRECISION Precision;
    
    // Optional activation function
    NV_META_COMMAND_OPTIONAL_ACTIVATION_DESC Activation;
    
    // Padding mode (only used when output tensor dimensions are different from input tensor dimensions)
    NV_META_COMMAND_PADDING_DESC Padding;
 
    // enables per channel scaling i.e, use Alpha1Resource and Alpha2Resource 
    // instead of Alpha1 and Alpha2 below
    NV_META_COMMAND_BOOL PerChannelScaling;
 
    // scaling factors used when PerChannelScaling is FALSE
    // set Alpha1 = 1.0f, Alpha2 = 0.0f for simple convolutions 
    // that don't need scaling or skip connection
    float Alpha1;
    float Alpha2;
 
    // Strides for the filter kernel position
    NvU64 Stride[NV_META_COMMAND_NUM_SPATIAL_DIM];
    
    // The distance per dimension between elements that are multiplied
    NvU64 Dilation[NV_META_COMMAND_NUM_SPATIAL_DIM];
    
    // Padding at the start of each dimension
    NvU64 StartPadding[NV_META_COMMAND_NUM_SPATIAL_DIM];
    
    // Padding at the end of each dimension
    NvU64 EndPadding[NV_META_COMMAND_NUM_SPATIAL_DIM];
    
    // Number of dimensions to which convolution occurs (2 or 3)
    NvU64 DimensionCount;
 
    // Number of channel groups convolved independently
    NvU64 GroupCount;
};
 
#else
 
enum NV_META_COMMAND_CONVOLUTION_DIRECTION
{
    NV_META_COMMAND_CONVOLUTION_DIRECTION_FORWARD,  // Corresponds to regular Convolution
    NV_META_COMMAND_CONVOLUTION_DIRECTION_BACKWARD, // Corresponds to ConvolutionTranspose
    
    NV_META_COMMAND_CONVOLUTION_DIRECTION_COUNT,
};
 
enum NV_META_COMMAND_CONVOLUTION_MODE
{
    NV_META_COMMAND_CONVOLUTION_MODE_CONVOLUTION,
    NV_META_COMMAND_CONVOLUTION_MODE_CROSS_CORRELATION,
    
    NV_META_COMMAND_CONVOLUTION_MODE_COUNT,
};
 
struct NV_META_COMMAND_CREATE_CONVOLUTION_EX_DESC
{
    // Descriptor of the input tensor
    NV_META_COMMAND_TENSOR_DESC DescIn;
    
    // Descriptor of the tensor acting as the filter kernel
    NV_META_COMMAND_TENSOR_DESC DescFilter;
    
    // Descriptor of the optional bias tensor
    NV_META_COMMAND_OPTIONAL_TENSOR_DESC DescBias;
    
    // Descriptor of the output tensor
    NV_META_COMMAND_TENSOR_DESC DescOut;
    
    // Convolution mode (CROSS_CORRELATION or CONVOLUTION)
    NvU64 Mode;     // NV_META_COMMAND_CONVOLUTION_MODE
    
    // Convolution direction (FORWARD or BACKWARD)
    NvU64 Direction;    // NV_META_COMMAND_CONVOLUTION_DIRECTION
    
    // Precision at which convolution is done
    NvU64 Precision;    // NV_META_COMMAND_PRECISION
    
    // Optional activation function
    NV_META_COMMAND_OPTIONAL_ACTIVATION_DESC Activation;
    
    // Padding mode (only used when output tensor dimensions are different from input tensor dimensions)
    NV_META_COMMAND_PADDING_DESC Padding;
 
    // enables per channel scaling i.e, use Alpha1Resource and Alpha2Resource 
    // instead of Alpha1 and Alpha2 below
    NV_META_COMMAND_BOOL PerChannelScaling;
 
    // scaling factors used when PerChannelScaling is FALSE
    // set Alpha1 = 1.0f, Alpha2 = 0.0f for simple convolutions 
    // that don't need scaling or skip connection
    float Alpha1;
    float Alpha2;
 
    // Strides for the filter kernel position
    NvU64 Stride[NV_META_COMMAND_NUM_SPATIAL_DIM];
    
    // The distance per dimension between elements that are multiplied
    NvU64 Dilation[NV_META_COMMAND_NUM_SPATIAL_DIM];
    
    // Padding at the start of each dimension
    NvU64 StartPadding[NV_META_COMMAND_NUM_SPATIAL_DIM];
    
    // Padding at the end of each dimension
    NvU64 EndPadding[NV_META_COMMAND_NUM_SPATIAL_DIM];
    
    // Number of dimensions to which convolution occurs (2 or 3)
    NvU64 DimensionCount;
 
    // Number of channel groups convolved independently
    NvU64 GroupCount;
};
#endif
 
 
// Fused Convolution variants
 
// supported combinations right now are: 
//  - Convolution + Max Pooling (also optionally outputs pre-pool data)
//  - 2x2 upsample + (optional) residual add + Convolution
//
// other combinations may be exposed in future
 
static const GUID MetaCommand_ConvolutionExFused = 
{ 0xe1b112eb, 0xdecd, 0x4ff6,{ 0x85, 0xbb, 0x1f, 0xe, 0x3a, 0xb0, 0x4, 0x14 } };
 
 
enum NV_META_COMMAND_CONVOLUTION_POOL_MODE
{
    NV_META_COMMAND_CONVOLUTION_POOL_MODE_NONE,
    NV_META_COMMAND_CONVOLUTION_POOL_MODE_REDUCTION_MAX,
    NV_META_COMMAND_CONVOLUTION_POOL_MODE_REDUCTION_AVG,
    NV_META_COMMAND_CONVOLUTION_POOL_MODE_REDUCTION_MIN,
 
    NV_META_COMMAND_CONVOLUTION_POOL_MODE_COUNT,
};
 
enum NV_META_COMMAND_CONVOLUTION_UPSAMPLE_MODE
{
    NV_META_COMMAND_CONVOLUTION_UPSAMPLE_MODE_NONE,
    NV_META_COMMAND_CONVOLUTION_UPSAMPLE_MODE_REPLICATE,
    NV_META_COMMAND_CONVOLUTION_UPSAMPLE_MODE_BILINEAR,
 
    NV_META_COMMAND_CONVOLUTION_UPSAMPLE_MODE_COUNT,
};
 
enum NV_META_COMMAND_CONVOLUTION_SKIP_MODE
{
    NV_META_COMMAND_CONVOLUTION_SKIP_MODE_NONE,
    NV_META_COMMAND_CONVOLUTION_SKIP_MODE_ADD,
    NV_META_COMMAND_CONVOLUTION_SKIP_MODE_CONCAT,
 
    NV_META_COMMAND_CONVOLUTION_SKIP_MODE_COUNT,
};
 
struct NV_META_COMMAND_CONVOLUTION_FUSE_DESC
{
    NV_META_COMMAND_CONVOLUTION_POOL_MODE PoolMode;
    NV_META_COMMAND_CONVOLUTION_UPSAMPLE_MODE UpsampleMode;
    NV_META_COMMAND_CONVOLUTION_SKIP_MODE SkipMode;
 
    NV_META_COMMAND_BOOL OutputPrepool;     // used with NV_META_COMMAND_CONVOLUTION_POOL_MODE
};
 
// uses same structures for init and execute descriptors
// SkipConnectionResource is used to specify the resource for pre-pool data or residual add
struct NV_META_COMMAND_CREATE_CONVOLUTION_EX_FUSED_DESC : NV_META_COMMAND_CREATE_CONVOLUTION_EX_DESC
{
    NV_META_COMMAND_CONVOLUTION_FUSE_DESC FuseDesc;
};
 
// make sure structure sizes match what the driver assumes
compile_time_assert(sizeof(NV_META_COMMAND_TENSOR_DESC) == 112);
compile_time_assert(sizeof(NV_META_COMMAND_CREATE_CONVOLUTION_EX_DESC) == 640);
compile_time_assert(sizeof(NV_META_COMMAND_CONVOLUTION_FUSE_DESC) == 20);
compile_time_assert(sizeof(NV_META_COMMAND_CREATE_CONVOLUTION_EX_FUSED_DESC) == 660);
 
 
// GEMM (General matrix multiply)
//
// Y = alpha * t(A) * t(B) + beta * C,
//
// where t is a matrix transform option
// 
// If C is null, and beta is non-zero, the output 
// matrix is used as C matrix. i.e, the operation performed is:
// Y = alpha * t(A) * t(B) + beta * Y
// 
static const GUID MetaCommand_Gemm = 
    { 0x8f9ff059, 0xfe72, 0x488e, { 0xa0, 0x66, 0xb1, 0x4e, 0x79, 0x48, 0xec, 0x8 } };
 
#if __cplusplus >= 201103L
 
enum NV_META_COMMAND_MATRIX_TRANSFORM : NvU64
{
    NV_META_COMMAND_MATRIX_TRANSFORM_NONE,
    NV_META_COMMAND_MATRIX_TRANSFORM_TRANSPOSE,
 
    NV_META_COMMAND_MATRIX_TRANSFORM_COUNT,
};
 
struct NV_META_COMMAND_CREATE_GEMM_DESC
{
    NV_META_COMMAND_TENSOR_DESC DescA;
    NV_META_COMMAND_TENSOR_DESC DescB;
    NV_META_COMMAND_OPTIONAL_TENSOR_DESC DescC;
    NV_META_COMMAND_TENSOR_DESC DescOut;
    NV_META_COMMAND_PRECISION Precision;
 
    NV_META_COMMAND_MATRIX_TRANSFORM TransA;
    NV_META_COMMAND_MATRIX_TRANSFORM TransB;
    float Alpha;
    float Beta;
 
    NV_META_COMMAND_OPTIONAL_ACTIVATION_DESC Activation;
};
 
#else
 
enum NV_META_COMMAND_MATRIX_TRANSFORM
{
    NV_META_COMMAND_MATRIX_TRANSFORM_NONE,
    NV_META_COMMAND_MATRIX_TRANSFORM_TRANSPOSE,
 
    NV_META_COMMAND_MATRIX_TRANSFORM_COUNT,
};
 
struct NV_META_COMMAND_CREATE_GEMM_DESC
{
    NV_META_COMMAND_TENSOR_DESC DescA;
    NV_META_COMMAND_TENSOR_DESC DescB;
    NV_META_COMMAND_OPTIONAL_TENSOR_DESC DescC;
    NV_META_COMMAND_TENSOR_DESC DescOut;
    NvU64 Precision;    // NV_META_COMMAND_PRECISION
 
    NvU64 TransA;       // NV_META_COMMAND_MATRIX_TRANSFORM
    NvU64 TransB;       // NV_META_COMMAND_MATRIX_TRANSFORM
    float Alpha;
    float Beta;
 
    NV_META_COMMAND_OPTIONAL_ACTIVATION_DESC Activation;
};
 
#endif
 
 
#pragma pack(pop)
 
#endif // #if defined (__cplusplus) && (defined(__d3d11_h__) || defined(__d3d12_h__))
 
 
#if defined (__cplusplus) && defined(__d3d11_h__)
//
// FUNCTION NAME: NvAPI_D3D11_EnumerateMetaCommands
//
//
 
NVAPI_INTERFACE NvAPI_D3D11_EnumerateMetaCommands(__in                                  ID3D11Device                    *pDevice,
                                                  __inout                               NvU32                           *pNumMetaCommands,
                                                  __out_ecount_opt(*pNumMetaCommands)   NVAPI_META_COMMAND_DESC         *pDescs);
 
#endif //defined(__cplusplus) && defined(__d3d11_h__)
 
 
 
#if defined (__cplusplus) && defined(__d3d11_h__)
//
// FUNCTION NAME: NvAPI_D3D11_CreateMetaCommand
//
//
 
#pragma pack(push, 4)
struct NV_D3D11_META_COMMAND_RESOURCE
{
    union
    {
         NVDX_ObjectHandle ResourceHandle;    // NVAPI handle of a buffer resource (use NvAPI_D3D11_GetResourceHandle to get this handle)
         NvU64             unused;            // to get correct sturcutre size on 32 bit builds
    };
    NvU64 Offset;                             // offset within the resource in bytes
};
 
struct NV_D3D11_META_COMMAND_INITIALIZE_CONVOLUTION_EX_DESC
{
    // Persistent resource used as scratch space by driver
    // it's written at time of init, and read at time of execute
    // use GetRequiredParameterResourceSize to query its size
    NV_D3D11_META_COMMAND_RESOURCE PersistentResource;
};
 
struct NV_D3D11_META_COMMAND_EXECUTE_CONVOLUTION_EX_DESC
{
    NV_D3D11_META_COMMAND_RESOURCE InputResource;
    NV_D3D11_META_COMMAND_RESOURCE FilterResource;
    NV_D3D11_META_COMMAND_RESOURCE BiasResource;            // optional
    NV_D3D11_META_COMMAND_RESOURCE OutputResource;
 
    // Alpha1Resource and Alpha2Resource are used only when 
    // PerChannelScaling is set. Otherwise the scalars Alpha1/Alpha2 are used
    // should have same dimension as bias
    NV_D3D11_META_COMMAND_RESOURCE Alpha1Resource;
    NV_D3D11_META_COMMAND_RESOURCE Alpha2Resource;
 
    // optional, same dimension/descriptor as output
    NV_D3D11_META_COMMAND_RESOURCE SkipConnectionResource;
 
 
    // should point to same memory that was specified at time of init
    NV_D3D11_META_COMMAND_RESOURCE PersistentResource;
    
    // temporary resource used as scratch space by driver
    // used for both read and write at the time of execute
    // use GetRequiredParameterResourceSize to query its size
    NV_D3D11_META_COMMAND_RESOURCE TemporaryResource;
};
 
// make sure structure sizes match what the driver assumes
compile_time_assert(sizeof(NV_D3D11_META_COMMAND_INITIALIZE_CONVOLUTION_EX_DESC) == 16);
compile_time_assert(sizeof(NV_D3D11_META_COMMAND_EXECUTE_CONVOLUTION_EX_DESC) == 144);
 
struct NV_D3D11_META_COMMAND_INITIALIZE_GEMM_DESC
{
    NV_D3D11_META_COMMAND_RESOURCE PersistentResource;
};
 
struct NV_D3D11_META_COMMAND_EXECUTE_GEMM_DESC
{
    NV_D3D11_META_COMMAND_RESOURCE AResource;
    NV_D3D11_META_COMMAND_RESOURCE BResource;
    NV_D3D11_META_COMMAND_RESOURCE CResource;
    NV_D3D11_META_COMMAND_RESOURCE OutputResource;
 
    NV_D3D11_META_COMMAND_RESOURCE PersistentResource;
    NV_D3D11_META_COMMAND_RESOURCE TemporaryResource;
};
 
// make sure structure sizes match what the driver assumes
compile_time_assert(sizeof(NV_D3D11_META_COMMAND_INITIALIZE_GEMM_DESC) == 16);
compile_time_assert(sizeof(NV_D3D11_META_COMMAND_EXECUTE_GEMM_DESC) == 96);
 
 
#pragma pack(pop)
 
DECLARE_INTERFACE_(__declspec(uuid("00BF193A-117B-42BC-BBCD-E964A0EA4F2B"))ID3D11NvMetaCommand_V1, IUnknown)
{
    BEGIN_INTERFACE
 
    // *** IUnknown methods ***
    STDMETHOD(QueryInterface)(THIS_ REFIID riid, void **ppv) PURE;
    STDMETHOD_(ULONG,AddRef)(THIS) PURE;
    STDMETHOD_(ULONG,Release)(THIS) PURE;
 
    // ** ID3D11NvMetaCommand methods ***
    // Return size of parameter
    STDMETHOD(GetRequiredParameterResourceSize)(THIS_ NV_META_COMMAND_RESOURCE_TYPE ResourceType, NvU64 *SizeInBytes) const PURE;
 
    END_INTERFACE
};
 
typedef ID3D11NvMetaCommand_V1    ID3D11NvMetaCommand;
#define ID3D11NvMetaCommand_VER1  MAKE_NVAPI_VERSION(IID3D11NvMetaCommand_V1, 1)
#define ID3D11NvMetaCommand_VER   ID3D11NvMetaCommand_VER1
 
NVAPI_INTERFACE NvAPI_D3D11_CreateMetaCommand(__in                                     ID3D11Device            *pDevice,
                                              __in                                     REFGUID                  CommandId,
                                              __in_bcount(CreationParametersDataSize)  const void              *pCreationParametersData,
                                              __in                                     NvU32                    CreationParametersDataSize,
                                              __out                                    ID3D11NvMetaCommand    **ppMetaCommand);
 
#endif //defined(__cplusplus) && defined(__d3d11_h__)
 
 
#if defined (__cplusplus) && defined(__d3d11_h__)
//
// FUNCTION NAME: NvAPI_D3D11_InitializeMetaCommand
//
//
 
NVAPI_INTERFACE NvAPI_D3D11_InitializeMetaCommand(__in                                          ID3D11DeviceContext       *pDeviceContext,
                                                  __in                                          ID3D11NvMetaCommand       *pMetaCommand,
                                                  __in_bcount(InitializationParametersDataSize) const void                *pInitializationParametersData,
                                                  __in                                          NvU32                      InitializationParametersDataSize);
 
#endif //defined(__cplusplus) && defined(__d3d11_h__)
 
 
#if defined (__cplusplus) && defined(__d3d11_h__)
//
// FUNCTION NAME: NvAPI_D3D11_ExecuteMetaCommand
//
//
 
NVAPI_INTERFACE NvAPI_D3D11_ExecuteMetaCommand(__in                                          ID3D11DeviceContext       *pDeviceContext,
                                               __in                                          ID3D11NvMetaCommand       *pMetaCommand,
                                               __in_bcount(ExecutionParametersDataSize)      const void                *pExecutionParametersData,
                                               __in                                          NvU32                      ExecutionParametersDataSize);
 
#endif //defined(__cplusplus) && defined(__d3d11_h__)
 
 
 
 
#if defined (__cplusplus) && defined(__d3d12_h__)
//
// FUNCTION NAME: NvAPI_D3D12_EnumerateMetaCommands
//
//
 
NVAPI_INTERFACE NvAPI_D3D12_EnumerateMetaCommands(__in                                  ID3D12Device                    *pDevice,
                                                  __inout                               NvU32                           *pNumMetaCommands,
                                                  __out_ecount_opt(*pNumMetaCommands)   NVAPI_META_COMMAND_DESC         *pDescs);
 
#endif //defined(__cplusplus) && defined(__d3d12_h__)
 
 
 
#if defined (__cplusplus) && defined(__d3d12_h__)
//
// FUNCTION NAME: NvAPI_D3D12_CreateMetaCommand
//
//
 
#pragma pack(push, 4)
struct NV_D3D12_META_COMMAND_INITIALIZE_CONVOLUTION_EX_DESC
{
    // Persistent resource used as scratch space by driver
    // it's written at time of init, and read at time of execute
    // use GetRequiredParameterResourceSize to query its size
    D3D12_GPU_VIRTUAL_ADDRESS PersistentResource;
};
 
struct NV_D3D12_META_COMMAND_EXECUTE_CONVOLUTION_EX_DESC
{
    D3D12_GPU_VIRTUAL_ADDRESS InputResource;
    D3D12_GPU_VIRTUAL_ADDRESS FilterResource;
    D3D12_GPU_VIRTUAL_ADDRESS BiasResource;             // optional
    D3D12_GPU_VIRTUAL_ADDRESS OutputResource;
 
    // Alpha1Resource and Alpha2Resource are used only when 
    // PerChannelScaling is set. Otherwise the scalars Alpha1/Alpha2 are used
    // should have same dimension as bias
    D3D12_GPU_VIRTUAL_ADDRESS Alpha1Resource;
    D3D12_GPU_VIRTUAL_ADDRESS Alpha2Resource;
 
   // optional, same dimension/descriptor as output
    D3D12_GPU_VIRTUAL_ADDRESS SkipConnectionResource;
 
    // should point to same memory that was specified at time of init
    D3D12_GPU_VIRTUAL_ADDRESS PersistentResource;
 
    // temporary resource used as scratch space by driver
    // both written and read at time of execute
    // use GetRequiredParameterResourceSize to query its size
    D3D12_GPU_VIRTUAL_ADDRESS TemporaryResource;
};
 
// make sure structure sizes match what the driver assumes
compile_time_assert(sizeof(NV_D3D12_META_COMMAND_INITIALIZE_CONVOLUTION_EX_DESC) == 8);
compile_time_assert(sizeof(NV_D3D12_META_COMMAND_EXECUTE_CONVOLUTION_EX_DESC) == 72);
 
struct NV_D3D12_META_COMMAND_INITIALIZE_GEMM_DESC
{
    NvU64 PersistentResource;
};
 
struct NV_D3D12_META_COMMAND_EXECUTE_GEMM_DESC
{
    NvU64 AResource;
    NvU64 BResource;
    NvU64 CResource;
    NvU64 OutputResource;
 
    NvU64 PersistentResource;
    NvU64 TemporaryResource;
};
 
// make sure structure sizes match what the driver assumes
compile_time_assert(sizeof(NV_D3D12_META_COMMAND_INITIALIZE_GEMM_DESC) == 8);
compile_time_assert(sizeof(NV_D3D12_META_COMMAND_EXECUTE_GEMM_DESC) == 48);
 
 
#pragma pack(pop)
 
DECLARE_INTERFACE_(__declspec(uuid("00BF193A-117B-42BC-BBCD-E964A0EA4F2B"))ID3D12NvMetaCommand_V1, IUnknown)
{
    BEGIN_INTERFACE
 
    // *** IUnknown methods ***
    STDMETHOD(QueryInterface)(THIS_ REFIID riid, void **ppv) PURE;
    STDMETHOD_(ULONG,AddRef)(THIS) PURE;
    STDMETHOD_(ULONG,Release)(THIS) PURE;
 
    // ** ID3D12NvMetaCommand methods ***
    // Return size of parameter
    STDMETHOD(GetRequiredParameterResourceSize)(THIS_ NV_META_COMMAND_RESOURCE_TYPE ResourceType, NvU64 *SizeInBytes) const PURE;
 
    END_INTERFACE
};
 
typedef ID3D12NvMetaCommand_V1    ID3D12NvMetaCommand;
#define ID3D12NvMetaCommand_VER1  MAKE_NVAPI_VERSION(IID3D12NvMetaCommand_V1, 1)
#define ID3D12NvMetaCommand_VER   ID3D12NvMetaCommand_VER1
 
NVAPI_INTERFACE NvAPI_D3D12_CreateMetaCommand(__in                                     ID3D12Device            *pDevice,
                                              __in                                     REFGUID                  CommandId,
                                              __in                                     NvU32                    NodeMask,
                                              __in_bcount(CreationParametersDataSize)  const void              *pCreationParametersData,
                                              __in                                     NvU32                    CreationParametersDataSize,
                                              __out                                    ID3D12NvMetaCommand    **ppMetaCommand);
 
#endif //defined(__cplusplus) && defined(__d3d12_h__)
 
 
#if defined (__cplusplus) && defined(__d3d12_h__)
//
// FUNCTION NAME: NvAPI_D3D12_InitializeMetaCommand
//
//
 
NVAPI_INTERFACE NvAPI_D3D12_InitializeMetaCommand(__in                                          ID3D12GraphicsCommandList *pCommandlist,
                                                  __in                                          ID3D12NvMetaCommand       *pMetaCommand,
                                                  __in_bcount(InitializationParametersDataSize) const void                *pInitializationParametersData,
                                                  __in                                          NvU32                      InitializationParametersDataSize);
 
#endif //defined(__cplusplus) && defined(__d3d12_h__)
 
 
#if defined (__cplusplus) && defined(__d3d12_h__)
//
// FUNCTION NAME: NvAPI_D3D12_ExecuteMetaCommand
//
//
 
NVAPI_INTERFACE NvAPI_D3D12_ExecuteMetaCommand(__in                                          ID3D12GraphicsCommandList *pCommandlist,
                                               __in                                          ID3D12NvMetaCommand       *pMetaCommand,
                                               __in_bcount(ExecutionParametersDataSize)      const void                *pExecutionParametersData,
                                               __in                                          NvU32                      ExecutionParametersDataSize);
 
#endif //defined(__cplusplus) && defined(__d3d12_h__)
 
 
#if defined (__cplusplus) && defined(__d3d12_h__)
//
// FUNCTION NAME: NvAPI_D3D12_CreateCommittedResource
//
//
 
typedef enum {
    NV_D3D12_RESOURCE_FLAG_NONE             = 0,
    NV_D3D12_RESOURCE_FLAG_HTEX             = 1,      
    NV_D3D12_RESOURCE_FLAG_CPUVISIBLE_VIDMEM= 2,      
} NV_D3D12_RESOURCE_FLAGS;
 
typedef struct _NV_RESOURCE_PARAMS_V1
{
    NvU32                     version;          
    NV_D3D12_RESOURCE_FLAGS   NVResourceFlags;  
} NV_RESOURCE_PARAMS_V1;
 
#define NV_RESOURCE_PARAMS_VER_1 MAKE_NVAPI_VERSION(NV_RESOURCE_PARAMS_V1, 1)
 
#define NV_RESOURCE_PARAMS_VER   NV_RESOURCE_PARAMS_VER_1
typedef NV_RESOURCE_PARAMS_V1    NV_RESOURCE_PARAMS;
 
NVAPI_INTERFACE NvAPI_D3D12_CreateCommittedResource(__in       ID3D12Device             *pDevice,
                                                    __in const D3D12_HEAP_PROPERTIES    *pHeapProperties,          
                                                    __in       D3D12_HEAP_FLAGS         HeapFlags,
                                                    __in const D3D12_RESOURCE_DESC      *pDesc,
                                                    __in       D3D12_RESOURCE_STATES    InitialState,
                                                    __in const D3D12_CLEAR_VALUE        *pOptimizedClearValue,
                                                    __in const NV_RESOURCE_PARAMS       *pNVResourceParams,
                                                    __in       REFIID                    riid,
                                                    __out_opt  void                      **ppvResource,
                                                    __out_opt  bool                      *pSupported);
 
#endif //defined(__cplusplus) && defined(__d3d12_h__)
 
 
#if defined (__cplusplus) && defined(__d3d12_h__)
//
// FUNCTION NAME: NvAPI_D3D12_GetCopyableFootprints
//
//
 
NVAPI_INTERFACE NvAPI_D3D12_GetCopyableFootprints(__in                               ID3D12Device                        *pDevice,
                                                  __in const                         D3D12_RESOURCE_DESC                 *pResourceDesc,
                                                  __in const                         NV_RESOURCE_PARAMS                  *pNVResourceParams,
                                                  __in                               UINT                                 FirstSubresource,
                                                  __in                               UINT                                 NumSubresources,
                                                  __in                               UINT64                               BaseOffset,
                                                  __out_ecount_opt(NumSubresources)  D3D12_PLACED_SUBRESOURCE_FOOTPRINT  *pLayouts,
                                                  __out_ecount_opt(NumSubresources)  UINT                                *pNumRows,
                                                  __out_ecount_opt(NumSubresources)  UINT64                              *pRowSizeInBytes,
                                                  __out_opt                          UINT64                              *pTotalBytes);
 
#endif //defined(__cplusplus) && defined(__d3d12_h__)
 
 
#if defined (__cplusplus) && defined(__d3d12_h__)
//
// FUNCTION NAME: NvAPI_D3D12_CopyTextureRegion
//
//
 
NVAPI_INTERFACE NvAPI_D3D12_CopyTextureRegion(__in              ID3D12GraphicsCommandList           *pCommandList,
                                              __in const        D3D12_TEXTURE_COPY_LOCATION         *pDst,
                                              __in              UINT                                 DstX,
                                              __in              UINT                                 DstY,
                                              __in              UINT                                 DstZ,
                                              __in const        D3D12_TEXTURE_COPY_LOCATION         *pSrc,
                                              __in_opt const    D3D12_BOX                           *pSrcBox);
 
#endif //defined(__cplusplus) && defined(__d3d12_h__)
 
 
 
#if defined (__cplusplus) && defined(__d3d12_h__)
//
// FUNCTION NAME: NvAPI_D3D12_IsNvShaderExtnOpCodeSupported
//
NVAPI_INTERFACE NvAPI_D3D12_IsNvShaderExtnOpCodeSupported(__in  ID3D12Device *pDevice,
                                                          __in  NvU32 opCode,
                                                          __out bool *pSupported);
 
#endif //defined (__cplusplus) && defined(__d3d12_h__)
 
 
#if defined (__cplusplus) && defined(__d3d12_h__)
//
// FUNCTION NAME: NvAPI_D3D12_GetOptimalThreadCountForMesh
//
NVAPI_INTERFACE NvAPI_D3D12_GetOptimalThreadCountForMesh(__in  ID3D12Device *pDevice,
                                                          __out NvU32 *pThreadCount);
 
#endif //defined (__cplusplus) && defined(__d3d12_h__)
 
 
#if defined(_D3D9_H_) || defined(__d3d10_h__) || defined(__d3d11_h__)
 
NVAPI_INTERFACE NvAPI_D3D_IsGSyncCapable(__in IUnknown *pDeviceOrContext, __in NVDX_ObjectHandle primarySurface, __out BOOL *pIsGsyncCapable);
#endif //if defined(_D3D9_H_) || defined(__d3d10_h__) || defined(__d3d11_h__)
 
 
 
#if defined(_D3D9_H_) || defined(__d3d10_h__) || defined(__d3d11_h__)
 
NVAPI_INTERFACE NvAPI_D3D_IsGSyncActive(__in IUnknown *pDeviceOrContext, __in NVDX_ObjectHandle primarySurface, __out BOOL *pIsGsyncActive);
#endif //if defined(_D3D9_H_) || defined(__d3d10_h__) || defined(__d3d11_h__)
 
 
 
#if defined (__cplusplus) && ( defined(__d3d10_h__) || defined(__d3d10_1_h__) || defined(__d3d11_h__) || defined(__d3d12_h__)) 
//
// FUNCTION NAME: NvAPI_D3D1x_DisableShaderDiskCache
//
NVAPI_INTERFACE NvAPI_D3D1x_DisableShaderDiskCache(IUnknown *pDevice);
 
#endif //defined (__cplusplus) && ( defined(__d3d10_h__) || defined(__d3d10_1_h__) || defined(__d3d11_h__) || defined(__d3d12_h__)) 
 
#if defined (__cplusplus) && defined(__d3d11_h__) 
//
// FUNCTION NAME: NvAPI_D3D11_MultiGPU_GetCaps
//
typedef struct _NV_MULTIGPU_CAPS_V1
{
    NvU32 multiGPUVersion;
    NvU32 reserved;
    NvU32 nTotalGPUs;
    NvU32 nSLIGPUs;
    NvU32 videoBridgePresent;
} NV_MULTIGPU_CAPS_V1, *PNV_MULTIGPU_CAPS_V1;
 
#endif //defined(__cplusplus) && defined(__d3d11_h__)
 
#if defined (__cplusplus) && defined(__d3d11_h__) 
 
typedef struct _NV_MULTIGPU_CAPS_V2
{
    NvU32 multiGPUVersion;
    union 
    {
        NvU32 reserved;
        NvU32 version;          
    };
    NvU32 nTotalGPUs;
    NvU32 nSLIGPUs;
    NvU32 videoBridgePresent;
    NvU32 NvLinkPresent;
    NvU32 fastNvLinkReads;
} NV_MULTIGPU_CAPS_V2, *PNV_MULTIGPU_CAPS_V2;
 
#define NV_MULTIGPU_CAPS_VER1   MAKE_NVAPI_VERSION(NV_MULTIGPU_CAPS_V1, 1)
#define NV_MULTIGPU_CAPS_VER2   MAKE_NVAPI_VERSION(NV_MULTIGPU_CAPS_V2, 2)
 
#define NV_MULTIGPU_CAPS_VER    NV_MULTIGPU_CAPS_VER2
typedef NV_MULTIGPU_CAPS_V2     NV_MULTIGPU_CAPS;
typedef PNV_MULTIGPU_CAPS_V2    PNV_MULTIGPU_CAPS;
 
#endif //defined(__cplusplus) && defined(__d3d11_h__)
 
#if defined (__cplusplus) && defined(__d3d11_h__) 
 
#ifndef NV_MULTIGPU_CAPS_VER
typedef NV_MULTIGPU_CAPS_V1     NV_MULTIGPU_CAPS;
typedef PNV_MULTIGPU_CAPS_V1    PNV_MULTIGPU_CAPS;
#endif
 
NVAPI_INTERFACE NvAPI_D3D11_MultiGPU_GetCaps(__inout PNV_MULTIGPU_CAPS pMultiGPUCaps);
 
#endif //defined(__cplusplus) && defined(__d3d11_h__)
 
#if defined (__cplusplus) && defined(__d3d11_h__) 
//
// FUNCTION NAME: NvAPI_D3D11_MultiGPU_Init
//
NVAPI_INTERFACE NvAPI_D3D11_MultiGPU_Init(__in bool bEnable);
 
#endif //defined(__cplusplus) && defined(__d3d11_h__)
 
#if defined (__cplusplus) && defined(__d3d11_h__) 
//
// FUNCTION NAME: NvAPI_D3D11_CreateMultiGPUDevice
 
 
 
#define NVAPI_COPY_ASYNCHRONOUSLY                    1
#endif //defined(__cplusplus) && defined(__d3d11_h__)
 
#if defined (__cplusplus) && defined(__d3d11_h__) 
#define NVAPI_COPY_P2P_READ                          2
#endif //defined(__cplusplus) && defined(__d3d11_h__)
 
#if defined (__cplusplus) && defined(__d3d11_h__) 
 
#define NVAPI_CPU_RESOURCE                  0xffffffff 
 
DECLARE_INTERFACE(ID3D11MultiGPUDevice_V1)
{
    STDMETHOD_(void,Destroy)(THIS) PURE;
    STDMETHOD_(UINT,SetGPUMask)(THIS_ __in UINT GPUMask) PURE;
    STDMETHOD_(NvAPI_Status,CopySubresourceRegion)(THIS_ __in ID3D11DeviceContext *pContext, __in ID3D11Resource *pDstResource, __in UINT DstSubresource, 
                                                   __in UINT DstGPUIndex, __in UINT DstX, __in UINT DstY, __in UINT DstZ, 
                                                   __in ID3D11Resource *pSrcResource, __in UINT SrcSubresource, __in UINT SrcGPUIndex, 
                                                   __in const D3D11_BOX *pSrcBox, __in UINT ExtendedFlags = 0) PURE;
#if defined(__d3d11_1_h__)
    STDMETHOD_(NvAPI_Status,CopySubresourceRegion1)(THIS_ __in ID3D11DeviceContext1 *pContext1, __in ID3D11Resource *pDstResource, __in UINT DstSubresource, 
                                                   __in UINT DstGPUIndex, __in UINT DstX, __in UINT DstY, __in UINT DstZ, 
                                                   __in ID3D11Resource *pSrcResource, __in UINT SrcSubresource, __in UINT SrcGPUIndex, 
                                                   __in const D3D11_BOX *pSrcBox, __in UINT CopyFlags, __in UINT ExtendedFlags = 0 ) PURE;
#else
    STDMETHOD_(NvAPI_Status,CopySubresourceRegion1)(THIS_ __in void *pContext1, __in ID3D11Resource *pDstResource, __in UINT DstSubresource, 
                                                   __in UINT DstGPUIndex, __in UINT DstX, __in UINT DstY, __in UINT DstZ, 
                                                   __in ID3D11Resource *pSrcResource, __in UINT SrcSubresource, __in UINT SrcGPUIndex, 
                                                   __in const D3D11_BOX *pSrcBox, __in UINT CopyFlags, __in UINT ExtendedFlags = 0 ) PURE;
#endif
    STDMETHOD_(NvAPI_Status,UpdateSubresource)(THIS_ __in ID3D11DeviceContext *pContext,__in ID3D11Resource *pDstResource, __in UINT DstSubresource, __in UINT DstGPUIndex, 
                                               __in const D3D11_BOX *pDstBox, __in const void *pSrcData, __in UINT SrcRowPitch, __in UINT SrcDepthPitch) PURE;
    STDMETHOD_(NvAPI_Status,VSSetConstantBuffers)(THIS_ __in ID3D11DeviceContext *pContext, __in UINT GPUMask, __in UINT StartSlot, 
                                                 __in UINT NumBuffers, __in ID3D11Buffer *const *ppConstantBuffers,
                                                 __in UINT *const pFirstConstant = NULL, __in UINT *const pNumConstants = NULL) PURE;
    STDMETHOD_(NvAPI_Status,PSSetConstantBuffers)(THIS_ __in ID3D11DeviceContext *pContext, __in UINT GPUMask, __in UINT StartSlot, 
                                                 __in UINT NumBuffers, __in ID3D11Buffer *const *ppConstantBuffers,
                                                 __in UINT *const pFirstConstant = NULL, __in UINT *const pNumConstants = NULL) PURE;
    STDMETHOD_(NvAPI_Status,GSSetConstantBuffers)(THIS_ __in ID3D11DeviceContext *pContext, __in UINT GPUMask, __in UINT StartSlot, 
                                                 __in UINT NumBuffers, __in ID3D11Buffer *const *ppConstantBuffers,
                                                 __in UINT *const pFirstConstant = NULL, __in UINT *const pNumConstants = NULL) PURE;
    STDMETHOD_(NvAPI_Status,DSSetConstantBuffers)(THIS_ __in ID3D11DeviceContext *pContext, __in UINT GPUMask, __in UINT StartSlot, 
                                                 __in UINT NumBuffers, __in ID3D11Buffer *const *ppConstantBuffers,
                                                 __in UINT *const pFirstConstant = NULL, __in UINT *const pNumConstants = NULL) PURE;
    STDMETHOD_(NvAPI_Status,HSSetConstantBuffers)(THIS_ __in ID3D11DeviceContext *pContext, __in UINT GPUMask, __in UINT StartSlot, 
                                                 __in UINT NumBuffers, __in ID3D11Buffer *const *ppConstantBuffers,
                                                 __in UINT *const pFirstConstant = NULL, __in UINT *const pNumConstants = NULL) PURE;
    STDMETHOD_(NvAPI_Status,CSSetConstantBuffers)(THIS_ __in ID3D11DeviceContext *pContext, __in UINT GPUMask, __in UINT StartSlot, 
                                                 __in UINT NumBuffers, __in ID3D11Buffer *const *ppConstantBuffers,
                                                 __in UINT *const pFirstConstant = NULL, __in UINT *const pNumConstants = NULL) PURE;
    STDMETHOD_(NvAPI_Status,SetViewports)(THIS_ __in ID3D11DeviceContext *pContext, __in UINT GPUMask, __in UINT NumViewports, 
                                          __in const D3D11_VIEWPORT *pViewports) PURE;
    STDMETHOD_(NvAPI_Status,SetScissorRects)(THIS_ __in ID3D11DeviceContext *pContext, __in UINT GPUMask, __in UINT NumRects, 
                                            __in const D3D11_RECT *pRects) PURE;
    STDMETHOD_(HRESULT,GetData)(THIS_ __in ID3D11DeviceContext *pContext, __in ID3D11Asynchronous *pAsync, __in UINT GPUIndex, 
                                    __out void *pData, __in UINT DataSize, __in UINT GetDataFlags) PURE;
#if defined(__d3d11_2_h__)
    STDMETHOD_(NvAPI_Status,UpdateTiles)(THIS_ __in ID3D11DeviceContext2 *pContext2, __in ID3D11Resource *pDestTiledResource, 
                                        __in UINT GPUMask, __in const D3D11_TILED_RESOURCE_COORDINATE *pDestTileRegionStartCoordinate, 
                                        __in const D3D11_TILE_REGION_SIZE *pDestTileRegionSize, __in const void *pSourceTileData, 
                                        __in UINT Flags) PURE;
#else
    STDMETHOD_(NvAPI_Status,UpdateTiles)(THIS_ __in void *pContext2, __in ID3D11Resource *pDestTiledResource, 
                                        __in UINT GPUMask, __in const void *pDestTileRegionStartCoordinate, 
                                        __in const void *pDestTileRegionSize, __in const void *pSourceTileData, 
                                        __in UINT Flags) PURE;
#endif
 
    STDMETHOD_(NvAPI_Status,CreateFences)(THIS_ __in UINT count, __out void **ppFences) PURE;
    STDMETHOD_(NvAPI_Status,SetFence)(THIS_ __in UINT GPUIndex, __in void *hFence, __in UINT64 value) PURE;
    STDMETHOD_(NvAPI_Status,WaitForFence)(THIS_ __in UINT GPUIMask, __in void *hFence, __in UINT64 value) PURE;
    STDMETHOD_(NvAPI_Status,FreeFences)(THIS_ __in UINT count, __in void **ppFences) PURE;
    STDMETHOD_(NvAPI_Status,PresentCompositingConfig )(THIS_ __in IUnknown *pSwapChain, __in UINT GPUMask, 
                                         __in const D3D11_RECT *pRects, __in UINT flags) PURE;
 
    STDMETHOD_(NvAPI_Status,SetContextGPUMask)(THIS_ __in ID3D11DeviceContext *pContext, __in UINT GPUMask) PURE;
    STDMETHOD_(NvAPI_Status,GetVideoBridgeStatus)(THIS_ __in IUnknown *pSwapChain, __in UINT* pVideoBridgeStatus) PURE;
 
    STDMETHOD_(NvAPI_Status,CreateMultiGPUConstantBuffer)(THIS_ __in const D3D11_BUFFER_DESC *pDesc, __in_opt const D3D11_SUBRESOURCE_DATA **ppInitialData, __out ID3D11Buffer **ppBuffer) PURE;
    STDMETHOD_(NvAPI_Status,ReleaseMultiGPUConstantBuffer)(THIS_ __in ID3D11Buffer *pBuffer) PURE;
    
    // Following XXSetMGPUConstantBuffers work the same way as DX XXSetConstantBuffers
    // The difference is that 
    // 1. They are setting constant buffers on GPUs that are defined by 
    //    current GPU mask that is set via SetGPUMask.
    // 2. For constant buffer created via CreateMultiGPUConstantBuffer these calls set GPU specific constant buffer.
    // 3. For regular constant buffers these calls set the same constant buffer on all GPUs defined by 1.
    // 4. If these functions are called in deferred context then GPUs are defined as GlobalGPUmask&LocalGPUMask
    //      where GlobalGPUmask is GPUMask set before CL execution
    //      and  LocalGPUMask is current GPUMask set in  CL.
    STDMETHOD_(NvAPI_Status,VSSetMGPUConstantBuffers)(THIS_ __in ID3D11DeviceContext *pContext, __in UINT StartSlot, 
                                                 __in UINT NumBuffers, __in ID3D11Buffer *const *ppConstantBuffers) PURE;
    STDMETHOD_(NvAPI_Status,PSSetMGPUConstantBuffers)(THIS_ __in ID3D11DeviceContext *pContext, __in UINT StartSlot, 
                                                 __in UINT NumBuffers, __in ID3D11Buffer *const *ppConstantBuffers) PURE;
    STDMETHOD_(NvAPI_Status,GSSetMGPUConstantBuffers)(THIS_ __in ID3D11DeviceContext *pContext, __in UINT StartSlot, 
                                                 __in UINT NumBuffers, __in ID3D11Buffer *const *ppConstantBuffers) PURE;
    STDMETHOD_(NvAPI_Status,DSSetMGPUConstantBuffers)(THIS_ __in ID3D11DeviceContext *pContext, __in UINT StartSlot, 
                                                 __in UINT NumBuffers, __in ID3D11Buffer *const *ppConstantBuffers) PURE;
    STDMETHOD_(NvAPI_Status,HSSetMGPUConstantBuffers)(THIS_ __in ID3D11DeviceContext *pContext, __in UINT StartSlot, 
                                                 __in UINT NumBuffers, __in ID3D11Buffer *const *ppConstantBuffers) PURE;
    STDMETHOD_(NvAPI_Status,CSSetMGPUConstantBuffers)(THIS_ __in ID3D11DeviceContext *pContext, __in UINT StartSlot, 
                                                 __in UINT NumBuffers, __in ID3D11Buffer *const *ppConstantBuffers) PURE;
    
    STDMETHOD_(NvAPI_Status,UpdateConstantBuffer)(__in ID3D11DeviceContext *pContext, __in ID3D11Buffer *pBuffer, __in const void *pSrcData, __in_opt UINT GPUMask = 0) PURE;
};
 
#define FENCE_SYNCHRONIZATION_START(pMultiGPUDevice, hFence, Value, srcGpu, dstGpu) \
    pMultiGPUDevice->SetFence(dstGpu, hFence, Value); \
    pMultiGPUDevice->WaitForFence(1 << (srcGpu), hFence, Value); \
    Value++;
 
#define FENCE_SYNCHRONIZATION_END(pMultiGPUDevice, hFence, Value, srcGpu, dstGpu) \
    pMultiGPUDevice->SetFence(srcGpu, hFence, Value); \
    pMultiGPUDevice->WaitForFence(1 << (dstGpu), hFence, Value); \
    Value++;
    
#define NVAPI_PRESENT_COMPOSITING_CONFIG_FLAG_USE_VIDEO_BRIDGE          0x01
#define NVAPI_PRESENT_COMPOSITING_CONFIG_FLAG_CLEAR_OUTBANDS            0x02
#define NVAPI_PRESENT_COMPOSITING_CONFIG_FLAG_GET_VIDEO_BRIDGE_STATUS   0x80000000
 
#define NVAPI_VIDEO_BRIDGE_STATUS_AVAILABLE       0
#define NVAPI_VIDEO_BRIDGE_STATUS_NOT_AVAILABLE   1
#define NVAPI_VIDEO_BRIDGE_STATUS_FAILED_ACCESS   2
#define NVAPI_VIDEO_BRIDGE_STATUS_UNKNOWN         3
 
#define NVAPI_ALL_GPUS              0
typedef ID3D11MultiGPUDevice_V1     ID3D11MultiGPUDevice;
 
#define ID3D11MultiGPUDevice_VER1   MAKE_NVAPI_VERSION(ID3D11MultiGPUDevice_V1, 1)
#define ID3D11MultiGPUDevice_VER2   MAKE_NVAPI_VERSION(ID3D11MultiGPUDevice_V1, 2)
#define ID3D11MultiGPUDevice_VER3   MAKE_NVAPI_VERSION(ID3D11MultiGPUDevice_V1, 3)
#define ID3D11MultiGPUDevice_VER    ID3D11MultiGPUDevice_VER3
 
#define ALL_GPUS 0
 
NVAPI_INTERFACE NvAPI_D3D11_CreateMultiGPUDevice(__in ID3D11Device *pDevice, __in ULONG version, __out ULONG *currentVersion, __out ID3D11MultiGPUDevice **ppD3D11MultiGPUDevice, __in UINT maxGpus=ALL_GPUS);
 
#endif //defined(__cplusplus) && defined(__d3d11_h__)
 
typedef struct _NV_QUERY_SINGLE_PASS_STEREO_SUPPORT_PARAMS_V1
{
    NvU32 version;                                                          // parameter struct version
    NvU32 bSinglePassStereoSupported;                                       // Single Pass Stereo supported
} NV_QUERY_SINGLE_PASS_STEREO_SUPPORT_PARAMS_V1;
 
typedef struct _NV_QUERY_SINGLE_PASS_STEREO_SUPPORT_PARAMS_V2
{
    NvU32 version;                                                          // _IN_     parameter struct version
    NvU32 bSinglePassStereoSupported : 1;                                   // _OUT_    Single Pass Stereo supported
    NvU32 bSinglePassStereoXYZWSupported : 1;                               // _OUT_    Single Pass Stereo XYZW supported
    NvU32 reserved : 30;                                                    // _INOUT_  bits reserved for future use
} NV_QUERY_SINGLE_PASS_STEREO_SUPPORT_PARAMS_V2;
 
typedef NV_QUERY_SINGLE_PASS_STEREO_SUPPORT_PARAMS_V2                 NV_QUERY_SINGLE_PASS_STEREO_SUPPORT_PARAMS;
#define NV_QUERY_SINGLE_PASS_STEREO_SUPPORT_PARAMS_VER1               MAKE_NVAPI_VERSION(NV_QUERY_SINGLE_PASS_STEREO_SUPPORT_PARAMS_V1, 1)
#define NV_QUERY_SINGLE_PASS_STEREO_SUPPORT_PARAMS_VER2               MAKE_NVAPI_VERSION(NV_QUERY_SINGLE_PASS_STEREO_SUPPORT_PARAMS_V2, 2)
#define NV_QUERY_SINGLE_PASS_STEREO_SUPPORT_PARAMS_VER                NV_QUERY_SINGLE_PASS_STEREO_SUPPORT_PARAMS_VER2
 
#ifndef NV_QUERY_SINGLE_PASS_STEREO_SUPPORT_PARAMS_VER
typedef NV_QUERY_SINGLE_PASS_STEREO_SUPPORT_PARAMS_V1                 NV_QUERY_SINGLE_PASS_STEREO_SUPPORT_PARAMS;
#define NV_QUERY_SINGLE_PASS_STEREO_SUPPORT_PARAMS_VER1               MAKE_NVAPI_VERSION(NV_QUERY_SINGLE_PASS_STEREO_SUPPORT_PARAMS_V1, 1)
#define NV_QUERY_SINGLE_PASS_STEREO_SUPPORT_PARAMS_VER                NV_QUERY_SINGLE_PASS_STEREO_SUPPORT_PARAMS_VER1
#endif
 
#if defined(__cplusplus) && (defined(_D3D9_H_) || defined(__d3d10_h__) || defined(__d3d10_1_h__) || defined(__d3d11_h__))
//
// FUNCTION NAME: NvAPI_D3D_QuerySinglePassStereoSupport
//
NVAPI_INTERFACE NvAPI_D3D_QuerySinglePassStereoSupport(__in IUnknown *pDevice,
                                                __inout NV_QUERY_SINGLE_PASS_STEREO_SUPPORT_PARAMS *pQuerySinglePassStereoSupportedParams);
 
#endif //defined(__cplusplus) && (defined(_D3D9_H_) || defined(__d3d10_h__) || defined(__d3d10_1_h__) || defined(__d3d11_h__))
 
#if defined(__cplusplus) && defined(_D3D9_H_) || defined(__d3d10_h__) || defined(__d3d10_1_h__) || defined(__d3d11_h__)
//
// FUNCTION NAME: NvAPI_D3D_SetSinglePassStereoMode
//
NVAPI_INTERFACE NvAPI_D3D_SetSinglePassStereoMode(__in IUnknown *pDevOrContext, __in NvU32 numViews, __in NvU32 renderTargetIndexOffset, __in NvU8 independentViewportMaskEnable);
 
#endif //defined(__cplusplus) && defined(_D3D9_H_) || defined(__d3d10_h__) || defined(__d3d10_1_h__) || defined(__d3d11_h__)
 
#if defined(__cplusplus) && ( defined(__d3d12_h__))
//
// FUNCTION NAME: NvAPI_D3D12_QuerySinglePassStereoSupport
//
 
NVAPI_INTERFACE NvAPI_D3D12_QuerySinglePassStereoSupport(__in ID3D12Device *pDevice,
                                                         __inout NV_QUERY_SINGLE_PASS_STEREO_SUPPORT_PARAMS *pQuerySinglePassStereoSupportedParams);
 
#endif // defined(__cplusplus) && ( defined(__d3d12_h__))
 
#if defined(__cplusplus) && ( defined(__d3d12_h__))
//
// FUNCTION NAME: NvAPI_D3D12_SetSinglePassStereoMode
//
 
NVAPI_INTERFACE NvAPI_D3D12_SetSinglePassStereoMode(__in ID3D12GraphicsCommandList* pCommandList,
                                                    __in NvU32 numViews,
                                                    __in NvU32 renderTargetIndexOffset,
                                                    __in NvU8 independentViewportMaskEnable);
 
#endif // defined(__cplusplus) && ( defined(__d3d12_h__))
 
 
typedef struct _NV_QUERY_MULTIVIEW_SUPPORT_PARAMS_V1
{
    NvU32 version;                                              //  _IN_     parameter struct version
    NvU32 bMultiViewSupported : 1;                              //  _OUT_    MultiView supported (Render 4 views in a single pass)
    NvU32 bSinglePassStereoSupported : 1;                       //  _OUT_    StereoX supported (Render 2 views in a single pass)
    NvU32 bSinglePassStereoXYZWSupported : 1;                   //  _OUT_    StereoXYZW supported (Render 2 views in a single pass)
    NvU32 reserved : 29;                                        //  _INOUT_  bits reserved for future use
} NV_QUERY_MULTIVIEW_SUPPORT_PARAMS_V1;
 
typedef NV_QUERY_MULTIVIEW_SUPPORT_PARAMS_V1                    NV_QUERY_MULTIVIEW_SUPPORT_PARAMS;
#define NV_QUERY_MULTIVIEW_SUPPORT_PARAMS_VER1                  MAKE_NVAPI_VERSION(NV_QUERY_MULTIVIEW_SUPPORT_PARAMS_V1, 1)
#define NV_QUERY_MULTIVIEW_SUPPORT_PARAMS_VER                   NV_QUERY_MULTIVIEW_SUPPORT_PARAMS_VER1
#define NV_MULTIVIEW_MAX_SUPPORTED_VIEWS                        4
 
#if defined(__cplusplus) && (defined(_D3D9_H_) || defined(__d3d10_h__) || defined(__d3d10_1_h__) || defined(__d3d11_h__))
//
// FUNCTION NAME: NvAPI_D3D_QueryMultiViewSupport
//
NVAPI_INTERFACE NvAPI_D3D_QueryMultiViewSupport(__in IUnknown *pDevice,
                                                __inout NV_QUERY_MULTIVIEW_SUPPORT_PARAMS *pQueryMultiViewSupportedParams);
 
#endif //defined(__cplusplus) && (defined(_D3D9_H_) || defined(__d3d10_h__) || defined(__d3d10_1_h__) || defined(__d3d11_h__))
 
typedef struct _NV_MULTIVIEW_PARAMS_V1
{
    NvU32 version;                                                                 // _IN_  parameter struct version
    NvU32 numViews;                                                                // _IN_  Number of views to render.
    NvU32 renderTargetIndexOffset[NV_MULTIVIEW_MAX_SUPPORTED_VIEWS];               // _IN_  Offset between render targets for each of the per views.
    NvU8  independentViewportMaskEnable;                                           // _IN_  Is the independent viewport mask enabled.
} NV_MULTIVIEW_PARAMS_V1;
 
typedef NV_MULTIVIEW_PARAMS_V1                                       NV_MULTIVIEW_PARAMS;
#define NV_MULTIVIEW_PARAMS_VER1                                     MAKE_NVAPI_VERSION(NV_MULTIVIEW_PARAMS_V1, 1)
#define NV_MULTIVIEW_PARAMS_VER                                      NV_MULTIVIEW_PARAMS_VER1
 
#if defined(__cplusplus) && defined(_D3D9_H_) || defined(__d3d10_h__) || defined(__d3d10_1_h__) || defined(__d3d11_h__)
//
// FUNCTION NAME: NvAPI_D3D_SetMultiViewMode
//
NVAPI_INTERFACE NvAPI_D3D_SetMultiViewMode(__in IUnknown *pDevOrContext, __in NV_MULTIVIEW_PARAMS *pMultiViewParams);
 
#endif //defined(__cplusplus) && defined(_D3D9_H_) || defined(__d3d10_h__) || defined(__d3d10_1_h__) || defined(__d3d11_h__)
 
typedef struct _NV_QUERY_MODIFIED_W_SUPPORT_PARAMS
{
    NvU32 version;                                                 // parameter struct version
    NvU32 bModifiedWSupported;                                     // Modified W supported
} NV_QUERY_MODIFIED_W_SUPPORT_PARAMS_V1;
 
typedef NV_QUERY_MODIFIED_W_SUPPORT_PARAMS_V1               NV_QUERY_MODIFIED_W_SUPPORT_PARAMS;
#define NV_QUERY_MODIFIED_W_SUPPORT_PARAMS_VER1             MAKE_NVAPI_VERSION(NV_QUERY_MODIFIED_W_SUPPORT_PARAMS_V1, 1)
#define NV_QUERY_MODIFIED_W_SUPPORT_PARAMS_VER              NV_QUERY_MODIFIED_W_SUPPORT_PARAMS_VER1
 
#if defined(__cplusplus) && (defined(_D3D9_H_) || defined(__d3d10_h__) || defined(__d3d10_1_h__) || defined(__d3d11_h__))
//
// FUNCTION NAME: NvAPI_D3D_QueryModifiedWSupport
//
NVAPI_INTERFACE NvAPI_D3D_QueryModifiedWSupport(__in IUnknown *pDev,
                                            __inout NV_QUERY_MODIFIED_W_SUPPORT_PARAMS *pQueryModifiedWSupportedParams);
#endif //defined(__cplusplus) && (defined(_D3D9_H_) || defined(__d3d10_h__) || defined(__d3d10_1_h__) || defined(__d3d11_h__))
 
#define NV_MODIFIED_W_MAX_VIEWPORTS    16
 
typedef struct _NV_MODIFIED_W_COEFFICIENTS
{
    float fA;                               // A coefficient in w' = w + Ax + By
    float fB;                               // B coefficient in w' = w + Ax + By
    float fAReserved;                       // reserved
    float fBReserved;                       // reserved
 
    float fReserved[2];                     // reserved
} NV_MODIFIED_W_COEFFICIENTS;
 
typedef struct _NV_MODIFIED_W_PARAMS
{
    NvU32 version;                                                                 // parameter struct version
    NvU32 numEntries;                                                              // number of valid NV_MODIFIED_W_COEFFICIENTS structs in array
    NV_MODIFIED_W_COEFFICIENTS modifiedWCoefficients[NV_MODIFIED_W_MAX_VIEWPORTS]; // coefficients
 
    NvU32 id;                                                     // reserved
    NvU32 reserved[NV_MODIFIED_W_MAX_VIEWPORTS];                  // reserved
} NV_MODIFIED_W_PARAMS_V1;
 
typedef NV_MODIFIED_W_PARAMS_V1      NV_MODIFIED_W_PARAMS;
#define NV_MODIFIED_W_PARAMS_VER1    MAKE_NVAPI_VERSION(NV_MODIFIED_W_PARAMS_V1, 1)
#define NV_MODIFIED_W_PARAMS_VER     NV_MODIFIED_W_PARAMS_VER1
 
#if defined(__cplusplus) && (defined(_D3D9_H_) || defined(__d3d10_h__) || defined(__d3d10_1_h__) || defined(__d3d11_h__))
//
// FUNCTION NAME: NvAPI_D3D_SetModifiedWMode
//
NVAPI_INTERFACE NvAPI_D3D_SetModifiedWMode(__in IUnknown *pDevOrContext, __in NV_MODIFIED_W_PARAMS *psModifiedWParams);
 
#endif //defined(__cplusplus) && (defined(_D3D9_H_) || defined(__d3d10_h__) || defined(__d3d10_1_h__) || defined(__d3d11_h__))
 
#if defined(__cplusplus) && ( defined(__d3d12_h__))
//
// FUNCTION NAME: NvAPI_D3D12_QueryModifiedWSupport
//
 
NVAPI_INTERFACE NvAPI_D3D12_QueryModifiedWSupport(__in ID3D12Device *pDevice,
                                                  __inout NV_QUERY_MODIFIED_W_SUPPORT_PARAMS *pQueryModifiedWSupportedParams);
 
#endif // defined(__cplusplus) && ( defined(__d3d12_h__))
 
#if defined(__cplusplus) && ( defined(__d3d12_h__))
//
// FUNCTION NAME: NvAPI_D3D12_SetModifiedWMode
//
 
NVAPI_INTERFACE NvAPI_D3D12_SetModifiedWMode(__in ID3D12GraphicsCommandList* pCommandList,
                                             __in NV_MODIFIED_W_PARAMS *pModifiedWParams);
 
#endif // defined(__cplusplus) && ( defined(__d3d12_h__))
 
 
#if defined(__cplusplus) && (defined(__d3d11_h__))
 
DECLARE_INTERFACE(ID3DLateLatchObject_V1)
{
    STDMETHOD_(UINT,Release)                    (THIS) PURE;                                    
    STDMETHOD_(NvAPI_Status,Latch)              (THIS_ __in IUnknown* pContext = NULL) PURE;    
    STDMETHOD_(ID3D11Buffer*,GetD3D11Buffer)    (THIS_ __in UINT index = 0) PURE;               
    STDMETHOD_(UINT,GetBufferCount)             (THIS) PURE;                                    
    STDMETHOD_(NvAPI_Status,UpdateData)         (THIS_ __in void **ppData) PURE;                
    STDMETHOD_(NvAPI_Status,UpdateData)         (THIS_ __in void *pData, __in size_t offset, 
                                                  __in size_t size, __in UINT index = 0) PURE;  
};
 
typedef ID3DLateLatchObject_V1    ID3DLateLatchObject;
#define ID3DLateLatchObject_VER1  MAKE_NVAPI_VERSION(ID3DLateLatchObject_V1, 1)
#define ID3DLateLatchObject_VER   ID3DLateLatchObject_VER1
 
typedef struct _NV_D3D_LATELATCH_OBJECT_DESC_V1
{
    NvU32                       version;
    NvU32                       numBuffers;                 // _IN_  Number of LateLatch buffers that the app wants to create. 
    D3D11_BUFFER_DESC           **ppBufferDesc;             // _IN_  Description of buffers
    ID3DLateLatchObject         **ppD3DLateLatchObject;     // _Out_ Pointer to created interface
} NV_D3D_LATELATCH_OBJECT_DESC_V1;
 
typedef NV_D3D_LATELATCH_OBJECT_DESC_V1    NV_D3D_LATELATCH_OBJECT_DESC;
#define NV_D3D_LATELATCH_OBJECT_DESC_VER1  MAKE_NVAPI_VERSION(NV_D3D_LATELATCH_OBJECT_DESC_V1, 1)
#define NV_D3D_LATELATCH_OBJECT_DESC_VER   NV_D3D_LATELATCH_OBJECT_DESC_VER1
 
//
// FUNCTION NAME: NvAPI_D3D_CreateLateLatchObject
//
 
NVAPI_INTERFACE NvAPI_D3D_CreateLateLatchObject(__in IUnknown *pDevice, __inout NV_D3D_LATELATCH_OBJECT_DESC* pLateLatchObjectDesc);
 
#endif // defined(__cplusplus) && (defined(__d3d11_h__))
 
 
 
#if defined(__cplusplus) && (defined(__d3d11_h__) || defined(__d3d12_h__))
typedef struct _NV_QUERY_LATELATCH_SUPPORT_PARAMS
{
    NvU32 version;                      
    NvU32 bLateLatchSupported;          
} NV_QUERY_LATELATCH_SUPPORT_PARAMS_V1;
 
typedef NV_QUERY_LATELATCH_SUPPORT_PARAMS_V1               NV_QUERY_LATELATCH_SUPPORT_PARAMS;
#define NV_QUERY_LATELATCH_SUPPORT_PARAMS_VER1             MAKE_NVAPI_VERSION(NV_QUERY_LATELATCH_SUPPORT_PARAMS_V1, 1)
#define NV_QUERY_LATELATCH_SUPPORT_PARAMS_VER              NV_QUERY_LATELATCH_SUPPORT_PARAMS_VER1
 
//
// FUNCTION NAME: NvAPI_D3D_QueryLateLatchSupport
//
NVAPI_INTERFACE NvAPI_D3D_QueryLateLatchSupport(__in IUnknown *pDevice,
                                            __inout NV_QUERY_LATELATCH_SUPPORT_PARAMS *pQueryLateLatchSupportParams);
#endif // defined(__cplusplus) && (defined(__d3d11_h__) || defined(__d3d12_h__))
 
 
 
#if defined (__cplusplus) && (defined(__d3d10_h__) || defined(__d3d10_1_h__) || defined(__d3d11_h__))
//
// FUNCTION NAME: NvAPI_D3D_RegisterDevice
//
NVAPI_INTERFACE NvAPI_D3D_RegisterDevice(__in IUnknown *pDev);
 
#endif //if defined(__cplusplus) && (defined(__d3d10_h__) || defined(__d3d10_1_h__) || defined(__d3d11_h__))
 
 
 
#if defined (__cplusplus) && (defined(__d3d11_h__) || defined(__d3d11_1_h__))
 
//
// FUNCTION NAME: NvAPI_D3D11_MultiDrawInstancedIndirect
//
 
NVAPI_INTERFACE NvAPI_D3D11_MultiDrawInstancedIndirect(__in ID3D11DeviceContext *pDevContext11,
                                                       __in NvU32                drawCount,
                                                       __in ID3D11Buffer        *pBuffer,
                                                       __in NvU32                alignedByteOffsetForArgs,
                                                       __in NvU32                alignedByteStrideForArgs);
 
#endif //defined (__cplusplus) && (defined(__d3d11_h__) || defined(__d3d11_1_h__))
 
 
#if defined (__cplusplus) && (defined(__d3d11_h__) || defined(__d3d11_1_h__))
 
//
// FUNCTION NAME: NvAPI_D3D11_MultiDrawIndexedInstancedIndirect
//
 
NVAPI_INTERFACE NvAPI_D3D11_MultiDrawIndexedInstancedIndirect(__in ID3D11DeviceContext *pDevContext11,
                                                              __in NvU32                drawCount,
                                                              __in ID3D11Buffer        *pBuffer,
                                                              __in NvU32                alignedByteOffsetForArgs,
                                                              __in NvU32                alignedByteStrideForArgs);
 
#endif //defined (__cplusplus) && (defined(__d3d11_h__) || defined(__d3d11_1_h__))
 
#if defined (__cplusplus) && ( defined(_D3D9_H_) || defined(__d3d10_h__) || defined(__d3d10_1_h__) ||defined(__d3d11_h__) )
//
// FUNCTION NAME:   NvAPI_D3D_ImplicitSLIControl
//
 
typedef enum _IMPLICIT_SLI_CONTROL
{
    DISABLE_IMPLICIT_SLI    = 0,
    ENABLE_IMPLICIT_SLI     = 1,
} IMPLICIT_SLI_CONTROL;
 
NVAPI_INTERFACE NvAPI_D3D_ImplicitSLIControl(__in IMPLICIT_SLI_CONTROL implicitSLIControl);
 
#endif //defined (__cplusplus) && ( defined(_D3D9_H_) || defined(__d3d10_h__) || defined(__d3d10_1_h__) ||defined(__d3d11_h__) )
 
 
#if defined (__cplusplus) && defined(__d3d12_h__)
//
// FUNCTION NAME: NvAPI_D3D12_GetNeedsAppFPBlendClamping
//
 
NVAPI_INTERFACE NvAPI_D3D12_GetNeedsAppFPBlendClamping(__in  ID3D12Device *pDevice,
                                                       __out bool         *pAppClampNeeded);
 
#endif //defined(__cplusplus) && defined(__d3d12_h__)
 
 
#if defined (__cplusplus) && defined(__d3d12_h__)
//
// FUNCTION NAME: NvAPI_D3D12_UseDriverHeapPriorities
//
 
NVAPI_INTERFACE NvAPI_D3D12_UseDriverHeapPriorities(__in ID3D12Device *pDevice);
 
#endif // defined (__cplusplus) && defined(__d3d12_h__)
 
#if defined(__cplusplus) && ( defined(__d3d12_h__))
 
 
typedef struct _NV_D3D12_MOSAIC_GETCOMPANIONALLOCATIONS
{
    __in    NvU32            version;               
    __in    ID3D12Device    *pDevice;               
    __in    ID3D12Resource  *pSwapChainBuffer;      
    __in    NvU32            companionBufferCount;  
    __inout ID3D12Resource **ppCompanionResources;  
} NV_D3D12_MOSAIC_GETCOMPANIONALLOCATIONS_V1;
 
typedef NV_D3D12_MOSAIC_GETCOMPANIONALLOCATIONS_V1              NV_D3D12_MOSAIC_GETCOMPANIONALLOCATIONS;
#define NV_D3D12_MOSAIC_GETCOMPANIONALLOCATIONS_VER1            MAKE_NVAPI_VERSION(NV_D3D12_MOSAIC_GETCOMPANIONALLOCATIONS_V1, 1)
#define NV_D3D12_MOSAIC_GETCOMPANIONALLOCATIONS_VER             NV_D3D12_MOSAIC_GETCOMPANIONALLOCATIONS_VER1
 
//
// FUNCTION NAME: NvAPI_D3D12_Mosaic_GetCompanionAllocations
//
 
NVAPI_INTERFACE NvAPI_D3D12_Mosaic_GetCompanionAllocations(__inout NV_D3D12_MOSAIC_GETCOMPANIONALLOCATIONS *params);
 
#endif // defined(__cplusplus) && ( defined(__d3d12_h__))
 
#if defined(__cplusplus) && ( defined(__d3d12_h__))
 
typedef struct _NV_D3D12_MOSAIC_GETVIEWPORTANDGPUPARTITIONS
{
    __in    NvU32                                     version;              
    __in    ID3D12Device                             *pDevice;              
    __in    ID3D12Resource                           *pSwapChainBuffer;     
    __inout NvU32                                    *pPartitionCount;      
    __inout RECT                                     *pViewport;            
    __inout NvU32                                    *pNodeMask;            
} NV_D3D12_MOSAIC_GETVIEWPORTANDGPUPARTITIONS_V1;
 
typedef NV_D3D12_MOSAIC_GETVIEWPORTANDGPUPARTITIONS_V1          NV_D3D12_MOSAIC_GETVIEWPORTANDGPUPARTITIONS;
#define NV_D3D12_MOSAIC_GETVIEWPORTANDGPUPARTITIONS_VER1        MAKE_NVAPI_VERSION(NV_D3D12_MOSAIC_GETVIEWPORTANDGPUPARTITIONS_V1, 1)
#define NV_D3D12_MOSAIC_GETVIEWPORTANDGPUPARTITIONS_VER         NV_D3D12_MOSAIC_GETVIEWPORTANDGPUPARTITIONS_VER1
 
//
// FUNCTION NAME: NvAPI_D3D12_Mosaic_GetViewportAndGpuPartitions
//
 
NVAPI_INTERFACE NvAPI_D3D12_Mosaic_GetViewportAndGpuPartitions(__inout NV_D3D12_MOSAIC_GETVIEWPORTANDGPUPARTITIONS *params);
 
#endif // defined(__cplusplus) && ( defined(__d3d12_h__))
 
 
#if defined(__cplusplus) && (defined(__d3d11_h__))
 
typedef struct _NV_D3D1x_GRAPHICS_CAPS_V1
{
    NvU32   bExclusiveScissorRectsSupported         :  1;     
    NvU32   bVariablePixelRateShadingSupported      :  1;     
    NvU32   reservedBits                            : 30;     // Reserved bits for future expansion
    NvU32   reserved[7];                                      // Reserved for future expansion
} NV_D3D1x_GRAPHICS_CAPS_V1;
 
#define NV_D3D1x_GRAPHICS_CAPS_VER1  MAKE_NVAPI_VERSION(NV_D3D1x_GRAPHICS_CAPS_V1, 1)
 
typedef struct _NV_D3D1x_GRAPHICS_CAPS_V2
{
    NvU32   bExclusiveScissorRectsSupported         :  1;     
    NvU32   bVariablePixelRateShadingSupported      :  1;     
    NvU32   bFastUAVClearSupported                  :  1;     
    NvU32   reservedBits                            : 29;     // Reserved bits for future expansion
    NvU16   majorSMVersion;                                   
    NvU16   minorSMVersion;                                   
    NvU32   reserved[14];                                     // Reserved for future expansion
} NV_D3D1x_GRAPHICS_CAPS_V2;
 
typedef NV_D3D1x_GRAPHICS_CAPS_V2    NV_D3D1x_GRAPHICS_CAPS;
#define NV_D3D1x_GRAPHICS_CAPS_VER2  MAKE_NVAPI_VERSION(NV_D3D1x_GRAPHICS_CAPS_V2, 2)
#define NV_D3D1x_GRAPHICS_CAPS_VER   NV_D3D1x_GRAPHICS_CAPS_VER2
 
//
// FUNCTION NAME: NvAPI_D3D1x_GetGraphicsCapabilities
//
 
NVAPI_INTERFACE NvAPI_D3D1x_GetGraphicsCapabilities(__in IUnknown *pDevice,
                                                    __in NvU32 structVersion,
                                                    __inout NV_D3D1x_GRAPHICS_CAPS *pGraphicsCaps);
 
#endif // defined(__cplusplus) && (defined(__d3d11_h__))
 
#if defined(__cplusplus) && (defined(__d3d12_h__))
 
typedef struct _NV_D3D12_GRAPHICS_CAPS_V1
{
    NvU32   bExclusiveScissorRectsSupported         :  1;     
    NvU32   bVariablePixelRateShadingSupported      :  1;     
    NvU32   bFastUAVClearSupported                  :  1;     
    NvU32   reservedBits                            : 29;     // Reserved bits for future expansion
    NvU16   majorSMVersion;                                   
    NvU16   minorSMVersion;                                   
    NvU32   reserved[6];                                      // Reserved for future expansion
} NV_D3D12_GRAPHICS_CAPS_V1;
 
typedef NV_D3D12_GRAPHICS_CAPS_V1    NV_D3D12_GRAPHICS_CAPS;
#define NV_D3D12_GRAPHICS_CAPS_VER1  MAKE_NVAPI_VERSION(NV_D3D12_GRAPHICS_CAPS_V1, 1)
#define NV_D3D12_GRAPHICS_CAPS_VER   NV_D3D12_GRAPHICS_CAPS_VER1
 
//
// FUNCTION NAME: NvAPI_D3D12_GetGraphicsCapabilities
//
 
NVAPI_INTERFACE NvAPI_D3D12_GetGraphicsCapabilities(__in IUnknown *pDevice,
                                                    __in NvU32 structVersion,
                                                    __inout NV_D3D12_GRAPHICS_CAPS *pGraphicsCaps);
 
#endif // defined(__cplusplus) && (defined(__d3d12_h__))
 
 
#if defined(__cplusplus) && (defined(__d3d11_h__) || defined(__d3d12_h__))
#define NV_MAX_NUM_EXCLUSIVE_SCISSOR_RECTS    16
#endif // defined(__cplusplus) && (defined(__d3d11_h__) || defined(__d3d12_h__))
 
#if defined(__cplusplus) && (defined(__d3d11_h__))
 
typedef struct _NV_D3D11_EXCLUSIVE_SCISSOR_RECT_DESC_V1
{
    bool        enableExclusiveScissorRect; 
    D3D11_RECT  scissorRect;                
} NV_D3D11_EXCLUSIVE_SCISSOR_RECT_DESC_V1;
 
typedef struct _NV_D3D11_EXCLUSIVE_SCISSOR_RECTS_DESC_V1
{
    NvU32                                       version;    
    NvU32                                       numRects;   
                                                            //        \note Passing zero will globally disable Exclusive Scissor Rects
                                                            //        \note Max value can be equal to NV_MAX_NUM_EXCLUSIVE_SCISSOR_RECTS
    NV_D3D11_EXCLUSIVE_SCISSOR_RECT_DESC_V1    *pRects;     
} NV_D3D11_EXCLUSIVE_SCISSOR_RECTS_DESC_V1;
 
typedef NV_D3D11_EXCLUSIVE_SCISSOR_RECTS_DESC_V1     NV_D3D11_EXCLUSIVE_SCISSOR_RECTS_DESC;
typedef NV_D3D11_EXCLUSIVE_SCISSOR_RECT_DESC_V1      NV_D3D11_EXCLUSIVE_SCISSOR_RECT_DESC;
#define NV_D3D11_EXCLUSIVE_SCISSOR_RECTS_DESC_VER1   MAKE_NVAPI_VERSION(NV_D3D11_EXCLUSIVE_SCISSOR_RECTS_DESC_V1, 1)
#define NV_D3D11_EXCLUSIVE_SCISSOR_RECTS_DESC_VER    NV_D3D11_EXCLUSIVE_SCISSOR_RECTS_DESC_VER1
 
//
// FUNCTION NAME: NvAPI_D3D11_RSSetExclusiveScissorRects
//
 
NVAPI_INTERFACE NvAPI_D3D11_RSSetExclusiveScissorRects(__in IUnknown *pContext,
                                                       __in NV_D3D11_EXCLUSIVE_SCISSOR_RECTS_DESC *pExclusiveScissorRectsDesc);
 
#endif // defined(__cplusplus) && (defined(__d3d11_h__))
 
#if defined(__cplusplus) && (defined(__d3d11_h__) || defined(__d3d12_h__))
 
#define NV_MAX_PIXEL_SHADING_RATES  16 // Currently only 12 Shading Rates are available
#define NV_MAX_NUM_VIEWPORTS        16
 
// Every element in Shading Rate Resource represents the shading rate for all pixels in the corresponding tile
// The Shading Rate Resource dimensions must be the bound render target size divided by the tile dimensions (width/height)
 
#define NV_VARIABLE_PIXEL_SHADING_TILE_WIDTH    16 // Width of the tile, in pixels
#define NV_VARIABLE_PIXEL_SHADING_TILE_HEIGHT   16 // Height of the tile, in pixels
 
typedef enum
{
    NV_PIXEL_X0_CULL_RASTER_PIXELS,         // No shading, tiles are culled
    NV_PIXEL_X16_PER_RASTER_PIXEL,          // 16 shading passes per 1 raster pixel
    NV_PIXEL_X8_PER_RASTER_PIXEL,           //  8 shading passes per 1 raster pixel
    NV_PIXEL_X4_PER_RASTER_PIXEL,           //  4 shading passes per 1 raster pixel
    NV_PIXEL_X2_PER_RASTER_PIXEL,           //  2 shading passes per 1 raster pixel
    NV_PIXEL_X1_PER_RASTER_PIXEL,           //  Per-pixel shading
    NV_PIXEL_X1_PER_2X1_RASTER_PIXELS,      //  1 shading pass per  2 raster pixels
    NV_PIXEL_X1_PER_1X2_RASTER_PIXELS,      //  1 shading pass per  2 raster pixels
    NV_PIXEL_X1_PER_2X2_RASTER_PIXELS,      //  1 shading pass per  4 raster pixels
    NV_PIXEL_X1_PER_4X2_RASTER_PIXELS,      //  1 shading pass per  8 raster pixels
    NV_PIXEL_X1_PER_2X4_RASTER_PIXELS,      //  1 shading pass per  8 raster pixels
    NV_PIXEL_X1_PER_4X4_RASTER_PIXELS       //  1 shading pass per 16 raster pixels
} NV_PIXEL_SHADING_RATE;
#endif // defined(__cplusplus) && (defined(__d3d11_h__) || defined(__d3d12_h__))
 
#if defined(__cplusplus) && (defined(__d3d11_h__))
typedef struct _NV_D3D11_VIEWPORT_SHADING_RATE_DESC_V1
{
    bool                    enableVariablePixelShadingRate;                         
    NV_PIXEL_SHADING_RATE   shadingRateTable[NV_MAX_PIXEL_SHADING_RATES];           
                                                                                    //        \note Shading Rate Resource View would be populated by application with indices of this table
} NV_D3D11_VIEWPORT_SHADING_RATE_DESC_V1;
 
typedef struct _NV_D3D11_VIEWPORTS_SHADING_RATE_DESC_V1
{
    NvU32                                        version;       
    NvU32                                        numViewports;  
                                                                //        \note Passing zero will globally disable Variable Pixel Rate Shading for all viewports immaterial of values in pViewports
                                                                //        \note Max value can be equal to NV_MAX_NUM_VIEWPORTS
    NV_D3D11_VIEWPORT_SHADING_RATE_DESC_V1      *pViewports;    
} NV_D3D11_VIEWPORTS_SHADING_RATE_DESC_V1;
 
typedef NV_D3D11_VIEWPORTS_SHADING_RATE_DESC_V1     NV_D3D11_VIEWPORTS_SHADING_RATE_DESC;
typedef NV_D3D11_VIEWPORT_SHADING_RATE_DESC_V1      NV_D3D11_VIEWPORT_SHADING_RATE_DESC;
#define NV_D3D11_VIEWPORTS_SHADING_RATE_DESC_VER1   MAKE_NVAPI_VERSION(NV_D3D11_VIEWPORTS_SHADING_RATE_DESC_V1, 1)
#define NV_D3D11_VIEWPORTS_SHADING_RATE_DESC_VER    NV_D3D11_VIEWPORTS_SHADING_RATE_DESC_VER1
 
//
// FUNCTION NAME: NvAPI_D3D11_RSSetViewportsPixelShadingRates
//
 
NVAPI_INTERFACE NvAPI_D3D11_RSSetViewportsPixelShadingRates(__in IUnknown *pContext,
                                                            __in NV_D3D11_VIEWPORTS_SHADING_RATE_DESC *pShadingRateDesc);
 
#endif // defined(__cplusplus) && (defined(__d3d11_h__))
 
#if defined(__cplusplus) && (defined(__d3d11_h__) || defined(__d3d12_h__))
 
typedef enum _NV_SRRV_DIMENSION
{ 
    NV_SRRV_DIMENSION_TEXTURE2D           = 4,
    NV_SRRV_DIMENSION_TEXTURE2DARRAY      = 5,
} NV_SRRV_DIMENSION;
 
typedef struct _NV_TEX2D_SRRV
{
    UINT MipSlice;
} NV_TEX2D_SRRV;
 
typedef struct _NV_TEX2D_ARRAY_SRRV
{
    UINT MipSlice;
    UINT FirstArraySlice;
    UINT ArraySize;
} NV_TEX2D_ARRAY_SRRV;
#endif // defined(__cplusplus) && (defined(__d3d11_h__) || defined(__d3d12_h__))
 
#if defined(__cplusplus) && (defined(__d3d11_h__))
typedef struct _NV_D3D11_SHADING_RATE_RESOURCE_VIEW_DESC_V1
{
    NvU32               version;                
    DXGI_FORMAT         Format;                 
    NV_SRRV_DIMENSION   ViewDimension;          
    union
    {
        NV_TEX2D_SRRV       Texture2D;
        NV_TEX2D_ARRAY_SRRV Texture2DArray;
    };
} NV_D3D11_SHADING_RATE_RESOURCE_VIEW_DESC_V1;
 
typedef NV_D3D11_SHADING_RATE_RESOURCE_VIEW_DESC_V1     NV_D3D11_SHADING_RATE_RESOURCE_VIEW_DESC;
#define NV_D3D11_SHADING_RATE_RESOURCE_VIEW_DESC_VER1   MAKE_NVAPI_VERSION(NV_D3D11_SHADING_RATE_RESOURCE_VIEW_DESC_V1, 1)
#define NV_D3D11_SHADING_RATE_RESOURCE_VIEW_DESC_VER    NV_D3D11_SHADING_RATE_RESOURCE_VIEW_DESC_VER1
 
DECLARE_INTERFACE_(__declspec(uuid("E14BE7F6-8FF5-4F5E-B63A-AD016EB8FBE5"))ID3D11NvShadingRateResourceView_V1, ID3D11View)
{
    BEGIN_INTERFACE
 
    // *** IUnknown methods ***
    STDMETHOD(QueryInterface)(THIS_ REFIID riid, void **ppv) PURE;
    STDMETHOD_(ULONG,AddRef)(THIS) PURE;
    STDMETHOD_(ULONG,Release)(THIS) PURE;
 
    // **** ID3D11View method **/
    // Get Shading Rate Resource used while creating the Shading Rate Resource View
    STDMETHOD_(void,GetResource)(THIS_ _Outptr_ ID3D11Resource **ppResource) PURE;
 
    // ** ID3D11NvShadingRateResourceView methods ***
    // The descriptor used while creating the Shading Rate Resource View
    STDMETHOD(GetDesc)(THIS_ NV_D3D11_SHADING_RATE_RESOURCE_VIEW_DESC* pDesc) PURE;
 
    END_INTERFACE
};
 
typedef ID3D11NvShadingRateResourceView_V1    ID3D11NvShadingRateResourceView;
#define ID3D11NvShadingRateResourceView_VER1  MAKE_NVAPI_VERSION(ID3D11NvShadingRateResourceView_V1, 1)
#define ID3D11NvShadingRateResourceView_VER   ID3D11NvShadingRateResourceView_VER1
 
//
// FUNCTION NAME: NvAPI_D3D11_CreateShadingRateResourceView
//
 
NVAPI_INTERFACE NvAPI_D3D11_CreateShadingRateResourceView(__in  ID3D11Device *pDevice,
                                                          __in  ID3D11Resource *pShadingRateResource,
                                                          __in  NV_D3D11_SHADING_RATE_RESOURCE_VIEW_DESC *pShadingRateResourceViewDesc,
                                                          __out ID3D11NvShadingRateResourceView **ppShadingRateResourceView);
 
#endif // defined(__cplusplus) && (defined(__d3d11_h__))
 
#if defined(__cplusplus) && (defined(__d3d11_h__))
 
//
// FUNCTION NAME: NvAPI_D3D11_RSSetShadingRateResourceView
//
 
NVAPI_INTERFACE NvAPI_D3D11_RSSetShadingRateResourceView(__in IUnknown *pContext,
                                                         __in ID3D11NvShadingRateResourceView *pShadingRateResourceView);
 
#endif // defined(__cplusplus) && (defined(__d3d11_h__))
 
#if defined(__cplusplus) && (defined(__d3d11_h__) || defined(__d3d12_h__))
 
// X, Y = sample position. S = sample number.
// The inner-most dimension is the sample number, followed by X and Y.
 
typedef struct _NV_PIXEL_SRSO_1x2
{
    struct NV_PIXEL_SRSO_1x2_X1 { NvU8 Y[2];         } X1;
    struct NV_PIXEL_SRSO_1x2_X2 { NvU8 YS[2][2];     } X2;
    struct NV_PIXEL_SRSO_1x2_X4 { NvU8 YS[2][4];     } X4;
    struct NV_PIXEL_SRSO_1x2_X8 { NvU8 YS[2][8];     } X8;
} NV_PIXEL_SRSO_1x2;
 
typedef struct _NV_PIXEL_SRSO_2x1
{
    struct NV_PIXEL_SRSO_2x1_X1 { NvU8 X[2];         } X1;
    struct NV_PIXEL_SRSO_2x1_X2 { NvU8 XS[2][2];     } X2;
    struct NV_PIXEL_SRSO_2x1_X4 { NvU8 XS[2][4];     } X4;
} NV_PIXEL_SRSO_2x1;
 
typedef struct _NV_PIXEL_SRSO_2x2
{
    struct NV_PIXEL_SRSO_2x2_X1 { NvU8 YX[2][2];     } X1;
    struct NV_PIXEL_SRSO_2x2_X2 { NvU8 YXS[2][2][2]; } X2;
    struct NV_PIXEL_SRSO_2x2_X4 { NvU8 YXS[2][2][4]; } X4;
} NV_PIXEL_SRSO_2x2;
 
typedef struct _NV_PIXEL_SRSO_2x4
{
    struct NV_PIXEL_SRSO_2x4_X1 { NvU8 YX[4][2];     } X1;
    struct NV_PIXEL_SRSO_2x4_X2 { NvU8 YXS[4][2][2]; } X2;
} NV_PIXEL_SRSO_2x4;
 
typedef struct _NV_PIXEL_SRSO_4x2
{
    struct NV_PIXEL_SRSO_4x2_X1 { NvU8 YX[2][4];     } X1;
} NV_PIXEL_SRSO_4x2;
 
typedef struct _NV_PIXEL_SRSO_4x4
{
    struct NV_PIXEL_SRSO_4x4_X1 { NvU8 YX[4][4];     } X1;
} NV_PIXEL_SRSO_4x4;
 
typedef struct _NV_PIXEL_SHADING_RATE_SAMPLE_ORDER_TABLE_V1
{
    NvU32 version;
    NV_PIXEL_SRSO_1x2 Pixel_1x2;
    NV_PIXEL_SRSO_2x1 Pixel_2x1;
    NV_PIXEL_SRSO_2x2 Pixel_2x2;
    NV_PIXEL_SRSO_2x4 Pixel_2x4;
    NV_PIXEL_SRSO_4x2 Pixel_4x2;
    NV_PIXEL_SRSO_4x4 Pixel_4x4;
} NV_PIXEL_SHADING_RATE_SAMPLE_ORDER_TABLE_V1;
 
typedef NV_PIXEL_SHADING_RATE_SAMPLE_ORDER_TABLE_V1     NV_PIXEL_SHADING_RATE_SAMPLE_ORDER_TABLE;
#define NV_PIXEL_SHADING_RATE_SAMPLE_ORDER_TABLE_VER1   MAKE_NVAPI_VERSION(NV_PIXEL_SHADING_RATE_SAMPLE_ORDER_TABLE_V1, 1)
#define NV_PIXEL_SHADING_RATE_SAMPLE_ORDER_TABLE_VER    NV_PIXEL_SHADING_RATE_SAMPLE_ORDER_TABLE_VER1
 
#endif // defined(__cplusplus) && (defined(__d3d11_h__) || defined(__d3d12_h__))
 
#if defined(__cplusplus) && (defined(__d3d11_h__))
//
// FUNCTION NAME: NvAPI_D3D11_RSGetPixelShadingRateSampleOrder
//
 
NVAPI_INTERFACE NvAPI_D3D11_RSGetPixelShadingRateSampleOrder(__in IUnknown *pContext,
                                                             __out NV_PIXEL_SHADING_RATE_SAMPLE_ORDER_TABLE* pSampleOrderTable);
 
#endif // defined(__cplusplus) && (defined(__d3d11_h__))
 
#if defined(__cplusplus) && (defined(__d3d11_h__))
 
//
// FUNCTION NAME: NvAPI_D3D11_RSSetPixelShadingRateSampleOrder
//
 
NVAPI_INTERFACE NvAPI_D3D11_RSSetPixelShadingRateSampleOrder(__in IUnknown *pContext,
                                                             __in NV_PIXEL_SHADING_RATE_SAMPLE_ORDER_TABLE* pSampleOrderTable);
 
#endif // defined(__cplusplus) && (defined(__d3d11_h__))
 
 
#if defined(__cplusplus) && (defined(__d3d11_h__))
typedef struct _NV_VRS_HELPER_LATCH_GAZE_PARAMS_V1
{
    NvU32               version;    
    NvU32               flags;      
} NV_VRS_HELPER_LATCH_GAZE_PARAMS_V1;
 
typedef NV_VRS_HELPER_LATCH_GAZE_PARAMS_V1     NV_VRS_HELPER_LATCH_GAZE_PARAMS;
#define NV_VRS_HELPER_LATCH_GAZE_PARAMS_VER1   MAKE_NVAPI_VERSION(NV_VRS_HELPER_LATCH_GAZE_PARAMS_V1, 1)
#define NV_VRS_HELPER_LATCH_GAZE_PARAMS_VER    NV_VRS_HELPER_LATCH_GAZE_PARAMS_VER1
 
typedef enum _NV_VRS_CONTENT_TYPE
{
    NV_VRS_CONTENT_TYPE_INVALID = 0x0,
    NV_VRS_CONTENT_TYPE_FOVEATED_RENDERING = 0x1,
    NV_VRS_CONTENT_TYPE_MAX = NV_VRS_CONTENT_TYPE_FOVEATED_RENDERING
} NV_VRS_CONTENT_TYPE;
 
typedef enum _NV_FOVEATED_RENDERING_SHADING_RATE_PRESET
{
    NV_FOVEATED_RENDERING_SHADING_RATE_PRESET_INVALID = 0,
    NV_FOVEATED_RENDERING_SHADING_RATE_PRESET_HIGHEST_PERFORMANCE = 1,
    NV_FOVEATED_RENDERING_SHADING_RATE_PRESET_HIGH_PERFORMANCE = 2,
    NV_FOVEATED_RENDERING_SHADING_RATE_PRESET_BALANCED = 3,
    NV_FOVEATED_RENDERING_SHADING_RATE_PRESET_HIGH_QUALITY = 4,
    NV_FOVEATED_RENDERING_SHADING_RATE_PRESET_HIGHEST_QUALITY = 5,
    NV_FOVEATED_RENDERING_SHADING_RATE_PRESET_CUSTOM = 6,
    NV_FOVEATED_RENDERING_SHADING_RATE_PRESET_MAX = NV_FOVEATED_RENDERING_SHADING_RATE_PRESET_CUSTOM
} NV_FOVEATED_RENDERING_SHADING_RATE_PRESET;
 
typedef struct _NV_FOVEATED_RENDERING_CUSTOM_SHADING_RATE_PRESET_DESC_V1
{
    NvU32 version;
 
    NV_PIXEL_SHADING_RATE InnerMostRegionShadingRate;       
    NV_PIXEL_SHADING_RATE MiddleRegionShadingRate;          
    NV_PIXEL_SHADING_RATE PeripheralRegionShadingRate;      
} NV_FOVEATED_RENDERING_CUSTOM_SHADING_RATE_PRESET_DESC_V1;
 
typedef NV_FOVEATED_RENDERING_CUSTOM_SHADING_RATE_PRESET_DESC_V1     NV_FOVEATED_RENDERING_CUSTOM_SHADING_RATE_PRESET_DESC;
#define NV_FOVEATED_RENDERING_CUSTOM_SHADING_RATE_PRESET_DESC_VER1   MAKE_NVAPI_VERSION(NV_FOVEATED_RENDERING_CUSTOM_SHADING_RATE_PRESET_DESC_V1, 1)
#define NV_FOVEATED_RENDERING_CUSTOM_SHADING_RATE_PRESET_DESC_VER    NV_FOVEATED_RENDERING_CUSTOM_SHADING_RATE_PRESET_DESC_VER1
 
typedef enum _NV_FOVEATED_RENDERING_FOVEATION_PATTERN_PRESET
{
    NV_FOVEATED_RENDERING_FOVEATION_PATTERN_PRESET_INVALID = 0,
    NV_FOVEATED_RENDERING_FOVEATION_PATTERN_PRESET_WIDE = 1,
    NV_FOVEATED_RENDERING_FOVEATION_PATTERN_PRESET_BALANCED = 2,
    NV_FOVEATED_RENDERING_FOVEATION_PATTERN_PRESET_NARROW = 3,
    NV_FOVEATED_RENDERING_FOVEATION_PATTERN_PRESET_CUSTOM = 4,
    NV_FOVEATED_RENDERING_FOVEATION_PATTERN_PRESET_MAX = NV_FOVEATED_RENDERING_FOVEATION_PATTERN_PRESET_CUSTOM
} NV_FOVEATED_RENDERING_FOVEATION_PATTERN_PRESET;
 
typedef struct _NV_FOVEATED_RENDERING_CUSTOM_FOVEATION_PATTERN_PRESET_DESC_V1
{
    NvU32 version;
 
    float fInnermostRadii[2];       
    float fMiddleRadii[2];          
    float fPeripheralRadii[2];      
} NV_FOVEATED_RENDERING_CUSTOM_FOVEATION_PATTERN_PRESET_DESC_V1;
 
typedef NV_FOVEATED_RENDERING_CUSTOM_FOVEATION_PATTERN_PRESET_DESC_V1     NV_FOVEATED_RENDERING_CUSTOM_FOVEATION_PATTERN_PRESET_DESC;
#define NV_FOVEATED_RENDERING_CUSTOM_FOVEATION_PATTERN_PRESET_DESC_VER1   MAKE_NVAPI_VERSION(NV_FOVEATED_RENDERING_CUSTOM_FOVEATION_PATTERN_PRESET_DESC_V1, 1)
#define NV_FOVEATED_RENDERING_CUSTOM_FOVEATION_PATTERN_PRESET_DESC_VER    NV_FOVEATED_RENDERING_CUSTOM_FOVEATION_PATTERN_PRESET_DESC_VER1
 
typedef struct _NV_FOVEATED_RENDERING_DESC_V1
{
    NvU32                                           version;  
    NvU32                                           flags;    
 
    NV_FOVEATED_RENDERING_SHADING_RATE_PRESET                       ShadingRatePreset;                  
    NV_FOVEATED_RENDERING_CUSTOM_SHADING_RATE_PRESET_DESC_V1        ShadingRateCustomPresetDesc;        
 
    NV_FOVEATED_RENDERING_FOVEATION_PATTERN_PRESET                  FoveationPatternPreset;             
    NV_FOVEATED_RENDERING_CUSTOM_FOVEATION_PATTERN_PRESET_DESC_V1   FoveationPatternCustomPresetDesc;   
 
    NvU32 GazeDataDeviceId;     
                                //        Should be 0 if gaze data is provided only from a single device. Should be less than (MAX_NUMBER_OF_GAZE_DATA_PROVIDERS - 1)
 
} NV_FOVEATED_RENDERING_DESC_V1;
 
typedef NV_FOVEATED_RENDERING_DESC_V1     NV_FOVEATED_RENDERING_DESC;
#define NV_FOVEATED_RENDERING_DESC_VER1   MAKE_NVAPI_VERSION(NV_FOVEATED_RENDERING_DESC_V1, 1)
#define NV_FOVEATED_RENDERING_DESC_VER    NV_FOVEATED_RENDERING_DESC_VER1
 
typedef enum _NV_VRS_RENDER_MODE
{
    NV_VRS_RENDER_MODE_INVALID = 0,
    NV_VRS_RENDER_MODE_MONO = 1,            // States mono rendering on the entire render target
    NV_VRS_RENDER_MODE_LEFT_EYE = 2,        // States Left eye rendering of a stereo pair on the entire render target
    NV_VRS_RENDER_MODE_RIGHT_EYE = 3,       // States Right eye rendering of a stereo pair on the entire render target
    NV_VRS_RENDER_MODE_STEREO = 4,          // States side-by-side stereo rendering on the render target
    NV_VRS_RENDER_MODE_MAX = NV_VRS_RENDER_MODE_STEREO
} NV_VRS_RENDER_MODE;
 
#define MAX_NUMBER_OF_GAZE_DATA_PROVIDERS   8   // Maximum number of gaze data providers / devices.
 
typedef struct _NV_VRS_HELPER_ENABLE_PARAMS_V1
{
    NvU32                   version;        
    NvU32                   flags;          
 
    NV_VRS_RENDER_MODE      RenderMode;     
    NV_VRS_CONTENT_TYPE     ContentType;    
 
    NV_FOVEATED_RENDERING_DESC_V1   sFoveatedRenderingDesc;     
} NV_VRS_HELPER_ENABLE_PARAMS_V1;
 
typedef NV_VRS_HELPER_ENABLE_PARAMS_V1     NV_VRS_HELPER_ENABLE_PARAMS;
#define NV_VRS_HELPER_ENABLE_PARAMS_VER1   MAKE_NVAPI_VERSION(NV_VRS_HELPER_ENABLE_PARAMS_V1, 1)
#define NV_VRS_HELPER_ENABLE_PARAMS_VER    NV_VRS_HELPER_ENABLE_PARAMS_VER1
 
typedef struct _NV_VRS_HELPER_DISABLE_PARAMS_V1
{
    NvU32           version;    
    NvU32           reserved;   
} NV_VRS_HELPER_DISABLE_PARAMS_V1;
 
typedef NV_VRS_HELPER_DISABLE_PARAMS_V1     NV_VRS_HELPER_DISABLE_PARAMS;
#define NV_VRS_HELPER_DISABLE_PARAMS_VER1   MAKE_NVAPI_VERSION(NV_VRS_HELPER_DISABLE_PARAMS_V1, 1)
#define NV_VRS_HELPER_DISABLE_PARAMS_VER    NV_VRS_HELPER_DISABLE_PARAMS_VER1
 
typedef struct _NV_VRS_HELPER_GET_SHADING_RATE_RESOURCE_PARAMS_V1
{
    NvU32                   version;                                        
    IUnknown              **ppShadingRateResource;                          
    NV_PIXEL_SHADING_RATE   shadingRateTable[NV_MAX_PIXEL_SHADING_RATES];   
} NV_VRS_HELPER_GET_SHADING_RATE_RESOURCE_PARAMS_V1;
 
typedef NV_VRS_HELPER_GET_SHADING_RATE_RESOURCE_PARAMS_V1     NV_VRS_HELPER_GET_SHADING_RATE_RESOURCE_PARAMS;
#define NV_VRS_HELPER_GET_SHADING_RATE_RESOURCE_PARAMS_VER1   MAKE_NVAPI_VERSION(NV_VRS_HELPER_GET_SHADING_RATE_RESOURCE_PARAMS_V1, 1)
#define NV_VRS_HELPER_GET_SHADING_RATE_RESOURCE_PARAMS_VER    NV_VRS_HELPER_GET_SHADING_RATE_RESOURCE_PARAMS_VER1
 
typedef struct _NV_VRS_HELPER_PURGE_INTERNAL_RESOURCES_PARAMS_V1
{
    NvU32           version;    
    NvU32           reserved;   
} NV_VRS_HELPER_PURGE_INTERNAL_RESOURCES_PARAMS_V1;
 
typedef NV_VRS_HELPER_PURGE_INTERNAL_RESOURCES_PARAMS_V1     NV_VRS_HELPER_PURGE_INTERNAL_RESOURCES_PARAMS;
#define NV_VRS_HELPER_PURGE_INTERNAL_RESOURCES_PARAMS_VER1   MAKE_NVAPI_VERSION(NV_VRS_HELPER_PURGE_INTERNAL_RESOURCES_PARAMS_V1, 1)
#define NV_VRS_HELPER_PURGE_INTERNAL_RESOURCES_PARAMS_VER    NV_VRS_HELPER_PURGE_INTERNAL_RESOURCES_PARAMS_VER1
 
DECLARE_INTERFACE(ID3DNvVRSHelper_V1)
{
    BEGIN_INTERFACE
 
    STDMETHOD_(ULONG,AddRef)(THIS) PURE;
    STDMETHOD_(ULONG,Release)(THIS) PURE;
 
    // Latches the latest gaze which will be used for subsequent foveated rendering. Recommended to be called once per frame before scene drawing begins.
    STDMETHOD_(NvAPI_Status,LatchGaze)(THIS_ IUnknown* pContext, NV_VRS_HELPER_LATCH_GAZE_PARAMS* pLatchGazeParams) PURE;
 
    // Enables VRS with sepcified content type and preset. This can be called per draw call.
    STDMETHOD_(NvAPI_Status,Enable)(THIS_ IUnknown* pContext, NV_VRS_HELPER_ENABLE_PARAMS* pEnableParams) PURE;
 
    // Disables VRS till re-enabled.
    STDMETHOD_(NvAPI_Status,Disable)(THIS_ IUnknown* pContext, NV_VRS_HELPER_DISABLE_PARAMS* pDisableParams) PURE;
 
    // Creates a 2D texture, copies the current shading rate pattern on it and returns the pointer to this texture.
    // It also returns an array that conveys which value in the shading rate resource corresponds to which exact pixel shading rate.
    STDMETHOD_(NvAPI_Status,GetShadingRateResource)(THIS_ IUnknown* pContext, NV_VRS_HELPER_GET_SHADING_RATE_RESOURCE_PARAMS *pGetShadingRateResourceParams) PURE;
 
    // Destroys all internally created shading rate resources and views.
    STDMETHOD_(NvAPI_Status,PurgeInternalShadingRateResources)(THIS_ IUnknown* pContext, NV_VRS_HELPER_PURGE_INTERNAL_RESOURCES_PARAMS* pPurgeParams) PURE;
 
    END_INTERFACE
};
 
typedef ID3DNvVRSHelper_V1    ID3DNvVRSHelper;
#define ID3DNvVRSHelper_VER1  MAKE_NVAPI_VERSION(ID3DNvVRSHelper_V1, 1)
#define ID3DNvVRSHelper_VER   ID3DNvVRSHelper_VER1
 
typedef struct _NV_VRS_HELPER_INIT_PARAMS_V1
{
    NvU32           version;    
    NvU32           flags;      
 
    ID3DNvVRSHelper_V1    **ppVRSHelper;  
} NV_VRS_HELPER_INIT_PARAMS_V1;
 
typedef NV_VRS_HELPER_INIT_PARAMS_V1     NV_VRS_HELPER_INIT_PARAMS;
#define NV_VRS_HELPER_INIT_PARAMS_VER1   MAKE_NVAPI_VERSION(NV_VRS_HELPER_INIT_PARAMS_V1, 1)
#define NV_VRS_HELPER_INIT_PARAMS_VER    NV_VRS_HELPER_INIT_PARAMS_VER1
 
//
// FUNCTION NAME: NvAPI_D3D_InitializeVRSHelper
//
 
NVAPI_INTERFACE NvAPI_D3D_InitializeVRSHelper(__in    IUnknown *pDevice,
                                              __inout NV_VRS_HELPER_INIT_PARAMS *pInitializeVRSHelperParams);
 
typedef enum _NV_GAZE_DATA_VALIDITY_FLAGS
{
    NV_GAZE_ORIGIN_VALID            = 0x1,
    NV_GAZE_DIRECTION_VALID         = 0x2,
    NV_GAZE_LOCATION_VALID          = 0x4,
    NV_GAZE_VELOCITY_VALID          = 0x8,
    NV_GAZE_PUPIL_DIAMETER_VALID    = 0x10,
    NV_GAZE_EYE_OPENNESS_VALID      = 0x20,
    NV_GAZE_EYE_SACCADE_DATA_VALID  = 0x40
} NV_GAZE_DATA_VALIDITY_FLAGS;
 
typedef struct _NV_FOVEATED_RENDERING_GAZE_DATA_PER_EYE
{
    NvU32 version;                          
 
    NvU32 GazeDataValidityFlags;            
 
    float fGazeOrigin_mm[3];                
    float fGazeDirection[3];                
    float fGazeNormalizedLocation[2];       
    float fGazeVelocity[2];                 
    float fPupilDiameter_mm;                
    float fEyeOpenness;                     
    BOOL  bInSaccade;                       
} NV_FOVEATED_RENDERING_GAZE_DATA_PER_EYE_V1;
 
typedef NV_FOVEATED_RENDERING_GAZE_DATA_PER_EYE_V1     NV_FOVEATED_RENDERING_GAZE_DATA_PER_EYE;
#define NV_FOVEATED_RENDERING_GAZE_DATA_PER_EYE_VER1   MAKE_NVAPI_VERSION(NV_FOVEATED_RENDERING_GAZE_DATA_PER_EYE_V1, 1)
#define NV_FOVEATED_RENDERING_GAZE_DATA_PER_EYE_VER    NV_FOVEATED_RENDERING_GAZE_DATA_PER_EYE_VER1
 
typedef struct _NV_FOVEATED_RENDERING_UPDATE_GAZE_DATA_PARAMS
{
    NvU32 version;              
    NvU32 flags;                
 
    NvU64 Timestamp;            
    union
    {
        NV_FOVEATED_RENDERING_GAZE_DATA_PER_EYE_V1 sMonoData;           
        struct
        {
            NV_FOVEATED_RENDERING_GAZE_DATA_PER_EYE_V1 sLeftEye;        
            NV_FOVEATED_RENDERING_GAZE_DATA_PER_EYE_V1 sRightEye;       
        } sStereoData;
    };
} NV_FOVEATED_RENDERING_UPDATE_GAZE_DATA_PARAMS_V1;
 
typedef NV_FOVEATED_RENDERING_UPDATE_GAZE_DATA_PARAMS_V1     NV_FOVEATED_RENDERING_UPDATE_GAZE_DATA_PARAMS;
#define NV_FOVEATED_RENDERING_UPDATE_GAZE_DATA_PARAMS_VER1   MAKE_NVAPI_VERSION(NV_FOVEATED_RENDERING_UPDATE_GAZE_DATA_PARAMS_V1, 1)
#define NV_FOVEATED_RENDERING_UPDATE_GAZE_DATA_PARAMS_VER    NV_FOVEATED_RENDERING_UPDATE_GAZE_DATA_PARAMS_VER1
 
 
DECLARE_INTERFACE(ID3DNvGazeHandler_V2)
{
    BEGIN_INTERFACE
 
    STDMETHOD_(ULONG,AddRef)(THIS) PURE;
    STDMETHOD_(ULONG,Release)(THIS) PURE;
 
    // Updates the gaze data for foveated rendering
    STDMETHOD_(NvAPI_Status,UpdateGazeData)(THIS_ IUnknown* pContext, NV_FOVEATED_RENDERING_UPDATE_GAZE_DATA_PARAMS* pUpdateGazeDataParams) PURE;
 
 
    END_INTERFACE
};
typedef ID3DNvGazeHandler_V2    ID3DNvGazeHandler;
#define ID3DNvGazeHandler_VER2  MAKE_NVAPI_VERSION(ID3DNvGazeHandler_V2, 2)
#define ID3DNvGazeHandler_VER   ID3DNvGazeHandler_VER2
 
DECLARE_INTERFACE(ID3DNvGazeHandler_V1)
{
    BEGIN_INTERFACE
 
    STDMETHOD_(ULONG,AddRef)(THIS) PURE;
    STDMETHOD_(ULONG,Release)(THIS) PURE;
 
    // Updates the gaze data for foveated rendering
    STDMETHOD_(NvAPI_Status,UpdateGazeData)(THIS_ IUnknown* pContext, NV_FOVEATED_RENDERING_UPDATE_GAZE_DATA_PARAMS* pUpdateGazeDataParams) PURE;
 
    END_INTERFACE
};
#define ID3DNvGazeHandler_VER1  MAKE_NVAPI_VERSION(ID3DNvGazeHandler_V1, 1)
#ifndef ID3DNvGazeHandler_VER
typedef ID3DNvGazeHandler_V1    ID3DNvGazeHandler;
#define ID3DNvGazeHandler_VER   ID3DNvGazeHandler_VER1
#endif
 
typedef enum _NV_GAZE_DATA_TYPE
{
    NV_GAZE_DATA_INVALID = 0,
    NV_GAZE_DATA_MONO = 1,
    NV_GAZE_DATA_STEREO = 2,
    NV_GAZE_DATA_MAX = NV_GAZE_DATA_STEREO
} NV_GAZE_DATA_TYPE;
 
typedef struct _NV_GAZE_HANDLER_INIT_PARAMS_V2
{
    NvU32               version;            
    
    NvU32               GazeDataDeviceId;   
                                            //        Should be 0 if gaze data is provided only from a single device. Should be less than (MAX_NUMBER_OF_GAZE_DATA_PROVIDERS - 1)
 
    NV_GAZE_DATA_TYPE   GazeDataType;       
    NvU32               flags;              
    float               fHorizontalFOV;     
    float               fVericalFOV;        
 
    ID3DNvGazeHandler_V2    **ppNvGazeHandler;    
} NV_GAZE_HANDLER_INIT_PARAMS_V2;
 
typedef NV_GAZE_HANDLER_INIT_PARAMS_V2     NV_GAZE_HANDLER_INIT_PARAMS;
#define NV_GAZE_HANDLER_INIT_PARAMS_VER2   MAKE_NVAPI_VERSION(NV_GAZE_HANDLER_INIT_PARAMS_V2, 2)
#define NV_GAZE_HANDLER_INIT_PARAMS_VER    NV_GAZE_HANDLER_INIT_PARAMS_VER2
 
typedef struct _NV_GAZE_HANDLER_INIT_PARAMS_V1
{
    NvU32               version;            
    
    NvU32               GazeDataDeviceId;   
                                            //        Should be 0 if gaze data is provided only from a single device. Should be less than (MAX_NUMBER_OF_GAZE_DATA_PROVIDERS - 1)
 
    NV_GAZE_DATA_TYPE   GazeDataType;       
    NvU32               flags;              
    float               fHorizontalFOV;     
    float               fVericalFOV;        
 
    ID3DNvGazeHandler_V1    **ppNvGazeHandler;    
} NV_GAZE_HANDLER_INIT_PARAMS_V1;
 
#define NV_GAZE_HANDLER_INIT_PARAMS_VER1   MAKE_NVAPI_VERSION(NV_GAZE_HANDLER_INIT_PARAMS_V1, 1)
#ifndef NV_GAZE_HANDLER_INIT_PARAMS_VER
typedef NV_GAZE_HANDLER_INIT_PARAMS_V1     NV_GAZE_HANDLER_INIT_PARAMS;
#define NV_GAZE_HANDLER_INIT_PARAMS_VER    NV_GAZE_HANDLER_INIT_PARAMS_VER1
#endif
 
#endif // defined(__cplusplus) && (defined(__d3d11_h__))
 
 
#if defined(__cplusplus) && (defined(__d3d11_h__))
//
// FUNCTION NAME: NvAPI_D3D_InitializeNvGazeHandler
//
 
NVAPI_INTERFACE NvAPI_D3D_InitializeNvGazeHandler(__in    IUnknown *pDevice,
                                                  __inout NV_GAZE_HANDLER_INIT_PARAMS *pInitializeNvGazeHandlerParams);
 
#endif // defined(__cplusplus) && (defined(__d3d11_h__))
 
#if defined (__cplusplus) && defined(__d3d11_h__) 
 
 
typedef enum NV_SMP_ASSIST_TYPE
{
    NV_SMP_ASSIST_NONE = 0,
    NV_SMP_ASSIST_MRS  = 1,       // SMP Assist required for Multi-Res Shading
    NV_SMP_ASSIST_LMS  = 2,       // SMP Assist required for Lens Matched Shading
    NV_SMP_ASSIST_NUM_TYPES
} NV_SMP_ASSIST_TYPE;
 
typedef enum NV_SMP_ASSIST_LEVEL
{
    NV_SMP_ASSIST_LEVEL_FULL    = 0,      // Full assistance. App selects a pre-baked MRS/LMS config, driver handles correct setting of viewport, scissors and FastGS
    NV_SMP_ASSIST_LEVEL_PARTIAL = 1,      // Partial assistance. App provides a custom MRS/LMS config, driver handles correct setting of viewport, scissors and FastGS
    NV_SMP_ASSIST_LEVEL_MINIMAL = 2,      // Minimal assistance. App provides viewports and scissors. App sets FastGS as required. App sets LMS params as required (NvAPI_D3D_SetModifiedWMode). App provides SMPType as NONE. Driver handles correct setting of viewports and scissors.
    NV_SMP_ASSIST_NUM_LEVELS
} NV_SMP_ASSIST_LEVEL;
 
typedef enum NV_MRS_CONFIG
{
    NV_MRS_CONFIG_BALANCED                     = 0,
    NV_MRS_CONFIG_AGGRESSIVE                   = 1,
    NV_MRS_CONFIG_OCULUSRIFT_CV1_CONSERVATIVE  = 2,
    NV_MRS_CONFIG_OCULUSRIFT_CV1_BALANCED      = 3,
    NV_MRS_CONFIG_OCULUSRIFT_CV1_AGGRESSIVE    = 4,
    NV_MRS_CONFIG_HTC_VIVE_CONSERVATIVE        = 5,
    NV_MRS_CONFIG_HTC_VIVE_BALANCED            = 6,
    NV_MRS_CONFIG_HTC_VIVE_AGGRESSIVE          = 7,
    NV_MRS_NUM_CONFIGS
} NV_MRS_CONFIG;
 
typedef enum NV_LMS_CONFIG
{
    NV_LMS_CONFIG_OCULUSRIFT_CV1_CONSERVATIVE = 0,
    NV_LMS_CONFIG_OCULUSRIFT_CV1_BALANCED     = 1,
    NV_LMS_CONFIG_OCULUSRIFT_CV1_AGGRESSIVE   = 2,
    NV_LMS_CONFIG_HTC_VIVE_CONSERVATIVE       = 3,
    NV_LMS_CONFIG_HTC_VIVE_BALANCED           = 4,
    NV_LMS_CONFIG_HTC_VIVE_AGGRESSIVE         = 5,
    NV_LMS_NUM_CONFIGS
} NV_LMS_CONFIG;
 
#define NV_SMP_ASSIST_FLAGS_DEFAULT    0x00000000
 
#define NV_SMP_ASSIST_MAX_VIEWPORTS    16
 
typedef struct _NV_MRS_CUSTOM_CONFIG_V1
{
    float           centerWidth;        
    float           centerHeight;
    float           centerX;            
    float           centerY;
    float           densityScaleX[3];   
    float           densityScaleY[3];
} NV_MRS_CUSTOM_CONFIG_V1;
 
typedef NV_MRS_CUSTOM_CONFIG_V1 NV_MRS_CUSTOM_CONFIG;
 
typedef struct _NV_MRS_INSTANCED_STEREO_CONFIG_V1
{                                          
    float           centerWidth[2];        
    float           centerHeight;
    float           centerX[2];            
    float           centerY;
    float           densityScaleX[5];      
    float           densityScaleY[3];
} NV_MRS_INSTANCED_STEREO_CONFIG_V1;
 
typedef NV_MRS_INSTANCED_STEREO_CONFIG_V1 NV_MRS_INSTANCED_STEREO_CONFIG;
 
typedef struct _NV_LMS_CUSTOM_CONFIG_V1
{
    float           warpLeft;           
    float           warpRight;          
    float           warpUp;             
    float           warpDown;           
 
    float           relativeSizeLeft;   
    float           relativeSizeRight;  
    float           relativeSizeUp;     
    float           relativeSizeDown;   
} NV_LMS_CUSTOM_CONFIG_V1;
 
typedef NV_LMS_CUSTOM_CONFIG_V1 NV_LMS_CUSTOM_CONFIG;
 
typedef struct _NV_LMS_INSTANCED_STEREO_CONFIG_V1
{                                             
    NV_LMS_CUSTOM_CONFIG_V1 sLeftConfig;      
    NV_LMS_CUSTOM_CONFIG_V1 sRightConfig;     
} NV_LMS_INSTANCED_STEREO_CONFIG_V1;
 
typedef NV_LMS_INSTANCED_STEREO_CONFIG_V1 NV_LMS_INSTANCED_STEREO_CONFIG;
 
typedef enum _NV_SMP_ASSIST_EYE_INDEX
{
    NV_SMP_ASSIST_EYE_INDEX_MONO                  = 0,            // Non-stereo rendering
    NV_SMP_ASSIST_EYE_INDEX_LEFT_EYE              = 1,            // Stereo - Rendering left eye
    NV_SMP_ASSIST_EYE_INDEX_RIGHT_EYE             = 2,            // Stereo - Rendering right eye
    NV_SMP_ASSIST_EYE_INDEX_INSTANCED_STEREO      = 3,            // Stereo - Rendering both eyes
} NV_SMP_ASSIST_EYE_INDEX;
 
#define NV_SMP_ASSIST_MINIMAL_LEVEL_NUM_EYE_INDICES 4 
 
typedef struct _NV_CUSTOM_RECTS_V1
{
    NvU32                     numViewports[NV_SMP_ASSIST_MINIMAL_LEVEL_NUM_EYE_INDICES];
    D3D11_VIEWPORT           *pViewports[NV_SMP_ASSIST_MINIMAL_LEVEL_NUM_EYE_INDICES];        
    D3D11_RECT               *pScissors[NV_SMP_ASSIST_MINIMAL_LEVEL_NUM_EYE_INDICES];         
} NV_CUSTOM_RECTS_V1;
 
typedef NV_CUSTOM_RECTS_V1 NV_CUSTOM_RECTS;
 
typedef struct _NV_SMP_ASSIST_ENABLE_PARAMS_V1
{
    NvU32                    version;          
    NV_SMP_ASSIST_EYE_INDEX  eEyeIndex;        
} NV_SMP_ASSIST_ENABLE_PARAMS_V1;
 
typedef NV_SMP_ASSIST_ENABLE_PARAMS_V1          NV_SMP_ASSIST_ENABLE_PARAMS;
#define NV_SMP_ASSIST_ENABLE_PARAMS_VER1        MAKE_NVAPI_VERSION(NV_SMP_ASSIST_ENABLE_PARAMS_V1, 1)
#define NV_SMP_ASSIST_ENABLE_PARAMS_VER         NV_SMP_ASSIST_ENABLE_PARAMS_VER1
 
typedef struct _NV_SMP_ASSIST_DISABLE_PARAMS_V1
{
    NvU32                version;               
    NvU32                Reserved;              
} NV_SMP_ASSIST_DISABLE_PARAMS_V1;
 
typedef NV_SMP_ASSIST_DISABLE_PARAMS_V1          NV_SMP_ASSIST_DISABLE_PARAMS;
#define NV_SMP_ASSIST_DISABLE_PARAMS_VER1        MAKE_NVAPI_VERSION(NV_SMP_ASSIST_DISABLE_PARAMS_V1, 1)
#define NV_SMP_ASSIST_DISABLE_PARAMS_VER         NV_SMP_ASSIST_DISABLE_PARAMS_VER1
 
// FastGS constant buffer data returned by the GetConstants API.
// Refer VRWorks SDK's multiprojection_dx app (struct FastGSCBData)
typedef struct _NV_SMP_ASSIST_FASTGSCBDATA_V1
{
    float NDCSplitsX[2];                        
    float NDCSplitsY[2];
} NV_SMP_ASSIST_FASTGSCBDATA_V1;
 
typedef NV_SMP_ASSIST_FASTGSCBDATA_V1 NV_SMP_ASSIST_FASTGSCBDATA;
 
typedef struct _NV_SMP_ASSIST_FASTGSCBDATA_MRS_INSTANCED_STEREO_V1
{
    float NDCSplitsX[4];                        
    float NDCSplitsY[2];
} NV_SMP_ASSIST_FASTGSCBDATA_MRS_INSTANCED_STEREO_V1;
 
typedef NV_SMP_ASSIST_FASTGSCBDATA_MRS_INSTANCED_STEREO_V1 NV_SMP_ASSIST_FASTGSCBDATA_MRS_INSTANCED_STEREO;
 
// Constant buffer data to supply the UV-remapping helper functions
// Refer VRWorks SDK's multiprojection_dx app (struct RemapCBData)
typedef struct _NV_SMP_ASSIST_REMAPCBDATA_V1
{
    float        ClipToWindowSplitsX[2];
    float        ClipToWindowSplitsY[2];
    float        ClipToWindowX[3][2];            // ClipToWindowX[i][0] is Scale and ClipToWindowX[i][1] is Bias
    float        ClipToWindowY[3][2];            // ClipToWindowY[i][0] is Scale and ClipToWindowY[i][1] is Bias
    float        ClipToWindowZ[2];               // ClipToWindowZ[0] is Scale and ClipToWindowZ[1] is Bias
 
    float        WindowToClipSplitsX[2];
    float        WindowToClipSplitsY[2];
    float        WindowToClipX[3][2];            // WindowToClipX[i][0] is Scale and WindowToClipX[i][1] is Bias
    float        WindowToClipY[3][2];            // WindowToClipY[i][0] is Scale and WindowToClipY[i][1] is Bias
    float        WindowToClipZ[2];               // WindowToClipZ[0] is Scale and WindowToClipZ[1] is Bias
 
    float       BoundingRectOriginX;
    float       BoundingRectOriginY;
    float       BoundingRectSizeWidth;
    float       BoundingRectSizeHeight;
    float       BoundingRectSizeInvWidth;
    float       BoundingRectSizeInvHeight;
 
    float        Padding[2];
}NV_SMP_ASSIST_REMAPCBDATA_V1;
 
typedef NV_SMP_ASSIST_REMAPCBDATA_V1 NV_SMP_ASSIST_REMAPCBDATA;
 
 
typedef struct _NV_SMP_ASSIST_GET_CONSTANTS_V3
{
    NvU32                    version;                                        
    NV_SMP_ASSIST_EYE_INDEX  eEyeIndex;                                      
    NvU32                    numViewports;                                   
    D3D11_VIEWPORT           *pViewports;                                    
    D3D11_RECT               *pScissors;                                     
                                                                             
    NV_SMP_ASSIST_TYPE       eSMPAssistType;                                 
    NV_SMP_ASSIST_LEVEL      eSMPAssistLevel;                                
                                                                             
    union                                                                    
    {                                                                        
        NV_MRS_CUSTOM_CONFIG_V1 sMRSConfig;                                  
        NV_LMS_CUSTOM_CONFIG_V1 sLMSConfig;                                  
    };                                                                       
                                                                             
    float projectionSizeWidth;                                               
    float projectionSizeHeight;                                              
                                                                             
    NV_SMP_ASSIST_FASTGSCBDATA_V1 *pFastGSCBData;                            
    NV_SMP_ASSIST_REMAPCBDATA_V1  *pRemapCBData;                             
                                                                             
    D3D11_VIEWPORT          boundingViewport;                                
    D3D11_RECT              boundingScissor;                                 
 
    union
    {                                                                             
        NV_MRS_INSTANCED_STEREO_CONFIG_V1 sMRS_ISConfig;                     
        NV_LMS_INSTANCED_STEREO_CONFIG_V1 sLMS_ISConfig;                     
    };
 
    NV_SMP_ASSIST_FASTGSCBDATA_MRS_INSTANCED_STEREO_V1 *pFastGSCBDataMRS_IS; 
} NV_SMP_ASSIST_GET_CONSTANTS_V3;
 
#define NV_SMP_ASSIST_GET_CONSTANTS_VER3        MAKE_NVAPI_VERSION(NV_SMP_ASSIST_GET_CONSTANTS_V3, 3)
typedef NV_SMP_ASSIST_GET_CONSTANTS_V3          NV_SMP_ASSIST_GET_CONSTANTS;
#define NV_SMP_ASSIST_GET_CONSTANTS_VER         NV_SMP_ASSIST_GET_CONSTANTS_VER3
 
 
typedef struct _NV_SMP_ASSIST_SETUP_PARAMS_V1
{
    NvU32                       version;             
    union
    {
        NV_MRS_CONFIG           eMRSConfig;          
        NV_LMS_CONFIG           eLMSConfig;          
        NV_MRS_CUSTOM_CONFIG_V1 sMRSCustomConfig;    
        NV_LMS_CUSTOM_CONFIG_V1 sLMSCustomConfig;    
        NV_CUSTOM_RECTS_V1      sCustomRects;        
    };
 
    float           resolutionScale;                 
    D3D11_VIEWPORT  boundingBox;                     
    float           vpOffsets[2];                    
} NV_SMP_ASSIST_SETUP_PARAMS_V1;
 
typedef NV_SMP_ASSIST_SETUP_PARAMS_V1          NV_SMP_ASSIST_SETUP_PARAMS;
#define NV_SMP_ASSIST_SETUP_PARAMS_VER1        MAKE_NVAPI_VERSION(NV_SMP_ASSIST_SETUP_PARAMS_V1, 1)
#define NV_SMP_ASSIST_SETUP_PARAMS_VER         NV_SMP_ASSIST_SETUP_PARAMS_VER1
 
typedef struct _NV_SMP_ASSIST_UPDATE_INSTANCEDSTEREO_DATA_PARAMS_V1
{
    NvU32                version;               
    NV_SMP_ASSIST_TYPE   eSMPAssistType;        // Patch instanced stereo shaders (created with packed eye index) with this SMPAssistType (NV_SMP_ASSIST_LMS only)
    float                leftCoeffs[4];         // Left eye: outpos.x = dotproduct(outputpos, leftCoeffs) + leftConst
    float                leftConst;
    float                rightCoeffs[4];        // Right eye: outpos.x = dotproduct(outputpos, rightCoeffs) + rightConst
    float                rightConst;
} NV_SMP_ASSIST_UPDATE_INSTANCEDSTEREO_DATA_PARAMS_V1;
 
typedef NV_SMP_ASSIST_UPDATE_INSTANCEDSTEREO_DATA_PARAMS_V1          NV_SMP_ASSIST_UPDATE_INSTANCEDSTEREO_DATA_PARAMS;
#define NV_SMP_ASSIST_UPDATE_INSTANCEDSTEREO_DATA_PARAMS_VER1        MAKE_NVAPI_VERSION(NV_SMP_ASSIST_UPDATE_INSTANCEDSTEREO_DATA_PARAMS_V1, 1)
#define NV_SMP_ASSIST_UPDATE_INSTANCEDSTEREO_DATA_PARAMS_VER         NV_SMP_ASSIST_UPDATE_INSTANCEDSTEREO_DATA_PARAMS_VER1
 
 
DECLARE_INTERFACE(ID3DNvSMPAssist_V1)
{
    // Disable SMP Assist for further Draw calls
    STDMETHOD_(NvAPI_Status,Disable)(THIS_ __in IUnknown *pDevContext, __in const NV_SMP_ASSIST_DISABLE_PARAMS *psSMPAssistDisableParams) PURE;
 
    // Enable SMP Assist for further Draw calls. App has to provide the type of rendering done in upcoming Draw calls - Mono/Left eye/Right eye/Instanced Stereo
    STDMETHOD_(NvAPI_Status,Enable)(THIS_ __in IUnknown *pDevContext, __in const NV_SMP_ASSIST_ENABLE_PARAMS *psSMPAssistEnableParams) PURE; 
 
    // Get the constants used by the drivers
    STDMETHOD_(NvAPI_Status,GetConstants)(THIS_ __inout NV_SMP_ASSIST_GET_CONSTANTS *psSMPAssistGetConstants) PURE; 
 
    // Setup the projections (rects, constant buffer data etc.)
    STDMETHOD_(NvAPI_Status,SetupProjections)(THIS_ __in IUnknown *pDevice, __in const NV_SMP_ASSIST_SETUP_PARAMS *psSMPAssistSetupParams) PURE;
 
    // Update instanced stereo specific data
    STDMETHOD_(NvAPI_Status,UpdateInstancedStereoData)(THIS_ __in IUnknown *pDevice, __in const NV_SMP_ASSIST_UPDATE_INSTANCEDSTEREO_DATA_PARAMS *psSMPAssistInstancedStereoParams) PURE;
};
 
typedef ID3DNvSMPAssist_V1     ID3DNvSMPAssist;
#define ID3DNVSMPASSIST_VER1   MAKE_NVAPI_VERSION(ID3DNvSMPAssist_V1, 1)
#define ID3DNVSMPASSIST_VER    ID3DNVSMPASSIST_VER1
 
 
typedef struct _NV_SMP_ASSIST_INITIALIZE_PARAMS_V1
{
    NvU32                   version;                 
    NV_SMP_ASSIST_TYPE      eSMPAssistType;          
    NV_SMP_ASSIST_LEVEL     eSMPAssistLevel;         
    NvU32                   flags;                   
 
    ID3DNvSMPAssist     **ppD3DNvSMPAssist;          
 
} NV_SMP_ASSIST_INITIALIZE_PARAMS_V1;
 
#define NV_SMP_ASSIST_INITIALIZE_PARAMS_VER1        MAKE_NVAPI_VERSION(NV_SMP_ASSIST_INITIALIZE_PARAMS_V1, 1)
#ifndef NV_SMP_ASSIST_INITIALIZE_PARAMS_VER
typedef NV_SMP_ASSIST_INITIALIZE_PARAMS_V1          NV_SMP_ASSIST_INITIALIZE_PARAMS;
#define NV_SMP_ASSIST_INITIALIZE_PARAMS_VER         NV_SMP_ASSIST_INITIALIZE_PARAMS_VER1
#endif
 
//
// FUNCTION NAME: NvAPI_D3D_InitializeSMPAssist
//
NVAPI_INTERFACE NvAPI_D3D_InitializeSMPAssist(__in IUnknown *pDevice, __inout NV_SMP_ASSIST_INITIALIZE_PARAMS *pSMPAssistInitParams);
 
#endif //defined(__cplusplus) && defined(__d3d11_h__)
 
#if defined (__cplusplus) && defined(__d3d11_h__) 
typedef struct _NV_QUERY_SMP_ASSIST_SUPPORT_PARAMS_V1
{
    NvU32               version;                       
    NV_SMP_ASSIST_TYPE  eSMPAssistType;                
    NV_SMP_ASSIST_LEVEL eSMPAssistLevel;               
    NvBool              bSMPAssistSupported;           
} NV_QUERY_SMP_ASSIST_SUPPORT_PARAMS_V1;
 
typedef NV_QUERY_SMP_ASSIST_SUPPORT_PARAMS_V1          NV_QUERY_SMP_ASSIST_SUPPORT_PARAMS;
#define NV_QUERY_SMP_ASSIST_SUPPORT_PARAMS_VER1        MAKE_NVAPI_VERSION(NV_QUERY_SMP_ASSIST_SUPPORT_PARAMS_V1, 1)
#define NV_QUERY_SMP_ASSIST_SUPPORT_PARAMS_VER         NV_QUERY_SMP_ASSIST_SUPPORT_PARAMS_VER1
 
//
// FUNCTION NAME: NvAPI_D3D_QuerySMPAssistSupport
//
NVAPI_INTERFACE NvAPI_D3D_QuerySMPAssistSupport(__in IUnknown *pDev, __inout NV_QUERY_SMP_ASSIST_SUPPORT_PARAMS *pQuerySMPAssistSupportParams);
 
#endif //defined(__cplusplus) && defined(__d3d11_h__)
 
 
 
typedef struct _NV_GET_SLEEP_STATUS_PARAMS
{
    NvU32  version;                                       
    NvBool bLowLatencyMode;                               
    NvBool bFsVrr;                                        
    NvBool bCplVsyncOn;                                   
    NvU8   rsvd[126];                                     
} NV_GET_SLEEP_STATUS_PARAMS_V1;
 
typedef NV_GET_SLEEP_STATUS_PARAMS_V1            NV_GET_SLEEP_STATUS_PARAMS;
#define NV_GET_SLEEP_STATUS_PARAMS_VER1          MAKE_NVAPI_VERSION(NV_GET_SLEEP_STATUS_PARAMS_V1, 1)
#define NV_GET_SLEEP_STATUS_PARAMS_VER           NV_GET_SLEEP_STATUS_PARAMS_VER1
 
#if defined(__cplusplus) && (defined(_D3D9_H_) || defined(__d3d10_h__) || defined(__d3d10_1_h__) || defined(__d3d11_h__) || defined(__d3d12_h__))
//
// FUNCTION NAME: NvAPI_D3D_GetSleepStatus
//
NVAPI_INTERFACE NvAPI_D3D_GetSleepStatus(__in IUnknown *pDev, __in NV_GET_SLEEP_STATUS_PARAMS *pGetSleepStatusParams);
#endif //defined(__cplusplus) && (defined(_D3D9_H_) || defined(__d3d10_h__) || defined(__d3d10_1_h__) || defined(__d3d11_h__) || defined(__d3d12_h__))
 
typedef struct _NV_SET_SLEEP_MODE_PARAMS
{
    NvU32  version;                                       
    NvBool bLowLatencyMode;                               
    NvBool bLowLatencyBoost;                              
    NvU32  minimumIntervalUs;                             
    NvBool bUseMarkersToOptimize;                         
    NvU8   rsvd[31];                                      
} NV_SET_SLEEP_MODE_PARAMS_V1;
 
typedef NV_SET_SLEEP_MODE_PARAMS_V1            NV_SET_SLEEP_MODE_PARAMS;
#define NV_SET_SLEEP_MODE_PARAMS_VER1          MAKE_NVAPI_VERSION(NV_SET_SLEEP_MODE_PARAMS_V1, 1)
#define NV_SET_SLEEP_MODE_PARAMS_VER           NV_SET_SLEEP_MODE_PARAMS_VER1
 
#if defined(__cplusplus) && (defined(_D3D9_H_) || defined(__d3d10_h__) || defined(__d3d10_1_h__) || defined(__d3d11_h__) || defined(__d3d12_h__))
//
// FUNCTION NAME: NvAPI_D3D_SetSleepMode
//
NVAPI_INTERFACE NvAPI_D3D_SetSleepMode(__in IUnknown *pDev, __in NV_SET_SLEEP_MODE_PARAMS *pSetSleepModeParams);
#endif //defined(__cplusplus) && (defined(_D3D9_H_) || defined(__d3d10_h__) || defined(__d3d10_1_h__) || defined(__d3d11_h__) || defined(__d3d12_h__))
 
#if defined(__cplusplus) && (defined(_D3D9_H_) || defined(__d3d10_h__) || defined(__d3d10_1_h__) || defined(__d3d11_h__) || defined(__d3d12_h__))
//
// FUNCTION NAME: NvAPI_D3D_Sleep
//
NVAPI_INTERFACE NvAPI_D3D_Sleep(__in IUnknown *pDev);
#endif //defined(__cplusplus) && (defined(_D3D9_H_) || defined(__d3d10_h__) || defined(__d3d10_1_h__) || defined(__d3d11_h__) || defined(__d3d12_h__))
 
typedef struct _NV_SET_REFLEX_SYNC_PARAMS
{
    NvU32  version;                                       
    NvU32  bEnable:1;                                     
    NvU32  bDisable:1;                                    
    NvU32  flagsRsvd:30;                                  
    NvU32  vblankIntervalUs;                              
    NvS32  timeInQueueUs;                                 
    NvU32  timeInQueueUsTarget;                           
    NvU8   rsvd[28];                                      
} NV_SET_REFLEX_SYNC_PARAMS_V1;
 
typedef NV_SET_REFLEX_SYNC_PARAMS_V1            NV_SET_REFLEX_SYNC_PARAMS;
#define NV_SET_REFLEX_SYNC_PARAMS_VER1          MAKE_NVAPI_VERSION(NV_SET_REFLEX_SYNC_PARAMS_V1, 1)
#define NV_SET_REFLEX_SYNC_PARAMS_VER           NV_SET_REFLEX_SYNC_PARAMS_VER1
 
#if defined(__cplusplus) && (defined(_D3D9_H_) || defined(__d3d10_h__) || defined(__d3d10_1_h__) || defined(__d3d11_h__) || defined(__d3d12_h__))
//
// FUNCTION NAME: NvAPI_D3D_SetReflexSync
//
NVAPI_INTERFACE NvAPI_D3D_SetReflexSync(__in IUnknown *pDev, __in NV_SET_REFLEX_SYNC_PARAMS *pSetReflexSyncParams);
#endif //defined(__cplusplus) && (defined(_D3D9_H_) || defined(__d3d10_h__) || defined(__d3d10_1_h__) || defined(__d3d11_h__) || defined(__d3d12_h__))
 
 
typedef struct _NV_LATENCY_RESULT_PARAMS
{
    NvU32  version;                                       
    struct FrameReport {
        NvU64 frameID;
        NvU64 inputSampleTime;
        NvU64 simStartTime;
        NvU64 simEndTime;
        NvU64 renderSubmitStartTime;
        NvU64 renderSubmitEndTime;
        NvU64 presentStartTime;
        NvU64 presentEndTime;
        NvU64 driverStartTime;
        NvU64 driverEndTime;
        NvU64 osRenderQueueStartTime;
        NvU64 osRenderQueueEndTime;
        NvU64 gpuRenderStartTime;
        NvU64 gpuRenderEndTime;
        NvU32 gpuActiveRenderTimeUs;                      
        NvU32 gpuFrameTimeUs;                             
        NvU8  rsvd[120];
    } frameReport[64];
    NvU8  rsvd[32];
} NV_LATENCY_RESULT_PARAMS_V1;
 
typedef NV_LATENCY_RESULT_PARAMS_V1            NV_LATENCY_RESULT_PARAMS;
#define NV_LATENCY_RESULT_PARAMS_VER1          MAKE_NVAPI_VERSION(NV_LATENCY_RESULT_PARAMS_V1, 1)
#define NV_LATENCY_RESULT_PARAMS_VER           NV_LATENCY_RESULT_PARAMS_VER1
 
#if defined(__cplusplus) && (defined(_D3D9_H_) || defined(__d3d10_h__) || defined(__d3d10_1_h__) || defined(__d3d11_h__) || defined(__d3d12_h__))
//
// FUNCTION NAME: NvAPI_D3D_GetLatency
//
NVAPI_INTERFACE NvAPI_D3D_GetLatency(__in IUnknown *pDev, __out NV_LATENCY_RESULT_PARAMS *pGetLatencyParams);
#endif //defined(__cplusplus) && (defined(_D3D9_H_) || defined(__d3d10_h__) || defined(__d3d10_1_h__) || defined(__d3d11_h__) || defined(__d3d12_h__))
 
typedef enum
{
    SIMULATION_START               =  0,
    SIMULATION_END                 =  1,
    RENDERSUBMIT_START             =  2,
    RENDERSUBMIT_END               =  3,
    PRESENT_START                  =  4,
    PRESENT_END                    =  5,
    INPUT_SAMPLE                   =  6,
    TRIGGER_FLASH                  =  7,
    PC_LATENCY_PING                =  8,
    OUT_OF_BAND_RENDERSUBMIT_START =  9,
    OUT_OF_BAND_RENDERSUBMIT_END   = 10,
    OUT_OF_BAND_PRESENT_START      = 11,
    OUT_OF_BAND_PRESENT_END        = 12,
} NV_LATENCY_MARKER_TYPE;
 
typedef struct _NV_LATENCY_MARKER_PARAMS
{
    NvU32  version;                                       
    NvU64  frameID;
    NV_LATENCY_MARKER_TYPE markerType;
    NvU8   rsvd[64];
} NV_LATENCY_MARKER_PARAMS_V1;
 
typedef NV_LATENCY_MARKER_PARAMS_V1            NV_LATENCY_MARKER_PARAMS;
#define NV_LATENCY_MARKER_PARAMS_VER1          MAKE_NVAPI_VERSION(NV_LATENCY_MARKER_PARAMS_V1, 1)
#define NV_LATENCY_MARKER_PARAMS_VER           NV_LATENCY_MARKER_PARAMS_VER1
 
#if defined(__cplusplus) && (defined(_D3D9_H_) || defined(__d3d10_h__) || defined(__d3d10_1_h__) || defined(__d3d11_h__) || defined(__d3d12_h__))
//
// FUNCTION NAME: NvAPI_D3D_SetLatencyMarker
//
NVAPI_INTERFACE NvAPI_D3D_SetLatencyMarker(__in IUnknown *pDev, __in NV_LATENCY_MARKER_PARAMS* pSetLatencyMarkerParams);
#endif //defined(__cplusplus) && (defined(_D3D9_H_) || defined(__d3d10_h__) || defined(__d3d10_1_h__) || defined(__d3d11_h__) || defined(__d3d12_h__))
 
typedef NV_LATENCY_MARKER_PARAMS_V1         NV_ASYNC_FRAME_MARKER_PARAMS_V1;
typedef NV_ASYNC_FRAME_MARKER_PARAMS_V1     NV_ASYNC_FRAME_MARKER_PARAMS;
#define NV_ASYNC_FRAME_MARKER_PARAMS_VER1   NV_LATENCY_MARKER_PARAMS_VER1
#define NV_ASYNC_FRAME_MARKER_PARAMS_VER    NV_LATENCY_MARKER_PARAMS_VER1
 
#if defined(__cplusplus) && (defined(__d3d12_h__))
//
// FUNCTION NAME: NvAPI_D3D12_SetAsyncFrameMarker
//
NVAPI_INTERFACE NvAPI_D3D12_SetAsyncFrameMarker(__in ID3D12CommandQueue *pCommandQueue, __in NV_ASYNC_FRAME_MARKER_PARAMS* pSetAsyncFrameMarkerParams);
#endif //defined(__cplusplus) && (defined(__d3d12_h__))
 
typedef enum
{
    OUT_OF_BAND_RENDER  = 0,
    OUT_OF_BAND_PRESENT = 1,
} NV_OUT_OF_BAND_CQ_TYPE;
 
#if defined(__cplusplus) && defined(__d3d12_h__)
//
// FUNCTION NAME: NvAPI_D3D12_NotifyOutOfBandCommandQueue
//
NVAPI_INTERFACE NvAPI_D3D12_NotifyOutOfBandCommandQueue(__in ID3D12CommandQueue *pCommandQueue, __in NV_OUT_OF_BAND_CQ_TYPE cqType);
#endif //defined(__cplusplus) && defined(__d3d12_h__))
 
 
#if defined (__cplusplus) && defined(__d3d12_h__)
 
// Experimental API for internal use. DO NOT USE!
NVAPI_INTERFACE NvAPI_D3D12_CreateCubinComputeShader(__in   ID3D12Device*       pDevice,
                                                     __in   const void*         pCubin,
                                                     __in   NvU32               size,
                                                     __in   NvU32               blockX, 
                                                     __in   NvU32               blockY, 
                                                     __in   NvU32               blockZ,
                                                     __out  NVDX_ObjectHandle*  phShader);
 
// Experimental API for internal use. DO NOT USE!
NVAPI_INTERFACE NvAPI_D3D12_CreateCubinComputeShaderEx(__in   ID3D12Device*       pDevice,
                                                       __in   const void*         pCubin,
                                                       __in   NvU32               size,
                                                       __in   NvU32               blockX, 
                                                       __in   NvU32               blockY, 
                                                       __in   NvU32               blockZ,
                                                       __in   NvU32               dynSharedMemBytes,
                                                       __in   const char*         pShaderName,
                                                       __out  NVDX_ObjectHandle*  phShader);
 
// Experimental API for internal use. DO NOT USE!
NVAPI_INTERFACE NvAPI_D3D12_CreateCubinComputeShaderWithName(__in   ID3D12Device*       pDevice,
                                                              __in   const void*         pCubin,
                                                              __in   NvU32               size,
                                                              __in   NvU32               blockX, 
                                                              __in   NvU32               blockY, 
                                                              __in   NvU32               blockZ,
                                                              __in   const char*         pShaderName,
                                                              __out  NVDX_ObjectHandle*  phShader);
 
// Experimental API for internal use. DO NOT USE!
NVAPI_INTERFACE NvAPI_D3D12_LaunchCubinShader(__in  ID3D12GraphicsCommandList*  pCommandList,
                                              __in   NVDX_ObjectHandle          hShader,
                                              __in   NvU32                      gridX,
                                              __in   NvU32                      gridY,
                                              __in   NvU32                      gridZ,
                                              __in   const void*                pParams,
                                              __in   NvU32                      paramSize);
 
// Experimental API for internal use. DO NOT USE!
NVAPI_INTERFACE NvAPI_D3D12_DestroyCubinComputeShader(__in  ID3D12Device*       pDevice,
                                                      __in  NVDX_ObjectHandle   hShader);
 
// Experimental API for internal use. DO NOT USE!
NVAPI_INTERFACE NvAPI_D3D12_GetCudaTextureObject(__in  ID3D12Device*                pDevice,
                                                 __in  D3D12_CPU_DESCRIPTOR_HANDLE  texDesc,
                                                 __in  D3D12_CPU_DESCRIPTOR_HANDLE  smpDesc,
                                                 __out NvU32*                       pTextureHandle);
 
// Experimental API for internal use. DO NOT USE!
NVAPI_INTERFACE NvAPI_D3D12_GetCudaSurfaceObject(__in  ID3D12Device*                pDevice,
                                                 __in  D3D12_CPU_DESCRIPTOR_HANDLE  uavDesc,
                                                 __out NvU32*                       pSurfaceHandle);
 
// Experimental API for internal use. DO NOT USE!
NVAPI_INTERFACE NvAPI_D3D12_IsFatbinPTXSupported(__in  ID3D12Device *pDevice,
                                                 __out bool *pSupported);
 
// Experimental API for internal use. DO NOT USE!
NVAPI_INTERFACE NvAPI_D3D12_CreateCuModule(__in   ID3D12Device*       pDevice,
                                           __in   const void*         pBlob,
                                           __in   NvU32               size,
                                           __out  NVDX_ObjectHandle*  phModule);
 
// Experimental API for internal use. DO NOT USE!
NVAPI_INTERFACE NvAPI_D3D12_EnumFunctionsInModule(__in     ID3D12Device*       pDevice,
                                                  __in     NVDX_ObjectHandle   hModule,
                                                  __inout  NvU32*              pArraySize,
                                                  __out    const char** const  pFunctionNames);
 
// Experimental API for internal use. DO NOT USE!
NVAPI_INTERFACE NvAPI_D3D12_CreateCuFunction(__in   ID3D12Device*       pDevice,
                                             __in   NVDX_ObjectHandle   hModule,
                                             __in   const char*         pName,
                                             __out  NVDX_ObjectHandle*  phFunction);
 
// Experimental API for internal use. DO NOT USE!
 
typedef struct _NVAPI_DIM3
{
    NvU32 x;
    NvU32 y;
    NvU32 z;
} NVAPI_DIM3;
 
typedef struct _NVAPI_CU_KERNEL_LAUNCH_PARAMS
{
    NVDX_ObjectHandle          hFunction;
    NVAPI_DIM3                 gridDim;
    NVAPI_DIM3                 blockDim;
    NvU32                      dynSharedMemBytes;
    void const *               pParams;
    NvU32                      paramSize;
} NVAPI_CU_KERNEL_LAUNCH_PARAMS;
 
NVAPI_INTERFACE NvAPI_D3D12_LaunchCuKernelChain(__in  ID3D12GraphicsCommandList*            pCommandList,
                                                __in  const NVAPI_CU_KERNEL_LAUNCH_PARAMS*  pKernels,
                                                __in  NvU32                                 numKernels);
 
// Experimental API for internal use. DO NOT USE!
 
typedef struct _NVAPI_CU_KERNEL_LAUNCH_PARAMS_EX
{
    NVDX_ObjectHandle          hFunction;
    NVAPI_DIM3                 gridDim;
    NVAPI_DIM3                 blockDim;
    NvU32                      dynSharedMemBytes;
 
    // either pParams/paramsSize is used or kernelParams is used
    void const *               pParams;
    NvU32                      paramSize;
    void                     **kernelParams;
} NVAPI_CU_KERNEL_LAUNCH_PARAMS_EX;
 
NVAPI_INTERFACE NvAPI_D3D12_LaunchCuKernelChainEx(__in  ID3D12GraphicsCommandList*               pCommandList,
                                                  __in  const NVAPI_CU_KERNEL_LAUNCH_PARAMS_EX*  pKernels,
                                                  __in  NvU32                                    numKernels);
 
 
// Experimental API for internal use. DO NOT USE!
NVAPI_INTERFACE NvAPI_D3D12_DestroyCuModule(__in  ID3D12Device*       pDevice,
                                            __in  NVDX_ObjectHandle   hModule);
 
// Experimental API for internal use. DO NOT USE!
NVAPI_INTERFACE NvAPI_D3D12_DestroyCuFunction(__in  ID3D12Device*       pDevice,
                                              __in  NVDX_ObjectHandle   hFunction);
#endif //if defined (__cplusplus) && defined(__d3d12_h__)
 
 
#if defined (__cplusplus) && defined(__d3d11_h__)
 
// Experimental API for internal use. DO NOT USE!
NVAPI_INTERFACE NvAPI_D3D11_CreateCubinComputeShader(__in   ID3D11Device*       pDevice,
                                                     __in   const void*         pCubin,
                                                     __in   NvU32               size,
                                                     __in   NvU32               blockX, 
                                                     __in   NvU32               blockY, 
                                                     __in   NvU32               blockZ,
                                                     __out  NVDX_ObjectHandle*  phShader);
 
// Experimental API for internal use. DO NOT USE!
NVAPI_INTERFACE NvAPI_D3D11_CreateCubinComputeShaderEx(__in   ID3D11Device*     pDevice,
                                                       __in   const void*         pCubin,
                                                       __in   NvU32               size,
                                                       __in   NvU32               blockX, 
                                                       __in   NvU32               blockY, 
                                                       __in   NvU32               blockZ,
                                                       __in   NvU32               dynSharedMemBytes,
                                                       __in   const char*         pShaderName,
                                                       __out  NVDX_ObjectHandle*  phShader);
 
// Experimental API for internal use. DO NOT USE!
NVAPI_INTERFACE NvAPI_D3D11_CreateCubinComputeShaderWithName(__in   ID3D11Device*       pDevice,
                                                             __in   const void*         pCubin,
                                                             __in   NvU32               size,
                                                             __in   NvU32               blockX, 
                                                             __in   NvU32               blockY, 
                                                             __in   NvU32               blockZ,
                                                             __in   const char*         pShaderName,
                                                             __out  NVDX_ObjectHandle*  phShader);
                                                     
 
// Experimental API for internal use. DO NOT USE!
NVAPI_INTERFACE NvAPI_D3D11_LaunchCubinShader(__in   ID3D11DeviceContext       *pDeviceContext,
                                              __in   NVDX_ObjectHandle          hShader,
                                              __in   NvU32                      gridX,
                                              __in   NvU32                      gridY,
                                              __in   NvU32                      gridZ,
                                              __in   const void*                pParams,
                                              __in   NvU32                      paramSize,
                                              __in   const NVDX_ObjectHandle*   pReadResources,
                                              __in   NvU32                      numReadResources,
                                              __in   const NVDX_ObjectHandle*   pWriteResources,
                                              __in   NvU32                      numWriteResources);
 
// Experimental API for internal use. DO NOT USE!
NVAPI_INTERFACE NvAPI_D3D11_DestroyCubinComputeShader(__in  ID3D11Device*       pDevice,
                                                      __in  NVDX_ObjectHandle   hShader);
                                                      
// Experimental API for internal use. DO NOT USE!
NVAPI_INTERFACE NvAPI_D3D11_IsFatbinPTXSupported(__in  ID3D11Device *pDevice,
                                                 __out bool *pSupported);
 
// Experimental API for internal use. DO NOT USE!
NVAPI_INTERFACE NvAPI_D3D11_CreateUnorderedAccessView(__in   ID3D11Device*                            pDevice,
                                                      __in   ID3D11Resource*                          pResource,
                                                      __in   const D3D11_UNORDERED_ACCESS_VIEW_DESC*  pDesc,
                                                      __out  ID3D11UnorderedAccessView**              ppUAV,
                                                      __out  NvU32*                                   pDriverHandle);
 
// Experimental API for internal use. DO NOT USE!
NVAPI_INTERFACE NvAPI_D3D11_CreateShaderResourceView(__in   ID3D11Device*                          pDevice,
                                                     __in   ID3D11Resource*                        pResource,
                                                     __in   const D3D11_SHADER_RESOURCE_VIEW_DESC* pDesc,
                                                     __out  ID3D11ShaderResourceView**             ppSRV,
                                                     __out  NvU32*                                 pDriverHandle);
 
// Experimental API for internal use. DO NOT USE!
NVAPI_INTERFACE NvAPI_D3D11_CreateSamplerState(__in   ID3D11Device*                          pDevice,
                                               __in   const D3D11_SAMPLER_DESC*              pSamplerDesc,
                                               __out  ID3D11SamplerState**                   ppSamplerState,
                                               __out  NvU32*                                 pDriverHandle);
                                                  
// Experimental API for internal use. DO NOT USE!
NVAPI_INTERFACE NvAPI_D3D11_GetCudaTextureObject(__in   ID3D11Device*                       pDevice,
                                                 __in   NvU32                               srvDriverHandle,
                                                 __in   NvU32                               samplerDriverHandle,
                                                 __out  NvU32*                              pCudaTextureHandle);
                                                      
// Experimental API for internal use. DO NOT USE!
NVAPI_INTERFACE NvAPI_D3D11_GetResourceGPUVirtualAddress(__in  ID3D11Device*                pDevice,
                                                         __in  const NVDX_ObjectHandle      hResource,
                                                         __out NvU64*                       pGpuVA);
#endif //defined(__cplusplus) && defined(__d3d11_h__)
 
 
#if defined(__cplusplus) && defined(__d3d12_h__)
typedef enum _NVAPI_D3D12_RAYTRACING_THREAD_REORDERING_CAPS
{
    NVAPI_D3D12_RAYTRACING_THREAD_REORDERING_CAP_NONE     = 0x0,       
    NVAPI_D3D12_RAYTRACING_THREAD_REORDERING_CAP_STANDARD = NV_BIT(0)  
} NVAPI_D3D12_RAYTRACING_THREAD_REORDERING_CAPS;
 
typedef enum _NVAPI_D3D12_RAYTRACING_OPACITY_MICROMAP_CAPS
{
    NVAPI_D3D12_RAYTRACING_OPACITY_MICROMAP_CAP_NONE     = 0x0,       
    NVAPI_D3D12_RAYTRACING_OPACITY_MICROMAP_CAP_STANDARD = NV_BIT(0)  
} NVAPI_D3D12_RAYTRACING_OPACITY_MICROMAP_CAPS;
 
typedef enum _NVAPI_D3D12_RAYTRACING_DISPLACEMENT_MICROMAP_CAPS
{
    NVAPI_D3D12_RAYTRACING_DISPLACEMENT_MICROMAP_CAP_NONE     = 0x0,       
    NVAPI_D3D12_RAYTRACING_DISPLACEMENT_MICROMAP_CAP_STANDARD = NV_BIT(0)  
} NVAPI_D3D12_RAYTRACING_DISPLACEMENT_MICROMAP_CAPS;
 
typedef enum _NVAPI_D3D12_RAYTRACING_CAPS_TYPE
{
    NVAPI_D3D12_RAYTRACING_CAPS_TYPE_THREAD_REORDERING      =  0,
    NVAPI_D3D12_RAYTRACING_CAPS_TYPE_OPACITY_MICROMAP       =  1,
    NVAPI_D3D12_RAYTRACING_CAPS_TYPE_DISPLACEMENT_MICROMAP  =  2,
    NVAPI_D3D12_RAYTRACING_CAPS_TYPE_INVALID                = -1
} NVAPI_D3D12_RAYTRACING_CAPS_TYPE;
 
//
// FUNCTION NAME: NvAPI_D3D12_GetRaytracingCaps
//
NVAPI_INTERFACE NvAPI_D3D12_GetRaytracingCaps(
    __in    ID3D12Device* pDevice,
    __in    NVAPI_D3D12_RAYTRACING_CAPS_TYPE type,
    __out   void* pData,
    __in    size_t dataSize);
#endif // defined(__cplusplus) && defined(__d3d12_h__)
 
#if defined(__cplusplus) && defined(__d3d12_h__) && defined(__ID3D12Device5_INTERFACE_DEFINED__) && defined(__ID3D12GraphicsCommandList4_INTERFACE_DEFINED__)
 
typedef enum _NVAPI_D3D12_RAYTRACING_VALIDATION_FLAGS
{
    NVAPI_D3D12_RAYTRACING_VALIDATION_FLAG_NONE              = 0x0,       
} NVAPI_D3D12_RAYTRACING_VALIDATION_FLAGS;
 
//
// FUNCTION NAME: NvAPI_D3D12_EnableRaytracingValidation
//
NVAPI_INTERFACE NvAPI_D3D12_EnableRaytracingValidation(
    __in     ID3D12Device5* pDevice,
    __in     NVAPI_D3D12_RAYTRACING_VALIDATION_FLAGS flags);
 
 
 
typedef enum _NVAPI_D3D12_RAYTRACING_VALIDATION_MESSAGE_SEVERITY
{
    NVAPI_D3D12_RAYTRACING_VALIDATION_MESSAGE_SEVERITY_ERROR    = 0x0,  
    NVAPI_D3D12_RAYTRACING_VALIDATION_MESSAGE_SEVERITY_WARNING  = 0x1   
} NVAPI_D3D12_RAYTRACING_VALIDATION_MESSAGE_SEVERITY;
 
typedef void(__stdcall *NVAPI_D3D12_RAYTRACING_VALIDATION_MESSAGE_CALLBACK)(void* pUserData, NVAPI_D3D12_RAYTRACING_VALIDATION_MESSAGE_SEVERITY severity, const char* messageCode, const char* message, const char* messageDetails);
 
//
// FUNCTION NAME: NvAPI_D3D12_RegisterRaytracingValidationMessageCallback
//
NVAPI_INTERFACE NvAPI_D3D12_RegisterRaytracingValidationMessageCallback(
    __in     ID3D12Device5* pDevice,
    __in     NVAPI_D3D12_RAYTRACING_VALIDATION_MESSAGE_CALLBACK pfnMessageCallback,
    __in_opt void* pUserData,
    __out    void** pHandle);
 
 
 
//
// FUNCTION NAME: NvAPI_D3D12_UnregisterRaytracingValidationMessageCallback
//
NVAPI_INTERFACE NvAPI_D3D12_UnregisterRaytracingValidationMessageCallback(
    __in  ID3D12Device5* pDevice,
    __in  void* handle);
 
 
 
//
// FUNCTION NAME: NvAPI_D3D12_FlushRaytracingValidationMessages
//
NVAPI_INTERFACE NvAPI_D3D12_FlushRaytracingValidationMessages(
    __in     ID3D12Device5* pDevice);
 
#endif // defined(__cplusplus) && defined(__d3d12_h__) && defined(__ID3D12Device5_INTERFACE_DEFINED__) && defined(__ID3D12GraphicsCommandList4_INTERFACE_DEFINED__)
 
#if defined(__cplusplus) && defined(__d3d12_h__) && (defined(__ID3D12Device5_INTERFACE_DEFINED__) || defined(__ID3D12GraphicsCommandList4_INTERFACE_DEFINED__))
 
// Types used by both device and command list functions.
 
typedef enum _NVAPI_D3D12_RAYTRACING_DISPLACEMENT_MICROMAP_ARRAY_BUILD_FLAGS
{
    NVAPI_D3D12_RAYTRACING_DISPLACEMENT_MICROMAP_ARRAY_BUILD_FLAG_NONE              = 0x0,       
    NVAPI_D3D12_RAYTRACING_DISPLACEMENT_MICROMAP_ARRAY_BUILD_FLAG_PREFER_FAST_TRACE = NV_BIT(0), 
    NVAPI_D3D12_RAYTRACING_DISPLACEMENT_MICROMAP_ARRAY_BUILD_FLAG_PREFER_FAST_BUILD = NV_BIT(1)  
} NVAPI_D3D12_RAYTRACING_DISPLACEMENT_MICROMAP_ARRAY_BUILD_FLAGS;
 
typedef enum _NVAPI_D3D12_RAYTRACING_DISPLACEMENT_MICROMAP_FORMAT
{
    NVAPI_D3D12_RAYTRACING_DISPLACEMENT_MICROMAP_FORMAT_DC1_64_TRIS_64_BYTES    = 0x1, 
    NVAPI_D3D12_RAYTRACING_DISPLACEMENT_MICROMAP_FORMAT_DC1_256_TRIS_128_BYTES  = 0x2, 
    NVAPI_D3D12_RAYTRACING_DISPLACEMENT_MICROMAP_FORMAT_DC1_1024_TRIS_128_BYTES = 0x3, 
 
} NVAPI_D3D12_RAYTRACING_DISPLACEMENT_MICROMAP_FORMAT;
 
typedef struct _NVAPI_D3D12_RAYTRACING_DISPLACEMENT_MICROMAP_USAGE_COUNT
{
    NvU32                                               count;            
    NvU32                                               subdivisionLevel; 
    NVAPI_D3D12_RAYTRACING_DISPLACEMENT_MICROMAP_FORMAT format;           
} NVAPI_D3D12_RAYTRACING_DISPLACEMENT_MICROMAP_USAGE_COUNT;
 
typedef struct _NVAPI_D3D12_RAYTRACING_DISPLACEMENT_MICROMAP_DESC
{
    NvU32 byteOffset;       
    NvU16 subdivisionLevel; 
    NvU16 format;           
} NVAPI_D3D12_RAYTRACING_DISPLACEMENT_MICROMAP_DESC;
 
typedef struct _NVAPI_D3D12_BUILD_RAYTRACING_DISPLACEMENT_MICROMAP_ARRAY_INPUTS
{
    NVAPI_D3D12_RAYTRACING_DISPLACEMENT_MICROMAP_ARRAY_BUILD_FLAGS  flags;             
    NvU32                                                           numDMMUsageCounts; 
    const NVAPI_D3D12_RAYTRACING_DISPLACEMENT_MICROMAP_USAGE_COUNT* pDMMUsageCounts;   
    D3D12_GPU_VIRTUAL_ADDRESS                                       inputBuffer;       
    D3D12_GPU_VIRTUAL_ADDRESS_AND_STRIDE                            perDMMDescs;       
} NVAPI_D3D12_BUILD_RAYTRACING_DISPLACEMENT_MICROMAP_ARRAY_INPUTS;
 
#endif // defined(__cplusplus) && defined(__d3d12_h__) && (defined(__ID3D12Device5_INTERFACE_DEFINED__) || defined(__ID3D12GraphicsCommandList4_INTERFACE_DEFINED__))
 
#if defined(__cplusplus) && defined(__d3d12_h__) && defined(__ID3D12Device5_INTERFACE_DEFINED__)
 
typedef struct _NVAPI_D3D12_RAYTRACING_DISPLACEMENT_MICROMAP_ARRAY_PREBUILD_INFO
{
    NvU64 resultDataMaxSizeInBytes; 
    NvU64 scratchDataSizeInBytes;   
} NVAPI_D3D12_RAYTRACING_DISPLACEMENT_MICROMAP_ARRAY_PREBUILD_INFO;
 
typedef struct _NVAPI_GET_RAYTRACING_DISPLACEMENT_MICROMAP_ARRAY_PREBUILD_INFO_PARAMS_V1
{
    NvU32                                                                  version; 
    const NVAPI_D3D12_BUILD_RAYTRACING_DISPLACEMENT_MICROMAP_ARRAY_INPUTS* pDesc;   
    NVAPI_D3D12_RAYTRACING_DISPLACEMENT_MICROMAP_ARRAY_PREBUILD_INFO*      pInfo;   
} NVAPI_GET_RAYTRACING_DISPLACEMENT_MICROMAP_ARRAY_PREBUILD_INFO_PARAMS_V1;
#define NVAPI_GET_RAYTRACING_DISPLACEMENT_MICROMAP_ARRAY_PREBUILD_INFO_PARAMS_VER1          MAKE_NVAPI_VERSION(NVAPI_GET_RAYTRACING_DISPLACEMENT_MICROMAP_ARRAY_PREBUILD_INFO_PARAMS_V1, 1)
typedef NVAPI_GET_RAYTRACING_DISPLACEMENT_MICROMAP_ARRAY_PREBUILD_INFO_PARAMS_V1            NVAPI_GET_RAYTRACING_DISPLACEMENT_MICROMAP_ARRAY_PREBUILD_INFO_PARAMS;
#define NVAPI_GET_RAYTRACING_DISPLACEMENT_MICROMAP_ARRAY_PREBUILD_INFO_PARAMS_VER           NVAPI_GET_RAYTRACING_DISPLACEMENT_MICROMAP_ARRAY_PREBUILD_INFO_PARAMS_VER1
 
//
// FUNCTION NAME: NvAPI_D3D12_GetRaytracingDisplacementMicromapArrayPrebuildInfo
//
NVAPI_INTERFACE NvAPI_D3D12_GetRaytracingDisplacementMicromapArrayPrebuildInfo(
    __in    ID3D12Device5* pDevice,
    __inout NVAPI_GET_RAYTRACING_DISPLACEMENT_MICROMAP_ARRAY_PREBUILD_INFO_PARAMS* pParams);
 
#endif // defined(__cplusplus) && defined(__d3d12_h__) && defined(__ID3D12Device5_INTERFACE_DEFINED__)
 
#if defined(__cplusplus) && defined(__d3d12_h__) && (defined(__ID3D12Device5_INTERFACE_DEFINED__) || defined(__ID3D12GraphicsCommandList4_INTERFACE_DEFINED__))
 
// Types used by both device and command list functions.
 
typedef enum _NVAPI_D3D12_RAYTRACING_OPACITY_MICROMAP_ARRAY_BUILD_FLAGS
{
    NVAPI_D3D12_RAYTRACING_OPACITY_MICROMAP_ARRAY_BUILD_FLAG_NONE              = 0x0,       
    NVAPI_D3D12_RAYTRACING_OPACITY_MICROMAP_ARRAY_BUILD_FLAG_PREFER_FAST_TRACE = NV_BIT(0), 
    NVAPI_D3D12_RAYTRACING_OPACITY_MICROMAP_ARRAY_BUILD_FLAG_PREFER_FAST_BUILD = NV_BIT(1)  
} NVAPI_D3D12_RAYTRACING_OPACITY_MICROMAP_ARRAY_BUILD_FLAGS;
 
typedef enum _NVAPI_D3D12_RAYTRACING_OPACITY_MICROMAP_FORMAT
{
    NVAPI_D3D12_RAYTRACING_OPACITY_MICROMAP_FORMAT_OC1_2_STATE = 0x1, 
    NVAPI_D3D12_RAYTRACING_OPACITY_MICROMAP_FORMAT_OC1_4_STATE = 0x2  
} NVAPI_D3D12_RAYTRACING_OPACITY_MICROMAP_FORMAT;
 
typedef struct _NVAPI_D3D12_RAYTRACING_OPACITY_MICROMAP_USAGE_COUNT
{
    NvU32                                          count;            
    NvU32                                          subdivisionLevel; 
    NVAPI_D3D12_RAYTRACING_OPACITY_MICROMAP_FORMAT format;           
} NVAPI_D3D12_RAYTRACING_OPACITY_MICROMAP_USAGE_COUNT;
 
typedef struct _NVAPI_D3D12_RAYTRACING_OPACITY_MICROMAP_DESC
{
    NvU32 byteOffset;       
    NvU16 subdivisionLevel; 
    NvU16 format;           
} NVAPI_D3D12_RAYTRACING_OPACITY_MICROMAP_DESC;
 
typedef struct _NVAPI_D3D12_BUILD_RAYTRACING_OPACITY_MICROMAP_ARRAY_INPUTS
{
    NVAPI_D3D12_RAYTRACING_OPACITY_MICROMAP_ARRAY_BUILD_FLAGS  flags;             
    NvU32                                                      numOMMUsageCounts; 
    const NVAPI_D3D12_RAYTRACING_OPACITY_MICROMAP_USAGE_COUNT* pOMMUsageCounts;   
    D3D12_GPU_VIRTUAL_ADDRESS                                  inputBuffer;       
    D3D12_GPU_VIRTUAL_ADDRESS_AND_STRIDE                       perOMMDescs;       
} NVAPI_D3D12_BUILD_RAYTRACING_OPACITY_MICROMAP_ARRAY_INPUTS;
 
#endif // defined(__cplusplus) && defined(__d3d12_h__) && (defined(__ID3D12Device5_INTERFACE_DEFINED__) || defined(__ID3D12GraphicsCommandList4_INTERFACE_DEFINED__))
 
#if defined(__cplusplus) && defined(__d3d12_h__) && defined(__ID3D12Device5_INTERFACE_DEFINED__)
 
typedef struct _NVAPI_D3D12_RAYTRACING_OPACITY_MICROMAP_ARRAY_PREBUILD_INFO
{
    NvU64 resultDataMaxSizeInBytes; 
    NvU64 scratchDataSizeInBytes;   
} NVAPI_D3D12_RAYTRACING_OPACITY_MICROMAP_ARRAY_PREBUILD_INFO;
 
typedef struct _NVAPI_GET_RAYTRACING_OPACITY_MICROMAP_ARRAY_PREBUILD_INFO_PARAMS_V1
{
    NvU32                                                             version; 
    const NVAPI_D3D12_BUILD_RAYTRACING_OPACITY_MICROMAP_ARRAY_INPUTS* pDesc;   
    NVAPI_D3D12_RAYTRACING_OPACITY_MICROMAP_ARRAY_PREBUILD_INFO*      pInfo;   
} NVAPI_GET_RAYTRACING_OPACITY_MICROMAP_ARRAY_PREBUILD_INFO_PARAMS_V1;
#define NVAPI_GET_RAYTRACING_OPACITY_MICROMAP_ARRAY_PREBUILD_INFO_PARAMS_VER1          MAKE_NVAPI_VERSION(NVAPI_GET_RAYTRACING_OPACITY_MICROMAP_ARRAY_PREBUILD_INFO_PARAMS_V1, 1)
typedef NVAPI_GET_RAYTRACING_OPACITY_MICROMAP_ARRAY_PREBUILD_INFO_PARAMS_V1            NVAPI_GET_RAYTRACING_OPACITY_MICROMAP_ARRAY_PREBUILD_INFO_PARAMS;
#define NVAPI_GET_RAYTRACING_OPACITY_MICROMAP_ARRAY_PREBUILD_INFO_PARAMS_VER           NVAPI_GET_RAYTRACING_OPACITY_MICROMAP_ARRAY_PREBUILD_INFO_PARAMS_VER1
 
//
// FUNCTION NAME: NvAPI_D3D12_GetRaytracingOpacityMicromapArrayPrebuildInfo
//
NVAPI_INTERFACE NvAPI_D3D12_GetRaytracingOpacityMicromapArrayPrebuildInfo(
    __in    ID3D12Device5* pDevice,
    __inout NVAPI_GET_RAYTRACING_OPACITY_MICROMAP_ARRAY_PREBUILD_INFO_PARAMS* pParams);
 
#endif // defined(__cplusplus) && defined(__d3d12_h__) && defined(__ID3D12Device5_INTERFACE_DEFINED__)
 
#if defined(__cplusplus) && defined(__d3d12_h__) && defined(__ID3D12Device5_INTERFACE_DEFINED__)
 
typedef enum _NVAPI_D3D12_PIPELINE_CREATION_STATE_FLAGS
{
    NVAPI_D3D12_PIPELINE_CREATION_STATE_FLAGS_NONE               = 0,         
    NVAPI_D3D12_PIPELINE_CREATION_STATE_FLAGS_ENABLE_OMM_SUPPORT = NV_BIT(0), 
    NVAPI_D3D12_PIPELINE_CREATION_STATE_FLAGS_ENABLE_DMM_SUPPORT = NV_BIT(1), 
} NVAPI_D3D12_PIPELINE_CREATION_STATE_FLAGS;
 
typedef struct _NVAPI_D3D12_SET_CREATE_PIPELINE_STATE_OPTIONS_PARAMS_V1
{
    NvU32 version; 
    NvU32 flags;   
} NVAPI_D3D12_SET_CREATE_PIPELINE_STATE_OPTIONS_PARAMS_V1;
#define NVAPI_D3D12_SET_CREATE_PIPELINE_STATE_OPTIONS_PARAMS_VER1          MAKE_NVAPI_VERSION(NVAPI_D3D12_SET_CREATE_PIPELINE_STATE_OPTIONS_PARAMS_V1, 1)
typedef NVAPI_D3D12_SET_CREATE_PIPELINE_STATE_OPTIONS_PARAMS_V1            NVAPI_D3D12_SET_CREATE_PIPELINE_STATE_OPTIONS_PARAMS;
#define NVAPI_D3D12_SET_CREATE_PIPELINE_STATE_OPTIONS_PARAMS_VER           NVAPI_D3D12_SET_CREATE_PIPELINE_STATE_OPTIONS_PARAMS_VER1
 
//
// FUNCTION NAME: NvAPI_D3D12_SetCreatePipelineStateOptions
//
 
NVAPI_INTERFACE NvAPI_D3D12_SetCreatePipelineStateOptions(
    __in ID3D12Device5* pDevice,
    __in const NVAPI_D3D12_SET_CREATE_PIPELINE_STATE_OPTIONS_PARAMS* pState);
 
#endif // defined(__cplusplus) && defined(__d3d12_h__) && defined(__ID3D12Device5_INTERFACE_DEFINED__)
 
#if defined(__cplusplus) && defined(__d3d12_h__) && defined(__ID3D12Device5_INTERFACE_DEFINED__)
 
typedef enum _NVAPI_D3D12_SERIALIZED_DATA_TYPE_EX
{
    // D3D12_SERIALIZED_DATA_TYPE flags
    NVAPI_D3D12_SERIALIZED_DATA_RAYTRACING_ACCELERATION_STRUCTURE_EX = 0x0,      
 
    // NVAPI_D3D12_SERIALIZED_DATA_TYPE_EX specific flags
    NVAPI_D3D12_SERIALIZED_DATA_RAYTRACING_OPACITY_MICROMAP_ARRAY_EX = 0x1,      
    NVAPI_D3D12_SERIALIZED_DATA_RAYTRACING_DISPLACEMENT_MICROMAP_ARRAY_EX = 0x2, 
 
} NVAPI_D3D12_SERIALIZED_DATA_TYPE_EX;
 
typedef struct _NVAPI_CHECK_DRIVER_MATCHING_IDENTIFIER_EX_PARAMS_V1
{
    NvU32                                                   version;            
    NVAPI_D3D12_SERIALIZED_DATA_TYPE_EX                     serializedDataType; 
    const D3D12_SERIALIZED_DATA_DRIVER_MATCHING_IDENTIFIER* pIdentifierToCheck; 
    D3D12_DRIVER_MATCHING_IDENTIFIER_STATUS                 checkStatus;        
} NVAPI_CHECK_DRIVER_MATCHING_IDENTIFIER_EX_PARAMS_V1;
#define NVAPI_CHECK_DRIVER_MATCHING_IDENTIFIER_EX_PARAMS_VER1          MAKE_NVAPI_VERSION(NVAPI_CHECK_DRIVER_MATCHING_IDENTIFIER_EX_PARAMS_V1, 1)
typedef NVAPI_CHECK_DRIVER_MATCHING_IDENTIFIER_EX_PARAMS_V1            NVAPI_CHECK_DRIVER_MATCHING_IDENTIFIER_EX_PARAMS;
#define NVAPI_CHECK_DRIVER_MATCHING_IDENTIFIER_EX_PARAMS_VER           NVAPI_CHECK_DRIVER_MATCHING_IDENTIFIER_EX_PARAMS_VER1
 
//
// FUNCTION NAME: NvAPI_D3D12_CheckDriverMatchingIdentifierEx
//
NVAPI_INTERFACE NvAPI_D3D12_CheckDriverMatchingIdentifierEx(
    __in    ID3D12Device5* pDevice,
    __inout NVAPI_CHECK_DRIVER_MATCHING_IDENTIFIER_EX_PARAMS* pParams);
 
#endif // defined(__cplusplus) && defined(__d3d12_h__) && defined(__ID3D12Device5_INTERFACE_DEFINED__)
 
#if defined(__cplusplus) && defined(__d3d12_h__) && defined(__ID3D12Device5_INTERFACE_DEFINED__)
 
typedef enum _NVAPI_D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAGS_EX
{
    // D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAGS flags
    NVAPI_D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAG_NONE_EX                            = 0x0,       
    NVAPI_D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAG_ALLOW_UPDATE_EX                    = NV_BIT(0), 
    NVAPI_D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAG_ALLOW_COMPACTION_EX                = NV_BIT(1), 
    NVAPI_D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAG_PREFER_FAST_TRACE_EX               = NV_BIT(2), 
    NVAPI_D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAG_PREFER_FAST_BUILD_EX               = NV_BIT(3), 
    NVAPI_D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAG_MINIMIZE_MEMORY_EX                 = NV_BIT(4), 
    NVAPI_D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAG_PERFORM_UPDATE_EX                  = NV_BIT(5), 
 
    // NVAPI_D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAGS_EX specific flags
    NVAPI_D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAG_ALLOW_OMM_UPDATE_EX                = NV_BIT(6), 
    NVAPI_D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAG_ALLOW_DISABLE_OMMS_EX              = NV_BIT(7), 
    NVAPI_D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAG_ALLOW_OMM_OPACITY_STATES_UPDATE_EX = NV_BIT(8), 
    NVAPI_D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAG_ALLOW_DATA_ACCESS_EX               = NV_BIT(9), 
 
} NVAPI_D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAGS_EX;
 
typedef enum _NVAPI_D3D12_RAYTRACING_GEOMETRY_TYPE_EX
{
    // D3D12_RAYTRACING_GEOMETRY_TYPE flags
    NVAPI_D3D12_RAYTRACING_GEOMETRY_TYPE_TRIANGLES_EX                  = 0x0, 
    NVAPI_D3D12_RAYTRACING_GEOMETRY_TYPE_PROCEDURAL_PRIMITIVE_AABBS_EX = 0x1, 
 
    // NVAPI_D3D12_RAYTRACING_GEOMETRY_TYPE_EX specific flags
    NVAPI_D3D12_RAYTRACING_GEOMETRY_TYPE_OMM_TRIANGLES_EX              = 0x2, 
    NVAPI_D3D12_RAYTRACING_GEOMETRY_TYPE_DMM_TRIANGLES_EX              = 0x3, 
 
} NVAPI_D3D12_RAYTRACING_GEOMETRY_TYPE_EX;
 
typedef enum _NVAPI_D3D12_RAYTRACING_OPACITY_MICROMAP_SPECIAL_INDEX
{
    NVAPI_D3D12_RAYTRACING_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_TRANSPARENT         = -1, 
    NVAPI_D3D12_RAYTRACING_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_OPAQUE              = -2, 
    NVAPI_D3D12_RAYTRACING_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_UNKNOWN_TRANSPARENT = -3, 
    NVAPI_D3D12_RAYTRACING_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_UNKNOWN_OPAQUE      = -4  
} NVAPI_D3D12_RAYTRACING_OPACITY_MICROMAP_SPECIAL_INDEX;
 
typedef struct _NVAPI_D3D12_RAYTRACING_GEOMETRY_OMM_ATTACHMENT_DESC
{
    D3D12_GPU_VIRTUAL_ADDRESS_AND_STRIDE                       opacityMicromapIndexBuffer;  
    DXGI_FORMAT                                                opacityMicromapIndexFormat;  
    NvU32                                                      opacityMicromapBaseLocation; 
    D3D12_GPU_VIRTUAL_ADDRESS                                  opacityMicromapArray;        
 
    NvU32                                                      numOMMUsageCounts;           
    const NVAPI_D3D12_RAYTRACING_OPACITY_MICROMAP_USAGE_COUNT* pOMMUsageCounts;             
 
} NVAPI_D3D12_RAYTRACING_GEOMETRY_OMM_ATTACHMENT_DESC;
 
typedef enum _NVAPI_D3D12_RAYTRACING_DISPLACEMENT_MICROMAP_PRIMITIVE_FLAGS
{
    NVAPI_D3D12_RAYTRACING_DISPLACEMENT_MICROMAP_PRIMITIVE_FLAG_DECIMATE_01 = NV_BIT(0),
    NVAPI_D3D12_RAYTRACING_DISPLACEMENT_MICROMAP_PRIMITIVE_FLAG_DECIMATE_12 = NV_BIT(1),
    NVAPI_D3D12_RAYTRACING_DISPLACEMENT_MICROMAP_PRIMITIVE_FLAG_DECIMATE_20 = NV_BIT(2),
 
} NVAPI_D3D12_RAYTRACING_DISPLACEMENT_MICROMAP_PRIMITIVE_FLAGS;
 
typedef struct _NVAPI_D3D12_RAYTRACING_GEOMETRY_DMM_ATTACHMENT_DESC
{
    D3D12_GPU_VIRTUAL_ADDRESS_AND_STRIDE                            triangleMicromapIndexBuffer;    
    DXGI_FORMAT                                                     triangleMicromapIndexFormat;    
    NvU32                                                           triangleMicromapBaseLocation;   
 
    D3D12_GPU_VIRTUAL_ADDRESS_AND_STRIDE                            trianglePrimitiveFlagsBuffer;   
 
    D3D12_GPU_VIRTUAL_ADDRESS_AND_STRIDE                            vertexBiasAndScaleBuffer;       
    DXGI_FORMAT                                                     vertexBiasAndScaleFormat;       
 
    D3D12_GPU_VIRTUAL_ADDRESS_AND_STRIDE                            vertexDisplacementVectorBuffer; 
    DXGI_FORMAT                                                     vertexDisplacementVectorFormat; 
 
    D3D12_GPU_VIRTUAL_ADDRESS                                       displacementMicromapArray;      
 
    NvU32                                                           numDMMUsageCounts;              
    const NVAPI_D3D12_RAYTRACING_DISPLACEMENT_MICROMAP_USAGE_COUNT* pDMMUsageCounts;                
 
} NVAPI_D3D12_RAYTRACING_GEOMETRY_DMM_ATTACHMENT_DESC;
 
typedef struct _NVAPI_D3D12_RAYTRACING_GEOMETRY_DMM_TRIANGLES_DESC
{
    D3D12_RAYTRACING_GEOMETRY_TRIANGLES_DESC            triangles;     
    NVAPI_D3D12_RAYTRACING_GEOMETRY_DMM_ATTACHMENT_DESC dmmAttachment; 
} NVAPI_D3D12_RAYTRACING_GEOMETRY_DMM_TRIANGLES_DESC;
 
typedef struct _NVAPI_D3D12_RAYTRACING_GEOMETRY_OMM_TRIANGLES_DESC
{
    D3D12_RAYTRACING_GEOMETRY_TRIANGLES_DESC            triangles;     
    NVAPI_D3D12_RAYTRACING_GEOMETRY_OMM_ATTACHMENT_DESC ommAttachment; 
} NVAPI_D3D12_RAYTRACING_GEOMETRY_OMM_TRIANGLES_DESC;
 
typedef struct _NVAPI_D3D12_RAYTRACING_GEOMETRY_DESC_EX
{
    NVAPI_D3D12_RAYTRACING_GEOMETRY_TYPE_EX type;  
    D3D12_RAYTRACING_GEOMETRY_FLAGS         flags; 
    union
    {
        D3D12_RAYTRACING_GEOMETRY_TRIANGLES_DESC           triangles;    
        D3D12_RAYTRACING_GEOMETRY_AABBS_DESC               aabbs;        
        NVAPI_D3D12_RAYTRACING_GEOMETRY_OMM_TRIANGLES_DESC ommTriangles; 
        NVAPI_D3D12_RAYTRACING_GEOMETRY_DMM_TRIANGLES_DESC dmmTriangles; 
    };
} NVAPI_D3D12_RAYTRACING_GEOMETRY_DESC_EX;
 
typedef enum _NVAPI_D3D12_RAYTRACING_INSTANCE_FLAGS_EX
{
    // D3D12_RAYTRACING_INSTANCE_FLAGS flags
    NVAPI_D3D12_RAYTRACING_INSTANCE_FLAG_NONE_EX                            = 0x0,       
    NVAPI_D3D12_RAYTRACING_INSTANCE_FLAG_TRIANGLE_CULL_DISABLE_EX           = NV_BIT(0), 
    NVAPI_D3D12_RAYTRACING_INSTANCE_FLAG_TRIANGLE_FRONT_COUNTERCLOCKWISE_EX = NV_BIT(1), 
    NVAPI_D3D12_RAYTRACING_INSTANCE_FLAG_FORCE_OPAQUE_EX                    = NV_BIT(2), 
    NVAPI_D3D12_RAYTRACING_INSTANCE_FLAG_FORCE_NON_OPAQUE_EX                = NV_BIT(3), 
 
    // NVAPI_D3D12_RAYTRACING_INSTANCE_FLAGS_EX specific flags
    NVAPI_D3D12_RAYTRACING_INSTANCE_FLAG_FORCE_OMM_2_STATE_EX               = NV_BIT(4), 
    NVAPI_D3D12_RAYTRACING_INSTANCE_FLAG_DISABLE_OMMS_EX                    = NV_BIT(5)  
} NVAPI_D3D12_RAYTRACING_INSTANCE_FLAGS_EX;
 
typedef struct _NVAPI_D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_INPUTS_EX
{
    D3D12_RAYTRACING_ACCELERATION_STRUCTURE_TYPE                 type;                      
    NVAPI_D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAGS_EX flags;                     
    NvU32                                                        numDescs;                  
    D3D12_ELEMENTS_LAYOUT                                        descsLayout;               
    NvU32                                                        geometryDescStrideInBytes; 
    union
    {
        D3D12_GPU_VIRTUAL_ADDRESS                            instanceDescs;   
        const NVAPI_D3D12_RAYTRACING_GEOMETRY_DESC_EX*       pGeometryDescs;  
        const NVAPI_D3D12_RAYTRACING_GEOMETRY_DESC_EX*const* ppGeometryDescs; 
    };
} NVAPI_D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_INPUTS_EX;
 
typedef struct _NVAPI_GET_RAYTRACING_ACCELERATION_STRUCTURE_PREBUILD_INFO_EX_PARAMS_V1
{
    NvU32                                                                version; 
    const NVAPI_D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_INPUTS_EX* pDesc;   
    D3D12_RAYTRACING_ACCELERATION_STRUCTURE_PREBUILD_INFO*               pInfo;   
} NVAPI_GET_RAYTRACING_ACCELERATION_STRUCTURE_PREBUILD_INFO_EX_PARAMS_V1;
#define NVAPI_GET_RAYTRACING_ACCELERATION_STRUCTURE_PREBUILD_INFO_EX_PARAMS_VER1          MAKE_NVAPI_VERSION(NVAPI_GET_RAYTRACING_ACCELERATION_STRUCTURE_PREBUILD_INFO_EX_PARAMS_V1, 1)
typedef NVAPI_GET_RAYTRACING_ACCELERATION_STRUCTURE_PREBUILD_INFO_EX_PARAMS_V1            NVAPI_GET_RAYTRACING_ACCELERATION_STRUCTURE_PREBUILD_INFO_EX_PARAMS;
#define NVAPI_GET_RAYTRACING_ACCELERATION_STRUCTURE_PREBUILD_INFO_EX_PARAMS_VER           NVAPI_GET_RAYTRACING_ACCELERATION_STRUCTURE_PREBUILD_INFO_EX_PARAMS_VER1
 
//
// FUNCTION NAME: NvAPI_D3D12_GetRaytracingAccelerationStructurePrebuildInfoEx
//
NVAPI_INTERFACE NvAPI_D3D12_GetRaytracingAccelerationStructurePrebuildInfoEx(
    __in    ID3D12Device5* pDevice,
    __inout NVAPI_GET_RAYTRACING_ACCELERATION_STRUCTURE_PREBUILD_INFO_EX_PARAMS* pParams);
 
#endif // defined(__cplusplus) && defined(__d3d12_h__) && defined(__ID3D12Device5_INTERFACE_DEFINED__)
 
#if defined(__cplusplus) && defined(__d3d12_h__) && defined(__ID3D12GraphicsCommandList4_INTERFACE_DEFINED__)
 
typedef struct _NVAPI_D3D12_BUILD_RAYTRACING_OPACITY_MICROMAP_ARRAY_DESC
{
    D3D12_GPU_VIRTUAL_ADDRESS                                  destOpacityMicromapArrayData;    
    NVAPI_D3D12_BUILD_RAYTRACING_OPACITY_MICROMAP_ARRAY_INPUTS inputs;                          
    D3D12_GPU_VIRTUAL_ADDRESS                                  scratchOpacityMicromapArrayData; 
} NVAPI_D3D12_BUILD_RAYTRACING_OPACITY_MICROMAP_ARRAY_DESC;
 
typedef struct _NVAPI_D3D12_RAYTRACING_OPACITY_MICROMAP_ARRAY_POSTBUILD_INFO_CURRENT_SIZE_DESC
{
    NvU64 currentSizeInBytes; 
} NVAPI_D3D12_RAYTRACING_OPACITY_MICROMAP_ARRAY_POSTBUILD_INFO_CURRENT_SIZE_DESC;
 
typedef enum _NVAPI_D3D12_RAYTRACING_OPACITY_MICROMAP_ARRAY_POSTBUILD_INFO_TYPE
{
    NVAPI_D3D12_RAYTRACING_OPACITY_MICROMAP_ARRAY_POSTBUILD_INFO_CURRENT_SIZE       = 0x0  
} NVAPI_D3D12_RAYTRACING_OPACITY_MICROMAP_ARRAY_POSTBUILD_INFO_TYPE;
 
typedef struct _NVAPI_D3D12_RAYTRACING_OPACITY_MICROMAP_ARRAY_POSTBUILD_INFO_DESC
{
    D3D12_GPU_VIRTUAL_ADDRESS                                        destBuffer; 
    NVAPI_D3D12_RAYTRACING_OPACITY_MICROMAP_ARRAY_POSTBUILD_INFO_TYPE infoType;  
} NVAPI_D3D12_RAYTRACING_OPACITY_MICROMAP_ARRAY_POSTBUILD_INFO_DESC;
 
typedef struct _NVAPI_BUILD_RAYTRACING_OPACITY_MICROMAP_ARRAY_PARAMS_V1
{
    NvU32                                                                    version;               
    const NVAPI_D3D12_BUILD_RAYTRACING_OPACITY_MICROMAP_ARRAY_DESC*          pDesc;                 
    NvU32                                                                    numPostbuildInfoDescs; 
    const NVAPI_D3D12_RAYTRACING_OPACITY_MICROMAP_ARRAY_POSTBUILD_INFO_DESC* pPostbuildInfoDescs;   
} NVAPI_BUILD_RAYTRACING_OPACITY_MICROMAP_ARRAY_PARAMS_V1;
#define NVAPI_BUILD_RAYTRACING_OPACITY_MICROMAP_ARRAY_PARAMS_VER1          MAKE_NVAPI_VERSION(NVAPI_BUILD_RAYTRACING_OPACITY_MICROMAP_ARRAY_PARAMS_V1, 1)
typedef NVAPI_BUILD_RAYTRACING_OPACITY_MICROMAP_ARRAY_PARAMS_V1            NVAPI_BUILD_RAYTRACING_OPACITY_MICROMAP_ARRAY_PARAMS;
#define NVAPI_BUILD_RAYTRACING_OPACITY_MICROMAP_ARRAY_PARAMS_VER           NVAPI_BUILD_RAYTRACING_OPACITY_MICROMAP_ARRAY_PARAMS_VER1
 
//
// FUNCTION NAME: NvAPI_D3D12_BuildRaytracingOpacityMicromapArray
//
NVAPI_INTERFACE NvAPI_D3D12_BuildRaytracingOpacityMicromapArray(
    __in ID3D12GraphicsCommandList4* pCommandList,
    __in NVAPI_BUILD_RAYTRACING_OPACITY_MICROMAP_ARRAY_PARAMS* pParams);
 
#endif // defined(__cplusplus) && defined(__d3d12_h__) && defined(__ID3D12GraphicsCommandList4_INTERFACE_DEFINED__)
 
#if defined(__cplusplus) && defined(__d3d12_h__) && defined(__ID3D12GraphicsCommandList4_INTERFACE_DEFINED__)
 
typedef struct _NVAPI_RELOCATE_RAYTRACING_OPACITY_MICROMAP_ARRAY_PARAMS_V1
{
    NvU32                     version;              
    D3D12_GPU_VIRTUAL_ADDRESS opacityMicromapArray; 
} NVAPI_RELOCATE_RAYTRACING_OPACITY_MICROMAP_ARRAY_PARAMS_V1;
#define NVAPI_RELOCATE_RAYTRACING_OPACITY_MICROMAP_ARRAY_PARAMS_VER1          MAKE_NVAPI_VERSION(NVAPI_RELOCATE_RAYTRACING_OPACITY_MICROMAP_ARRAY_PARAMS_V1, 1)
typedef NVAPI_RELOCATE_RAYTRACING_OPACITY_MICROMAP_ARRAY_PARAMS_V1            NVAPI_RELOCATE_RAYTRACING_OPACITY_MICROMAP_ARRAY_PARAMS;
#define NVAPI_RELOCATE_RAYTRACING_OPACITY_MICROMAP_ARRAY_PARAMS_VER           NVAPI_RELOCATE_RAYTRACING_OPACITY_MICROMAP_ARRAY_PARAMS_VER1
 
//
// FUNCTION NAME: NvAPI_D3D12_RelocateRaytracingOpacityMicromapArray
//
NVAPI_INTERFACE NvAPI_D3D12_RelocateRaytracingOpacityMicromapArray(
    __in ID3D12GraphicsCommandList4* pCommandList,
    __in const NVAPI_RELOCATE_RAYTRACING_OPACITY_MICROMAP_ARRAY_PARAMS* pParams);
 
#endif // defined(__cplusplus) && defined(__d3d12_h__) && defined(__ID3D12GraphicsCommandList4_INTERFACE_DEFINED__)
 
#if defined(__cplusplus) && defined(__d3d12_h__) && defined(__ID3D12GraphicsCommandList4_INTERFACE_DEFINED__)
 
typedef struct _NVAPI_D3D12_BUILD_RAYTRACING_DISPLACEMENT_MICROMAP_ARRAY_DESC
{
    D3D12_GPU_VIRTUAL_ADDRESS                                       destDisplacementMicromapArrayData;    
    NVAPI_D3D12_BUILD_RAYTRACING_DISPLACEMENT_MICROMAP_ARRAY_INPUTS inputs;                               
    D3D12_GPU_VIRTUAL_ADDRESS                                       scratchDisplacementMicromapArrayData; 
} NVAPI_D3D12_BUILD_RAYTRACING_DISPLACEMENT_MICROMAP_ARRAY_DESC;
 
typedef struct _NVAPI_D3D12_RAYTRACING_DISPLACEMENT_MICROMAP_ARRAY_POSTBUILD_INFO_CURRENT_SIZE_DESC
{
    NvU64 currentSizeInBytes; 
} NVAPI_D3D12_RAYTRACING_DISPLACEMENT_MICROMAP_ARRAY_POSTBUILD_INFO_CURRENT_SIZE_DESC;
 
typedef enum _NVAPI_D3D12_RAYTRACING_DISPLACEMENT_MICROMAP_ARRAY_POSTBUILD_INFO_TYPE
{
    NVAPI_D3D12_RAYTRACING_DISPLACEMENT_MICROMAP_ARRAY_POSTBUILD_INFO_CURRENT_SIZE = 0x0, 
} NVAPI_D3D12_RAYTRACING_DISPLACEMENT_MICROMAP_ARRAY_POSTBUILD_INFO_TYPE;
 
typedef struct _NVAPI_D3D12_RAYTRACING_DISPLACEMENT_MICROMAP_ARRAY_POSTBUILD_INFO_DESC
{
    D3D12_GPU_VIRTUAL_ADDRESS                                              destBuffer; 
    NVAPI_D3D12_RAYTRACING_DISPLACEMENT_MICROMAP_ARRAY_POSTBUILD_INFO_TYPE infoType;   
} NVAPI_D3D12_RAYTRACING_DISPLACEMENT_MICROMAP_ARRAY_POSTBUILD_INFO_DESC;
 
typedef struct _NVAPI_BUILD_RAYTRACING_DISPLACEMENT_MICROMAP_ARRAY_PARAMS_V1
{
    NvU32                                                                         version;               
    const NVAPI_D3D12_BUILD_RAYTRACING_DISPLACEMENT_MICROMAP_ARRAY_DESC*          pDesc;                 
    NvU32                                                                         numPostbuildInfoDescs; 
    const NVAPI_D3D12_RAYTRACING_DISPLACEMENT_MICROMAP_ARRAY_POSTBUILD_INFO_DESC* pPostbuildInfoDescs;   
} NVAPI_BUILD_RAYTRACING_DISPLACEMENT_MICROMAP_ARRAY_PARAMS_V1;
#define NVAPI_BUILD_RAYTRACING_DISPLACEMENT_MICROMAP_ARRAY_PARAMS_VER1          MAKE_NVAPI_VERSION(NVAPI_BUILD_RAYTRACING_DISPLACEMENT_MICROMAP_ARRAY_PARAMS_V1, 1)
typedef NVAPI_BUILD_RAYTRACING_DISPLACEMENT_MICROMAP_ARRAY_PARAMS_V1            NVAPI_BUILD_RAYTRACING_DISPLACEMENT_MICROMAP_ARRAY_PARAMS;
#define NVAPI_BUILD_RAYTRACING_DISPLACEMENT_MICROMAP_ARRAY_PARAMS_VER           NVAPI_BUILD_RAYTRACING_DISPLACEMENT_MICROMAP_ARRAY_PARAMS_VER1
 
//
// FUNCTION NAME: NvAPI_D3D12_BuildRaytracingDisplacementMicromapArray
//
NVAPI_INTERFACE NvAPI_D3D12_BuildRaytracingDisplacementMicromapArray(
    __in ID3D12GraphicsCommandList4* pCommandList,
    __in NVAPI_BUILD_RAYTRACING_DISPLACEMENT_MICROMAP_ARRAY_PARAMS* pParams);
 
#endif // defined(__cplusplus) && defined(__d3d12_h__) && defined(__ID3D12GraphicsCommandList4_INTERFACE_DEFINED__)
 
#if defined(__cplusplus) && defined(__d3d12_h__) && defined(__ID3D12GraphicsCommandList4_INTERFACE_DEFINED__)
 
typedef struct _NVAPI_RELOCATE_RAYTRACING_DISPLACEMENT_MICROMAP_ARRAY_PARAMS_V1
{
    NvU32                     version;                   
    D3D12_GPU_VIRTUAL_ADDRESS displacementMicromapArray; 
} NVAPI_RELOCATE_RAYTRACING_DISPLACEMENT_MICROMAP_ARRAY_PARAMS_V1;
#define NVAPI_RELOCATE_RAYTRACING_DISPLACEMENT_MICROMAP_ARRAY_PARAMS_VER1          MAKE_NVAPI_VERSION(NVAPI_RELOCATE_RAYTRACING_DISPLACEMENT_MICROMAP_ARRAY_PARAMS_V1, 1)
typedef NVAPI_RELOCATE_RAYTRACING_DISPLACEMENT_MICROMAP_ARRAY_PARAMS_V1            NVAPI_RELOCATE_RAYTRACING_DISPLACEMENT_MICROMAP_ARRAY_PARAMS;
#define NVAPI_RELOCATE_RAYTRACING_DISPLACEMENT_MICROMAP_ARRAY_PARAMS_VER           NVAPI_RELOCATE_RAYTRACING_DISPLACEMENT_MICROMAP_ARRAY_PARAMS_VER1
 
//
// FUNCTION NAME: NvAPI_D3D12_RelocateRaytracingDisplacementMicromapArray
//
NVAPI_INTERFACE NvAPI_D3D12_RelocateRaytracingDisplacementMicromapArray(
    __in ID3D12GraphicsCommandList4* pCommandList,
    __in const NVAPI_RELOCATE_RAYTRACING_DISPLACEMENT_MICROMAP_ARRAY_PARAMS* pParams);
 
#endif // defined(__cplusplus) && defined(__d3d12_h__) && defined(__ID3D12GraphicsCommandList4_INTERFACE_DEFINED__)
 
#if defined(__cplusplus) && defined(__d3d12_h__) && defined(__ID3D12GraphicsCommandList4_INTERFACE_DEFINED__)
 
typedef struct _NVAPI_EMIT_RAYTRACING_DISPLACEMENT_MICROMAP_ARRAY_POSTBUILD_INFO_PARAMS_V1
{
    NvU32                                                                         version;    
    const NVAPI_D3D12_RAYTRACING_DISPLACEMENT_MICROMAP_ARRAY_POSTBUILD_INFO_DESC* pDesc;      
    NvU32                                                                         numSources; 
    const D3D12_GPU_VIRTUAL_ADDRESS*                                              pSources;   
} NVAPI_EMIT_RAYTRACING_DISPLACEMENT_MICROMAP_ARRAY_POSTBUILD_INFO_PARAMS_V1;
#define NVAPI_EMIT_RAYTRACING_DISPLACEMENT_MICROMAP_ARRAY_POSTBUILD_INFO_PARAMS_VER1          MAKE_NVAPI_VERSION(NVAPI_EMIT_RAYTRACING_DISPLACEMENT_MICROMAP_ARRAY_POSTBUILD_INFO_PARAMS_V1, 1)
typedef NVAPI_EMIT_RAYTRACING_DISPLACEMENT_MICROMAP_ARRAY_POSTBUILD_INFO_PARAMS_V1            NVAPI_EMIT_RAYTRACING_DISPLACEMENT_MICROMAP_ARRAY_POSTBUILD_INFO_PARAMS;
#define NVAPI_EMIT_RAYTRACING_DISPLACEMENT_MICROMAP_ARRAY_POSTBUILD_INFO_PARAMS_VER           NVAPI_EMIT_RAYTRACING_DISPLACEMENT_MICROMAP_ARRAY_POSTBUILD_INFO_PARAMS_VER1
 
//
// FUNCTION NAME: NvAPI_D3D12_EmitRaytracingDisplacementMicromapArrayPostbuildInfo
//
NVAPI_INTERFACE NvAPI_D3D12_EmitRaytracingDisplacementMicromapArrayPostbuildInfo(
    __in ID3D12GraphicsCommandList4* pCommandList,
    __in const NVAPI_EMIT_RAYTRACING_DISPLACEMENT_MICROMAP_ARRAY_POSTBUILD_INFO_PARAMS* pParams);
 
#endif // defined(__cplusplus) && defined(__d3d12_h__) && defined(__ID3D12GraphicsCommandList4_INTERFACE_DEFINED__)
 
#if defined(__cplusplus) && defined(__d3d12_h__) && defined(__ID3D12GraphicsCommandList4_INTERFACE_DEFINED__)
 
typedef struct _NVAPI_EMIT_RAYTRACING_OPACITY_MICROMAP_ARRAY_POSTBUILD_INFO_PARAMS_V1
{
    NvU32                                                                    version;    
    const NVAPI_D3D12_RAYTRACING_OPACITY_MICROMAP_ARRAY_POSTBUILD_INFO_DESC* pDesc;      
    NvU32                                                                    numSources; 
    const D3D12_GPU_VIRTUAL_ADDRESS*                                         pSources;   
} NVAPI_EMIT_RAYTRACING_OPACITY_MICROMAP_ARRAY_POSTBUILD_INFO_PARAMS_V1;
#define NVAPI_EMIT_RAYTRACING_OPACITY_MICROMAP_ARRAY_POSTBUILD_INFO_PARAMS_VER1          MAKE_NVAPI_VERSION(NVAPI_EMIT_RAYTRACING_OPACITY_MICROMAP_ARRAY_POSTBUILD_INFO_PARAMS_V1, 1)
typedef NVAPI_EMIT_RAYTRACING_OPACITY_MICROMAP_ARRAY_POSTBUILD_INFO_PARAMS_V1            NVAPI_EMIT_RAYTRACING_OPACITY_MICROMAP_ARRAY_POSTBUILD_INFO_PARAMS;
#define NVAPI_EMIT_RAYTRACING_OPACITY_MICROMAP_ARRAY_POSTBUILD_INFO_PARAMS_VER           NVAPI_EMIT_RAYTRACING_OPACITY_MICROMAP_ARRAY_POSTBUILD_INFO_PARAMS_VER1
 
//
// FUNCTION NAME: NvAPI_D3D12_EmitRaytracingOpacityMicromapArrayPostbuildInfo
//
NVAPI_INTERFACE NvAPI_D3D12_EmitRaytracingOpacityMicromapArrayPostbuildInfo(
    __in ID3D12GraphicsCommandList4* pCommandList,
    __in const NVAPI_EMIT_RAYTRACING_OPACITY_MICROMAP_ARRAY_POSTBUILD_INFO_PARAMS* pParams);
 
#endif // defined(__cplusplus) && defined(__d3d12_h__) && defined(__ID3D12GraphicsCommandList4_INTERFACE_DEFINED__)
 
#if defined(__cplusplus) && defined(__d3d12_h__) && defined(__ID3D12GraphicsCommandList4_INTERFACE_DEFINED__)
 
typedef struct _NVAPI_D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_DESC_EX
{
    D3D12_GPU_VIRTUAL_ADDRESS                                     destAccelerationStructureData;    
    NVAPI_D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_INPUTS_EX inputs;                           
    D3D12_GPU_VIRTUAL_ADDRESS                                     sourceAccelerationStructureData;  
    D3D12_GPU_VIRTUAL_ADDRESS                                     scratchAccelerationStructureData; 
} NVAPI_D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_DESC_EX;
 
typedef struct _NVAPI_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_EX_PARAMS_V1
{
    NvU32                                                              version;               
    const NVAPI_D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_DESC_EX* pDesc;                 
    NvU32                                                              numPostbuildInfoDescs; 
    const D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_DESC* pPostbuildInfoDescs;   
} NVAPI_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_EX_PARAMS_V1;
#define NVAPI_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_EX_PARAMS_VER1          MAKE_NVAPI_VERSION(NVAPI_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_EX_PARAMS_V1, 1)
typedef NVAPI_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_EX_PARAMS_V1            NVAPI_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_EX_PARAMS;
#define NVAPI_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_EX_PARAMS_VER           NVAPI_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_EX_PARAMS_VER1
 
//
// FUNCTION NAME: NvAPI_D3D12_BuildRaytracingAccelerationStructureEx
//
NVAPI_INTERFACE NvAPI_D3D12_BuildRaytracingAccelerationStructureEx(
    __in ID3D12GraphicsCommandList4* pCommandList,
    __in const NVAPI_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_EX_PARAMS* pParams);
 
#endif // defined(__cplusplus) && defined(__d3d12_h__) && defined(__ID3D12GraphicsCommandList4_INTERFACE_DEFINED__)
 
#if defined(__cplusplus) && defined(__d3d12_h__) && defined(__ID3D12GraphicsCommandList4_INTERFACE_DEFINED__)
 
// 
// Miscellaneous
//
 
typedef enum _NVAPI_D3D12_RAYTRACING_OPACITY_MICROMAP_STATE
{
    NVAPI_D3D12_RAYTRACING_OPACITY_MICROMAP_STATE_TRANSPARENT         = 0, 
    NVAPI_D3D12_RAYTRACING_OPACITY_MICROMAP_STATE_OPAQUE              = 1, 
    NVAPI_D3D12_RAYTRACING_OPACITY_MICROMAP_STATE_UNKNOWN_TRANSPARENT = 2, 
    NVAPI_D3D12_RAYTRACING_OPACITY_MICROMAP_STATE_UNKNOWN_OPAQUE      = 3  
} NVAPI_D3D12_RAYTRACING_OPACITY_MICROMAP_STATE;
 
#define NVAPI_D3D12_RAYTRACING_OPACITY_MICROMAP_ARRAY_BYTE_ALIGNMENT 256
 
#define NVAPI_D3D12_RAYTRACING_OPACITY_MICROMAP_OC1_MAX_SUBDIVISION_LEVEL 12
 
typedef enum _NVAPI_RAY_FLAGS_EX
{
    // RAY_FLAGS flags
    NVAPI_RAY_FLAG_NONE_EX                            = 0x0,        
    NVAPI_RAY_FLAG_FORCE_OPAQUE_EX                    = NV_BIT( 0), 
    NVAPI_RAY_FLAG_FORCE_NON_OPAQUE_EX                = NV_BIT( 1), 
    NVAPI_RAY_FLAG_ACCEPT_FIRST_HIT_AND_END_SEARCH_EX = NV_BIT( 2), 
    NVAPI_RAY_FLAG_SKIP_CLOSEST_HIT_SHADER_EX         = NV_BIT( 3), 
    NVAPI_RAY_FLAG_CULL_BACK_FACING_TRIANGLES_EX      = NV_BIT( 4), 
    NVAPI_RAY_FLAG_CULL_FRONT_FACING_TRIANGLES_EX     = NV_BIT( 5), 
    NVAPI_RAY_FLAG_CULL_OPAQUE_EX                     = NV_BIT( 6), 
    NVAPI_RAY_FLAG_CULL_NON_OPAQUE_EX                 = NV_BIT( 7), 
    NVAPI_RAY_FLAG_SKIP_TRIANGLES_EX                  = NV_BIT( 8), 
    NVAPI_RAY_FLAG_SKIP_PROCEDURAL_PRIMITIVES_EX      = NV_BIT( 9), 
 
    // NVAPI_RAY_FLAGS_EX specific flags
    NVAPI_RAY_FLAG_FORCE_OMM_2_STATE_EX               = NV_BIT(10), 
} NVAPI_RAY_FLAG_EX;
 
#define NVAPI_D3D12_RAYTRACING_DISPLACEMENT_MICROMAP_ARRAY_BYTE_ALIGNMENT 256
 
#define NVAPI_D3D12_RAYTRACING_DISPLACEMENT_MICROMAP_DC1_MAX_SUBDIVISION_LEVEL 5
 
#endif // defined(__cplusplus) && defined(__d3d12_h__) && defined(__ID3D12GraphicsCommandList4_INTERFACE_DEFINED__)
 
 
typedef enum _NV_D3D12_WORKSTATION_FEATURE_TYPE
{
    NV_D3D12_WORKSTATION_FEATURE_TYPE_PRESENT_BARRIER = 1,       // PresentBarrier feature
    NV_D3D12_WORKSTATION_FEATURE_TYPE_RDMA_BAR1_SUPPORT = 2,     // RDMA heap supported via Bar1 carveout
} NV_D3D12_WORKSTATION_FEATURE_TYPE;
 
// parameter structure for NV_D3D12_WORKSTATION_FEATURE_TYPE_RDMA_BAR1_AVAILABLE related information
typedef struct _NV_D3D12_WORKSTATION_FEATURE_RDMA_PROPERTIES
{
    NvU64 rdmaHeapSize;     // maximum available Bar1 heap size for RDMA allocations
} NV_D3D12_WORKSTATION_FEATURE_RDMA_PROPERTIES;
 
// parameter structure for querying workstation feature information
typedef struct _NV_D3D12_WORKSTATION_FEATURE_PROPERTIES
{
    NvU32 version;                                              
    NV_D3D12_WORKSTATION_FEATURE_TYPE   workstationFeatureType; 
    NvBool                              supported;              
    union
    {
        NV_D3D12_WORKSTATION_FEATURE_RDMA_PROPERTIES  rdmaInfo;       
    };
} NVAPI_D3D12_WORKSTATION_FEATURE_PROPERTIES_PARAMS_V1;
 
#define NVAPI_D3D12_WORKSTATION_FEATURE_PROPERTIES_PARAMS_VER1 MAKE_NVAPI_VERSION(NVAPI_D3D12_WORKSTATION_FEATURE_PROPERTIES_PARAMS_V1,1)
#define NVAPI_D3D12_WORKSTATION_FEATURE_PROPERTIES_PARAMS_VER  NVAPI_D3D12_WORKSTATION_FEATURE_PROPERTIES_PARAMS_VER1
#define NVAPI_D3D12_WORKSTATION_FEATURE_PROPERTIES_PARAMS      NVAPI_D3D12_WORKSTATION_FEATURE_PROPERTIES_PARAMS_V1
 
 
#if defined(__cplusplus) && defined(__d3d12_h__)
//
// FUNCTION NAME: NvAPI_D3D12_QueryWorkstationFeatureProperties
//
NVAPI_INTERFACE NvAPI_D3D12_QueryWorkstationFeatureProperties(__in ID3D12Device *pDevice, __inout NVAPI_D3D12_WORKSTATION_FEATURE_PROPERTIES_PARAMS *pWorkstationFeatureProperties);
#endif // defined(__cplusplus) && defined(__d3d12_h__)
 
 
#if defined (__cplusplus) && defined(__d3d12_h__)
 
//
// FUNCTION NAME: NvAPI_D3D12_CreateCommittedRDMABuffer
//
//
 
NVAPI_INTERFACE NvAPI_D3D12_CreateCommittedRDMABuffer(
        __in  ID3D12Device* pDevice,
        __in  NvU64 size,
        __in  NvU32 heapCreationNodeMask,
        __in  NvU32 heapVisibleNodeMask,
        __in  REFIID riidResource,
        __out void **ppvResource,
        __out void **ppRDMAAddress);
 
#endif //defined(__cplusplus) && defined(__d3d12_h__)
 
#if defined(__cplusplus) && defined(__d3d12_h__)
 
//
// NVAPI DIRECT TYPE NAME: INvAPI_DirectD3D12GraphicsCommandList
//
class INvAPI_DirectD3D12GraphicsCommandList
{
public:
    virtual bool IsValid() const = 0;
    virtual ID3D12GraphicsCommandList* GetID3D12GraphicsCommandList() const = 0;
 
    void DispatchGraphics(NvU32 numDispatches);
    void SetMarker(void* pMarkerData, NvU32 markerSize);
};
 
//
// NVAPI DIRECT FUNCTION NAME: NvAPI_DirectD3D12GraphicsCommandList_Create
//
NVAPI_INTERFACE NvAPI_DirectD3D12GraphicsCommandList_Create(__in  ID3D12GraphicsCommandList              *pDXD3D12GraphicsCommandList, 
                                                            __out INvAPI_DirectD3D12GraphicsCommandList **ppReturnD3D12GraphicsCommandList);
 
//
// NVAPI DIRECT FUNCTION NAME: NvAPI_DirectD3D12GraphicsCommandList_Release
//
NVAPI_INTERFACE NvAPI_DirectD3D12GraphicsCommandList_Release(__in INvAPI_DirectD3D12GraphicsCommandList *pD3D12GraphicsCommandList);
 
 
//
// NVAPI DIRECT FUNCTION NAME: NvAPI_DirectD3D12GraphicsCommandList_Reset
//
NVAPI_INTERFACE NvAPI_DirectD3D12GraphicsCommandList_Reset(__in INvAPI_DirectD3D12GraphicsCommandList *pD3D12GraphicsCommandList);
#endif
 
 
 
// Video Input Output (VIO) API
 
 
 
typedef NvU32   NVVIOOWNERID;                               
 
 
 
 
#define NVVIOOWNERID_NONE                   0      
 
 
typedef enum _NVVIOOWNERTYPE                               
{
    NVVIOOWNERTYPE_NONE                             ,       
    NVVIOOWNERTYPE_APPLICATION                      ,       
    NVVIOOWNERTYPE_DESKTOP                          ,       
}NVVIOOWNERTYPE;
 
// Access rights for NvAPI_VIO_Open()
 
#define NVVIO_O_READ                        0x00000000      
 
#define NVVIO_O_WRITE_EXCLUSIVE             0x00010001      
 
#define NVVIO_VALID_ACCESSRIGHTS            (NVVIO_O_READ              | \
                                             NVVIO_O_WRITE_EXCLUSIVE   )
 
              
#define NVVIO_OWNERID_INITIALIZED  0x80000000
 
#define NVVIO_OWNERID_EXCLUSIVE    0x40000000
                                              
#define NVVIO_OWNERID_TYPEMASK     0x0FFFFFFF 
 
 
              
//---------------------------------------------------------------------
// Enumerations
//---------------------------------------------------------------------
 
 
 
typedef enum _NVVIOSIGNALFORMAT
{
    NVVIOSIGNALFORMAT_NONE,                
    NVVIOSIGNALFORMAT_487I_59_94_SMPTE259_NTSC,     
    NVVIOSIGNALFORMAT_576I_50_00_SMPTE259_PAL,      
    NVVIOSIGNALFORMAT_1035I_60_00_SMPTE260,         
    NVVIOSIGNALFORMAT_1035I_59_94_SMPTE260,         
    NVVIOSIGNALFORMAT_1080I_50_00_SMPTE295,         
    NVVIOSIGNALFORMAT_1080I_60_00_SMPTE274,         
    NVVIOSIGNALFORMAT_1080I_59_94_SMPTE274,         
    NVVIOSIGNALFORMAT_1080I_50_00_SMPTE274,         
    NVVIOSIGNALFORMAT_1080P_30_00_SMPTE274,         
    NVVIOSIGNALFORMAT_1080P_29_97_SMPTE274,         
    NVVIOSIGNALFORMAT_1080P_25_00_SMPTE274,         
    NVVIOSIGNALFORMAT_1080P_24_00_SMPTE274,         
    NVVIOSIGNALFORMAT_1080P_23_976_SMPTE274,        
    NVVIOSIGNALFORMAT_720P_60_00_SMPTE296,          
    NVVIOSIGNALFORMAT_720P_59_94_SMPTE296,          
    NVVIOSIGNALFORMAT_720P_50_00_SMPTE296,          
    NVVIOSIGNALFORMAT_1080I_48_00_SMPTE274,         
    NVVIOSIGNALFORMAT_1080I_47_96_SMPTE274,         
    NVVIOSIGNALFORMAT_720P_30_00_SMPTE296,          
    NVVIOSIGNALFORMAT_720P_29_97_SMPTE296,          
    NVVIOSIGNALFORMAT_720P_25_00_SMPTE296,          
    NVVIOSIGNALFORMAT_720P_24_00_SMPTE296,          
    NVVIOSIGNALFORMAT_720P_23_98_SMPTE296,          
    NVVIOSIGNALFORMAT_2048P_30_00_SMPTE372,         
    NVVIOSIGNALFORMAT_2048P_29_97_SMPTE372,         
    NVVIOSIGNALFORMAT_2048I_60_00_SMPTE372,         
    NVVIOSIGNALFORMAT_2048I_59_94_SMPTE372,         
    NVVIOSIGNALFORMAT_2048P_25_00_SMPTE372,         
    NVVIOSIGNALFORMAT_2048I_50_00_SMPTE372,         
    NVVIOSIGNALFORMAT_2048P_24_00_SMPTE372,         
    NVVIOSIGNALFORMAT_2048P_23_98_SMPTE372,         
    NVVIOSIGNALFORMAT_2048I_48_00_SMPTE372,         
    NVVIOSIGNALFORMAT_2048I_47_96_SMPTE372,         
    
    NVVIOSIGNALFORMAT_1080PSF_25_00_SMPTE274,       
    NVVIOSIGNALFORMAT_1080PSF_29_97_SMPTE274,       
    NVVIOSIGNALFORMAT_1080PSF_30_00_SMPTE274,       
    NVVIOSIGNALFORMAT_1080PSF_24_00_SMPTE274,       
    NVVIOSIGNALFORMAT_1080PSF_23_98_SMPTE274,       
 
    NVVIOSIGNALFORMAT_1080P_50_00_SMPTE274_3G_LEVEL_A, 
    NVVIOSIGNALFORMAT_1080P_59_94_SMPTE274_3G_LEVEL_A, 
    NVVIOSIGNALFORMAT_1080P_60_00_SMPTE274_3G_LEVEL_A, 
    
    NVVIOSIGNALFORMAT_1080P_60_00_SMPTE274_3G_LEVEL_B, 
    NVVIOSIGNALFORMAT_1080I_60_00_SMPTE274_3G_LEVEL_B, 
    NVVIOSIGNALFORMAT_2048I_60_00_SMPTE372_3G_LEVEL_B, 
    NVVIOSIGNALFORMAT_1080P_50_00_SMPTE274_3G_LEVEL_B, 
    NVVIOSIGNALFORMAT_1080I_50_00_SMPTE274_3G_LEVEL_B, 
    NVVIOSIGNALFORMAT_2048I_50_00_SMPTE372_3G_LEVEL_B, 
    NVVIOSIGNALFORMAT_1080P_30_00_SMPTE274_3G_LEVEL_B, 
    NVVIOSIGNALFORMAT_2048P_30_00_SMPTE372_3G_LEVEL_B, 
    NVVIOSIGNALFORMAT_1080P_25_00_SMPTE274_3G_LEVEL_B, 
    NVVIOSIGNALFORMAT_2048P_25_00_SMPTE372_3G_LEVEL_B, 
    NVVIOSIGNALFORMAT_1080P_24_00_SMPTE274_3G_LEVEL_B, 
    NVVIOSIGNALFORMAT_2048P_24_00_SMPTE372_3G_LEVEL_B, 
    NVVIOSIGNALFORMAT_1080I_48_00_SMPTE274_3G_LEVEL_B, 
    NVVIOSIGNALFORMAT_2048I_48_00_SMPTE372_3G_LEVEL_B, 
    NVVIOSIGNALFORMAT_1080P_59_94_SMPTE274_3G_LEVEL_B, 
    NVVIOSIGNALFORMAT_1080I_59_94_SMPTE274_3G_LEVEL_B, 
    NVVIOSIGNALFORMAT_2048I_59_94_SMPTE372_3G_LEVEL_B, 
    NVVIOSIGNALFORMAT_1080P_29_97_SMPTE274_3G_LEVEL_B, 
    NVVIOSIGNALFORMAT_2048P_29_97_SMPTE372_3G_LEVEL_B, 
    NVVIOSIGNALFORMAT_1080P_23_98_SMPTE274_3G_LEVEL_B, 
    NVVIOSIGNALFORMAT_2048P_23_98_SMPTE372_3G_LEVEL_B, 
    NVVIOSIGNALFORMAT_1080I_47_96_SMPTE274_3G_LEVEL_B, 
    NVVIOSIGNALFORMAT_2048I_47_96_SMPTE372_3G_LEVEL_B, 
    
    NVVIOSIGNALFORMAT_END                              
 
}NVVIOSIGNALFORMAT;
 
typedef enum _NVVIOVIDEOSTANDARD
{
    NVVIOVIDEOSTANDARD_SMPTE259                        ,       
    NVVIOVIDEOSTANDARD_SMPTE260                        ,       
    NVVIOVIDEOSTANDARD_SMPTE274                        ,       
    NVVIOVIDEOSTANDARD_SMPTE295                        ,       
    NVVIOVIDEOSTANDARD_SMPTE296                        ,       
    NVVIOVIDEOSTANDARD_SMPTE372                        ,       
}NVVIOVIDEOSTANDARD;
 
typedef enum _NVVIOVIDEOTYPE
{
    NVVIOVIDEOTYPE_SD                                  ,       
    NVVIOVIDEOTYPE_HD                                  ,       
}NVVIOVIDEOTYPE;
 
typedef enum _NVVIOINTERLACEMODE 
{
    NVVIOINTERLACEMODE_PROGRESSIVE                     ,       
    NVVIOINTERLACEMODE_INTERLACE                       ,       
    NVVIOINTERLACEMODE_PSF                             ,       
}NVVIOINTERLACEMODE;
 
typedef enum _NVVIODATAFORMAT
{
    NVVIODATAFORMAT_UNKNOWN   = -1                     ,       
    NVVIODATAFORMAT_R8G8B8_TO_YCRCB444                 ,       
    NVVIODATAFORMAT_R8G8B8A8_TO_YCRCBA4444             ,       
    NVVIODATAFORMAT_R8G8B8Z10_TO_YCRCBZ4444            ,       
    NVVIODATAFORMAT_R8G8B8_TO_YCRCB422                 ,       
    NVVIODATAFORMAT_R8G8B8A8_TO_YCRCBA4224             ,       
    NVVIODATAFORMAT_R8G8B8Z10_TO_YCRCBZ4224            ,       
    NVVIODATAFORMAT_X8X8X8_444_PASSTHRU                ,       
    NVVIODATAFORMAT_X8X8X8A8_4444_PASSTHRU             ,       
    NVVIODATAFORMAT_X8X8X8Z10_4444_PASSTHRU            ,       
    NVVIODATAFORMAT_X10X10X10_444_PASSTHRU             ,       
    NVVIODATAFORMAT_X10X8X8_444_PASSTHRU               ,       
    NVVIODATAFORMAT_X10X8X8A10_4444_PASSTHRU           ,       
    NVVIODATAFORMAT_X10X8X8Z10_4444_PASSTHRU           ,       
    NVVIODATAFORMAT_DUAL_R8G8B8_TO_DUAL_YCRCB422       ,       
    NVVIODATAFORMAT_DUAL_X8X8X8_TO_DUAL_422_PASSTHRU   ,       
    NVVIODATAFORMAT_R10G10B10_TO_YCRCB422              ,       
    NVVIODATAFORMAT_R10G10B10_TO_YCRCB444              ,       
    NVVIODATAFORMAT_X12X12X12_444_PASSTHRU             ,       
    NVVIODATAFORMAT_X12X12X12_422_PASSTHRU             ,       
    NVVIODATAFORMAT_Y10CR10CB10_TO_YCRCB422            ,       
    NVVIODATAFORMAT_Y8CR8CB8_TO_YCRCB422               ,       
    NVVIODATAFORMAT_Y10CR8CB8A10_TO_YCRCBA4224         ,       
    NVVIODATAFORMAT_R10G10B10_TO_RGB444                ,       
    NVVIODATAFORMAT_R12G12B12_TO_YCRCB444              ,       
    NVVIODATAFORMAT_R12G12B12_TO_YCRCB422              ,       
}NVVIODATAFORMAT;
 
typedef enum _NVVIOOUTPUTAREA
{
    NVVIOOUTPUTAREA_FULLSIZE                           ,       
    NVVIOOUTPUTAREA_SAFEACTION                         ,       
    NVVIOOUTPUTAREA_SAFETITLE                          ,       
}NVVIOOUTPUTAREA;
 
typedef enum _NVVIOSYNCSOURCE
{
    NVVIOSYNCSOURCE_SDISYNC                            ,       
    NVVIOSYNCSOURCE_COMPSYNC                           ,       
}NVVIOSYNCSOURCE;
 
typedef enum _NVVIOCOMPSYNCTYPE
{
    NVVIOCOMPSYNCTYPE_AUTO                             ,       
    NVVIOCOMPSYNCTYPE_BILEVEL                          ,       
    NVVIOCOMPSYNCTYPE_TRILEVEL                         ,       
}NVVIOCOMPSYNCTYPE;
 
typedef enum _NVVIOINPUTOUTPUTSTATUS
{
    NVINPUTOUTPUTSTATUS_OFF                            ,       
    NVINPUTOUTPUTSTATUS_ERROR                          ,       
    NVINPUTOUTPUTSTATUS_SDI_SD                         ,       
    NVINPUTOUTPUTSTATUS_SDI_HD                         ,       
}NVVIOINPUTOUTPUTSTATUS;
 
typedef enum _NVVIOSYNCSTATUS
{
    NVVIOSYNCSTATUS_OFF                                ,       
    NVVIOSYNCSTATUS_ERROR                              ,       
    NVVIOSYNCSTATUS_SYNCLOSS                           ,       
    NVVIOSYNCSTATUS_COMPOSITE                          ,       
    NVVIOSYNCSTATUS_SDI_SD                             ,       
    NVVIOSYNCSTATUS_SDI_HD                             ,       
}NVVIOSYNCSTATUS;
 
typedef enum _NVVIOCAPTURESTATUS
{
    NVVIOSTATUS_STOPPED                                ,       
    NVVIOSTATUS_RUNNING                                ,       
    NVVIOSTATUS_ERROR                                  ,       
}NVVIOCAPTURESTATUS;
 
typedef enum _NVVIOSTATUSTYPE
{
    NVVIOSTATUSTYPE_IN                                 ,       
    NVVIOSTATUSTYPE_OUT                                ,       
}NVVIOSTATUSTYPE;
 
 
#define NVAPI_MAX_VIO_DEVICES                 8   
 
#define NVAPI_MAX_VIO_JACKS                   4   
 
 
#define NVAPI_MAX_VIO_CHANNELS_PER_JACK       2   
 
#define NVAPI_MAX_VIO_STREAMS                 4   
 
#define NVAPI_MIN_VIO_STREAMS                 1   
 
#define NVAPI_MAX_VIO_LINKS_PER_STREAM        2   
 
 
#define NVAPI_MAX_FRAMELOCK_MAPPING_MODES     20
 
#define NVAPI_GVI_MIN_RAW_CAPTURE_IMAGES      1   
 
#define NVAPI_GVI_MAX_RAW_CAPTURE_IMAGES      32  
 
#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.
 
typedef enum _NVVIOCONFIGTYPE
{
    NVVIOCONFIGTYPE_IN                                 ,       
    NVVIOCONFIGTYPE_OUT                                ,       
}NVVIOCONFIGTYPE;
 
typedef enum _NVVIOCOLORSPACE
{
    NVVIOCOLORSPACE_UNKNOWN,
    NVVIOCOLORSPACE_YCBCR,
    NVVIOCOLORSPACE_YCBCRA,
    NVVIOCOLORSPACE_YCBCRD,
    NVVIOCOLORSPACE_GBR,
    NVVIOCOLORSPACE_GBRA,
    NVVIOCOLORSPACE_GBRD,
} NVVIOCOLORSPACE;
 
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
//---------------------------------------------------------------------
 
 
 
#define NVVIOCAPS_VIDOUT_SDI                0x00000001      
 
#define NVVIOCAPS_SYNC_INTERNAL             0x00000100      
 
#define NVVIOCAPS_SYNC_GENLOCK              0x00000200      
 
#define NVVIOCAPS_SYNCSRC_SDI               0x00001000      
 
#define NVVIOCAPS_SYNCSRC_COMP              0x00002000      
 
#define NVVIOCAPS_OUTPUTMODE_DESKTOP        0x00010000      
 
#define NVVIOCAPS_OUTPUTMODE_OPENGL         0x00020000      
 
#define NVVIOCAPS_VIDIN_SDI                 0x00100000  
 
#define NVVIOCAPS_PACKED_ANC_SUPPORTED      0x00200000     
 
#define NVVIOCAPS_AUDIO_BLANKING_SUPPORTED  0x00400000  
 
#define NVVIOCLASS_SDI                      0x00000001      
 
typedef struct _NVVIOCAPS
{
    NvU32             version;                              
    NvAPI_String      adapterName;                          
    NvU32             adapterClass;                         
    NvU32             adapterCaps;                          
    NvU32             dipSwitch;                            
    NvU32             dipSwitchReserved;                    
    NvU32             boardID;                              
    struct                                                  //
    {                                                      
        NvU32          majorVersion;                        
        NvU32          minorVersion;                        
    } driver;                                               //
    struct                                                  
    {                                                       
        NvU32          majorVersion;                        
        NvU32          minorVersion;                        
    } firmWare;                                             //
    NVVIOOWNERID      ownerId;                              
    NVVIOOWNERTYPE    ownerType;                            
} NVVIOCAPS;
 
#define NVVIOCAPS_VER1  MAKE_NVAPI_VERSION(NVVIOCAPS,1)
#define NVVIOCAPS_VER2  MAKE_NVAPI_VERSION(NVVIOCAPS,2)
#define NVVIOCAPS_VER   NVVIOCAPS_VER2
 
typedef struct _NVVIOCHANNELSTATUS
{
    NvU32                  smpte352;                         
    NVVIOSIGNALFORMAT      signalFormat;                     
    NVVIOBITSPERCOMPONENT  bitsPerComponent;                 
    NVVIOCOMPONENTSAMPLING samplingFormat;                   
    NVVIOCOLORSPACE        colorSpace;                       
    NVVIOLINKID            linkID;                           
} NVVIOCHANNELSTATUS;
 
typedef struct _NVVIOINPUTSTATUS
{
    NVVIOCHANNELSTATUS     vidIn[NVAPI_MAX_VIO_JACKS][NVAPI_MAX_VIO_CHANNELS_PER_JACK];     
    NVVIOCAPTURESTATUS     captureStatus;                  
} NVVIOINPUTSTATUS;
 
typedef struct _NVVIOOUTPUTSTATUS
{
    NVVIOINPUTOUTPUTSTATUS    vid1Out;                        
    NVVIOINPUTOUTPUTSTATUS    vid2Out;                        
    NVVIOSYNCSTATUS        sdiSyncIn;                      
    NVVIOSYNCSTATUS        compSyncIn;                     
    NvU32            syncEnable;                     
    NVVIOSYNCSOURCE        syncSource;                     
    NVVIOSIGNALFORMAT        syncFormat;                     
    NvU32            frameLockEnable;                
    NvU32            outputVideoLocked;              
    NvU32            dataIntegrityCheckErrorCount;   
    NvU32            dataIntegrityCheckEnabled;      
    NvU32            dataIntegrityCheckFailed;       
    NvU32                       uSyncSourceLocked;              
    NvU32                       uPowerOn;                       
} NVVIOOUTPUTSTATUS;
 
typedef struct _NVVIOSTATUS
{
    NvU32                 version;                        
    NVVIOSTATUSTYPE       nvvioStatusType;                
    union                                                   
    {
        NVVIOINPUTSTATUS  inStatus;                       
        NVVIOOUTPUTSTATUS outStatus;                      
    }vioStatus;      
} NVVIOSTATUS;
 
#define NVVIOSTATUS_VER   MAKE_NVAPI_VERSION(NVVIOSTATUS,1)
 
typedef struct _NVVIOOUTPUTREGION
{
    NvU32              x;                                    
    NvU32              y;                                    
    NvU32              width;                                
    NvU32              height;                               
} NVVIOOUTPUTREGION;
 
typedef struct _NVVIOGAMMARAMP8
{
    NvU16              uRed[256];                            
    NvU16              uGreen[256];                          
    NvU16              uBlue[256];                           
} NVVIOGAMMARAMP8;
 
typedef struct _NVVIOGAMMARAMP10
{
    NvU16              uRed[1024];                           
    NvU16              uGreen[1024];                         
    NvU16              uBlue[1024];                          
} NVVIOGAMMARAMP10;
 
 
typedef struct _NVVIOSYNCDELAY
{
    NvU32              version;                              
    NvU32              horizontalDelay;                      
    NvU32              verticalDelay;                        
} NVVIOSYNCDELAY;
 
#define NVVIOSYNCDELAY_VER   MAKE_NVAPI_VERSION(NVVIOSYNCDELAY,1)
 
 
typedef struct _NVVIOVIDEOMODE
{
    NvU32                horizontalPixels;                   
    NvU32                verticalLines;                      
    float                fFrameRate;                         
    NVVIOINTERLACEMODE   interlaceMode;                      
    NVVIOVIDEOSTANDARD   videoStandard;                      
    NVVIOVIDEOTYPE       videoType;                          
} NVVIOVIDEOMODE;
 
typedef struct _NVVIOSIGNALFORMATDETAIL
{   
    NVVIOSIGNALFORMAT    signalFormat;                       
    NVVIOVIDEOMODE       videoMode;                          
}NVVIOSIGNALFORMATDETAIL;
 
 
#define NVVIOBUFFERFORMAT_R8G8B8                  0x00000001
 
#define NVVIOBUFFERFORMAT_R8G8B8Z24               0x00000002
   
#define NVVIOBUFFERFORMAT_R8G8B8A8                0x00000004   
 
#define NVVIOBUFFERFORMAT_R8G8B8A8Z24             0x00000008   
 
#define NVVIOBUFFERFORMAT_R16FPG16FPB16FP         0x00000010   
 
#define NVVIOBUFFERFORMAT_R16FPG16FPB16FPZ24      0x00000020   
 
#define NVVIOBUFFERFORMAT_R16FPG16FPB16FPA16FP    0x00000040   
 
#define NVVIOBUFFERFORMAT_R16FPG16FPB16FPA16FPZ24 0x00000080   
 
 
 
typedef struct _NVVIODATAFORMATDETAIL
{
    NVVIODATAFORMAT   dataFormat;                              
    NvU32             vioCaps;                                 
}NVVIODATAFORMATDETAIL;
 
typedef struct _NVVIOCOLORCONVERSION
{
    NvU32       version;                                    
    float       colorMatrix[3][3];                          
    float       colorOffset[3];                             
    float       colorScale[3];                              
    NvU32      compositeSafe;                               
} NVVIOCOLORCONVERSION;
 
#define NVVIOCOLORCONVERSION_VER   MAKE_NVAPI_VERSION(NVVIOCOLORCONVERSION,1)
 
typedef struct _NVVIOGAMMACORRECTION
{
    NvU32            version;                               
    NvU32            vioGammaCorrectionType;                
    union                                                   
    {                                                       
        NVVIOGAMMARAMP8  gammaRamp8;                        
        NVVIOGAMMARAMP10 gammaRamp10;                       
    }gammaRamp;                                      
    float            fGammaValueR;            
    float            fGammaValueG;            
    float            fGammaValueB;            
} NVVIOGAMMACORRECTION;
 
#define NVVIOGAMMACORRECTION_VER   MAKE_NVAPI_VERSION(NVVIOGAMMACORRECTION,1)
 
#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      
#define NVVIOCONFIG_DATAFORMAT              0x00000002      
#define NVVIOCONFIG_OUTPUTREGION            0x00000004      
#define NVVIOCONFIG_OUTPUTAREA              0x00000008      
#define NVVIOCONFIG_COLORCONVERSION         0x00000010      
#define NVVIOCONFIG_GAMMACORRECTION         0x00000020      
#define NVVIOCONFIG_SYNCSOURCEENABLE        0x00000040      
#define NVVIOCONFIG_SYNCDELAY               0x00000080      
#define NVVIOCONFIG_COMPOSITESYNCTYPE       0x00000100      
#define NVVIOCONFIG_FRAMELOCKENABLE         0x00000200      
#define NVVIOCONFIG_422FILTER               0x00000400      
#define NVVIOCONFIG_COMPOSITETERMINATE      0x00000800      
#define NVVIOCONFIG_DATAINTEGRITYCHECK      0x00001000      
#define NVVIOCONFIG_CSCOVERRIDE             0x00002000      
#define NVVIOCONFIG_FLIPQUEUELENGTH         0x00004000      
#define NVVIOCONFIG_ANCTIMECODEGENERATION   0x00008000      
#define NVVIOCONFIG_COMPOSITE               0x00010000      
#define NVVIOCONFIG_ALPHAKEYCOMPOSITE       0x00020000      
#define NVVIOCONFIG_COMPOSITE_Y             0x00040000      
#define NVVIOCONFIG_COMPOSITE_CR            0x00080000      
#define NVVIOCONFIG_COMPOSITE_CB            0x00100000      
#define NVVIOCONFIG_FULL_COLOR_RANGE        0x00200000      
#define NVVIOCONFIG_RGB_DATA                0x00400000      
#define NVVIOCONFIG_RESERVED_SDIOUTPUTENABLE         0x00800000      
#define NVVIOCONFIG_STREAMS                 0x01000000      
#define NVVIOCONFIG_ANC_PARITY_COMPUTATION  0x02000000      
#define NVVIOCONFIG_ANC_AUDIO_REPEAT        0x04000000      
 
 
// 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 | \
                                  NVVIOCONFIG_ANC_AUDIO_REPEAT )
 
#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 | \
                                   NVVIOCONFIG_ANC_AUDIO_REPEAT)
 
#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    | \
                                        NVVIOCONFIG_ANC_AUDIO_REPEAT)                                            
                                             
 
// No members can be deleted from below structure. Only add new members at the 
// end of the structure.
typedef struct _NVVIOOUTPUTCONFIG_V1
{
    NVVIOSIGNALFORMAT    signalFormat;                         
    NVVIODATAFORMAT      dataFormat;                           
    NVVIOOUTPUTREGION    outputRegion;                         
    NVVIOOUTPUTAREA      outputArea;                           
    NVVIOCOLORCONVERSION colorConversion;                      
    NVVIOGAMMACORRECTION gammaCorrection;
    NvU32                syncEnable;                           
    NVVIOSYNCSOURCE      syncSource;                           
    NVVIOSYNCDELAY       syncDelay;                            
    NVVIOCOMPSYNCTYPE    compositeSyncType;                    
    NvU32                frameLockEnable;                      
    NvU32                psfSignalFormat;                      
    NvU32                enable422Filter;                      
    NvU32                compositeTerminate;                   
    NvU32                enableDataIntegrityCheck;             
    NvU32                cscOverride;                          
    NvU32                flipQueueLength;                      
    NvU32                enableANCTimeCodeGeneration;          
    NvU32                enableComposite;                      
    NvU32                enableAlphaKeyComposite;              
    NVVIOCOMPOSITERANGE  compRange;                            
    NvU8                 reservedData[256];                    
    NvU32                enableFullColorRange;                 
    NvU32                enableRGBData;                        
} NVVIOOUTPUTCONFIG_V1;
 
typedef struct _NVVIOOUTPUTCONFIG_V2
{
    NVVIOSIGNALFORMAT    signalFormat;                         
    NVVIODATAFORMAT      dataFormat;                           
    NVVIOOUTPUTREGION    outputRegion;                         
    NVVIOOUTPUTAREA      outputArea;                           
    NVVIOCOLORCONVERSION colorConversion;                      
    NVVIOGAMMACORRECTION gammaCorrection;
    NvU32                syncEnable;                           
    NVVIOSYNCSOURCE      syncSource;                           
    NVVIOSYNCDELAY       syncDelay;                            
    NVVIOCOMPSYNCTYPE    compositeSyncType;                    
    NvU32                frameLockEnable;                      
    NvU32                psfSignalFormat;                      
    NvU32                enable422Filter;                      
    NvU32                compositeTerminate;                   
    NvU32                enableDataIntegrityCheck;             
    NvU32                cscOverride;                          
    NvU32                flipQueueLength;                      
    NvU32                enableANCTimeCodeGeneration;          
    NvU32                enableComposite;                      
    NvU32                enableAlphaKeyComposite;              
    NVVIOCOMPOSITERANGE  compRange;                            
    NvU8                 reservedData[256];                    
    NvU32                enableFullColorRange;                 
    NvU32                enableRGBData;                        
    NVVIOANCPARITYCOMPUTATION ancParityComputation;            
} NVVIOOUTPUTCONFIG_V2;
 
typedef struct _NVVIOOUTPUTCONFIG_V3
{
    NVVIOSIGNALFORMAT    signalFormat;                         
    NVVIODATAFORMAT      dataFormat;                           
    NVVIOOUTPUTREGION    outputRegion;                         
    NVVIOOUTPUTAREA      outputArea;                           
    NVVIOCOLORCONVERSION colorConversion;                      
    NVVIOGAMMACORRECTION gammaCorrection;
    NvU32                syncEnable;                           
    NVVIOSYNCSOURCE      syncSource;                           
    NVVIOSYNCDELAY       syncDelay;                            
    NVVIOCOMPSYNCTYPE    compositeSyncType;                    
    NvU32                frameLockEnable;                      
    NvU32                psfSignalFormat;                      
    NvU32                enable422Filter;                      
    NvU32                compositeTerminate;                   
    NvU32                enableDataIntegrityCheck;             
    NvU32                cscOverride;                          
    NvU32                flipQueueLength;                      
    NvU32                enableANCTimeCodeGeneration;          
    NvU32                enableComposite;                      
    NvU32                enableAlphaKeyComposite;              
    NVVIOCOMPOSITERANGE  compRange;                            
    NvU8                 reservedData[256];                    
    NvU32                enableFullColorRange;                 
    NvU32                enableRGBData;                        
    NVVIOANCPARITYCOMPUTATION ancParityComputation;            
    NvU32                enableAudioBlanking;                  
} NVVIOOUTPUTCONFIG_V3;
 
typedef struct _NVVIOSTREAM
{
    NvU32                   bitsPerComponent;                     
    NVVIOCOMPONENTSAMPLING  sampling;                             
    NvU32                   expansionEnable;                      
    NvU32                   numLinks;                             
    struct
    {
        NvU32               jack;                                 
        NvU32               channel;                              
    } links[NVAPI_MAX_VIO_LINKS_PER_STREAM];
} NVVIOSTREAM;
 
typedef struct _NVVIOINPUTCONFIG
{
    NvU32                numRawCaptureImages;                  
    NVVIOSIGNALFORMAT    signalFormat;                         
    NvU32                numStreams;                           
    NVVIOSTREAM          streams[NVAPI_MAX_VIO_STREAMS];       
    NvU32                bTestMode;                            
} NVVIOINPUTCONFIG;
 
typedef struct _NVVIOCONFIG_V1
{
    NvU32                version;                              
    NvU32                fields;                               
    NVVIOCONFIGTYPE      nvvioConfigType;                      
    union                                                   
    {
        NVVIOINPUTCONFIG  inConfig;                            
        NVVIOOUTPUTCONFIG_V1 outConfig;                           
    }vioConfig; 
} NVVIOCONFIG_V1;
 
 
typedef struct _NVVIOCONFIG_V2
{
    NvU32                version;                              
    NvU32                fields;                               
    NVVIOCONFIGTYPE      nvvioConfigType;                      
    union
    {
        NVVIOINPUTCONFIG     inConfig;                         
        NVVIOOUTPUTCONFIG_V2 outConfig;                        
    }vioConfig;
} NVVIOCONFIG_V2;
 
typedef struct _NVVIOCONFIG_V3
{
    NvU32                version;                              
    NvU32                fields;                               
    NVVIOCONFIGTYPE      nvvioConfigType;                      
    union
    {
        NVVIOINPUTCONFIG     inConfig;                         
        NVVIOOUTPUTCONFIG_V3 outConfig;                        
    }vioConfig;
} NVVIOCONFIG_V3;
typedef NVVIOOUTPUTCONFIG_V3 NVVIOOUTPUTCONFIG;
typedef NVVIOCONFIG_V3 NVVIOCONFIG;
 
#define NVVIOCONFIG_VER1  MAKE_NVAPI_VERSION(NVVIOCONFIG_V1,1)
#define NVVIOCONFIG_VER2  MAKE_NVAPI_VERSION(NVVIOCONFIG_V2,2)
#define NVVIOCONFIG_VER3  MAKE_NVAPI_VERSION(NVVIOCONFIG_V3,3)
#define NVVIOCONFIG_VER   NVVIOCONFIG_VER3
 
 
typedef struct
{
    NvPhysicalGpuHandle                    hPhysicalGpu;                    
    NvVioHandle                         hVioHandle;                     
    NvU32                               vioId;                          
    NvU32                               outputId;            
} NVVIOTOPOLOGYTARGET;                                                    
 
typedef struct _NV_VIO_TOPOLOGY
{
    NvU32                       version;
    NvU32                       vioTotalDeviceCount;                    
    NVVIOTOPOLOGYTARGET         vioTarget[NVAPI_MAX_VIO_DEVICES];       
}NV_VIO_TOPOLOGY, NVVIOTOPOLOGY;
 
 
#define NV_VIO_TOPOLOGY_VER  MAKE_NVAPI_VERSION(NV_VIO_TOPOLOGY,1)
 
#define NVVIOTOPOLOGY_VER    MAKE_NVAPI_VERSION(NVVIOTOPOLOGY,1)
 
 
 
 
 
 
__nvapi_deprecated_function("Do not use this function - it is deprecated in release 440.")
NVAPI_INTERFACE NvAPI_VIO_GetCapabilities(NvVioHandle     hVioHandle,
                                          NVVIOCAPS       *pAdapterCaps);
 
 
__nvapi_deprecated_function("Do not use this function - it is deprecated in release 440.")
NVAPI_INTERFACE NvAPI_VIO_Open(NvVioHandle       hVioHandle,
                               NvU32             vioClass,
                               NVVIOOWNERTYPE    ownerType);
 
__nvapi_deprecated_function("Do not use this function - it is deprecated in release 440.")
NVAPI_INTERFACE NvAPI_VIO_Close(NvVioHandle       hVioHandle,
                                NvU32             bRelease);
__nvapi_deprecated_function("Do not use this function - it is deprecated in release 440.")
NVAPI_INTERFACE NvAPI_VIO_Status(NvVioHandle     hVioHandle, 
                                 NVVIOSTATUS     *pStatus);
 
__nvapi_deprecated_function("Do not use this function - it is deprecated in release 440.")
NVAPI_INTERFACE NvAPI_VIO_SyncFormatDetect(NvVioHandle hVioHandle,
                                           NvU32       *pWait);
__nvapi_deprecated_function("Do not use this function - it is deprecated in release 440.")
NVAPI_INTERFACE NvAPI_VIO_GetConfig(NvVioHandle        hVioHandle,
                                    NVVIOCONFIG        *pConfig); 
 
__nvapi_deprecated_function("Do not use this function - it is deprecated in release 440.")
NVAPI_INTERFACE NvAPI_VIO_SetConfig(NvVioHandle            hVioHandle,
                                    const NVVIOCONFIG      *pConfig);
 
__nvapi_deprecated_function("Do not use this function - it is deprecated in release 290. Instead, use NvAPI_VIO_SetConfig.")
NVAPI_INTERFACE NvAPI_VIO_SetCSC(NvVioHandle           hVioHandle,
                                 NVVIOCOLORCONVERSION  *pCSC);
__nvapi_deprecated_function("Do not use this function - it is deprecated in release 290. Instead, use NvAPI_VIO_GetConfig.")
NVAPI_INTERFACE NvAPI_VIO_GetCSC(NvVioHandle           hVioHandle,
                                 NVVIOCOLORCONVERSION  *pCSC);
__nvapi_deprecated_function("Do not use this function - it is deprecated in release 290. Instead, use NvAPI_VIO_SetConfig.")
NVAPI_INTERFACE NvAPI_VIO_SetGamma(NvVioHandle           hVioHandle,
                                   NVVIOGAMMACORRECTION  *pGamma);
 
__nvapi_deprecated_function("Do not use this function - it is deprecated in release 290. Instead, use NvAPI_VIO_GetConfig.")
NVAPI_INTERFACE NvAPI_VIO_GetGamma(NvVioHandle           hVioHandle,
                                   NVVIOGAMMACORRECTION* pGamma);
__nvapi_deprecated_function("Do not use this function - it is deprecated in release 290. Instead, use NvAPI_VIO_SetConfig.")
NVAPI_INTERFACE NvAPI_VIO_SetSyncDelay(NvVioHandle            hVioHandle,
                                       const NVVIOSYNCDELAY   *pSyncDelay);
 
__nvapi_deprecated_function("Do not use this function - it is deprecated in release 290. Instead, use NvAPI_VIO_GetConfig.")
NVAPI_INTERFACE NvAPI_VIO_GetSyncDelay(NvVioHandle      hVioHandle,
                                       NVVIOSYNCDELAY   *pSyncDelay);
 
typedef enum _NVVIOPCILINKRATE
{
    NVVIOPCILINKRATE_UNKNOWN          = 0,
    NVVIOPCILINKRATE_GEN1             = 1,                    //<! 2.5 Gbps.
    NVVIOPCILINKRATE_GEN2             = 2,                    //<! 5 Gbps.
    NVVIOPCILINKRATE_GEN3             = 3,                    //<! 8 Gbps.
}NVVIOPCILINKRATE;
 
typedef enum _NVVIOPCILINKWIDTH
{
    NVVIOPCILINKWIDTH_UNKNOWN         = 0,
    NVVIOPCILINKWIDTH_x1              = 1,
    NVVIOPCILINKWIDTH_x2              = 2,
    NVVIOPCILINKWIDTH_x4              = 4,
    NVVIOPCILINKWIDTH_x8              = 8,
    NVVIOPCILINKWIDTH_x16            = 16,
}NVVIOPCILINKWIDTH;
 
typedef struct _NVVIOPCIINFO
{
    NvU32                     version;                            
    
    NvU32                   pciDeviceId;                        
    NvU32                   pciSubSystemId;                        
    NvU32                   pciRevisionId;                        
    NvU32                   pciDomain;                            
    NvU32                   pciBus;                                
    NvU32                   pciSlot;                            
    NVVIOPCILINKWIDTH       pciLinkWidth;                        
    NVVIOPCILINKRATE           pciLinkRate;                        
} NVVIOPCIINFO_V1;
 
typedef NVVIOPCIINFO_V1                                         NVVIOPCIINFO;
#define NVVIOPCIINFO_VER1                                          MAKE_NVAPI_VERSION(NVVIOPCIINFO_V1,1)
#define NVVIOPCIINFO_VER                                        NVVIOPCIINFO_VER1
 
//
// FUNCTION NAME: NvAPI_VIO_GetPCIInfo()
//
// DESCRIPTION:   This API gets PCI information of the attached SDI(input) capture card.
//
// PARAMETERS:      hVioHandle    (IN)    - Handle to SDI capture card.
//                  pVioPCIInfo    (OUT)    - PCI information of the attached SDI capture card.
//
//
//
__nvapi_deprecated_function("Do not use this function - it is deprecated in release 440.")
NVAPI_INTERFACE NvAPI_VIO_GetPCIInfo(__in NvVioHandle hVioHandle, 
                                            __inout NVVIOPCIINFO* pVioPCIInfo);
 
__nvapi_deprecated_function("Do not use this function - it is deprecated in release 440.")
NVAPI_INTERFACE NvAPI_VIO_IsRunning(NvVioHandle   hVioHandle);
 
__nvapi_deprecated_function("Do not use this function - it is deprecated in release 440.")
NVAPI_INTERFACE NvAPI_VIO_Start(NvVioHandle     hVioHandle);
 
__nvapi_deprecated_function("Do not use this function - it is deprecated in release 440.")
NVAPI_INTERFACE NvAPI_VIO_Stop(NvVioHandle     hVioHandle);
 
 
__nvapi_deprecated_function("Do not use this function - it is deprecated in release 440.")
NVAPI_INTERFACE NvAPI_VIO_IsFrameLockModeCompatible(NvVioHandle              hVioHandle,
                                                    NvU32                    srcEnumIndex,
                                                    NvU32                    destEnumIndex,
                                                    NvU32*                   pbCompatible);
 
 
__nvapi_deprecated_function("Do not use this function - it is deprecated in release 440.")
NVAPI_INTERFACE NvAPI_VIO_EnumDevices(NvVioHandle       hVioHandle[NVAPI_MAX_VIO_DEVICES],
                                      NvU32             *vioDeviceCount);
                                                                                          
 
__nvapi_deprecated_function("Do not use this function - it is deprecated in release 440.")
NVAPI_INTERFACE NvAPI_VIO_QueryTopology(NV_VIO_TOPOLOGY   *pNvVIOTopology);
 
 
__nvapi_deprecated_function("Do not use this function - it is deprecated in release 440.")
NVAPI_INTERFACE NvAPI_VIO_EnumSignalFormats(NvVioHandle              hVioHandle,
                                            NvU32                    enumIndex,
                                            NVVIOSIGNALFORMATDETAIL  *pSignalFormatDetail);
 
__nvapi_deprecated_function("Do not use this function - it is deprecated in release 440.")
NVAPI_INTERFACE NvAPI_VIO_EnumDataFormats(NvVioHandle            hVioHandle,
                                          NvU32                  enumIndex,
                                          NVVIODATAFORMATDETAIL  *pDataFormatDetail);
                                                                                      
 
 
 
 
 
//  CAMERA TEST API
//  These APIs allows test apps to perform low level camera tests
 
//
// FUNCTION NAME: NvAPI_Stereo_CreateConfigurationProfileRegistryKey
//
 
 
typedef enum _NV_StereoRegistryProfileType
{
    NVAPI_STEREO_DEFAULT_REGISTRY_PROFILE, 
    NVAPI_STEREO_DX9_REGISTRY_PROFILE,     
    NVAPI_STEREO_DX10_REGISTRY_PROFILE     
} NV_STEREO_REGISTRY_PROFILE_TYPE;
 
 
NVAPI_INTERFACE NvAPI_Stereo_CreateConfigurationProfileRegistryKey(NV_STEREO_REGISTRY_PROFILE_TYPE registryProfileType);
 
 
 
 
//
// FUNCTION NAME: NvAPI_Stereo_DeleteConfigurationProfileRegistryKey
//
NVAPI_INTERFACE NvAPI_Stereo_DeleteConfigurationProfileRegistryKey(NV_STEREO_REGISTRY_PROFILE_TYPE registryProfileType);
 
//
// FUNCTION NAME: NvAPI_Stereo_SetConfigurationProfileValue
//
//
 
 
typedef enum _NV_StereoRegistryID
{
    NVAPI_CONVERGENCE_ID,         
    NVAPI_FRUSTUM_ADJUST_MODE_ID, 
} NV_STEREO_REGISTRY_ID;
 
 
NVAPI_INTERFACE NvAPI_Stereo_SetConfigurationProfileValue(NV_STEREO_REGISTRY_PROFILE_TYPE registryProfileType, NV_STEREO_REGISTRY_ID valueRegistryID, void *pValue);
 
 
//
// FUNCTION NAME: NvAPI_Stereo_DeleteConfigurationProfileValue
//
NVAPI_INTERFACE NvAPI_Stereo_DeleteConfigurationProfileValue(NV_STEREO_REGISTRY_PROFILE_TYPE registryProfileType, NV_STEREO_REGISTRY_ID valueRegistryID);
 
 
 
 
 
 
 
typedef struct _NVAPI_STEREO_CAPS
{
    NvU32 version;
    NvU32 supportsWindowedModeOff        : 1;
    NvU32 supportsWindowedModeAutomatic  : 1;
    NvU32 supportsWindowedModePersistent : 1;
    NvU32 reserved                       : 29;  // must be 0
    NvU32 reserved2[3];                         // must be 0
} NVAPI_STEREO_CAPS_V1;
 
#define NVAPI_STEREO_CAPS_VER1  MAKE_NVAPI_VERSION(NVAPI_STEREO_CAPS,1)
#define NVAPI_STEREO_CAPS_VER   NVAPI_STEREO_CAPS_VER1
 
typedef NVAPI_STEREO_CAPS_V1    NVAPI_STEREO_CAPS;
 
 
//
// FUNCTION NAME: NvAPI_Stereo_GetStereoSupport
//
NVAPI_INTERFACE NvAPI_Stereo_GetStereoSupport(__in NvMonitorHandle hMonitor, __out NVAPI_STEREO_CAPS *pCaps);
 
 
 
 
 
 
 
 
 
//
// FUNCTION NAME: NvAPI_Stereo_DecreaseSeparation
//
NVAPI_INTERFACE NvAPI_Stereo_DecreaseSeparation(StereoHandle stereoHandle);
 
 
//
// FUNCTION NAME: NvAPI_Stereo_IncreaseSeparation
//
NVAPI_INTERFACE NvAPI_Stereo_IncreaseSeparation(StereoHandle stereoHandle);
 
 
 
 
//
// FUNCTION NAME: NvAPI_Stereo_DecreaseConvergence
//
NVAPI_INTERFACE NvAPI_Stereo_DecreaseConvergence(StereoHandle stereoHandle);
 
 
//
// FUNCTION NAME: NvAPI_Stereo_IncreaseConvergence
//
NVAPI_INTERFACE NvAPI_Stereo_IncreaseConvergence(StereoHandle stereoHandle);
 
 
//
// FUNCTION NAME: NvAPI_Stereo_GetFrustumAdjustMode
//
 
typedef enum _NV_FrustumAdjustMode
{
    NVAPI_NO_FRUSTUM_ADJUST,    
    NVAPI_FRUSTUM_STRETCH,      
    NVAPI_FRUSTUM_CLEAR_EDGES   
} NV_FRUSTUM_ADJUST_MODE;
 
NVAPI_INTERFACE NvAPI_Stereo_GetFrustumAdjustMode(StereoHandle stereoHandle, NV_FRUSTUM_ADJUST_MODE *pFrustumAdjustMode);
 
 
 
 
 
//
// FUNCTION NAME: NvAPI_Stereo_SetFrustumAdjustMode
//
NVAPI_INTERFACE NvAPI_Stereo_SetFrustumAdjustMode(StereoHandle stereoHandle, NV_FRUSTUM_ADJUST_MODE newFrustumAdjustModeValue);
 
 
//
// FUNCTION NAME: NvAPI_Stereo_CaptureJpegImage
//
NVAPI_INTERFACE NvAPI_Stereo_CaptureJpegImage(StereoHandle stereoHandle, NvU32 quality);
 
//
// FUNCTION NAME: NvAPI_Stereo_InitActivation
//
 
 
typedef enum _NVAPI_STEREO_INIT_ACTIVATION_FLAGS
{
    NVAPI_STEREO_INIT_ACTIVATION_IMMEDIATE = 0X00,
    NVAPI_STEREO_INIT_ACTIVATION_DELAYED = 0x01,
} NVAPI_STEREO_INIT_ACTIVATION_FLAGS;
 
NVAPI_INTERFACE NvAPI_Stereo_InitActivation(__in StereoHandle hStereoHandle, __in NVAPI_STEREO_INIT_ACTIVATION_FLAGS flags);
 
 
//
// FUNCTION NAME: NvAPI_Stereo_Trigger_Activation
//
NVAPI_INTERFACE NvAPI_Stereo_Trigger_Activation(__in StereoHandle hStereoHandle);
 
//
// FUNCTION NAME: NvAPI_Stereo_CapturePngImage
//
NVAPI_INTERFACE NvAPI_Stereo_CapturePngImage(StereoHandle stereoHandle);
 
 
//
// FUNCTION NAME: NvAPI_Stereo_ReverseStereoBlitControl
//
NVAPI_INTERFACE NvAPI_Stereo_ReverseStereoBlitControl(StereoHandle hStereoHandle, NvU8 TurnOn);
 
 
//
// FUNCTION NAME: NvAPI_Stereo_SetNotificationMessage
//
NVAPI_INTERFACE NvAPI_Stereo_SetNotificationMessage(StereoHandle hStereoHandle, NvU64 hWnd,NvU64 messageID);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
#define NVAPI_STEREO_QUADBUFFERED_API_VERSION   0x2
 
 typedef enum _NV_StereoSwapChainMode
 {
   NVAPI_STEREO_SWAPCHAIN_DEFAULT = 0,
   NVAPI_STEREO_SWAPCHAIN_STEREO = 1,
   NVAPI_STEREO_SWAPCHAIN_MONO = 2,
 } NV_STEREO_SWAPCHAIN_MODE;
 
#if defined(__d3d10_h__) || defined(__d3d10_1_h__) || defined(__d3d11_h__)
//
// FUNCTION NAME: NvAPI_D3D1x_CreateSwapChain
//
NVAPI_INTERFACE NvAPI_D3D1x_CreateSwapChain(StereoHandle hStereoHandle,
                                            DXGI_SWAP_CHAIN_DESC* pDesc,
                                            IDXGISwapChain** ppSwapChain,
                                            NV_STEREO_SWAPCHAIN_MODE mode);
 
#endif //if defined(__d3d10_h__) || defined(__d3d10_1_h__) || defined(__d3d11_h__)
 
 
#if defined(_D3D9_H_) //NvAPI_D3D9_CreateSwapChain
//
// FUNCTION NAME: NvAPI_D3D9_CreateSwapChain
//
NVAPI_INTERFACE NvAPI_D3D9_CreateSwapChain(StereoHandle hStereoHandle,
                                           D3DPRESENT_PARAMETERS *pPresentationParameters,
                                           IDirect3DSwapChain9 **ppSwapChain,
                                           NV_STEREO_SWAPCHAIN_MODE mode);
#endif //if defined(_D3D9_H_) //NvAPI_D3D9_CreateSwapChain
 
 
 
 
 
 
 
// GPU Profile APIs
 
NV_DECLARE_HANDLE(NvDRSSessionHandle);
NV_DECLARE_HANDLE(NvDRSProfileHandle);
 
#define NVAPI_DRS_GLOBAL_PROFILE                             ((NvDRSProfileHandle) -1)
 
#define NVAPI_SETTING_MAX_VALUES                             100
 
typedef enum _NVDRS_SETTING_TYPE
{
     NVDRS_DWORD_TYPE,
     NVDRS_BINARY_TYPE,
     NVDRS_STRING_TYPE,
     NVDRS_WSTRING_TYPE
} NVDRS_SETTING_TYPE;
 
typedef enum _NVDRS_SETTING_LOCATION
{
     NVDRS_CURRENT_PROFILE_LOCATION,
     NVDRS_GLOBAL_PROFILE_LOCATION,
     NVDRS_BASE_PROFILE_LOCATION,
     NVDRS_DEFAULT_PROFILE_LOCATION
} NVDRS_SETTING_LOCATION;
 
 
typedef struct _NVDRS_GPU_SUPPORT
{
    NvU32 geforce    :  1;
    NvU32 quadro     :  1;
    NvU32 nvs        :  1;
    NvU32 reserved4  :  1;
    NvU32 reserved5  :  1;
    NvU32 reserved6  :  1;
    NvU32 reserved7  :  1;
    NvU32 reserved8  :  1;
    NvU32 reserved9  :  1;
    NvU32 reserved10 :  1;
    NvU32 reserved11 :  1;
    NvU32 reserved12 :  1;
    NvU32 reserved13 :  1;
    NvU32 reserved14 :  1;
    NvU32 reserved15 :  1;
    NvU32 reserved16 :  1;
    NvU32 reserved17 :  1;
    NvU32 reserved18 :  1;
    NvU32 reserved19 :  1;
    NvU32 reserved20 :  1;
    NvU32 reserved21 :  1;
    NvU32 reserved22 :  1;
    NvU32 reserved23 :  1;
    NvU32 reserved24 :  1;
    NvU32 reserved25 :  1;
    NvU32 reserved26 :  1;
    NvU32 reserved27 :  1;
    NvU32 reserved28 :  1;
    NvU32 reserved29 :  1;
    NvU32 reserved30 :  1;
    NvU32 reserved31 :  1;
    NvU32 reserved32 :  1;
} NVDRS_GPU_SUPPORT;
 
typedef struct _NVDRS_BINARY_SETTING 
{
     NvU32                valueLength;               
     NvU8                 valueData[NVAPI_BINARY_DATA_MAX];
} NVDRS_BINARY_SETTING;
 
typedef struct _NVDRS_SETTING_VALUES
{
     NvU32                      version;                
     NvU32                      numSettingValues;       
     NVDRS_SETTING_TYPE         settingType;            
     union                                              
     {
         NvU32                      u32DefaultValue;    
         NVDRS_BINARY_SETTING       binaryDefaultValue; 
         NvAPI_UnicodeString        wszDefaultValue;    
     };
     union                                                
     {                                                    
         NvU32                      u32Value;           
         NVDRS_BINARY_SETTING       binaryValue;        
         NvAPI_UnicodeString        wszValue;           
     }settingValues[NVAPI_SETTING_MAX_VALUES];
} NVDRS_SETTING_VALUES;
 
#define NVDRS_SETTING_VALUES_VER    MAKE_NVAPI_VERSION(NVDRS_SETTING_VALUES,1)
     
typedef struct _NVDRS_SETTING_V1
{
     NvU32                      version;                
     NvAPI_UnicodeString        settingName;            
     NvU32                      settingId;              
     NVDRS_SETTING_TYPE         settingType;            
     NVDRS_SETTING_LOCATION     settingLocation;        
     NvU32                      isCurrentPredefined;    
     NvU32                      isPredefinedValid;      
     union                                              
     {
         NvU32                      u32PredefinedValue;    
         NVDRS_BINARY_SETTING       binaryPredefinedValue; 
         NvAPI_UnicodeString        wszPredefinedValue;    
     };
     union                                              
     {
         NvU32                      u32CurrentValue;    
         NVDRS_BINARY_SETTING       binaryCurrentValue; 
         NvAPI_UnicodeString        wszCurrentValue;    
     };                                                 
} NVDRS_SETTING_V1;
 
#define NVDRS_SETTING_VER1        MAKE_NVAPI_VERSION(NVDRS_SETTING_V1, 1)
 
typedef NVDRS_SETTING_V1          NVDRS_SETTING;
#define NVDRS_SETTING_VER         NVDRS_SETTING_VER1
 
typedef struct _NVDRS_APPLICATION_V1
{
     NvU32                      version;            
     NvU32                      isPredefined;       
     NvAPI_UnicodeString        appName;            
     NvAPI_UnicodeString        userFriendlyName;   
     NvAPI_UnicodeString        launcher;           
} NVDRS_APPLICATION_V1;
 
typedef struct _NVDRS_APPLICATION_V2
{
     NvU32                      version;            
     NvU32                      isPredefined;       
     NvAPI_UnicodeString        appName;            
     NvAPI_UnicodeString        userFriendlyName;   
     NvAPI_UnicodeString        launcher;           
     NvAPI_UnicodeString        fileInFolder;       
} NVDRS_APPLICATION_V2;
 
typedef struct _NVDRS_APPLICATION_V3
{
     NvU32                      version;            
     NvU32                      isPredefined;       
     NvAPI_UnicodeString        appName;            
     NvAPI_UnicodeString        userFriendlyName;   
     NvAPI_UnicodeString        launcher;           
     NvAPI_UnicodeString        fileInFolder;       
     NvU32                      isMetro:1;          
     NvU32                      isCommandLine:1;    
     NvU32                      reserved:30;        
} NVDRS_APPLICATION_V3;
 
typedef struct _NVDRS_APPLICATION_V4
{
     NvU32                      version;            
     NvU32                      isPredefined;       
     NvAPI_UnicodeString        appName;            
     NvAPI_UnicodeString        userFriendlyName;   
     NvAPI_UnicodeString        launcher;           
     NvAPI_UnicodeString        fileInFolder;       
     NvU32                      isMetro:1;          
     NvU32                      isCommandLine:1;    
     NvU32                      reserved:30;        
     NvAPI_UnicodeString        commandLine;        
} NVDRS_APPLICATION_V4;
 
#define NVDRS_APPLICATION_VER_V1        MAKE_NVAPI_VERSION(NVDRS_APPLICATION_V1,1)
#define NVDRS_APPLICATION_VER_V2        MAKE_NVAPI_VERSION(NVDRS_APPLICATION_V2,2)
#define NVDRS_APPLICATION_VER_V3        MAKE_NVAPI_VERSION(NVDRS_APPLICATION_V3,3)
#define NVDRS_APPLICATION_VER_V4        MAKE_NVAPI_VERSION(NVDRS_APPLICATION_V4,4)
 
typedef NVDRS_APPLICATION_V4 NVDRS_APPLICATION;
#define NVDRS_APPLICATION_VER NVDRS_APPLICATION_VER_V4
 
typedef struct _NVDRS_PROFILE_V1
{
     NvU32                      version;            
     NvAPI_UnicodeString        profileName;        
     NVDRS_GPU_SUPPORT          gpuSupport;         
     NvU32                      isPredefined;       
     NvU32                      numOfApps;          
     NvU32                      numOfSettings;      
} NVDRS_PROFILE_V1;
 
typedef NVDRS_PROFILE_V1         NVDRS_PROFILE;
 
#define NVDRS_PROFILE_VER1       MAKE_NVAPI_VERSION(NVDRS_PROFILE_V1,1)
#define NVDRS_PROFILE_VER        NVDRS_PROFILE_VER1
 
 
//
// FUNCTION NAME: NvAPI_DRS_CreateSession
//
//
NVAPI_INTERFACE NvAPI_DRS_CreateSession(NvDRSSessionHandle *phSession);
 
 
//
// FUNCTION NAME: NvAPI_DRS_DestroySession
//
//
NVAPI_INTERFACE NvAPI_DRS_DestroySession(NvDRSSessionHandle hSession);
 
//
// FUNCTION NAME: NvAPI_DRS_LoadSettings
//
//
NVAPI_INTERFACE NvAPI_DRS_LoadSettings(NvDRSSessionHandle hSession);
 
 
//
// FUNCTION NAME: NvAPI_DRS_SaveSettings
//
//
NVAPI_INTERFACE NvAPI_DRS_SaveSettings(NvDRSSessionHandle hSession);
 
//
// FUNCTION NAME: NvAPI_DRS_LoadSettingsFromFile
//
//
NVAPI_INTERFACE NvAPI_DRS_LoadSettingsFromFile(NvDRSSessionHandle hSession, NvAPI_UnicodeString fileName);
 
//
// FUNCTION NAME: NvAPI_DRS_SaveSettingsToFile
//
//
NVAPI_INTERFACE NvAPI_DRS_SaveSettingsToFile(NvDRSSessionHandle hSession, NvAPI_UnicodeString fileName);
 
 
 
 
//
// FUNCTION NAME: NvAPI_DRS_CreateProfile
//
NVAPI_INTERFACE NvAPI_DRS_CreateProfile(NvDRSSessionHandle hSession, NVDRS_PROFILE *pProfileInfo, NvDRSProfileHandle *phProfile);
 
//
// FUNCTION NAME: NvAPI_DRS_DeleteProfile
//
NVAPI_INTERFACE NvAPI_DRS_DeleteProfile(NvDRSSessionHandle hSession, NvDRSProfileHandle hProfile);
 
//
// FUNCTION NAME: NvAPI_DRS_SetCurrentGlobalProfile
//
NVAPI_INTERFACE NvAPI_DRS_SetCurrentGlobalProfile(NvDRSSessionHandle hSession, NvAPI_UnicodeString wszGlobalProfileName);
 
 
//
// FUNCTION NAME: NvAPI_DRS_GetCurrentGlobalProfile
//
NVAPI_INTERFACE NvAPI_DRS_GetCurrentGlobalProfile(NvDRSSessionHandle hSession, NvDRSProfileHandle *phProfile);
 
//
// FUNCTION NAME: NvAPI_DRS_GetProfileInfo
//
NVAPI_INTERFACE NvAPI_DRS_GetProfileInfo(NvDRSSessionHandle hSession, NvDRSProfileHandle hProfile, NVDRS_PROFILE *pProfileInfo);
 
//
// FUNCTION NAME: NvAPI_DRS_SetProfileInfo
//
NVAPI_INTERFACE NvAPI_DRS_SetProfileInfo(NvDRSSessionHandle hSession, NvDRSProfileHandle hProfile, NVDRS_PROFILE *pProfileInfo);
 
 
//
// FUNCTION NAME: NvAPI_DRS_FindProfileByName
//
NVAPI_INTERFACE NvAPI_DRS_FindProfileByName(NvDRSSessionHandle hSession, NvAPI_UnicodeString profileName, NvDRSProfileHandle* phProfile);
 
//
// FUNCTION NAME: NvAPI_DRS_EnumProfiles
//
NVAPI_INTERFACE NvAPI_DRS_EnumProfiles(NvDRSSessionHandle hSession, NvU32 index, NvDRSProfileHandle *phProfile);
 
//
// FUNCTION NAME: NvAPI_DRS_GetNumProfiles
//
NVAPI_INTERFACE NvAPI_DRS_GetNumProfiles(NvDRSSessionHandle hSession, NvU32 *numProfiles);
 
//
// FUNCTION NAME: NvAPI_DRS_CreateApplication
//
NVAPI_INTERFACE NvAPI_DRS_CreateApplication(NvDRSSessionHandle hSession, NvDRSProfileHandle  hProfile, NVDRS_APPLICATION *pApplication);
 
 
//
// FUNCTION NAME: NvAPI_DRS_DeleteApplicationEx
//
NVAPI_INTERFACE NvAPI_DRS_DeleteApplicationEx(NvDRSSessionHandle hSession, NvDRSProfileHandle hProfile, NVDRS_APPLICATION *pApp);
 
 
//
// FUNCTION NAME: NvAPI_DRS_DeleteApplication
//
NVAPI_INTERFACE NvAPI_DRS_DeleteApplication(NvDRSSessionHandle hSession, NvDRSProfileHandle hProfile, NvAPI_UnicodeString appName);
 
//
// FUNCTION NAME: NvAPI_DRS_GetApplicationInfo
//
//                                                single out only one executable.
NVAPI_INTERFACE NvAPI_DRS_GetApplicationInfo(NvDRSSessionHandle hSession, NvDRSProfileHandle hProfile, NvAPI_UnicodeString appName, NVDRS_APPLICATION *pApplication);
 
//
// FUNCTION NAME: NvAPI_DRS_EnumApplications
//
NVAPI_INTERFACE NvAPI_DRS_EnumApplications(NvDRSSessionHandle hSession, NvDRSProfileHandle hProfile, NvU32 startIndex, NvU32 *appCount, NVDRS_APPLICATION *pApplication);
 
//
// FUNCTION NAME: NvAPI_DRS_FindApplicationByName
//
NVAPI_INTERFACE NvAPI_DRS_FindApplicationByName(__in NvDRSSessionHandle hSession, __in NvAPI_UnicodeString appName, __out NvDRSProfileHandle *phProfile, __inout NVDRS_APPLICATION *pApplication);
 
//
// FUNCTION NAME: NvAPI_DRS_SetSetting
//
NVAPI_INTERFACE NvAPI_DRS_SetSetting(NvDRSSessionHandle hSession, NvDRSProfileHandle hProfile, NVDRS_SETTING *pSetting);
 
//
// FUNCTION NAME: NvAPI_DRS_GetSetting
//
NVAPI_INTERFACE NvAPI_DRS_GetSetting(NvDRSSessionHandle hSession, NvDRSProfileHandle hProfile, NvU32 settingId, NVDRS_SETTING *pSetting);
 
 
//
// FUNCTION NAME: NvAPI_DRS_EnumSettings
//
NVAPI_INTERFACE NvAPI_DRS_EnumSettings(NvDRSSessionHandle hSession, NvDRSProfileHandle hProfile, NvU32 startIndex, NvU32 *settingsCount, NVDRS_SETTING *pSetting);
 
//
// FUNCTION NAME: NvAPI_DRS_EnumAvailableSettingIds
//
NVAPI_INTERFACE NvAPI_DRS_EnumAvailableSettingIds(NvU32 *pSettingIds, NvU32 *pMaxCount);
 
//
// FUNCTION NAME: NvAPI_DRS_EnumAvailableSettingValues
//
NVAPI_INTERFACE NvAPI_DRS_EnumAvailableSettingValues(NvU32 settingId, NvU32 *pMaxNumValues, NVDRS_SETTING_VALUES *pSettingValues);
 
//
// FUNCTION NAME: NvAPI_DRS_GetSettingIdFromName
//
NVAPI_INTERFACE NvAPI_DRS_GetSettingIdFromName(NvAPI_UnicodeString settingName, NvU32 *pSettingId);
 
//
// FUNCTION NAME: NvAPI_DRS_GetSettingNameFromId
//
NVAPI_INTERFACE NvAPI_DRS_GetSettingNameFromId(NvU32 settingId, NvAPI_UnicodeString *pSettingName);
 
//
// FUNCTION NAME: NvAPI_DRS_DeleteProfileSetting
//
NVAPI_INTERFACE NvAPI_DRS_DeleteProfileSetting(NvDRSSessionHandle hSession, NvDRSProfileHandle hProfile, NvU32 settingId);
 
//
// FUNCTION NAME: NvAPI_DRS_RestoreAllDefaults
//
NVAPI_INTERFACE NvAPI_DRS_RestoreAllDefaults(NvDRSSessionHandle hSession);
 
//
// FUNCTION NAME: NvAPI_DRS_RestoreProfileDefault
//
NVAPI_INTERFACE NvAPI_DRS_RestoreProfileDefault(NvDRSSessionHandle hSession, NvDRSProfileHandle hProfile);
 
//
// FUNCTION NAME: NvAPI_DRS_RestoreProfileDefaultSetting
//
NVAPI_INTERFACE NvAPI_DRS_RestoreProfileDefaultSetting(NvDRSSessionHandle hSession, NvDRSProfileHandle hProfile, NvU32 settingId);
 
//
// FUNCTION NAME: NvAPI_DRS_GetBaseProfile
//
NVAPI_INTERFACE NvAPI_DRS_GetBaseProfile(NvDRSSessionHandle hSession, NvDRSProfileHandle *phProfile);
 
 
 
 
 
typedef struct
{
    NvU32               version;            
    NvU32               vendorId;           
    NvU32               deviceId;           
    NvAPI_ShortString   szVendorName;       
    NvAPI_ShortString   szChipsetName;      
    NvU32               flags;              
    NvU32               subSysVendorId;     
    NvU32               subSysDeviceId;     
    NvAPI_ShortString   szSubSysVendorName; 
    NvU32               HBvendorId;         
    NvU32               HBdeviceId;         
    NvU32               HBsubSysVendorId;   
    NvU32               HBsubSysDeviceId;   
 
} NV_CHIPSET_INFO_v4;
 
typedef struct
{
    NvU32               version;            
    NvU32               vendorId;           
    NvU32               deviceId;           
    NvAPI_ShortString   szVendorName;       
    NvAPI_ShortString   szChipsetName;      
    NvU32               flags;              
    NvU32               subSysVendorId;     
    NvU32               subSysDeviceId;     
    NvAPI_ShortString   szSubSysVendorName; 
} NV_CHIPSET_INFO_v3;
 
typedef enum
{
    NV_CHIPSET_INFO_HYBRID          = 0x00000001,
} NV_CHIPSET_INFO_FLAGS;
 
typedef struct
{
    NvU32               version;        
    NvU32               vendorId;       
    NvU32               deviceId;       
    NvAPI_ShortString   szVendorName;   
    NvAPI_ShortString   szChipsetName;  
    NvU32               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
//
NVAPI_INTERFACE NvAPI_SYS_GetChipSetInfo(NV_CHIPSET_INFO *pChipSetInfo);
 
 
typedef struct 
{
    NvU32 version;    
    NvU32 currentLidState;
    NvU32 currentDockState;
    NvU32 currentLidPolicy;
    NvU32 currentDockPolicy;
    NvU32 forcedLidMechanismPresent;
    NvU32 forcedDockMechanismPresent;
}NV_LID_DOCK_PARAMS;
 
 
#define NV_LID_DOCK_PARAMS_VER  MAKE_NVAPI_VERSION(NV_LID_DOCK_PARAMS,1)
//
// FUNCTION NAME: NvAPI_GetLidDockInfo
//
NVAPI_INTERFACE NvAPI_SYS_GetLidAndDockInfo(NV_LID_DOCK_PARAMS *pLidAndDock);
 
 
 
 
// FUNCTION NAME:   NvAPI_SYS_GetDisplayIdFromGpuAndOutputId
//
NVAPI_INTERFACE NvAPI_SYS_GetDisplayIdFromGpuAndOutputId(NvPhysicalGpuHandle hPhysicalGpu, NvU32 outputId, NvU32* displayId);
 
 
// FUNCTION NAME:   NvAPI_SYS_GetGpuAndOutputIdFromDisplayId
//
NVAPI_INTERFACE NvAPI_SYS_GetGpuAndOutputIdFromDisplayId(NvU32 displayId, NvPhysicalGpuHandle *hPhysicalGpu, NvU32 *outputId);
 
 
// FUNCTION NAME:   NvAPI_SYS_GetPhysicalGpuFromDisplayId
//
NVAPI_INTERFACE NvAPI_SYS_GetPhysicalGpuFromDisplayId(NvU32 displayId, NvPhysicalGpuHandle *hPhysicalGpu);
 
typedef struct _NV_DISPLAY_DRIVER_INFO
{
    NvU32 version;                                    
    NvU32 driverVersion;                              
    NvAPI_ShortString szBuildBranch;                  
    NvU32 bIsDCHDriver                        : 1;    
    NvU32 bIsNVIDIAStudioPackage              : 1;    
    NvU32 bIsNVIDIAGameReadyPackage           : 1;    
    NvU32 bIsNVIDIARTXProductionBranchPackage : 1;    
    NvU32 bIsNVIDIARTXNewFeatureBranchPackage : 1;    
    NvU32 reserved                            : 27;   
} NV_DISPLAY_DRIVER_INFO_V1;
 
typedef struct _NV_DISPLAY_DRIVER_INFO_V2
{
    NvU32 version;                                    
    NvU32 driverVersion;                              
    NvAPI_ShortString szBuildBranch;                  
    NvU32 bIsDCHDriver                        : 1;    
    NvU32 bIsNVIDIAStudioPackage              : 1;    
    NvU32 bIsNVIDIAGameReadyPackage           : 1;    
    NvU32 bIsNVIDIARTXProductionBranchPackage : 1;    
    NvU32 bIsNVIDIARTXNewFeatureBranchPackage : 1;    
    NvU32 reserved                            : 27;   
    NvAPI_ShortString szBuildBaseBranch;              
    NvU32 reservedEx;                                 
} NV_DISPLAY_DRIVER_INFO_V2;
 
#define NV_DISPLAY_DRIVER_INFO_VER1             MAKE_NVAPI_VERSION(NV_DISPLAY_DRIVER_INFO_V1, 1)
#define NV_DISPLAY_DRIVER_INFO_VER2             MAKE_NVAPI_VERSION(NV_DISPLAY_DRIVER_INFO_V2, 2)
typedef NV_DISPLAY_DRIVER_INFO_V2               NV_DISPLAY_DRIVER_INFO;
#define NV_DISPLAY_DRIVER_INFO_VER              NV_DISPLAY_DRIVER_INFO_VER2
 
//
// FUNCTION NAME: NvAPI_SYS_GetDisplayDriverInfo
//
NVAPI_INTERFACE NvAPI_SYS_GetDisplayDriverInfo(__inout NV_DISPLAY_DRIVER_INFO *pDriverInfo);
 
 
typedef struct _NV_CLIENT_CALLBACK_SETTINGS_SUPER_V1
{
    void* pCallbackParam;
 
    NvU8 rsvd[64];
} NV_CLIENT_CALLBACK_SETTINGS_SUPER_V1;
 
typedef NV_CLIENT_CALLBACK_SETTINGS_SUPER_V1 NV_GPU_CLIENT_CALLBACK_SETTINGS_SUPER_V1;
 
 
typedef struct _NV_GPU_CLIENT_PERIODIC_CALLBACK_SETTINGS_SUPER_V1
{
    NV_GPU_CLIENT_CALLBACK_SETTINGS_SUPER_V1 super;
 
    NvU32 callbackPeriodms;
 
    NvU8 rsvd[64];
} NV_GPU_CLIENT_PERIODIC_CALLBACK_SETTINGS_SUPER_V1;
 
typedef struct _NV_GPU_CLIENT_CALLBACK_DATA_SUPER_V1
{
    void* pCallbackParam;
 
    NvU8 rsvd[64];
} NV_GPU_CLIENT_CALLBACK_DATA_SUPER_V1;
 
 
typedef enum _NV_GPU_CLIENT_UTIL_DOMAIN_ID
{
    NV_GPU_CLIENT_UTIL_DOMAIN_GRAPHICS = 0,
    NV_GPU_CLIENT_UTIL_DOMAIN_FRAME_BUFFER = 1,
    NV_GPU_CLIENT_UTIL_DOMAIN_VIDEO = 2,
    NV_GPU_CLIENT_UTIL_DOMAIN_RSVD = 3,
} NV_GPU_CLIENT_UTIL_DOMAIN_ID;
 
#define NV_GPU_CLIENT_UTIL_DOMAINS_MAX_V1                                    (4)
 
typedef struct _NV_GPU_CLIENT_UTILIZATION_DATA_V1
{
    NV_GPU_CLIENT_UTIL_DOMAIN_ID utilId;
 
    NvU32 utilizationPercent;
 
    NvU8 rsvd[61];
} NV_GPU_CLIENT_UTILIZATION_DATA_V1;
 
typedef struct _NV_GPU_CLIENT_CALLBACK_UTILIZATION_DATA_V1
{
    NV_GPU_CLIENT_CALLBACK_DATA_SUPER_V1 super;
 
    NvU32 numUtils;
 
    NvU64 timestamp;
 
    NvU8 rsvd[64];
 
    NV_GPU_CLIENT_UTILIZATION_DATA_V1 utils[NV_GPU_CLIENT_UTIL_DOMAINS_MAX_V1];
} NV_GPU_CLIENT_CALLBACK_UTILIZATION_DATA_V1;
 
typedef void (__cdecl *NV_GPU_CLIENT_UTILIZATION_PERIODIC_CALLBACK_V1)(NvPhysicalGpuHandle hPhysicalGpu, NV_GPU_CLIENT_CALLBACK_UTILIZATION_DATA_V1* pData);
 
typedef struct _NV_GPU_CLIENT_UTILIZATION_PERIODIC_CALLBACK_SETTINGS_V1
{
    NvU32 version;
 
    NV_GPU_CLIENT_PERIODIC_CALLBACK_SETTINGS_SUPER_V1 super;
 
    NV_GPU_CLIENT_UTILIZATION_PERIODIC_CALLBACK_V1 callback;
 
    NvU8 rsvd[64];
} NV_GPU_CLIENT_UTILIZATION_PERIODIC_CALLBACK_SETTINGS_V1;
 
#define NV_GPU_CLIENT_UTILIZATION_PERIODIC_CALLBACK_SETTINGS_VER1  MAKE_NVAPI_VERSION(NV_GPU_CLIENT_UTILIZATION_PERIODIC_CALLBACK_SETTINGS_V1, 1)
typedef NV_GPU_CLIENT_UTILIZATION_PERIODIC_CALLBACK_SETTINGS_V1    NV_GPU_CLIENT_UTILIZATION_PERIODIC_CALLBACK_SETTINGS;
#define NV_GPU_CLIENT_UTILIZATION_PERIODIC_CALLBACK_SETTINGS_VER   NV_GPU_CLIENT_UTILIZATION_PERIODIC_CALLBACK_SETTINGS_VER1
 
//
// FUNCTION NAME: NvAPI_GPU_ClientRegisterForUtilizationSampleUpdates
//
NVAPI_INTERFACE NvAPI_GPU_ClientRegisterForUtilizationSampleUpdates(__in NvPhysicalGpuHandle hPhysicalGpu, __in NV_GPU_CLIENT_UTILIZATION_PERIODIC_CALLBACK_SETTINGS* pCallbackSettings);
 
 
 
 
 
#ifdef __cplusplus
}; //extern "C" {
 
#endif
 
#pragma pack(pop)
 
#endif // _NVAPI_H
 
#include"nvapi_lite_salend.h"