node-gpuinfo 1.0.0

package/src/includes/adlx/ADLXHelper/ADLXHelper.c

@@ -0,0 +1,175 @@
+//
+// Copyright (c) 2021 - 2025 Advanced Micro Devices, Inc. All rights reserved.
+//
+//-------------------------------------------------------------------------------------------------
+#include "ADLXHelper.h"
+
+typedef struct ADLXHelper
+{
+	//Handle to the ADLX dll
+	adlx_handle m_hDLLHandle;
+
+	//Full Version of this ADLX instance
+	adlx_uint64 m_ADLXFullVersion;
+
+	//Version of this ADLX instance
+	const char* m_ADLXVersion;
+
+	//The ADLX system services interface
+	IADLXSystem* m_pSystemServices;
+
+	//the ADL mapping interface
+	IADLMapping* m_pAdlMapping;
+
+	//ADLX function - query full version
+	ADLXQueryFullVersion_Fn m_fullVersionFn;
+
+	//ADLX function - qery version
+	ADLXQueryVersion_Fn m_versionFn;
+
+	//ADLX function - initialize with ADL
+	ADLXInitializeWithCallerAdl_Fn m_initWithADLFn;
+
+	//ADLX function - initialize with incompatible driver
+	ADLXInitialize_Fn m_initFnEx;
+
+	//ADLX function - initialize
+	ADLXInitialize_Fn m_initFn;
+
+	//ADLX function - terminate
+	ADLXTerminate_Fn m_terminateFn;
+}ADLXHelper;
+
+static ADLXHelper g_ADLX = {NULL, 0, NULL, NULL, NULL, NULL, NULL, NULL, NULL};
+
+ADLX_RESULT InitializePrivate (adlx_handle  adlContext, ADLX_ADL_Main_Memory_Free adlMainMemoryFree, adlx_bool useIncompatibleDriver);
+
+//-------------------------------------------------------------------------------------------------
+//Initialization
+ADLX_RESULT ADLXHelper_Initialize ()
+{
+    return InitializePrivate (NULL, NULL, false);
+}
+
+ADLX_RESULT ADLXHelper_InitializeWithIncompatibleDriver()
+{
+    return InitializePrivate(NULL, NULL, true);
+}
+
+ADLX_RESULT ADLXHelper_InitializeWithCallerAdl (adlx_handle adlContext, ADLX_ADL_Main_Memory_Free adlMainMemoryFree)
+{
+	if (adlContext == NULL || adlMainMemoryFree == NULL)
+	{
+		return ADLX_INVALID_ARGS;
+	}
+    return InitializePrivate (adlContext, adlMainMemoryFree, false);
+}
+
+//-------------------------------------------------------------------------------------------------
+//Termination
+ADLX_RESULT ADLXHelper_Terminate()
+{
+	ADLX_RESULT res = ADLX_OK;
+	if (g_ADLX.m_hDLLHandle != NULL)
+	{
+		g_ADLX.m_ADLXFullVersion = 0;
+		g_ADLX.m_ADLXVersion = NULL;
+		g_ADLX.m_pSystemServices = NULL;
+		g_ADLX.m_pAdlMapping = NULL;
+		if (NULL != g_ADLX.m_terminateFn)
+		{
+			res = g_ADLX.m_terminateFn();
+		}
+		g_ADLX.m_fullVersionFn = NULL;
+		g_ADLX.m_versionFn = NULL;
+		g_ADLX.m_initWithADLFn = NULL;
+		g_ADLX.m_initFnEx = NULL;
+		g_ADLX.m_initFn = NULL;
+		g_ADLX.m_terminateFn = NULL;
+		adlx_free_library(g_ADLX.m_hDLLHandle);
+		g_ADLX.m_hDLLHandle = NULL;
+	}
+	return res;
+}
+
+//-------------------------------------------------------------------------------------------------
+//Get the full version for this ADLX instance
+adlx_uint64 ADLXHelper_QueryFullVersion()
+{
+	return g_ADLX.m_ADLXFullVersion;
+}
+
+//-------------------------------------------------------------------------------------------------
+//Get the version for this ADLX instance
+const char* ADLXHelper_QueryVersion()
+{
+	return g_ADLX.m_ADLXVersion;
+}
+
+//-------------------------------------------------------------------------------------------------
+//Get the IADLXSystem interface
+IADLXSystem* ADLXHelper_GetSystemServices()
+{
+	return g_ADLX.m_pSystemServices;
+}
+
+//-------------------------------------------------------------------------------------------------
+//Get the IADLMapping interface
+IADLMapping* ADLXHelper_GetAdlMapping ()
+{
+    return g_ADLX.m_pAdlMapping;
+}
+
+//-------------------------------------------------------------------------------------------------
+//Loads ADLX and finds the function pointers to the ADLX functions
+ADLX_RESULT LoadADLXDll()
+{
+	if (g_ADLX.m_hDLLHandle == NULL)
+	{
+		g_ADLX.m_hDLLHandle = adlx_load_library(ADLX_DLL_NAME);
+		if (g_ADLX.m_hDLLHandle)
+		{
+			g_ADLX.m_fullVersionFn = (ADLXQueryFullVersion_Fn)adlx_get_proc_address(g_ADLX.m_hDLLHandle, ADLX_QUERY_FULL_VERSION_FUNCTION_NAME);
+			g_ADLX.m_versionFn = (ADLXQueryVersion_Fn)adlx_get_proc_address(g_ADLX.m_hDLLHandle, ADLX_QUERY_VERSION_FUNCTION_NAME);
+			g_ADLX.m_initWithADLFn = (ADLXInitializeWithCallerAdl_Fn)adlx_get_proc_address(g_ADLX.m_hDLLHandle, ADLX_INIT_WITH_CALLER_ADL_FUNCTION_NAME);
+			g_ADLX.m_initFnEx = (ADLXInitialize_Fn)adlx_get_proc_address(g_ADLX.m_hDLLHandle, ADLX_INIT_WITH_INCOMPATIBLE_DRIVER_FUNCTION_NAME);
+			g_ADLX.m_initFn = (ADLXInitialize_Fn)adlx_get_proc_address(g_ADLX.m_hDLLHandle, ADLX_INIT_FUNCTION_NAME);
+			g_ADLX.m_terminateFn = (ADLXTerminate_Fn)adlx_get_proc_address(g_ADLX.m_hDLLHandle, ADLX_TERMINATE_FUNCTION_NAME);
+		}
+	}
+	if (g_ADLX.m_fullVersionFn && g_ADLX.m_versionFn && g_ADLX.m_initWithADLFn && g_ADLX.m_initFnEx && g_ADLX.m_initFn && g_ADLX.m_terminateFn)
+	{
+		return ADLX_OK;
+	}
+	return ADLX_FAIL;
+}
+
+//-------------------------------------------------------------------------------------------------
+//Initializes ADLX based on the  parameters
+ADLX_RESULT InitializePrivate (adlx_handle  adlContext, ADLX_ADL_Main_Memory_Free adlMainMemoryFree, adlx_bool useIncompatibleDriver)
+{
+	ADLX_RESULT res = LoadADLXDll();
+	if (ADLX_OK == res)
+	{
+		g_ADLX.m_fullVersionFn(&g_ADLX.m_ADLXFullVersion);
+		g_ADLX.m_versionFn(&g_ADLX.m_ADLXVersion);
+		if (adlContext != NULL && adlMainMemoryFree != NULL)
+		{
+			res = g_ADLX.m_initWithADLFn(ADLX_FULL_VERSION, &g_ADLX.m_pSystemServices, &g_ADLX.m_pAdlMapping, adlContext, adlMainMemoryFree);
+		}
+		else
+		{
+			if (useIncompatibleDriver)
+			{
+				res = g_ADLX.m_initFnEx(ADLX_FULL_VERSION, &g_ADLX.m_pSystemServices);
+			}
+			else
+			{
+				res = g_ADLX.m_initFn(ADLX_FULL_VERSION, &g_ADLX.m_pSystemServices);
+			}
+		}
+		return res;
+	}
+
+	return ADLX_FAIL;
+}

package/src/includes/adlx/ADLXHelper/ADLXHelper.h

@@ -0,0 +1,245 @@
+// 
+// Copyright (c) 2021 - 2025 Advanced Micro Devices, Inc. All rights reserved.
+//
+//-------------------------------------------------------------------------------------------------
+
+#ifndef ADLX_ADLXFactory_h
+#define ADLX_ADLXFactory_h
+#pragma once
+
+#include "../ADLX.h"
+
+/**
+* @page page_cHelpADLXHelper_Initialize ADLXHelper_Initialize
+* @ENG_START_DOX
+* @brief Initializes ADLX with default parameters.<br>
+* @ENG_END_DOX
+*
+* @syntax
+* @codeStart
+*  @ref ADLX_RESULT ADLXHelper_Initialize ()
+* @codeEnd
+* @params
+* N/A
+*
+* @retvalues
+* @ENG_START_DOX
+* If __ADLXHelper_Initialize__ is successfully executed, __ADLX_OK__ is returned.<br>
+* If __ADLXHelper_Initialize__ is not successfully executed, an error code is returned.<br>
+* If ADLX was previously successfully initialized with any of the initialization functions, __ADLX_ALREADY_INITIALIZED__ is returned.<br>
+* Refer to @ref ADLX_RESULT for success codes and error codes.
+* @ENG_END_DOX
+*
+* @detaileddesc
+* @ENG_START_DOX
+* @details This function is used when an application does not use the ADL library and initializes ADLX with default parameters.<br>
+* For more information for initializing ADLX with default parameters, refer to @ref @adlx_gpu_support "ADLX GPU Support".<br>
+* @ENG_END_DOX
+*
+* @requirements
+* @DetailsTable{#include "ADLXHelper/Windows/C/ADLXHelper.h", @ADLX_First_Ver}
+*/
+ADLX_RESULT             ADLXHelper_Initialize();
+
+/**
+* @page page_cHelpADLXHelper_InitializeWithIncompatibleDriver ADLXHelper_InitializeWithIncompatibleDriver
+* @ENG_START_DOX
+* @brief Initializes ADLX with a legacy driver.<br>
+* @ENG_END_DOX
+*
+* @syntax
+* @codeStart
+*  @ref ADLX_RESULT ADLXHelper_InitializeWithIncompatibleDriver ()
+* @codeEnd
+* @params
+* N/A
+*
+* @retvalues
+* @ENG_START_DOX
+* If __ADLXHelper_InitializeWithIncompatibleDriver__ is successfully executed, __ADLX_OK__ is returned.<br>
+* If __ADLXHelper_InitializeWithIncompatibleDriver__ is not successfully executed, an error code is returned.<br>
+* If ADLX was previously successfully initialized with any of the initialization functions, __ADLX_ALREADY_INITIALIZED__ is returned.<br>
+* Refer to @ref ADLX_RESULT for success codes and error codes.<br>
+* @ENG_END_DOX
+*
+* @detaileddesc
+* @ENG_START_DOX
+* @details This function is used when an application does not use the ADL library and initializes ADLX to consider AMD GPUs using legacy AMD graphics driver.<br>
+* For more information for initializing ADLX with a legacy driver, refer to @ref @adlx_gpu_support "ADLX GPU Support".<br>
+* @ENG_END_DOX
+*
+* @requirements
+* @DetailsTable{#include "ADLXHelper/Windows/C/ADLXHelper.h", @ADLX_First_Ver}
+*/
+ADLX_RESULT             ADLXHelper_InitializeWithIncompatibleDriver();
+
+/**
+* @page page_cHelpADLXHelper_InitializeWithCallerAdl ADLXHelper_InitializeWithCallerAdl
+* @ENG_START_DOX
+* @brief Initializes ADLX with an ADL context.
+* @ENG_END_DOX
+*
+* @syntax
+* @codeStart
+*  @ref ADLX_RESULT ADLXHelper_InitializeWithCallerAdl (adlx_handle adlContext, @ref ADLX_ADL_Main_Memory_Free adlMainMemoryFree)
+* @codeEnd
+* @params
+* @paramrow{1.,[in],adlContext,adlx_handle,@ENG_START_DOX The ADL context. @ENG_END_DOX}
+* @paramrow{2.,[in],adlMainMemoryFree,@ref ADLX_ADL_Main_Memory_Free,@ENG_START_DOX The callback handler of the memory deallocation function. @ENG_END_DOX}
+*
+* @retvalues
+* @ENG_START_DOX
+* If __ADLXHelper_InitializeWithCallerAdl__ is successfully executed, __ADLX_OK__ is returned.<br>
+* If __ADLXHelper_InitializeWithCallerAdl__ is not successfully executed, an error code is returned.<br>
+* If ADLX was previously successfully initialized with any of the Initialize versions, __ADLX_ALREADY_INITIALIZED__ is returned.<br>
+* Refer to @ref ADLX_RESULT for success codes and error codes.<br>
+* @ENG_END_DOX
+*
+* @detaileddesc
+* @ENG_START_DOX
+* @details
+* This function is used when an application also uses ADL. A typical scenario is the application is transitioning from ADL to ADLX with some programming already completed with ADL.<br>
+* In such case, the application shall pass the parameters in this function that corresponds to the current ADL initialization already in use, which are: an ADL context and a callback for the memory deallocation when ADL was initialized.<br>
+* For more information for initializing ADLX with an ADL context, refer to @ref page_guide_use_ADLX "Using ADLX in an ADL application".<br>
+* @ENG_END_DOX
+*
+* @requirements
+* @DetailsTable{#include "ADLXHelper/Windows/C/ADLXHelper.h", @ADLX_First_Ver}
+*/
+ADLX_RESULT             ADLXHelper_InitializeWithCallerAdl (adlx_handle adlContext, ADLX_ADL_Main_Memory_Free adlMainMemoryFree);
+
+/**
+* @page page_cHelpADLXHelper_Terminate ADLXHelper_Terminate
+* @ENG_START_DOX
+* @brief Terminates ADLX and releases ADLX library.
+* @ENG_END_DOX
+*
+* @syntax
+* @codeStart
+*  @ref ADLX_RESULT ADLXHelper_Terminate ()
+* @codeEnd
+* @params
+* N/A
+*
+* @retvalues
+* @ENG_START_DOX
+* If __ADLXHelper_Terminate__ is successfully executed, __ADLX_OK__ is returned.<br>
+* If __ADLXHelper_Terminate__ is not successfully executed, an error code is returned.<br>
+* Refer to @ref ADLX_RESULT for success codes and error codes.
+* @ENG_END_DOX
+*
+* @detaileddesc
+* @ENG_START_DOX
+* @details
+* Any interface obtained from ADLX that is not released becomes invalid.<br>
+* Any attempt of calling ADLX interface after termination could result in errors such as exceptions or crashes.<br>
+* @ENG_END_DOX
+*
+* @requirements
+* @DetailsTable{#include "ADLXHelper/Windows/C/ADLXHelper.h", @ADLX_First_Ver}
+*/
+ADLX_RESULT             ADLXHelper_Terminate();
+
+/**
+* @page page_cHelpADLXHelper_GetSystemServices ADLXHelper_GetSystemServices
+* @ENG_START_DOX
+* @brief Gets the ADLX system interface.
+* @ENG_END_DOX
+*
+* @syntax
+* @codeStart
+*  @ref DOX_IADLXSystem* ADLXHelper_GetSystemServices ()
+* @codeEnd
+* @params
+* N/A
+*
+* @retvalues
+* @ENG_START_DOX
+* If ADLX was successfully initialized before this function call, the @ref DOX_IADLXSystem interface is returned.<br>
+* If ADLX was not successfully initialized, __nullptr__ is returned.
+* @ENG_END_DOX
+*
+* @requirements
+* @DetailsTable{#include "ADLXHelper/Windows/C/ADLXHelper.h", @ADLX_First_Ver}
+*/
+IADLXSystem*            ADLXHelper_GetSystemServices ();
+
+/**
+* @page page_cHelpADLXHelper_GetAdlMapping ADLXHelper_GetAdlMapping
+* @ENG_START_DOX
+* @brief Gets the ADL Mapping interface.
+* @ENG_END_DOX
+*
+* @syntax
+* @codeStart
+*  @ref DOX_IADLMapping* ADLXHelper_GetAdlMapping ()
+* @codeEnd
+* @params
+* N/A
+*
+* @retvalues
+* @ENG_START_DOX
+* If ADLX was successfully initialized with ADL, a valid pointer of the @ref DOX_IADLMapping interface is returned.<br>
+* If ADLX was initialized under any of the following circumstances, __nullptr__ is returned.<br>
+* - ADLX initialization was with other initialization methods.<br>
+* - ADLX initialization was failed.<br>
+* - ADLX initialization was not called.<br>
+* @ENG_END_DOX
+*
+* @detaileddesc
+* @ENG_START_DOX
+* @details __ADLXHelper_GetAdlMapping__ is used to convert data between ADL and ADLX in applications where ADLX was initialized with @ref page_cHelpADLXHelper_InitializeWithCallerAdl.
+* @ENG_END_DOX
+*
+* @requirements
+* @DetailsTable{#include "ADLXHelper/Windows/C/ADLXHelper.h", @ADLX_First_Ver}
+*/
+IADLMapping*            ADLXHelper_GetAdlMapping();
+
+/**
+* @page page_cHelpADLXHelper_QueryFullVersion ADLXHelper_QueryFullVersion
+* @ENG_START_DOX
+* @brief Gets the full version of ADLX.
+* @ENG_END_DOX
+*
+* @syntax
+* @codeStart
+*  adlx_uint64 ADLXHelper_QueryFullVersion ()
+* @codeEnd
+* @params
+* N/A
+*
+* @retvalues
+* @ENG_START_DOX
+* The full version of ADLX.
+* @ENG_END_DOX
+*
+* @requirements
+* @DetailsTable{#include "ADLXHelper/Windows/C/ADLXHelper.h", @ADLX_First_Ver}
+*/
+adlx_uint64             ADLXHelper_QueryFullVersion();
+
+/**
+* @page page_cHelpADLXHelper_QueryVersion ADLXHelper_QueryVersion
+* @ENG_START_DOX
+* @brief Gets the version of ADLX.
+* @ENG_END_DOX
+*
+* @syntax
+* @codeStart
+*  const char* ADLXHelper_QueryVersion ();
+* @codeEnd
+* @params
+* N/A
+*
+* @retvalues
+* @ENG_START_DOX
+* The version of ADLX.
+* @ENG_END_DOX
+*
+* @requirements
+* @DetailsTable{#include "ADLXHelper/Windows/C/ADLXHelper.h", @ADLX_First_Ver}
+*/
+const char*             ADLXHelper_QueryVersion();
+#endif // __ADLXFactoryC_h__
+

package/src/includes/adlx/ADLXHelper/WinAPIS.c

@@ -0,0 +1,64 @@
+// 
+// Copyright (c) 2021 - 2025 Advanced Micro Devices, Inc. All rights reserved.
+//
+//-------------------------------------------------------------------------------------------------
+//This abstracts Win32 APIs in ADLX ones so we insulate from platform
+#include "../ADLXDefines.h"
+
+#if defined(_WIN32) // Microsoft compiler
+    #include <Windows.h>
+#else
+#error define your copiler
+#endif
+static volatile uint64_t v = 0;
+
+//----------------------------------------------------------------------------------------
+// threading
+//----------------------------------------------------------------------------------------
+adlx_long ADLX_CDECL_CALL adlx_atomic_inc (adlx_long* X)
+{
+#if defined(_WIN32) // Microsoft compiler
+    return InterlockedIncrement((long*)X);
+#endif    
+}
+
+//----------------------------------------------------------------------------------------
+adlx_long ADLX_CDECL_CALL adlx_atomic_dec (adlx_long* X)
+{    
+#if defined(_WIN32) // Microsoft compiler
+    return InterlockedDecrement((long*)X);
+#endif  
+
+}
+
+//----------------------------------------------------------------------------------------
+adlx_handle ADLX_CDECL_CALL adlx_load_library (const TCHAR* filename)
+{
+#if defined(METRO_APP)
+    return LoadPackagedLibrary (filename, 0);
+#elif defined(_WIN32) // Microsoft compiler	
+    return LoadLibraryEx(filename, NULL, LOAD_LIBRARY_SEARCH_USER_DIRS |
+		LOAD_LIBRARY_SEARCH_APPLICATION_DIR |
+		LOAD_LIBRARY_SEARCH_DEFAULT_DIRS |
+		LOAD_LIBRARY_SEARCH_SYSTEM32);
+#endif
+}
+
+//----------------------------------------------------------------------------------------
+int ADLX_CDECL_CALL adlx_free_library (adlx_handle module)
+{
+#if defined(_WIN32) // Microsoft compiler
+    return FreeLibrary((HMODULE)module) == TRUE;
+#endif
+}
+
+//----------------------------------------------------------------------------------------
+void* ADLX_CDECL_CALL adlx_get_proc_address (adlx_handle module, const char* procName)
+{
+#if defined(_WIN32) // Microsoft compiler
+	return (void*)GetProcAddress((HMODULE)module, procName);
+#endif
+}
+
+
+//#endif //_WIN32

package/src/includes/adlx/ADLXStructures.h

@@ -0,0 +1,206 @@
+//
+// Copyright (c) 2021 - 2025 Advanced Micro Devices, Inc. All rights reserved.
+//
+//-------------------------------------------------------------------------------------------------
+
+#ifndef ADLX_STRUCTURES_H
+#define ADLX_STRUCTURES_H
+#pragma once
+#include "ADLXDefines.h"
+
+/**   @file */
+//-------------------------------------------------------------------------------------------------
+#pragma region ADLX_RGB
+/**
+ * @struct ADLX_RGB
+ * @ingroup structuresVal
+ * @ENG_START_DOX
+ * @brief This structure contains RGB information.
+ * @ENG_END_DOX
+ */
+typedef struct
+{
+    adlx_double gamutR;         /**< @ENG_START_DOX Red @ENG_END_DOX */
+    adlx_double gamutG;         /**< @ENG_START_DOX Green @ENG_END_DOX */
+    adlx_double gamutB;         /**< @ENG_START_DOX Blue @ENG_END_DOX */
+} ADLX_RGB;
+#pragma endregion ADLX_RGB
+
+#pragma region ADLX_Point
+/**
+ *  @struct ADLX_Point
+ *  @ingroup structuresVal
+ *  @ENG_START_DOX
+ *  @brief This structure contains information on driver point coordinates, and is used to store the driver-point coodinates for gamut, as well as white point.
+ *  @ENG_END_DOX
+ */
+typedef struct
+{
+    adlx_int          x;           /**< @ENG_START_DOX The x coordinate. @ENG_END_DOX */
+    adlx_int          y;           /**< @ENG_START_DOX The y coordinate. @ENG_END_DOX */
+} ADLX_Point;
+#pragma endregion ADLX_Point
+
+#pragma region ADLX_GamutColorSpace
+/**
+ *  @struct ADLX_GamutColorSpace
+ *  @ingroup structuresVal
+ *  @ENG_START_DOX
+ *  @brief This structure contains information on driver-supported gamut coordinates
+ *  @ENG_END_DOX
+ */
+typedef struct
+{
+    ADLX_Point      red;                /**<  @ENG_START_DOX The red channel chromaticity coordinate. @ENG_END_DOX */
+    ADLX_Point      green;              /**<  @ENG_START_DOX The green channel chromaticity coordinate. @ENG_END_DOX */
+    ADLX_Point      blue;               /**<  @ENG_START_DOX The blue channel chromaticity coordinate. @ENG_END_DOX */
+} ADLX_GamutColorSpace;
+#pragma endregion ADLX_GamutColorSpace
+
+#pragma region ADLX_GammaRamp
+/**
+ *  @struct ADLX_GammaRamp
+ *  @ingroup structuresVal
+ *  @ENG_START_DOX
+ *  @brief This structure contains the display gamma ramp used to program the re-gamma LUT.
+ *  @ENG_END_DOX
+ */
+typedef struct
+{
+    adlx_uint16  gamma[256 * 3];        /**< @ENG_START_DOX The gamma ramp is a buffer containing 256 triplets of adlx_uint16 values.
+                                        Each triplet consists of red, green and blue values. @ENG_END_DOX */
+} ADLX_GammaRamp;
+#pragma endregion ADLX_GammaRamp
+
+#pragma region ADLX_RegammaCoeff
+/**
+ *  @struct ADLX_RegammaCoeff
+ *  @ingroup structuresVal
+ *  @ENG_START_DOX
+ *  @brief This structure contains information on driver-supported re-gamma coefficients used to build the re-gamma curve.
+ *  @ENG_END_DOX
+ */
+typedef struct
+{
+    adlx_int    coefficientA0;          /**<  @ENG_START_DOX The a0 gamma coefficient. @ENG_END_DOX */
+    adlx_int    coefficientA1;          /**<  @ENG_START_DOX The a1 gamma coefficient. @ENG_END_DOX */
+    adlx_int    coefficientA2;          /**<  @ENG_START_DOX The a2 gamma coefficient. @ENG_END_DOX */
+    adlx_int    coefficientA3;          /**<  @ENG_START_DOX The a3 gamma coefficient. @ENG_END_DOX */
+    adlx_int    gamma;                  /**<  @ENG_START_DOX The regamma divider. @ENG_END_DOX */
+} ADLX_RegammaCoeff;
+#pragma endregion ADLX_RegammaCoeff
+
+#pragma region ADLX_TimingInfo
+/**
+ *  @struct ADLX_TimingInfo
+ *  @ingroup structuresVal
+ *  @ENG_START_DOX
+ *  @brief This structure contains display timing information.
+ *  @ENG_END_DOX
+ */
+typedef struct
+{
+    adlx_int timingFlags;    /**< @ENG_START_DOX The detailed timing flag. @ENG_END_DOX */
+    adlx_int hTotal;         /**< @ENG_START_DOX The total number of pixels that compose all scan lines during a horizontal sync. @ENG_END_DOX */
+    adlx_int vTotal;         /**< @ENG_START_DOX The total number of vertical pixels permitted/processed per sync. @ENG_END_DOX */
+
+    adlx_int hDisplay;       /**< @ENG_START_DOX The number of horizontal pixels within the active area. @ENG_END_DOX */
+    adlx_int vDisplay;       /**< @ENG_START_DOX The number of vertical pixels within the active display area. @ENG_END_DOX */
+
+    adlx_int hFrontPorch;    /**< @ENG_START_DOX The number of horizontal pixels between the end of the active area and the next sync. This is the distance between the right/bottom portion of the display up to the right/bottom portion of the actual image. @ENG_END_DOX */
+    adlx_int vFrontPorch;    /**< @ENG_START_DOX The number of vertical pixels between the end of the active area and the next sync. This is the distance between the right/bottom portion of the display to the right/bottom portion of the actual image. @ENG_END_DOX */
+
+    adlx_int hSyncWidth;    /**< @ENG_START_DOX The number of pixels that compose a scan line during a horizontal sync. @ENG_END_DOX */
+    adlx_int vSyncWidth;    /**< @ENG_START_DOX The number of vertical pixels permitted/processed during a sync. @ENG_END_DOX */
+
+    adlx_int hPolarity;    /**< @ENG_START_DOX The horizontal polarity of sync signals, 0 POSITIVE; 1 NEGATIVE. Positive makes the active signals high while negative makes the active signals low. @ENG_END_DOX */
+    adlx_int vPolarity;    /**< @ENG_START_DOX The vertical polarity of sync signals, 0 POSITIVE; 1 NEGATIVE. Positive makes the active signals high while negative makes the active signals low. @ENG_END_DOX */
+} ADLX_TimingInfo;
+
+#pragma endregion ADLX_TimingInfo
+
+#pragma region ADLX_CustomResolution
+/** @struct ADLX_CustomResolution
+ *  @ingroup structuresVal
+ * @ENG_START_DOX
+ *  @brief This structure contains information for custom resolution parameters on a given display.
+ * @ENG_END_DOX
+ *
+ */
+typedef struct
+{
+    adlx_int resWidth;                     /**< @ENG_START_DOX The resolution width. @ENG_END_DOX */
+    adlx_int resHeight;                    /**< @ENG_START_DOX The resolution height. @ENG_END_DOX */
+    adlx_int refreshRate;                  /**< @ENG_START_DOX The refresh rate. @ENG_END_DOX */
+    ADLX_DISPLAY_SCAN_TYPE presentation;   /**< @ENG_START_DOX The presentation method, 0 PROGRESSIVE; 1 INTERLACED. @ENG_END_DOX */
+    ADLX_TIMING_STANDARD timingStandard;   /**< @ENG_START_DOX The display timing standard. @ENG_END_DOX */
+    adlx_long GPixelClock;                 /**< @ENG_START_DOX The speed at which pixels are transmitted within on a refresh cycle. @ENG_END_DOX */
+    ADLX_TimingInfo detailedTiming;        /**< @ENG_START_DOX The detailed timing information. @ENG_END_DOX */
+} ADLX_CustomResolution;
+
+#pragma endregion ADLX_CustomResolution
+
+#pragma region ADLX_IntRange
+/** @struct ADLX_IntRange
+ *  @ingroup structuresVal
+ * @ENG_START_DOX
+ *  @brief This structure contains information on the integer range.
+ * @ENG_END_DOX
+ *
+ */
+typedef struct
+{
+    adlx_int minValue;           /**< @ENG_START_DOX The minimum integer value. @ENG_END_DOX */
+    adlx_int maxValue;           /**< @ENG_START_DOX The maximum integer value. @ENG_END_DOX */
+    adlx_int step;               /**< @ENG_START_DOX The accepted integer range step. @ENG_END_DOX */
+} ADLX_IntRange;
+#pragma endregion ADLX_IntRange
+
+#pragma region ADLX_UINT16_RGB
+/** @struct ADLX_UINT16_RGB
+ *  @ingroup structuresVal
+ * @ENG_START_DOX
+ *  @brief This structure contains UINT16 RGB information.
+ * @ENG_END_DOX
+ *
+ */
+typedef struct ADLX_UINT16_RGB
+{
+    adlx_uint16 red;        /**< @ENG_START_DOX Red @ENG_END_DOX */
+    adlx_uint16 green;      /**< @ENG_START_DOX Green @ENG_END_DOX */
+    adlx_uint16 blue;       /**< @ENG_START_DOX Blue @ENG_END_DOX */
+} ADLX_UINT16_RGB;
+#pragma endregion ADLX_UINT16_RGB
+
+#pragma region ADLX_3DLUT_Data
+/** @struct ADLX_3DLUT_Data
+ *  @ingroup structuresVal
+ * @ENG_START_DOX
+ *  @brief This structure contains custom 3D LUT information.
+ * @ENG_END_DOX
+ *
+ */
+
+typedef struct ADLX_3DLUT_Data
+{
+    ADLX_UINT16_RGB data[MAX_USER_3DLUT_NUM_POINTS * MAX_USER_3DLUT_NUM_POINTS * MAX_USER_3DLUT_NUM_POINTS];     /**< @ENG_START_DOX The data is a buffer containing 17*17*17 triplets of @ref ADLX_UINT16_RGB values. Each triplet consists of red, green and blue values.
+                                                 For 3D LUT data we use ushort 0 - 0xFFFF, data must be zero-padded to 16-bit. @ENG_END_DOX */
+} ADLX_3DLUT_Data;
+#pragma endregion ADLX_3DLUT_Data
+
+#pragma region ADLX_LUID
+/**
+* @struct ADLX_LUID
+* @ingroup structuresVal
+* @ENG_START_DOX
+* @brief This structure contains the local identifier information of the adapter.
+* @ENG_END_DOX
+*/
+typedef struct ADLX_LUID
+{
+    adlx_ulong lowPart;    /**< @ENG_START_DOX Specifies the low part of the local id. @ENG_END_DOX */
+    adlx_long highPart;    /**< @ENG_START_DOX Specifies the high part of the local id. @ENG_END_DOX */
+} ADLX_LUID;
+#pragma endregion ADLX_LUID
+
+#endif //ADLX_STRUCTURES_H