diff --git a/NvApiDriverSettings.c b/NvApiDriverSettings.c index f19c312..9461ddb 100644 --- a/NvApiDriverSettings.c +++ b/NvApiDriverSettings.c @@ -1,6 +1,6 @@ /*********************************************************************************************************\ |* *| -|* SPDX-FileCopyrightText: Copyright (c) 2019-2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. *| +|* SPDX-FileCopyrightText: Copyright (c) 2019-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. *| |* SPDX-License-Identifier: MIT *| |* *| |* Permission is hereby granted, free of charge, to any person obtaining a *| @@ -426,11 +426,35 @@ EValues_NGX_DLAA_OVERRIDE g_valuesNGX_DLAA_OVERRIDE[NGX_DLAA_OVERRIDE_NUM_VALUES NGX_DLAA_OVERRIDE_DLAA_ON, }; +EValues_NGX_DLSSG_DYNAMIC_MULTI_FRAME_COUNT_MAX g_valuesNGX_DLSSG_DYNAMIC_MULTI_FRAME_COUNT_MAX[NGX_DLSSG_DYNAMIC_MULTI_FRAME_COUNT_MAX_NUM_VALUES] = +{ + NGX_DLSSG_DYNAMIC_MULTI_FRAME_COUNT_MAX_OFF, + NGX_DLSSG_DYNAMIC_MULTI_FRAME_COUNT_MAX_MIN, + NGX_DLSSG_DYNAMIC_MULTI_FRAME_COUNT_MAX_MAX, +}; + +EValues_NGX_DLSSG_DYNAMIC_TARGET_FRAME_RATE g_valuesNGX_DLSSG_DYNAMIC_TARGET_FRAME_RATE[NGX_DLSSG_DYNAMIC_TARGET_FRAME_RATE_NUM_VALUES] = +{ + NGX_DLSSG_DYNAMIC_TARGET_FRAME_RATE_DISABLED, + NGX_DLSSG_DYNAMIC_TARGET_FRAME_RATE_MIN, + NGX_DLSSG_DYNAMIC_TARGET_FRAME_RATE_MAX, + NGX_DLSSG_DYNAMIC_TARGET_FRAME_RATE_AUTO, +}; + +EValues_NGX_DLSSG_MODE g_valuesNGX_DLSSG_MODE[NGX_DLSSG_MODE_NUM_VALUES] = +{ + NGX_DLSSG_MODE_DISABLED, + NGX_DLSSG_MODE_OFF, + NGX_DLSSG_MODE_ON, + NGX_DLSSG_MODE_AUTO, + NGX_DLSSG_MODE_DYNAMIC, +}; + EValues_NGX_DLSSG_MULTI_FRAME_COUNT g_valuesNGX_DLSSG_MULTI_FRAME_COUNT[NGX_DLSSG_MULTI_FRAME_COUNT_NUM_VALUES] = { + NGX_DLSSG_MULTI_FRAME_COUNT_OFF, NGX_DLSSG_MULTI_FRAME_COUNT_MIN, NGX_DLSSG_MULTI_FRAME_COUNT_MAX, - NGX_DLSSG_MULTI_FRAME_COUNT_DEFAULT, }; EValues_NGX_DLSS_FG_OVERRIDE g_valuesNGX_DLSS_FG_OVERRIDE[NGX_DLSS_FG_OVERRIDE_NUM_VALUES] = @@ -439,6 +463,39 @@ EValues_NGX_DLSS_FG_OVERRIDE g_valuesNGX_DLSS_FG_OVERRIDE[NGX_DLSS_FG_OVERRIDE_N NGX_DLSS_FG_OVERRIDE_ON, }; +EValues_NGX_DLSS_FG_OVERRIDE_RENDER_PRESET_SELECTION g_valuesNGX_DLSS_FG_OVERRIDE_RENDER_PRESET_SELECTION[NGX_DLSS_FG_OVERRIDE_RENDER_PRESET_SELECTION_NUM_VALUES] = +{ + NGX_DLSS_FG_OVERRIDE_RENDER_PRESET_SELECTION_OFF, + NGX_DLSS_FG_OVERRIDE_RENDER_PRESET_SELECTION_RENDER_PRESET_A, + NGX_DLSS_FG_OVERRIDE_RENDER_PRESET_SELECTION_RENDER_PRESET_B, + NGX_DLSS_FG_OVERRIDE_RENDER_PRESET_SELECTION_RENDER_PRESET_C, + NGX_DLSS_FG_OVERRIDE_RENDER_PRESET_SELECTION_RENDER_PRESET_D, + NGX_DLSS_FG_OVERRIDE_RENDER_PRESET_SELECTION_RENDER_PRESET_E, + NGX_DLSS_FG_OVERRIDE_RENDER_PRESET_SELECTION_RENDER_PRESET_F, + NGX_DLSS_FG_OVERRIDE_RENDER_PRESET_SELECTION_RENDER_PRESET_G, + NGX_DLSS_FG_OVERRIDE_RENDER_PRESET_SELECTION_RENDER_PRESET_H, + NGX_DLSS_FG_OVERRIDE_RENDER_PRESET_SELECTION_RENDER_PRESET_I, + NGX_DLSS_FG_OVERRIDE_RENDER_PRESET_SELECTION_RENDER_PRESET_J, + NGX_DLSS_FG_OVERRIDE_RENDER_PRESET_SELECTION_RENDER_PRESET_K, + NGX_DLSS_FG_OVERRIDE_RENDER_PRESET_SELECTION_RENDER_PRESET_L, + NGX_DLSS_FG_OVERRIDE_RENDER_PRESET_SELECTION_RENDER_PRESET_M, + NGX_DLSS_FG_OVERRIDE_RENDER_PRESET_SELECTION_RENDER_PRESET_N, + NGX_DLSS_FG_OVERRIDE_RENDER_PRESET_SELECTION_RENDER_PRESET_O, + NGX_DLSS_FG_OVERRIDE_RENDER_PRESET_SELECTION_RENDER_PRESET_P, + NGX_DLSS_FG_OVERRIDE_RENDER_PRESET_SELECTION_RENDER_PRESET_Q, + NGX_DLSS_FG_OVERRIDE_RENDER_PRESET_SELECTION_RENDER_PRESET_R, + NGX_DLSS_FG_OVERRIDE_RENDER_PRESET_SELECTION_RENDER_PRESET_S, + NGX_DLSS_FG_OVERRIDE_RENDER_PRESET_SELECTION_RENDER_PRESET_T, + NGX_DLSS_FG_OVERRIDE_RENDER_PRESET_SELECTION_RENDER_PRESET_U, + NGX_DLSS_FG_OVERRIDE_RENDER_PRESET_SELECTION_RENDER_PRESET_V, + NGX_DLSS_FG_OVERRIDE_RENDER_PRESET_SELECTION_RENDER_PRESET_W, + NGX_DLSS_FG_OVERRIDE_RENDER_PRESET_SELECTION_RENDER_PRESET_X, + NGX_DLSS_FG_OVERRIDE_RENDER_PRESET_SELECTION_RENDER_PRESET_Y, + NGX_DLSS_FG_OVERRIDE_RENDER_PRESET_SELECTION_RENDER_PRESET_Z, + NGX_DLSS_FG_OVERRIDE_RENDER_PRESET_SELECTION_RENDER_PRESET_Default, + NGX_DLSS_FG_OVERRIDE_RENDER_PRESET_SELECTION_RENDER_PRESET_Latest, +}; + EValues_NGX_DLSS_FG_OVERRIDE_RESERVED_KEY1 g_valuesNGX_DLSS_FG_OVERRIDE_RESERVED_KEY1[NGX_DLSS_FG_OVERRIDE_RESERVED_KEY1_NUM_VALUES] = { NGX_DLSS_FG_OVERRIDE_RESERVED_KEY1_DEFAULT, @@ -449,6 +506,28 @@ EValues_NGX_DLSS_FG_OVERRIDE_RESERVED_KEY2 g_valuesNGX_DLSS_FG_OVERRIDE_RESERVED NGX_DLSS_FG_OVERRIDE_RESERVED_KEY2_DEFAULT, }; +EValues_NGX_DLSS_NR_OVERRIDE g_valuesNGX_DLSS_NR_OVERRIDE[NGX_DLSS_NR_OVERRIDE_NUM_VALUES] = +{ + NGX_DLSS_NR_OVERRIDE_OFF, + NGX_DLSS_NR_OVERRIDE_ON, +}; + +EValues_NGX_DLSS_NR_OVERRIDE_RENDER_PRESET_SELECTION g_valuesNGX_DLSS_NR_OVERRIDE_RENDER_PRESET_SELECTION[NGX_DLSS_NR_OVERRIDE_RENDER_PRESET_SELECTION_NUM_VALUES] = +{ + NGX_DLSS_NR_OVERRIDE_RENDER_PRESET_SELECTION_OFF, + NGX_DLSS_NR_OVERRIDE_RENDER_PRESET_SELECTION_RENDER_PRESET_A, + NGX_DLSS_NR_OVERRIDE_RENDER_PRESET_SELECTION_RENDER_PRESET_B, + NGX_DLSS_NR_OVERRIDE_RENDER_PRESET_SELECTION_RENDER_PRESET_C, + NGX_DLSS_NR_OVERRIDE_RENDER_PRESET_SELECTION_RENDER_PRESET_D, + NGX_DLSS_NR_OVERRIDE_RENDER_PRESET_SELECTION_RENDER_PRESET_Latest, +}; + +EValues_NGX_DLSS_NR_SL_OVERRIDE g_valuesNGX_DLSS_NR_SL_OVERRIDE[NGX_DLSS_NR_SL_OVERRIDE_NUM_VALUES] = +{ + NGX_DLSS_NR_SL_OVERRIDE_OFF, + NGX_DLSS_NR_SL_OVERRIDE_ON, +}; + EValues_NGX_DLSS_OVERRIDE_OPTIMAL_SETTINGS g_valuesNGX_DLSS_OVERRIDE_OPTIMAL_SETTINGS[NGX_DLSS_OVERRIDE_OPTIMAL_SETTINGS_NUM_VALUES] = { NGX_DLSS_OVERRIDE_OPTIMAL_SETTINGS_NGX_DLSS_OVERRIDE_OPTIMAL_SETTINGS_NONE, @@ -503,6 +582,13 @@ EValues_NGX_DLSS_RR_OVERRIDE_RESERVED_KEY2 g_valuesNGX_DLSS_RR_OVERRIDE_RESERVED NGX_DLSS_RR_OVERRIDE_RESERVED_KEY2_DEFAULT, }; +EValues_NGX_DLSS_RR_OVERRIDE_SCALING_RATIO g_valuesNGX_DLSS_RR_OVERRIDE_SCALING_RATIO[NGX_DLSS_RR_OVERRIDE_SCALING_RATIO_NUM_VALUES] = +{ + NGX_DLSS_RR_OVERRIDE_SCALING_RATIO_MIN, + NGX_DLSS_RR_OVERRIDE_SCALING_RATIO_MAX, + NGX_DLSS_RR_OVERRIDE_SCALING_RATIO_DEFAULT, +}; + EValues_NGX_DLSS_SR_MODE g_valuesNGX_DLSS_SR_MODE[NGX_DLSS_SR_MODE_NUM_VALUES] = { NGX_DLSS_SR_MODE_NGX_DLSS_SR_MODE_PERFORMANCE, @@ -512,6 +598,7 @@ EValues_NGX_DLSS_SR_MODE g_valuesNGX_DLSS_SR_MODE[NGX_DLSS_SR_MODE_NUM_VALUES] = NGX_DLSS_SR_MODE_NGX_DLSS_SR_MODE_DLAA, NGX_DLSS_SR_MODE_NGX_DLSS_SR_MODE_ULTRA_PERFORMANCE, NGX_DLSS_SR_MODE_NGX_DLSS_SR_MODE_CUSTOM, + NGX_DLSS_SR_MODE_NGX_DLSS_SR_MODE_RESERVED_A, }; EValues_NGX_DLSS_SR_OVERRIDE g_valuesNGX_DLSS_SR_OVERRIDE[NGX_DLSS_SR_OVERRIDE_NUM_VALUES] = @@ -551,6 +638,13 @@ EValues_NGX_DLSS_SR_OVERRIDE_RESERVED_KEY2 g_valuesNGX_DLSS_SR_OVERRIDE_RESERVED NGX_DLSS_SR_OVERRIDE_RESERVED_KEY2_DEFAULT, }; +EValues_NGX_DLSS_SR_OVERRIDE_SCALING_RATIO g_valuesNGX_DLSS_SR_OVERRIDE_SCALING_RATIO[NGX_DLSS_SR_OVERRIDE_SCALING_RATIO_NUM_VALUES] = +{ + NGX_DLSS_SR_OVERRIDE_SCALING_RATIO_MIN, + NGX_DLSS_SR_OVERRIDE_SCALING_RATIO_MAX, + NGX_DLSS_SR_OVERRIDE_SCALING_RATIO_DEFAULT, +}; + EValues_NV_QUALITY_UPSCALING g_valuesNV_QUALITY_UPSCALING[NV_QUALITY_UPSCALING_NUM_VALUES] = { NV_QUALITY_UPSCALING_OFF, @@ -876,6 +970,12 @@ EValues_PRERENDERLIMIT g_valuesPRERENDERLIMIT[PRERENDERLIMIT_NUM_VALUES] = PRERENDERLIMIT_APP_CONTROLLED, }; +EValues_PS_OFFLINE_SHADER_COMPILER g_valuesPS_OFFLINE_SHADER_COMPILER[PS_OFFLINE_SHADER_COMPILER_NUM_VALUES] = +{ + PS_OFFLINE_SHADER_COMPILER_OFF, + PS_OFFLINE_SHADER_COMPILER_ON, +}; + EValues_PS_SHADERDISKCACHE g_valuesPS_SHADERDISKCACHE[PS_SHADERDISKCACHE_NUM_VALUES] = { PS_SHADERDISKCACHE_OFF, @@ -1016,21 +1116,30 @@ SettingDWORDNameString mapSettingDWORD[TOTAL_DWORD_SETTING_NUM] = {LATENCY_INDICATOR_AUTOALIGN_ID, LATENCY_INDICATOR_AUTOALIGN_STRING, 2, (NvU32 *)g_valuesLATENCY_INDICATOR_AUTOALIGN, LATENCY_INDICATOR_AUTOALIGN_ENABLED}, {MCSFRSHOWSPLIT_ID, MCSFRSHOWSPLIT_STRING, 2, (NvU32 *)g_valuesMCSFRSHOWSPLIT, MCSFRSHOWSPLIT_DISABLED}, {NGX_DLAA_OVERRIDE_ID, NGX_DLAA_OVERRIDE_STRING, 2, (NvU32 *)g_valuesNGX_DLAA_OVERRIDE, NGX_DLAA_OVERRIDE_DLAA_DEFAULT}, - {NGX_DLSSG_MULTI_FRAME_COUNT_ID, NGX_DLSSG_MULTI_FRAME_COUNT_STRING, 3, (NvU32 *)g_valuesNGX_DLSSG_MULTI_FRAME_COUNT, NGX_DLSSG_MULTI_FRAME_COUNT_DEFAULT}, + {NGX_DLSSG_DYNAMIC_MULTI_FRAME_COUNT_MAX_ID, NGX_DLSSG_DYNAMIC_MULTI_FRAME_COUNT_MAX_STRING, 3, (NvU32 *)g_valuesNGX_DLSSG_DYNAMIC_MULTI_FRAME_COUNT_MAX, NGX_DLSSG_DYNAMIC_MULTI_FRAME_COUNT_MAX_OFF}, + {NGX_DLSSG_DYNAMIC_TARGET_FRAME_RATE_ID, NGX_DLSSG_DYNAMIC_TARGET_FRAME_RATE_STRING, 4, (NvU32 *)g_valuesNGX_DLSSG_DYNAMIC_TARGET_FRAME_RATE, NGX_DLSSG_DYNAMIC_TARGET_FRAME_RATE_DISABLED}, + {NGX_DLSSG_MODE_ID, NGX_DLSSG_MODE_STRING, 5, (NvU32 *)g_valuesNGX_DLSSG_MODE, NGX_DLSSG_MODE_DISABLED}, + {NGX_DLSSG_MULTI_FRAME_COUNT_ID, NGX_DLSSG_MULTI_FRAME_COUNT_STRING, 3, (NvU32 *)g_valuesNGX_DLSSG_MULTI_FRAME_COUNT, NGX_DLSSG_MULTI_FRAME_COUNT_OFF}, {NGX_DLSS_FG_OVERRIDE_ID, NGX_DLSS_FG_OVERRIDE_STRING, 2, (NvU32 *)g_valuesNGX_DLSS_FG_OVERRIDE, NGX_DLSS_FG_OVERRIDE_OFF}, + {NGX_DLSS_FG_OVERRIDE_RENDER_PRESET_SELECTION_ID, NGX_DLSS_FG_OVERRIDE_RENDER_PRESET_SELECTION_STRING, 29, (NvU32 *)g_valuesNGX_DLSS_FG_OVERRIDE_RENDER_PRESET_SELECTION, NGX_DLSS_FG_OVERRIDE_RENDER_PRESET_SELECTION_OFF}, {NGX_DLSS_FG_OVERRIDE_RESERVED_KEY1_ID, NGX_DLSS_FG_OVERRIDE_RESERVED_KEY1_STRING, 1, NULL, NGX_DLSS_FG_OVERRIDE_RESERVED_KEY1_DEFAULT}, {NGX_DLSS_FG_OVERRIDE_RESERVED_KEY2_ID, NGX_DLSS_FG_OVERRIDE_RESERVED_KEY2_STRING, 1, NULL, NGX_DLSS_FG_OVERRIDE_RESERVED_KEY2_DEFAULT}, + {NGX_DLSS_NR_OVERRIDE_ID, NGX_DLSS_NR_OVERRIDE_STRING, 2, (NvU32 *)g_valuesNGX_DLSS_NR_OVERRIDE, NGX_DLSS_NR_OVERRIDE_OFF}, + {NGX_DLSS_NR_OVERRIDE_RENDER_PRESET_SELECTION_ID, NGX_DLSS_NR_OVERRIDE_RENDER_PRESET_SELECTION_STRING, 6, (NvU32 *)g_valuesNGX_DLSS_NR_OVERRIDE_RENDER_PRESET_SELECTION, NGX_DLSS_NR_OVERRIDE_RENDER_PRESET_SELECTION_OFF}, + {NGX_DLSS_NR_SL_OVERRIDE_ID, NGX_DLSS_NR_SL_OVERRIDE_STRING, 2, (NvU32 *)g_valuesNGX_DLSS_NR_SL_OVERRIDE, NGX_DLSS_NR_SL_OVERRIDE_OFF}, {NGX_DLSS_OVERRIDE_OPTIMAL_SETTINGS_ID, NGX_DLSS_OVERRIDE_OPTIMAL_SETTINGS_STRING, 2, (NvU32 *)g_valuesNGX_DLSS_OVERRIDE_OPTIMAL_SETTINGS, NGX_DLSS_OVERRIDE_OPTIMAL_SETTINGS_NGX_DLSS_OVERRIDE_OPTIMAL_SETTINGS_NONE}, {NGX_DLSS_RR_MODE_ID, NGX_DLSS_RR_MODE_STRING, 7, (NvU32 *)g_valuesNGX_DLSS_RR_MODE, NGX_DLSS_RR_MODE_NGX_DLSS_RR_MODE_SNIPPET_CONTROLLED}, {NGX_DLSS_RR_OVERRIDE_ID, NGX_DLSS_RR_OVERRIDE_STRING, 2, (NvU32 *)g_valuesNGX_DLSS_RR_OVERRIDE, NGX_DLSS_RR_OVERRIDE_OFF}, {NGX_DLSS_RR_OVERRIDE_RENDER_PRESET_SELECTION_ID, NGX_DLSS_RR_OVERRIDE_RENDER_PRESET_SELECTION_STRING, 17, (NvU32 *)g_valuesNGX_DLSS_RR_OVERRIDE_RENDER_PRESET_SELECTION, NGX_DLSS_RR_OVERRIDE_RENDER_PRESET_SELECTION_OFF}, {NGX_DLSS_RR_OVERRIDE_RESERVED_KEY1_ID, NGX_DLSS_RR_OVERRIDE_RESERVED_KEY1_STRING, 1, NULL, NGX_DLSS_RR_OVERRIDE_RESERVED_KEY1_DEFAULT}, {NGX_DLSS_RR_OVERRIDE_RESERVED_KEY2_ID, NGX_DLSS_RR_OVERRIDE_RESERVED_KEY2_STRING, 1, NULL, NGX_DLSS_RR_OVERRIDE_RESERVED_KEY2_DEFAULT}, - {NGX_DLSS_SR_MODE_ID, NGX_DLSS_SR_MODE_STRING, 7, (NvU32 *)g_valuesNGX_DLSS_SR_MODE, NGX_DLSS_SR_MODE_NGX_DLSS_SR_MODE_SNIPPET_CONTROLLED}, + {NGX_DLSS_RR_OVERRIDE_SCALING_RATIO_ID, NGX_DLSS_RR_OVERRIDE_SCALING_RATIO_STRING, 3, (NvU32 *)g_valuesNGX_DLSS_RR_OVERRIDE_SCALING_RATIO, NGX_DLSS_RR_OVERRIDE_SCALING_RATIO_DEFAULT}, + {NGX_DLSS_SR_MODE_ID, NGX_DLSS_SR_MODE_STRING, 8, (NvU32 *)g_valuesNGX_DLSS_SR_MODE, NGX_DLSS_SR_MODE_NGX_DLSS_SR_MODE_SNIPPET_CONTROLLED}, {NGX_DLSS_SR_OVERRIDE_ID, NGX_DLSS_SR_OVERRIDE_STRING, 2, (NvU32 *)g_valuesNGX_DLSS_SR_OVERRIDE, NGX_DLSS_SR_OVERRIDE_OFF}, {NGX_DLSS_SR_OVERRIDE_RENDER_PRESET_SELECTION_ID, NGX_DLSS_SR_OVERRIDE_RENDER_PRESET_SELECTION_STRING, 17, (NvU32 *)g_valuesNGX_DLSS_SR_OVERRIDE_RENDER_PRESET_SELECTION, NGX_DLSS_SR_OVERRIDE_RENDER_PRESET_SELECTION_OFF}, {NGX_DLSS_SR_OVERRIDE_RESERVED_KEY1_ID, NGX_DLSS_SR_OVERRIDE_RESERVED_KEY1_STRING, 1, NULL, NGX_DLSS_SR_OVERRIDE_RESERVED_KEY1_DEFAULT}, {NGX_DLSS_SR_OVERRIDE_RESERVED_KEY2_ID, NGX_DLSS_SR_OVERRIDE_RESERVED_KEY2_STRING, 1, NULL, NGX_DLSS_SR_OVERRIDE_RESERVED_KEY2_DEFAULT}, + {NGX_DLSS_SR_OVERRIDE_SCALING_RATIO_ID, NGX_DLSS_SR_OVERRIDE_SCALING_RATIO_STRING, 3, (NvU32 *)g_valuesNGX_DLSS_SR_OVERRIDE_SCALING_RATIO, NGX_DLSS_SR_OVERRIDE_SCALING_RATIO_DEFAULT}, {NV_QUALITY_UPSCALING_ID, NV_QUALITY_UPSCALING_STRING, 2, (NvU32 *)g_valuesNV_QUALITY_UPSCALING, NV_QUALITY_UPSCALING_OFF}, {OPTIMUS_MAXAA_ID, OPTIMUS_MAXAA_STRING, 2, (NvU32 *)g_valuesOPTIMUS_MAXAA, 0x00000000}, {PHYSXINDICATOR_ID, PHYSXINDICATOR_STRING, 2, (NvU32 *)g_valuesPHYSXINDICATOR, PHYSXINDICATOR_DISABLED}, @@ -1068,6 +1177,7 @@ SettingDWORDNameString mapSettingDWORD[TOTAL_DWORD_SETTING_NUM] = {LODBIASADJUST_ID, LODBIASADJUST_STRING, 2, (NvU32 *)g_valuesLODBIASADJUST, 0x00000000}, {MAXWELL_B_SAMPLE_INTERLEAVE_ID, MAXWELL_B_SAMPLE_INTERLEAVE_STRING, 2, (NvU32 *)g_valuesMAXWELL_B_SAMPLE_INTERLEAVE, MAXWELL_B_SAMPLE_INTERLEAVE_OFF}, {PRERENDERLIMIT_ID, PRERENDERLIMIT_STRING, 3, (NvU32 *)g_valuesPRERENDERLIMIT, PRERENDERLIMIT_APP_CONTROLLED}, + {PS_OFFLINE_SHADER_COMPILER_ID, PS_OFFLINE_SHADER_COMPILER_STRING, 2, (NvU32 *)g_valuesPS_OFFLINE_SHADER_COMPILER, PS_OFFLINE_SHADER_COMPILER_ON}, {PS_SHADERDISKCACHE_ID, PS_SHADERDISKCACHE_STRING, 2, (NvU32 *)g_valuesPS_SHADERDISKCACHE, PS_SHADERDISKCACHE_ON}, {PS_SHADERDISKCACHE_MAX_SIZE_ID, PS_SHADERDISKCACHE_MAX_SIZE_STRING, 2, (NvU32 *)g_valuesPS_SHADERDISKCACHE_MAX_SIZE, 0x00000000}, {PS_TEXFILTER_ANISO_OPTS2_ID, PS_TEXFILTER_ANISO_OPTS2_STRING, 2, (NvU32 *)g_valuesPS_TEXFILTER_ANISO_OPTS2, PS_TEXFILTER_ANISO_OPTS2_OFF}, diff --git a/NvApiDriverSettings.h b/NvApiDriverSettings.h index 3c4308a..555b4d4 100644 --- a/NvApiDriverSettings.h +++ b/NvApiDriverSettings.h @@ -1,6 +1,6 @@ /*********************************************************************************************************\ |* *| -|* SPDX-FileCopyrightText: Copyright (c) 2019-2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. *| +|* SPDX-FileCopyrightText: Copyright (c) 2019-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. *| |* SPDX-License-Identifier: MIT *| |* *| |* Permission is hereby granted, free of charge, to any person obtaining a *| @@ -77,21 +77,30 @@ #define LATENCY_INDICATOR_AUTOALIGN_STRING L"Autoalign flash indicator" #define MCSFRSHOWSPLIT_STRING L"SLI indicator" #define NGX_DLAA_OVERRIDE_STRING L"Override DLSS mode to be DLAA" +#define NGX_DLSSG_DYNAMIC_MULTI_FRAME_COUNT_MAX_STRING L"Override maximum DLSSG dynamic multi frame count" +#define NGX_DLSSG_DYNAMIC_TARGET_FRAME_RATE_STRING L"Override DLSSG Target Frame Rate" +#define NGX_DLSSG_MODE_STRING L"Override DLSSG mode" #define NGX_DLSSG_MULTI_FRAME_COUNT_STRING L"Override DLSSG multi-frame count" #define NGX_DLSS_FG_OVERRIDE_STRING L"Enable DLSS-FG override" +#define NGX_DLSS_FG_OVERRIDE_RENDER_PRESET_SELECTION_STRING L"Override DLSS-FG preset" #define NGX_DLSS_FG_OVERRIDE_RESERVED_KEY1_STRING L"Override reserved key 1 for FG" #define NGX_DLSS_FG_OVERRIDE_RESERVED_KEY2_STRING L"Override reserved key 2 for FG" +#define NGX_DLSS_NR_OVERRIDE_STRING L"Enable DLSS NR override" +#define NGX_DLSS_NR_OVERRIDE_RENDER_PRESET_SELECTION_STRING L"Override DLSS NR presets" +#define NGX_DLSS_NR_SL_OVERRIDE_STRING L"Enable DLSS NR SL override" #define NGX_DLSS_OVERRIDE_OPTIMAL_SETTINGS_STRING L"Override DLSS performance mode to be ultra-perfomance" #define NGX_DLSS_RR_MODE_STRING L"Override DLSS-RR performance mode" #define NGX_DLSS_RR_OVERRIDE_STRING L"Enable DLSS-RR override" #define NGX_DLSS_RR_OVERRIDE_RENDER_PRESET_SELECTION_STRING L"Override DLSS-RR preset" #define NGX_DLSS_RR_OVERRIDE_RESERVED_KEY1_STRING L"Override reserved key 1 for RR" #define NGX_DLSS_RR_OVERRIDE_RESERVED_KEY2_STRING L"Override reserved key 2 for RR" +#define NGX_DLSS_RR_OVERRIDE_SCALING_RATIO_STRING L"Override scaling ratio for DLSS-RR" #define NGX_DLSS_SR_MODE_STRING L"Override DLSS-SR performance mode" #define NGX_DLSS_SR_OVERRIDE_STRING L"Enable DLSS-SR override" #define NGX_DLSS_SR_OVERRIDE_RENDER_PRESET_SELECTION_STRING L"Override DLSS-SR presets" #define NGX_DLSS_SR_OVERRIDE_RESERVED_KEY1_STRING L"Override reserved key 1 for SR" #define NGX_DLSS_SR_OVERRIDE_RESERVED_KEY2_STRING L"Override reserved key 2 for SR" +#define NGX_DLSS_SR_OVERRIDE_SCALING_RATIO_STRING L"Override scaling ratio for DLSS-SR" #define NV_QUALITY_UPSCALING_STRING L"NVIDIA Quality upscaling" #define OPTIMUS_MAXAA_STRING L"Maximum AA samples allowed for a given application" #define PHYSXINDICATOR_STRING L"Display the PhysX indicator" @@ -130,6 +139,7 @@ #define LODBIASADJUST_STRING L"Texture filtering - LOD Bias" #define MAXWELL_B_SAMPLE_INTERLEAVE_STRING L"Enable sample interleaving (MFAA)" #define PRERENDERLIMIT_STRING L"Maximum pre-rendered frames" +#define PS_OFFLINE_SHADER_COMPILER_STRING L"Offline Shader Compile" #define PS_SHADERDISKCACHE_STRING L"Shader Cache" #define PS_SHADERDISKCACHE_DLL_PATH_WCHAR_STRING L"shader cache path to dll" #define PS_SHADERDISKCACHE_MAX_SIZE_STRING L"Shader disk cache maximum size" @@ -196,21 +206,30 @@ enum ESetting { LATENCY_INDICATOR_AUTOALIGN_ID = 0x1095F170, MCSFRSHOWSPLIT_ID = 0x10287051, NGX_DLAA_OVERRIDE_ID = 0x10E41DF4, + NGX_DLSSG_DYNAMIC_MULTI_FRAME_COUNT_MAX_ID = 0x10562D0F, + NGX_DLSSG_DYNAMIC_TARGET_FRAME_RATE_ID = 0x10CF4125, + NGX_DLSSG_MODE_ID = 0x10308298, NGX_DLSSG_MULTI_FRAME_COUNT_ID = 0x104D6667, NGX_DLSS_FG_OVERRIDE_ID = 0x10E41E03, + NGX_DLSS_FG_OVERRIDE_RENDER_PRESET_SELECTION_ID = 0x10E41DF1, NGX_DLSS_FG_OVERRIDE_RESERVED_KEY1_ID = 0x10C7D57E, NGX_DLSS_FG_OVERRIDE_RESERVED_KEY2_ID = 0x10C7D519, + NGX_DLSS_NR_OVERRIDE_ID = 0x10E41E04, + NGX_DLSS_NR_OVERRIDE_RENDER_PRESET_SELECTION_ID = 0x10E41DF8, + NGX_DLSS_NR_SL_OVERRIDE_ID = 0x10E41E05, NGX_DLSS_OVERRIDE_OPTIMAL_SETTINGS_ID = 0x10AFB76C, NGX_DLSS_RR_MODE_ID = 0x10BD9423, NGX_DLSS_RR_OVERRIDE_ID = 0x10E41E02, NGX_DLSS_RR_OVERRIDE_RENDER_PRESET_SELECTION_ID = 0x10E41DF7, NGX_DLSS_RR_OVERRIDE_RESERVED_KEY1_ID = 0x10C7D86C, NGX_DLSS_RR_OVERRIDE_RESERVED_KEY2_ID = 0x10C7D597, + NGX_DLSS_RR_OVERRIDE_SCALING_RATIO_ID = 0x10C7D4A2, NGX_DLSS_SR_MODE_ID = 0x10AFB768, NGX_DLSS_SR_OVERRIDE_ID = 0x10E41E01, NGX_DLSS_SR_OVERRIDE_RENDER_PRESET_SELECTION_ID = 0x10E41DF3, NGX_DLSS_SR_OVERRIDE_RESERVED_KEY1_ID = 0x10C7D684, NGX_DLSS_SR_OVERRIDE_RESERVED_KEY2_ID = 0x10C7D82C, + NGX_DLSS_SR_OVERRIDE_SCALING_RATIO_ID = 0x10E41DF5, NV_QUALITY_UPSCALING_ID = 0x10444444, OPTIMUS_MAXAA_ID = 0x10F9DC83, PHYSXINDICATOR_ID = 0x1094F16F, @@ -249,6 +268,7 @@ enum ESetting { LODBIASADJUST_ID = 0x00738E8F, MAXWELL_B_SAMPLE_INTERLEAVE_ID = 0x0098C1AC, PRERENDERLIMIT_ID = 0x007BA09E, + PS_OFFLINE_SHADER_COMPILER_ID = 0x00D74EF6, PS_SHADERDISKCACHE_ID = 0x00198FFF, PS_SHADERDISKCACHE_DLL_PATH_WCHAR_ID = 0x0019A002, PS_SHADERDISKCACHE_MAX_SIZE_ID = 0x00AC8497, @@ -263,9 +283,9 @@ enum ESetting { SET_VAB_DATA_ID = 0x00AB8687, VSYNCMODE_ID = 0x00A879CF, VSYNCTEARCONTROL_ID = 0x005A375C, - TOTAL_DWORD_SETTING_NUM = 112, + TOTAL_DWORD_SETTING_NUM = 122, TOTAL_WSTRING_SETTING_NUM = 5, - TOTAL_SETTING_NUM = 117, + TOTAL_SETTING_NUM = 127, INVALID_SETTING_ID = 0xFFFFFFFF }; @@ -704,11 +724,39 @@ enum EValues_NGX_DLAA_OVERRIDE { NGX_DLAA_OVERRIDE_DEFAULT = NGX_DLAA_OVERRIDE_DLAA_DEFAULT }; +enum EValues_NGX_DLSSG_DYNAMIC_MULTI_FRAME_COUNT_MAX { + NGX_DLSSG_DYNAMIC_MULTI_FRAME_COUNT_MAX_OFF = 0, + NGX_DLSSG_DYNAMIC_MULTI_FRAME_COUNT_MAX_MIN = 1, + NGX_DLSSG_DYNAMIC_MULTI_FRAME_COUNT_MAX_MAX = 16777215, + NGX_DLSSG_DYNAMIC_MULTI_FRAME_COUNT_MAX_NUM_VALUES = 3, + NGX_DLSSG_DYNAMIC_MULTI_FRAME_COUNT_MAX_DEFAULT = NGX_DLSSG_DYNAMIC_MULTI_FRAME_COUNT_MAX_OFF +}; + +enum EValues_NGX_DLSSG_DYNAMIC_TARGET_FRAME_RATE { + NGX_DLSSG_DYNAMIC_TARGET_FRAME_RATE_DISABLED = 0, + NGX_DLSSG_DYNAMIC_TARGET_FRAME_RATE_MIN = 0x00000001, + NGX_DLSSG_DYNAMIC_TARGET_FRAME_RATE_MAX = 0x00FFFFFF, + NGX_DLSSG_DYNAMIC_TARGET_FRAME_RATE_AUTO = 0x01000000, + NGX_DLSSG_DYNAMIC_TARGET_FRAME_RATE_NUM_VALUES = 4, + NGX_DLSSG_DYNAMIC_TARGET_FRAME_RATE_DEFAULT = NGX_DLSSG_DYNAMIC_TARGET_FRAME_RATE_DISABLED +}; + +enum EValues_NGX_DLSSG_MODE { + NGX_DLSSG_MODE_DISABLED = 0, + NGX_DLSSG_MODE_OFF = 1, + NGX_DLSSG_MODE_ON = 2, + NGX_DLSSG_MODE_AUTO = 3, + NGX_DLSSG_MODE_DYNAMIC = 4, + NGX_DLSSG_MODE_NUM_VALUES = 5, + NGX_DLSSG_MODE_DEFAULT = NGX_DLSSG_MODE_DISABLED +}; + enum EValues_NGX_DLSSG_MULTI_FRAME_COUNT { + NGX_DLSSG_MULTI_FRAME_COUNT_OFF = 0, NGX_DLSSG_MULTI_FRAME_COUNT_MIN = 1, NGX_DLSSG_MULTI_FRAME_COUNT_MAX = 15, - NGX_DLSSG_MULTI_FRAME_COUNT_DEFAULT = 1, NGX_DLSSG_MULTI_FRAME_COUNT_NUM_VALUES = 3, + NGX_DLSSG_MULTI_FRAME_COUNT_DEFAULT = NGX_DLSSG_MULTI_FRAME_COUNT_OFF }; enum EValues_NGX_DLSS_FG_OVERRIDE { @@ -718,6 +766,40 @@ enum EValues_NGX_DLSS_FG_OVERRIDE { NGX_DLSS_FG_OVERRIDE_DEFAULT = NGX_DLSS_FG_OVERRIDE_OFF }; +enum EValues_NGX_DLSS_FG_OVERRIDE_RENDER_PRESET_SELECTION { + NGX_DLSS_FG_OVERRIDE_RENDER_PRESET_SELECTION_OFF = 0, + NGX_DLSS_FG_OVERRIDE_RENDER_PRESET_SELECTION_RENDER_PRESET_A = 1, + NGX_DLSS_FG_OVERRIDE_RENDER_PRESET_SELECTION_RENDER_PRESET_B = 2, + NGX_DLSS_FG_OVERRIDE_RENDER_PRESET_SELECTION_RENDER_PRESET_C = 3, + NGX_DLSS_FG_OVERRIDE_RENDER_PRESET_SELECTION_RENDER_PRESET_D = 4, + NGX_DLSS_FG_OVERRIDE_RENDER_PRESET_SELECTION_RENDER_PRESET_E = 5, + NGX_DLSS_FG_OVERRIDE_RENDER_PRESET_SELECTION_RENDER_PRESET_F = 6, + NGX_DLSS_FG_OVERRIDE_RENDER_PRESET_SELECTION_RENDER_PRESET_G = 7, + NGX_DLSS_FG_OVERRIDE_RENDER_PRESET_SELECTION_RENDER_PRESET_H = 8, + NGX_DLSS_FG_OVERRIDE_RENDER_PRESET_SELECTION_RENDER_PRESET_I = 9, + NGX_DLSS_FG_OVERRIDE_RENDER_PRESET_SELECTION_RENDER_PRESET_J = 10, + NGX_DLSS_FG_OVERRIDE_RENDER_PRESET_SELECTION_RENDER_PRESET_K = 11, + NGX_DLSS_FG_OVERRIDE_RENDER_PRESET_SELECTION_RENDER_PRESET_L = 12, + NGX_DLSS_FG_OVERRIDE_RENDER_PRESET_SELECTION_RENDER_PRESET_M = 13, + NGX_DLSS_FG_OVERRIDE_RENDER_PRESET_SELECTION_RENDER_PRESET_N = 14, + NGX_DLSS_FG_OVERRIDE_RENDER_PRESET_SELECTION_RENDER_PRESET_O = 15, + NGX_DLSS_FG_OVERRIDE_RENDER_PRESET_SELECTION_RENDER_PRESET_P = 16, + NGX_DLSS_FG_OVERRIDE_RENDER_PRESET_SELECTION_RENDER_PRESET_Q = 17, + NGX_DLSS_FG_OVERRIDE_RENDER_PRESET_SELECTION_RENDER_PRESET_R = 18, + NGX_DLSS_FG_OVERRIDE_RENDER_PRESET_SELECTION_RENDER_PRESET_S = 19, + NGX_DLSS_FG_OVERRIDE_RENDER_PRESET_SELECTION_RENDER_PRESET_T = 20, + NGX_DLSS_FG_OVERRIDE_RENDER_PRESET_SELECTION_RENDER_PRESET_U = 21, + NGX_DLSS_FG_OVERRIDE_RENDER_PRESET_SELECTION_RENDER_PRESET_V = 22, + NGX_DLSS_FG_OVERRIDE_RENDER_PRESET_SELECTION_RENDER_PRESET_W = 23, + NGX_DLSS_FG_OVERRIDE_RENDER_PRESET_SELECTION_RENDER_PRESET_X = 24, + NGX_DLSS_FG_OVERRIDE_RENDER_PRESET_SELECTION_RENDER_PRESET_Y = 25, + NGX_DLSS_FG_OVERRIDE_RENDER_PRESET_SELECTION_RENDER_PRESET_Z = 26, + NGX_DLSS_FG_OVERRIDE_RENDER_PRESET_SELECTION_RENDER_PRESET_Default = 0x00fffffe, + NGX_DLSS_FG_OVERRIDE_RENDER_PRESET_SELECTION_RENDER_PRESET_Latest = 0x00ffffff, + NGX_DLSS_FG_OVERRIDE_RENDER_PRESET_SELECTION_NUM_VALUES = 29, + NGX_DLSS_FG_OVERRIDE_RENDER_PRESET_SELECTION_DEFAULT = NGX_DLSS_FG_OVERRIDE_RENDER_PRESET_SELECTION_OFF +}; + enum EValues_NGX_DLSS_FG_OVERRIDE_RESERVED_KEY1 { NGX_DLSS_FG_OVERRIDE_RESERVED_KEY1_DEFAULT = 0, NGX_DLSS_FG_OVERRIDE_RESERVED_KEY1_NUM_VALUES = 1, @@ -728,6 +810,31 @@ enum EValues_NGX_DLSS_FG_OVERRIDE_RESERVED_KEY2 { NGX_DLSS_FG_OVERRIDE_RESERVED_KEY2_NUM_VALUES = 1, }; +enum EValues_NGX_DLSS_NR_OVERRIDE { + NGX_DLSS_NR_OVERRIDE_OFF = 0, + NGX_DLSS_NR_OVERRIDE_ON = 1, + NGX_DLSS_NR_OVERRIDE_NUM_VALUES = 2, + NGX_DLSS_NR_OVERRIDE_DEFAULT = NGX_DLSS_NR_OVERRIDE_OFF +}; + +enum EValues_NGX_DLSS_NR_OVERRIDE_RENDER_PRESET_SELECTION { + NGX_DLSS_NR_OVERRIDE_RENDER_PRESET_SELECTION_OFF = 0, + NGX_DLSS_NR_OVERRIDE_RENDER_PRESET_SELECTION_RENDER_PRESET_A = 1, + NGX_DLSS_NR_OVERRIDE_RENDER_PRESET_SELECTION_RENDER_PRESET_B = 2, + NGX_DLSS_NR_OVERRIDE_RENDER_PRESET_SELECTION_RENDER_PRESET_C = 3, + NGX_DLSS_NR_OVERRIDE_RENDER_PRESET_SELECTION_RENDER_PRESET_D = 4, + NGX_DLSS_NR_OVERRIDE_RENDER_PRESET_SELECTION_RENDER_PRESET_Latest = 0x00ffffff, + NGX_DLSS_NR_OVERRIDE_RENDER_PRESET_SELECTION_NUM_VALUES = 6, + NGX_DLSS_NR_OVERRIDE_RENDER_PRESET_SELECTION_DEFAULT = NGX_DLSS_NR_OVERRIDE_RENDER_PRESET_SELECTION_OFF +}; + +enum EValues_NGX_DLSS_NR_SL_OVERRIDE { + NGX_DLSS_NR_SL_OVERRIDE_OFF = 0, + NGX_DLSS_NR_SL_OVERRIDE_ON = 1, + NGX_DLSS_NR_SL_OVERRIDE_NUM_VALUES = 2, + NGX_DLSS_NR_SL_OVERRIDE_DEFAULT = NGX_DLSS_NR_SL_OVERRIDE_OFF +}; + enum EValues_NGX_DLSS_OVERRIDE_OPTIMAL_SETTINGS { NGX_DLSS_OVERRIDE_OPTIMAL_SETTINGS_NGX_DLSS_OVERRIDE_OPTIMAL_SETTINGS_NONE = 0x0000, NGX_DLSS_OVERRIDE_OPTIMAL_SETTINGS_NGX_DLSS_OVERRIDE_OPTIMAL_SETTINGS_PERF_TO_9X = 0x0001, @@ -786,6 +893,13 @@ enum EValues_NGX_DLSS_RR_OVERRIDE_RESERVED_KEY2 { NGX_DLSS_RR_OVERRIDE_RESERVED_KEY2_NUM_VALUES = 1, }; +enum EValues_NGX_DLSS_RR_OVERRIDE_SCALING_RATIO { + NGX_DLSS_RR_OVERRIDE_SCALING_RATIO_MIN = 33, + NGX_DLSS_RR_OVERRIDE_SCALING_RATIO_MAX = 100, + NGX_DLSS_RR_OVERRIDE_SCALING_RATIO_DEFAULT = 0, + NGX_DLSS_RR_OVERRIDE_SCALING_RATIO_NUM_VALUES = 3, +}; + enum EValues_NGX_DLSS_SR_MODE { NGX_DLSS_SR_MODE_NGX_DLSS_SR_MODE_PERFORMANCE = 0, NGX_DLSS_SR_MODE_NGX_DLSS_SR_MODE_BALANCED = 1, @@ -794,7 +908,8 @@ enum EValues_NGX_DLSS_SR_MODE { NGX_DLSS_SR_MODE_NGX_DLSS_SR_MODE_DLAA = 4, NGX_DLSS_SR_MODE_NGX_DLSS_SR_MODE_ULTRA_PERFORMANCE = 5, NGX_DLSS_SR_MODE_NGX_DLSS_SR_MODE_CUSTOM = 6, - NGX_DLSS_SR_MODE_NUM_VALUES = 7, + NGX_DLSS_SR_MODE_NGX_DLSS_SR_MODE_RESERVED_A = 7, + NGX_DLSS_SR_MODE_NUM_VALUES = 8, NGX_DLSS_SR_MODE_DEFAULT = NGX_DLSS_SR_MODE_NGX_DLSS_SR_MODE_SNIPPET_CONTROLLED }; @@ -837,6 +952,13 @@ enum EValues_NGX_DLSS_SR_OVERRIDE_RESERVED_KEY2 { NGX_DLSS_SR_OVERRIDE_RESERVED_KEY2_NUM_VALUES = 1, }; +enum EValues_NGX_DLSS_SR_OVERRIDE_SCALING_RATIO { + NGX_DLSS_SR_OVERRIDE_SCALING_RATIO_MIN = 33, + NGX_DLSS_SR_OVERRIDE_SCALING_RATIO_MAX = 100, + NGX_DLSS_SR_OVERRIDE_SCALING_RATIO_DEFAULT = 0, + NGX_DLSS_SR_OVERRIDE_SCALING_RATIO_NUM_VALUES = 3, +}; + enum EValues_NV_QUALITY_UPSCALING { NV_QUALITY_UPSCALING_OFF = 0, NV_QUALITY_UPSCALING_ON = 1, @@ -1196,6 +1318,13 @@ enum EValues_PRERENDERLIMIT { PRERENDERLIMIT_DEFAULT = PRERENDERLIMIT_APP_CONTROLLED }; +enum EValues_PS_OFFLINE_SHADER_COMPILER { + PS_OFFLINE_SHADER_COMPILER_OFF = 0x07184358, + PS_OFFLINE_SHADER_COMPILER_ON = 0x64318112, + PS_OFFLINE_SHADER_COMPILER_NUM_VALUES = 2, + PS_OFFLINE_SHADER_COMPILER_DEFAULT = PS_OFFLINE_SHADER_COMPILER_ON +}; + enum EValues_PS_SHADERDISKCACHE { PS_SHADERDISKCACHE_OFF = 0x00000000, PS_SHADERDISKCACHE_ON = 0x00000001, @@ -1207,7 +1336,7 @@ enum EValues_PS_SHADERDISKCACHE_MAX_SIZE { PS_SHADERDISKCACHE_MAX_SIZE_MIN = 0x0, PS_SHADERDISKCACHE_MAX_SIZE_MAX = 0xffffffff, PS_SHADERDISKCACHE_MAX_SIZE_NUM_VALUES = 2, - PS_SHADERDISKCACHE_MAX_SIZE_DEFAULT = 0x2000 + PS_SHADERDISKCACHE_MAX_SIZE_DEFAULT = 0x4000 }; enum EValues_PS_TEXFILTER_ANISO_OPTS2 { diff --git a/README.md b/README.md new file mode 100644 index 0000000..69e7647 --- /dev/null +++ b/README.md @@ -0,0 +1,20 @@ +# NVAPI SDK + +NVAPI is NVIDIA's API for accessing GPU and driver features on systems with NVIDIA hardware. This repository contains the public, open-source components of the NVAPI SDK: headers, interface definitions, and libraries (nvapi.lib / nvapi64.lib) for building applications that use NVAPI. The actual NVAPI implementation is provided by the NVIDIA GPU driver installed on the system. +## Documentation + +For detailed information on NVAPI features and usage, see the documentation in the [docs](docs) folder. + +## Sample Code + +The [Sample_Code](Sample_Code) folder contains example applications that demonstrate key SDK features and API usage. + +## License + +This project is licensed under the MIT License. See the [LICENSE](License.txt) file for details. + +## Contributing + +This project is currently not accepting contributions. + +For bug reports, comments, or questions, please visit the [NVAPI Developer Forum](https://forums.developer.nvidia.com/c/developer-tools/other-tools/nvapi/) diff --git a/Sample_Code/CustomTiming/CustomTiming.cpp b/Sample_Code/CustomTiming/CustomTiming.cpp index cf52c18..08c0ee2 100644 --- a/Sample_Code/CustomTiming/CustomTiming.cpp +++ b/Sample_Code/CustomTiming/CustomTiming.cpp @@ -1,5 +1,5 @@ /* - * SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. + * SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. * SPDX-License-Identifier: MIT * * Permission is hereby granted, free of charge, to any person obtaining a @@ -49,7 +49,7 @@ NvAPI_Status ApplyCustomDisplay(); // This function enumerates the display Ids of all the connected displays -NvAPI_Status GetConnectedDisplays(NvU32 *displayIds, NvU32 *noDisplays); +NvAPI_Status GetConnectedDisplays(NvU32 *displayIds, NvU32 capacity, NvU32 *noDisplays); // This function applies custom display settings, saves them and reverts back. void loadCustomDisplay(NV_CUSTOM_DISPLAY *customDisplay); @@ -105,7 +105,7 @@ void loadCustomDisplay(NV_CUSTOM_DISPLAY *cd) cd->yRatio = 1; } -NvAPI_Status GetConnectedDisplays(NvU32 *displayIds, NvU32 *noDisplays) +NvAPI_Status GetConnectedDisplays(NvU32 *displayIds, NvU32 capacity, NvU32 *noDisplays) { NvAPI_Status ret = NVAPI_OK; @@ -133,7 +133,7 @@ NvAPI_Status GetConnectedDisplays(NvU32 *displayIds, NvU32 *noDisplays) { // alocations for the display ids NV_GPU_DISPLAYIDS *dispIds = (NV_GPU_DISPLAYIDS *)malloc( sizeof(NV_GPU_DISPLAYIDS)*dispIdCount ); - + if (!dispIds) return NVAPI_OUT_OF_MEMORY; for(NvU32 dispIndex = 0; dispIndex < dispIdCount; dispIndex++) { dispIds[dispIndex].version = NV_GPU_DISPLAYIDS_VER; // adding the correct version information @@ -142,6 +142,7 @@ NvAPI_Status GetConnectedDisplays(NvU32 *displayIds, NvU32 *noDisplays) // second call to get the display ids if(NvAPI_GPU_GetConnectedDisplayIds(nvGPUHandle[Count], dispIds, &dispIdCount, 0) != NVAPI_OK) { + free(dispIds); return NVAPI_ERROR; } @@ -151,9 +152,11 @@ NvAPI_Status GetConnectedDisplays(NvU32 *displayIds, NvU32 *noDisplays) { continue; } + if (noDisplay >= capacity) break; displayIds[noDisplay] = dispIds[dispIndex].displayId; noDisplay++; } + free(dispIds); } } @@ -171,7 +174,7 @@ NvAPI_Status ApplyCustomDisplay() NvU32 displayIds[NVAPI_MAX_DISPLAYS] = {0}; - ret = GetConnectedDisplays(&displayIds[0],&noDisplays); + ret = GetConnectedDisplays(&displayIds[0], NVAPI_MAX_DISPLAYS, &noDisplays); if(ret != NVAPI_OK) { printf("\nCall to GetConnectedDisplays() failed"); @@ -248,7 +251,7 @@ NvAPI_Status ApplyCustomDisplay() printf("NvAPI_DISP_RevertCustomDisplayTrial()"); // Revert the new custom display settings tried. - ret = NvAPI_DISP_RevertCustomDisplayTrial(&displayIds[0],1); + ret = NvAPI_DISP_RevertCustomDisplayTrial(&displayIds[0], noDisplays); if ( ret != NVAPI_OK) { printf("NvAPI_DISP_RevertCustomDisplayTrial() failed = %d", ret); //failed to revert custom display trail diff --git a/Sample_Code/DisplayColorControl/DisplayColorControl.cpp b/Sample_Code/DisplayColorControl/DisplayColorControl.cpp index ddc5401..605ce6b 100644 --- a/Sample_Code/DisplayColorControl/DisplayColorControl.cpp +++ b/Sample_Code/DisplayColorControl/DisplayColorControl.cpp @@ -1,5 +1,5 @@ /* - * SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. + * SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. * SPDX-License-Identifier: MIT * * Permission is hereby granted, free of charge, to any person obtaining a diff --git a/Sample_Code/DisplayColorControl/NVHelper.cpp b/Sample_Code/DisplayColorControl/NVHelper.cpp index 094506f..e995195 100644 --- a/Sample_Code/DisplayColorControl/NVHelper.cpp +++ b/Sample_Code/DisplayColorControl/NVHelper.cpp @@ -1,5 +1,5 @@ /* - * SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. + * SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. * SPDX-License-Identifier: MIT * * Permission is hereby granted, free of charge, to any person obtaining a @@ -85,6 +85,12 @@ NvAPI_Status GetConnectedDisplays(NvPhysicalGpuHandle gpuHandle, NV_GPU_DISPLAYI if (displayCount == 0) return nvapiReturnStatus; + if (displayCount > NVAPI_MAX_DISPLAYS) + { + printf("\nDisplay count is greater than NVAPI_MAX_DISPLAYS.\nReturn Error : %s", GetNvAPIStatusString(nvapiReturnStatus)); + return NVAPI_INVALID_ARGUMENT; + } + // alocation for the display ids NV_GPU_DISPLAYIDS *dispIds = new NV_GPU_DISPLAYIDS[displayCount]; if (!dispIds) @@ -92,12 +98,19 @@ NvAPI_Status GetConnectedDisplays(NvPhysicalGpuHandle gpuHandle, NV_GPU_DISPLAYI return NVAPI_OUT_OF_MEMORY; } - dispIds[0].version = NV_GPU_DISPLAYIDS_VER; + for (NvU32 i = 0; i < displayCount; i++) + { + dispIds[i].version = NV_GPU_DISPLAYIDS_VER; + } nvapiReturnStatus = NvAPI_GPU_GetConnectedDisplayIds(gpuHandle, dispIds, &displayCount, 0); if (nvapiReturnStatus == NVAPI_OK) { - memcpy_s(pDisplayID, sizeof(NV_GPU_DISPLAYIDS) * NVAPI_MAX_DISPLAYS, dispIds, sizeof(NV_GPU_DISPLAYIDS) * displayCount); + if (memcpy_s(pDisplayID, sizeof(NV_GPU_DISPLAYIDS) * NVAPI_MAX_DISPLAYS, dispIds, sizeof(NV_GPU_DISPLAYIDS) * displayCount) != 0) + { + delete[] dispIds; + return NVAPI_ERROR; + } displayIdCount = displayCount; } diff --git a/Sample_Code/DisplayColorControl/NVHelper.h b/Sample_Code/DisplayColorControl/NVHelper.h index 80aca21..fb26850 100644 --- a/Sample_Code/DisplayColorControl/NVHelper.h +++ b/Sample_Code/DisplayColorControl/NVHelper.h @@ -1,5 +1,5 @@ /* - * SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. + * SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. * SPDX-License-Identifier: MIT * * Permission is hereby granted, free of charge, to any person obtaining a diff --git a/Sample_Code/DisplayColorControl/stdafx.h b/Sample_Code/DisplayColorControl/stdafx.h new file mode 100644 index 0000000..d33daa6 --- /dev/null +++ b/Sample_Code/DisplayColorControl/stdafx.h @@ -0,0 +1,18 @@ +// stdafx.h : include file for standard system include files, +// or project specific include files that are used frequently, but +// are changed infrequently +// + +#pragma once + +#define _CRT_SECURE_NO_WARNINGS // To deprecate the warning messages for not using unsecure functions. + +#include "targetver.h" + +#include +#include +#include +#include +#include +#include +#include diff --git a/Sample_Code/DisplayColorControl/targetver.h b/Sample_Code/DisplayColorControl/targetver.h new file mode 100644 index 0000000..13f8c8c --- /dev/null +++ b/Sample_Code/DisplayColorControl/targetver.h @@ -0,0 +1,45 @@ +/************************************************************************************************************************************\ +|* *| +|* Copyright � 2025 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 *| +|* and / or non-disclosure 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. *| +|* *| +\************************************************************************************************************************************/ +#pragma once + +// The following macros define the minimum required platform. The minimum required platform +// is the earliest version of Windows, Internet Explorer etc. that has the necessary features to run +// your application. The macros work by enabling all features available on platform versions up to and +// including the version specified. + +// Modify the following defines if you have to target a platform prior to the ones specified below. +// Refer to MSDN for the latest info on corresponding values for different platforms. +#ifndef _WIN32_WINNT // Specifies that the minimum required platform is Windows Vista. +#define _WIN32_WINNT 0x0600 // Change this to the appropriate value to target other versions of Windows. +#endif \ No newline at end of file diff --git a/Sample_Code/DisplayConfiguration/DisplayConfiguration.cpp b/Sample_Code/DisplayConfiguration/DisplayConfiguration.cpp index c79f210..3344e82 100644 --- a/Sample_Code/DisplayConfiguration/DisplayConfiguration.cpp +++ b/Sample_Code/DisplayConfiguration/DisplayConfiguration.cpp @@ -1,5 +1,5 @@ /* - * SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. + * SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. * SPDX-License-Identifier: MIT * * Permission is hereby granted, free of charge, to any person obtaining a @@ -90,10 +90,7 @@ NvAPI_Status AllocateAndGetDisplayConfig(NvU32* pathInfoCount, NV_DISPLAYCONFIG_ // Retrieve the targetInfo counts ret = NvAPI_DISP_GetDisplayConfig(&pathCount, pathInfo); - if (ret != NVAPI_OK) - { - return ret; - } + if (ret != NVAPI_OK) goto cleanup; for (NvU32 i = 0; i < pathCount; i++) { @@ -105,29 +102,24 @@ NvAPI_Status AllocateAndGetDisplayConfig(NvU32* pathInfoCount, NV_DISPLAYCONFIG_ } else { - #ifdef NV_DISPLAYCONFIG_PATH_INFO_VER3 pathInfo[i].sourceModeInfo = (NV_DISPLAYCONFIG_SOURCE_MODE_INFO*) malloc(pathInfo[i].sourceModeInfoCount * sizeof(NV_DISPLAYCONFIG_SOURCE_MODE_INFO)); #endif - - } - if (pathInfo[i].sourceModeInfo == NULL) - { - return NVAPI_OUT_OF_MEMORY; } + if (pathInfo[i].sourceModeInfo == NULL) { ret = NVAPI_OUT_OF_MEMORY; goto cleanup; } + memset(pathInfo[i].sourceModeInfo, 0, sizeof(NV_DISPLAYCONFIG_SOURCE_MODE_INFO)); // Allocate the target array pathInfo[i].targetInfo = (NV_DISPLAYCONFIG_PATH_TARGET_INFO*) malloc(pathInfo[i].targetInfoCount * sizeof(NV_DISPLAYCONFIG_PATH_TARGET_INFO)); - if (pathInfo[i].targetInfo == NULL) - { - return NVAPI_OUT_OF_MEMORY; - } + if (pathInfo[i].targetInfo == NULL) { ret = NVAPI_OUT_OF_MEMORY; goto cleanup; } + // Allocate the target details memset(pathInfo[i].targetInfo, 0, pathInfo[i].targetInfoCount * sizeof(NV_DISPLAYCONFIG_PATH_TARGET_INFO)); for (NvU32 j = 0 ; j < pathInfo[i].targetInfoCount ; j++) { pathInfo[i].targetInfo[j].details = (NV_DISPLAYCONFIG_PATH_ADVANCED_TARGET_INFO*) malloc(sizeof(NV_DISPLAYCONFIG_PATH_ADVANCED_TARGET_INFO)); + if (pathInfo[i].targetInfo[j].details == NULL) { ret = NVAPI_OUT_OF_MEMORY; goto cleanup; } memset(pathInfo[i].targetInfo[j].details, 0, sizeof(NV_DISPLAYCONFIG_PATH_ADVANCED_TARGET_INFO)); pathInfo[i].targetInfo[j].details->version = NV_DISPLAYCONFIG_PATH_ADVANCED_TARGET_INFO_VER; } @@ -135,14 +127,28 @@ pathInfo[i].sourceModeInfo = (NV_DISPLAYCONFIG_SOURCE_MODE_INFO*) malloc(pathInf // Retrieve the full path info ret = NvAPI_DISP_GetDisplayConfig(&pathCount, pathInfo); - if (ret != NVAPI_OK) - { - return ret; - } + if (ret != NVAPI_OK) goto cleanup; *pathInfoCount = pathCount; *pPathInfo = pathInfo; return NVAPI_OK; + +cleanup: + if (pathInfo) + { + for (NvU32 i = 0; i < pathCount; i++) + { + if (pathInfo[i].targetInfo) + { + for (NvU32 j = 0; j < pathInfo[i].targetInfoCount; j++) + free(pathInfo[i].targetInfo[j].details); + free(pathInfo[i].targetInfo); + } + free(pathInfo[i].sourceModeInfo); + } + free(pathInfo); + } + return ret; } // This function is used to display the current GPU configuration and the connected displays @@ -181,6 +187,9 @@ void ShowCurrentDisplayConfig(void) for(NvU32 GpuIndex = 0; GpuIndex < physicalGpuCount; GpuIndex++) { + NvU32 nDisplayIds = 0; + NV_GPU_DISPLAYIDS* pDisplayIds = NULL; + ret = NvAPI_GPU_GetConnectedDisplayIds(hPhysicalGpu[GpuIndex], pDisplayIds, &nDisplayIds, 0); if((ret == NVAPI_OK) && nDisplayIds) { @@ -189,7 +198,10 @@ void ShowCurrentDisplayConfig(void) if (pDisplayIds) { memset(pDisplayIds, 0, nDisplayIds * sizeof(NV_GPU_DISPLAYIDS)); - pDisplayIds[GpuIndex].version = NV_GPU_DISPLAYIDS_VER; + for (NvU32 j = 0; j < nDisplayIds; j++) + { + pDisplayIds[j].version = NV_GPU_DISPLAYIDS_VER; + } ret = NvAPI_GPU_GetConnectedDisplayIds(hPhysicalGpu[DisplayGpuIndex], pDisplayIds, &nDisplayIds, 0); for(NvU32 DisplayIdIndex = 0; DisplayIdIndex < nDisplayIds; DisplayIdIndex++) { @@ -197,6 +209,7 @@ void ShowCurrentDisplayConfig(void) if(!pDisplayIds[DisplayIdIndex].displayId)printf("(NONE)"); printf("\n"); } + free(pDisplayIds); } } else @@ -257,7 +270,6 @@ NvAPI_Status SetMode(void) return ret; NV_DISPLAYCONFIG_PATH_ADVANCED_TARGET_INFO *details = NULL; - details = (NV_DISPLAYCONFIG_PATH_ADVANCED_TARGET_INFO*)malloc(sizeof(NV_DISPLAYCONFIG_PATH_ADVANCED_TARGET_INFO)); if( pathCount == 1 ) { @@ -292,7 +304,7 @@ NvAPI_Status SetMode(void) memset(primary, 0, pathInfo[0].targetInfoCount * sizeof(NV_DISPLAYCONFIG_PATH_TARGET_INFO)); primary->displayId = pathInfo[0].targetInfo[0].displayId; printf("."); - delete pathInfo[0].targetInfo; + free(pathInfo[0].targetInfo); pathInfo[0].targetInfo = primary; pathInfo[0].targetInfo[1].displayId = DisplayID; pathInfo[0].sourceModeInfo[0].bGDIPrimary = 1; // Decide the primary display @@ -312,8 +324,7 @@ NvAPI_Status SetMode(void) primary->displayId = DisplayID; primary->details = details; primary--; - delete pathInfo[0].targetInfo; - pathInfo[0].targetInfo = (NV_DISPLAYCONFIG_PATH_TARGET_INFO*) malloc(2 * sizeof(NV_DISPLAYCONFIG_PATH_TARGET_INFO)); + free(pathInfo[0].targetInfo); pathInfo[0].targetInfo = primary; } pathInfo[0].sourceModeInfo[0].bGDIPrimary = 1;// Decide the primary display diff --git a/Sample_Code/DisplayConfiguration/targetver.h b/Sample_Code/DisplayConfiguration/targetver.h index ebeed35..75c19f5 100644 --- a/Sample_Code/DisplayConfiguration/targetver.h +++ b/Sample_Code/DisplayConfiguration/targetver.h @@ -1,5 +1,5 @@ /* - * SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. + * SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. * SPDX-License-Identifier: MIT * * Permission is hereby granted, free of charge, to any person obtaining a diff --git a/Sample_Code/GPUHandleEnumeration/gpuHandleEnumeration.c b/Sample_Code/GPUHandleEnumeration/gpuHandleEnumeration.c index a91085e..7d9d2c1 100644 --- a/Sample_Code/GPUHandleEnumeration/gpuHandleEnumeration.c +++ b/Sample_Code/GPUHandleEnumeration/gpuHandleEnumeration.c @@ -1,5 +1,5 @@ /* - * SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. + * SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. * SPDX-License-Identifier: MIT * * Permission is hereby granted, free of charge, to any person obtaining a @@ -71,7 +71,7 @@ int main() } printf("\n\nThe enumerated logical GPU handles are listed below. GPU_Count=%d.\n", nvLogicalGPUs.gpuHandleCount); - for (NvU32 i = 0; i < nvLogicalGPUs.gpuHandleCount; i++) + for (NvU32 i = 0; i < nvLogicalGPUs.gpuHandleCount && i < NVAPI_MAX_LOGICAL_GPUS; i++) { printf("\nLogical_GPUHandle[%d]:0x%p | AdapterType = %d", i, nvLogicalGPUs.gpuHandleData[i].hLogicalGpu, nvLogicalGPUs.gpuHandleData[i].adapterType); @@ -91,7 +91,7 @@ int main() return -1; } - for (NvU32 i = 0; i < nvPhysicalGPUs.gpuHandleCount; i++) + for (NvU32 i = 0; i < nvPhysicalGPUs.gpuHandleCount && i < NVAPI_MAX_PHYSICAL_GPUS; i++) { printf("\nPhysical_GPUHandle[%d]:0x%p | AdapterType = %d", i, nvPhysicalGPUs.gpuHandleData[i].hPhysicalGpu, nvPhysicalGPUs.gpuHandleData[i].adapterType); diff --git a/Sample_Code/QSYNC_Event_Registration/QSYNC_Event_Registration.cpp b/Sample_Code/QSYNC_Event_Registration/QSYNC_Event_Registration.cpp index 1be803e..15f1de8 100644 --- a/Sample_Code/QSYNC_Event_Registration/QSYNC_Event_Registration.cpp +++ b/Sample_Code/QSYNC_Event_Registration/QSYNC_Event_Registration.cpp @@ -1,5 +1,5 @@ /* - * SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. + * SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. * SPDX-License-Identifier: MIT * * Permission is hereby granted, free of charge, to any person obtaining a diff --git a/Sample_Code/Sync_Configuration/Sync_Configuration.cpp b/Sample_Code/Sync_Configuration/Sync_Configuration.cpp index 85e9efb..f696361 100644 --- a/Sample_Code/Sync_Configuration/Sync_Configuration.cpp +++ b/Sample_Code/Sync_Configuration/Sync_Configuration.cpp @@ -1,5 +1,5 @@ /* - * SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved. + * SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. * SPDX-License-Identifier: MIT * * Permission is hereby granted, free of charge, to any person obtaining a @@ -28,9 +28,13 @@ #include #include"nvapi.h" +static inline const char* safe_lookup(const char* const* tbl, size_t n, unsigned idx) +{ + return (idx < n) ? tbl[idx] : ""; +} static const char* g_connector[] = {"NONE", "PRIMARY", "SECONDARY", "TERTIARY","QUARTERNARY"}; -static const char* g_dispSyncState[] = {"UNSYNCED", "SLAVE", "MASTER"}; +static const char* g_dispSyncState[] = {"UNSYNCED", "CLIENT", "SERVER"}; static const char* g_RJ45Status[] = {"OUTPUT", "INPUT", "UNUSED"}; static const char* g_RJ45Ethernet[] = {"NO", "YES"}; @@ -92,10 +96,10 @@ NvAPI_Status gSyncQueryParameters(NvGSyncDeviceHandle hNvGSyncDevice) printf("Refresh Rate : %d\n", StatusParams.refreshRate); printf("Incoming house sync freq : %d\n", StatusParams.houseSyncIncoming); printf("House sync present : %d\n", StatusParams.bHouseSync); - printf("RJ45[0] : %s\n", g_RJ45Status[(NvU32)StatusParams.RJ45_IO[0]]); - printf("RJ45[1] : %s\n", g_RJ45Status[(NvU32)StatusParams.RJ45_IO[1]]); - printf("RJ45[0] to ethernet? : %s\n", g_RJ45Ethernet[StatusParams.RJ45_Ethernet[0]]); - printf("RJ45[1] to ethernet? : %s\n", g_RJ45Ethernet[StatusParams.RJ45_Ethernet[1]]); + printf("RJ45[0] : %s\n", safe_lookup(g_RJ45Status, sizeof(g_RJ45Status)/sizeof(g_RJ45Status[0]), (NvU32)StatusParams.RJ45_IO[0])); + printf("RJ45[1] : %s\n", safe_lookup(g_RJ45Status, sizeof(g_RJ45Status)/sizeof(g_RJ45Status[0]), (NvU32)StatusParams.RJ45_IO[1])); + printf("RJ45[0] to ethernet? : %s\n", safe_lookup(g_RJ45Ethernet, sizeof(g_RJ45Ethernet)/sizeof(g_RJ45Ethernet[0]), StatusParams.RJ45_Ethernet[0])); + printf("RJ45[1] to ethernet? : %s\n", safe_lookup(g_RJ45Ethernet, sizeof(g_RJ45Ethernet)/sizeof(g_RJ45Ethernet[0]), StatusParams.RJ45_Ethernet[1])); } else { @@ -113,7 +117,7 @@ NvAPI_Status gSyncQuerySyncStatus(NvGSyncDeviceHandle nvGSyncHandle) NvU32 gsyncGpuCount = 0; ret = NvAPI_GSync_GetTopology(nvGSyncHandle, &gsyncGpuCount, NULL, NULL, NULL); - if ((ret != NVAPI_OK) && (gsyncGpuCount < 1)) + if ((ret != NVAPI_OK) || (gsyncGpuCount < 1)) { printf("GetTopology Call failed\n"); return ret; @@ -169,7 +173,7 @@ NvAPI_Status gsyncGetTopology(NvGSyncDeviceHandle *nvGSyncHandle, NvU32 count) NvU32 gsyncDisplayCount = 0; ret = NvAPI_GSync_GetTopology(nvGSyncHandle[k], &gsyncGpuCount, NULL, &gsyncDisplayCount, NULL); - if ((ret != NVAPI_OK)) + if ((ret != NVAPI_OK) || (gsyncGpuCount < 1) || (gsyncDisplayCount < 1)) { printf("GetTopology Call failed\n"); return ret; @@ -183,7 +187,7 @@ NvAPI_Status gsyncGetTopology(NvGSyncDeviceHandle *nvGSyncHandle, NvU32 count) gsyncSysInfo.gsyncTopo[k].hNvGSyncDevice = nvGSyncHandle[k]; ret = NvAPI_GSync_GetTopology(nvGSyncHandle[k], &gsyncGpuCount, pGsyncGpu, &gsyncDisplayCount, pGsyncDisp); - if (ret != NVAPI_OK) + if ((ret != NVAPI_OK) || (gsyncGpuCount < 1) || (gsyncDisplayCount < 1)) { printf("GetTopology Call failed\n"); @@ -201,8 +205,8 @@ NvAPI_Status gsyncGetTopology(NvGSyncDeviceHandle *nvGSyncHandle, NvU32 count) return ret; } - gsyncSysInfo.gsyncTopo[k].gpuCount = gsyncGpuCount; - for(NvU32 i=0; i NVAPI_MAX_GPUS_PER_GSYNC) ? NVAPI_MAX_GPUS_PER_GSYNC : gsyncGpuCount; + for(NvU32 i=0; i