node-gpuinfo 1.0.0

package/src/includes/adlx/IDisplays1.h

@@ -0,0 +1,191 @@
+//
+// Copyright (c) 2021 - 2025 Advanced Micro Devices, Inc. All rights reserved.
+//
+//-------------------------------------------------------------------------------------------------
+
+#ifndef ADLX_IDISPLAYS1_H
+#define ADLX_IDISPLAYS1_H
+#pragma once
+
+#include "IDisplays.h"
+
+//-------------------------------------------------------------------------------------------------
+//IDisplays1.h - Interfaces for ADLX Display Information functionality
+
+#pragma region IADLXDisplayServices1
+
+#if defined (__cplusplus)
+namespace adlx
+{
+    class ADLX_NO_VTABLE IADLXDisplayConnectivityExperience;
+    class ADLX_NO_VTABLE IADLXDisplayBlanking;
+    class ADLX_NO_VTABLE IADLXDisplayServices1 : public IADLXDisplayServices
+    {
+    public:
+        ADLX_DECLARE_IID(L"IADLXDisplayServices1")
+
+        /**
+        *@page DOX_IADLXDisplayServices1_GetDisplayBlanking GetDisplayBlanking
+        *@ENG_START_DOX @brief Gets the reference counted display blanking interface of a display. @ENG_END_DOX
+        *
+        *@syntax
+        *@codeStart
+        * @ref ADLX_RESULT    GetDisplayBlanking (IADLXDisplay* pDisplay, @ref DOX_IADLXDisplayBlanking** ppDisplayBlanking)
+        *@codeEnd
+        *
+        *@params
+        *@paramrow{1.,[in],pDisplay,@ref DOX_IADLXDisplay*,@ENG_START_DOX The pointer to the display interface. @ENG_END_DOX}
+        *@paramrow{2.,[out],ppDisplayBlanking,@ref DOX_IADLXDisplayBlanking **,@ENG_START_DOX The address of a pointer to the returned interface. If the interface is not successfully returned\, the method sets the dereferenced address __*ppDisplayBlanking__ to __nullptr__. @ENG_END_DOX}
+        *
+        *@retvalues
+        *@ENG_START_DOX
+        * If the interface is successfully returned, __ADLX_OK__ is returned. <br>
+        * If the interface is not successfully returned, 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 The returned interface must be discarded with @ref DOX_IADLXInterface_Release when it's no longer needed. @ENG_END_DOX
+        *
+        *@addinfo
+        *@ENG_START_DOX
+        *When using ADLX interfaces as smart pointers in C++, it isn't necessary to call @ref DOX_IADLXInterface_Release as it's called by smart pointers in the internal implementation. @ENG_END_DOX
+        *
+        *@copydoc IADLXDisplayServices1_REQ_TABLE
+        *
+        */
+        virtual ADLX_RESULT ADLX_STD_CALL GetDisplayBlanking(IADLXDisplay* pDisplay, IADLXDisplayBlanking** ppDisplayBlanking) = 0;
+
+    };  //IADLXDisplayServices1
+    //----------------------------------------------------------------------------------------------
+    typedef IADLXInterfacePtr_T<IADLXDisplayServices1> IADLXDisplayServices1Ptr;
+} // namespace adlx
+#else //__cplusplus
+ADLX_DECLARE_IID(IADLXDisplayServices1, L"IADLXDisplayServices1")
+typedef struct IADLXDisplayServices1 IADLXDisplayServices1;
+
+typedef struct IADLXDisplayFreeSync IADLXDisplayFreeSync;
+typedef struct IADLXDisplayVSR IADLXDisplayVSR;
+typedef struct IADLXDisplayGPUScaling IADLXDisplayGPUScaling;
+typedef struct IADLXDisplayScalingMode IADLXDisplayScalingMode;
+typedef struct IADLXDisplayIntegerScaling IADLXDisplayIntegerScaling;
+typedef struct IADLXDisplayColorDepth IADLXDisplayColorDepth;
+typedef struct IADLXDisplayPixelFormat IADLXDisplayPixelFormat;
+typedef struct IADLXDisplayCustomColor IADLXDisplayCustomColor;
+typedef struct IADLXDisplayHDCP IADLXDisplayHDCP;
+typedef struct IADLXDisplayCustomResolution IADLXDisplayCustomResolution;
+typedef struct IADLXDisplayChangedHandling IADLXDisplayChangedHandling;
+typedef struct IADLXDisplayVariBright IADLXDisplayVariBright;
+typedef struct IADLXDisplayConnectivityExperience IADLXDisplayConnectivityExperience;
+typedef struct IADLXDisplayBlanking IADLXDisplayBlanking;
+
+typedef struct IADLXDisplayServices1Vtbl
+{
+    //IADLXInterface
+    adlx_long(ADLX_STD_CALL* Acquire)(IADLXDisplayServices1* pThis);
+    adlx_long(ADLX_STD_CALL* Release)(IADLXDisplayServices1* pThis);
+    ADLX_RESULT(ADLX_STD_CALL* QueryInterface)(IADLXDisplayServices1* pThis, const wchar_t* interfaceId, void** ppInterface);
+
+    //IADLXDisplayServices
+    ADLX_RESULT(ADLX_STD_CALL* GetNumberOfDisplays)(IADLXDisplayServices1* pThis, adlx_uint* numDisplays);
+    ADLX_RESULT(ADLX_STD_CALL* GetDisplays)(IADLXDisplayServices1* pThis, IADLXDisplayList** ppDisplays);
+    ADLX_RESULT(ADLX_STD_CALL* Get3DLUT)(IADLXDisplayServices1* pThis, IADLXDisplay* pDisplay, IADLXDisplay3DLUT** ppDisp3DLUT);
+    ADLX_RESULT(ADLX_STD_CALL* GetGamut)(IADLXDisplayServices1* pThis, IADLXDisplay* pDisplay, IADLXDisplayGamut** ppDispGamut);
+    ADLX_RESULT(ADLX_STD_CALL* GetGamma)(IADLXDisplayServices1* pThis, IADLXDisplay* pDisplay, IADLXDisplayGamma** ppDispGamma);
+    ADLX_RESULT(ADLX_STD_CALL* GetDisplayChangedHandling)(IADLXDisplayServices1* pThis, IADLXDisplayChangedHandling** ppDisplayChangedHandling);
+    ADLX_RESULT(ADLX_STD_CALL* GetFreeSync)(IADLXDisplayServices1* pThis, IADLXDisplay* pDisplay, IADLXDisplayFreeSync** ppFreeSync);
+    ADLX_RESULT(ADLX_STD_CALL* GetVirtualSuperResolution)(IADLXDisplayServices1* pThis, IADLXDisplay* pDisplay, IADLXDisplayVSR** ppVSR);
+    ADLX_RESULT(ADLX_STD_CALL* GetGPUScaling)(IADLXDisplayServices1* pThis, IADLXDisplay* pDisplay, IADLXDisplayGPUScaling** ppGPUScaling);
+    ADLX_RESULT(ADLX_STD_CALL* GetScalingMode)(IADLXDisplayServices1* pThis, IADLXDisplay* pDisplay, IADLXDisplayScalingMode** ppScalingMode);
+    ADLX_RESULT(ADLX_STD_CALL* GetIntegerScaling)(IADLXDisplayServices1* pThis, IADLXDisplay* pDisplay, IADLXDisplayIntegerScaling** ppIntegerScaling);
+    ADLX_RESULT(ADLX_STD_CALL* GetColorDepth)(IADLXDisplayServices1* pThis, IADLXDisplay* pDisplay, IADLXDisplayColorDepth** ppColorDepth);
+    ADLX_RESULT(ADLX_STD_CALL* GetPixelFormat)(IADLXDisplayServices1* pThis, IADLXDisplay* pDisplay, IADLXDisplayPixelFormat** ppPixelFormat);
+    ADLX_RESULT(ADLX_STD_CALL* GetCustomColor)(IADLXDisplayServices1* pThis, IADLXDisplay* pDisplay, IADLXDisplayCustomColor** ppCustomColor);
+    ADLX_RESULT(ADLX_STD_CALL* GetHDCP)(IADLXDisplayServices1* pThis, IADLXDisplay* pDisplay, IADLXDisplayHDCP** ppHDCP);
+    ADLX_RESULT(ADLX_STD_CALL* GetCustomResolution)(IADLXDisplayServices1* pThis, IADLXDisplay* pDisplay, IADLXDisplayCustomResolution** ppCustomResolution);
+    ADLX_RESULT(ADLX_STD_CALL* GetVariBright)(IADLXDisplayServices1* pThis, IADLXDisplay* pDisplay, IADLXDisplayVariBright** ppVariBright);
+
+    //IADLXDisplayServices1
+    ADLX_RESULT(ADLX_STD_CALL* GetDisplayBlanking)(IADLXDisplayServices1* pThis, IADLXDisplay* pDisplay, IADLXDisplayBlanking** ppDisplayBlanking);
+} IADLXDisplayServices1Vtbl;
+
+struct IADLXDisplayServices1 { const IADLXDisplayServices1Vtbl* pVtbl; };
+#endif
+
+#pragma endregion IADLXDisplayServices1
+
+#pragma region IADLXDisplaySettingsChangedEvent1
+#if defined (__cplusplus)
+namespace adlx
+{
+    class ADLX_NO_VTABLE IADLXDisplaySettingsChangedEvent1 : public IADLXDisplaySettingsChangedEvent
+    {
+    public:
+        ADLX_DECLARE_IID(L"IADLXDisplaySettingsChangedEvent1")
+
+        /**
+        *@page DOX_IADLXDisplaySettingsChangedEvent1_IsDisplayBlankingChanged IsDisplayBlankingChanged
+        *@ENG_START_DOX @brief Checks if the display blanking of the display is changed. @ENG_END_DOX
+        *
+        *@syntax
+        *@codeStart
+        * adlx_bool    IsDisplayBlankingChanged ()
+        *@codeEnd
+        *
+        *@params
+        *N/A
+        *
+        *@retvalues
+        *@ENG_START_DOX
+        * If the display blanking settings are changed, __true__ is returned. <br>
+        * If the display blanking settings are not changed, __false__ is returned. @ENG_END_DOX
+        *
+        *@copydoc IADLXDisplaySettingsChangedEvent1_REQ_TABLE
+        *
+        */
+        virtual adlx_bool ADLX_STD_CALL IsDisplayBlankingChanged() = 0;
+    }; //IADLXDisplaySettingsChangedEvent1
+    //----------------------------------------------------------------------------------------------
+    typedef IADLXInterfacePtr_T<IADLXDisplaySettingsChangedEvent1> IADLXDisplaySettingsChangedEvent1Ptr;
+} //namespace adlx
+#else //__cplusplus
+ADLX_DECLARE_IID(IADLXDisplaySettingsChangedEvent1, L"IADLXDisplaySettingsChangedEvent1")
+typedef struct IADLXDisplaySettingsChangedEvent1 IADLXDisplaySettingsChangedEvent1;
+
+typedef struct IADLXDisplaySettingsChangedEvent1Vtbl
+{
+    //IADLXInterface
+    adlx_long(ADLX_STD_CALL* Acquire)(IADLXDisplaySettingsChangedEvent1* pThis);
+    adlx_long(ADLX_STD_CALL* Release)(IADLXDisplaySettingsChangedEvent1* pThis);
+    ADLX_RESULT(ADLX_STD_CALL* QueryInterface)(IADLXDisplaySettingsChangedEvent1* pThis, const wchar_t* interfaceId, void** ppInterface);
+
+    //IADLXChangedEvent
+    ADLX_SYNC_ORIGIN(ADLX_STD_CALL* GetOrigin)(IADLXDisplaySettingsChangedEvent1* pThis);
+
+    // IADLXDisplaySettingsChangedEvent interface
+    ADLX_RESULT(ADLX_STD_CALL* GetDisplay)(IADLXDisplaySettingsChangedEvent1* pThis, IADLXDisplay** ppDisplay);
+    adlx_bool(ADLX_STD_CALL* IsFreeSyncChanged)(IADLXDisplaySettingsChangedEvent1* pThis);
+    adlx_bool(ADLX_STD_CALL* IsVSRChanged)(IADLXDisplaySettingsChangedEvent1* pThis);
+    adlx_bool(ADLX_STD_CALL* IsGPUScalingChanged)(IADLXDisplaySettingsChangedEvent1* pThis);
+    adlx_bool(ADLX_STD_CALL* IsScalingModeChanged)(IADLXDisplaySettingsChangedEvent1* pThis);
+    adlx_bool(ADLX_STD_CALL* IsIntegerScalingChanged)(IADLXDisplaySettingsChangedEvent1* pThis);
+    adlx_bool(ADLX_STD_CALL* IsColorDepthChanged)(IADLXDisplaySettingsChangedEvent1* pThis);
+    adlx_bool(ADLX_STD_CALL* IsPixelFormatChanged)(IADLXDisplaySettingsChangedEvent1* pThis);
+    adlx_bool(ADLX_STD_CALL* IsHDCPChanged)(IADLXDisplaySettingsChangedEvent1* pThis);
+    adlx_bool(ADLX_STD_CALL* IsCustomColorHueChanged)(IADLXDisplaySettingsChangedEvent1* pThis);
+    adlx_bool(ADLX_STD_CALL* IsCustomColorSaturationChanged)(IADLXDisplaySettingsChangedEvent1* pThis);
+    adlx_bool(ADLX_STD_CALL* IsCustomColorBrightnessChanged)(IADLXDisplaySettingsChangedEvent1* pThis);
+    adlx_bool(ADLX_STD_CALL* IsCustomColorTemperatureChanged)(IADLXDisplaySettingsChangedEvent1* pThis);
+    adlx_bool(ADLX_STD_CALL* IsCustomColorContrastChanged)(IADLXDisplaySettingsChangedEvent1* pThis);
+    adlx_bool(ADLX_STD_CALL* IsCustomResolutionChanged)(IADLXDisplaySettingsChangedEvent1* pThis);
+    adlx_bool(ADLX_STD_CALL* IsVariBrightChanged)(IADLXDisplaySettingsChangedEvent1* pThis);
+
+    // IADLXDisplaySettingsChangedEvent1 interface
+    adlx_bool(ADLX_STD_CALL* IsDisplayBlankingChanged)(IADLXDisplaySettingsChangedEvent1* pThis);
+
+} IADLXDisplaySettingsChangedEvent1Vtbl;
+
+struct IADLXDisplaySettingsChangedEvent1 { const IADLXDisplaySettingsChangedEvent1Vtbl* pVtbl; };
+#endif //__cplusplus
+#pragma endregion IADLXDisplaySettingsChangedEvent1
+
+#endif //ADLX_IDISPLAYS1_H

package/src/includes/adlx/IDisplays2.h

@@ -0,0 +1,188 @@
+//
+// Copyright (c) 2021 - 2025 Advanced Micro Devices, Inc. All rights reserved.
+//
+//-------------------------------------------------------------------------------------------------
+
+#ifndef ADLX_IDISPLAYS2_H
+#define ADLX_IDISPLAYS2_H
+#pragma once
+
+#include "IDisplays1.h"
+
+//-------------------------------------------------------------------------------------------------
+//IDisplays2.h - Interfaces for ADLX Display Information functionality
+
+#pragma region IADLXDisplayServices2
+
+#if defined (__cplusplus)
+namespace adlx
+{
+    class ADLX_NO_VTABLE IADLXDisplayConnectivityExperience;
+    class ADLX_NO_VTABLE IADLXDisplayServices2 : public IADLXDisplayServices1
+    {
+    public:
+        ADLX_DECLARE_IID(L"IADLXDisplayServices2")
+
+        /**
+        *@page DOX_IADLXDisplayServices2_GetDisplayConnectivityExperience GetDisplayConnectivityExperience
+        *@ENG_START_DOX @brief Gets the reference counted DCE interface for a display. @ENG_END_DOX
+        *
+        *@syntax
+        *@codeStart
+        * @ref ADLX_RESULT    GetDisplayConnectivityExperience (@ref DOX_IADLXDisplay* pDisplay, @ref DOX_IADLXDisplayConnectivityExperience ** ppDisplayConnectivityExperience)
+        *@codeEnd
+        *
+        *@params
+        *@paramrow{1.,[in],pDisplay,@ref DOX_IADLXDisplay*,@ENG_START_DOX The pointer to the display interface. @ENG_END_DOX}
+        *@paramrow{2.,[out],ppDisplayConnectivityExperience,@ref DOX_IADLXDisplayConnectivityExperience **,@ENG_START_DOX The address of a pointer to the returned interface. If the interface is not successfully returned\, the method sets the dereferenced address __*ppDisplayConnectivityExperience__ to __nullptr__. @ENG_END_DOX}
+        *
+        *@retvalues
+        *@ENG_START_DOX
+        * If the interface is successfully returned, __ADLX_OK__ is returned. <br>
+        * If the interface is not successfully returned, 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 The returned interface must be discarded with @ref DOX_IADLXInterface_Release when it is no longer needed. @ENG_END_DOX
+        *
+        *@addinfo
+        *@ENG_START_DOX
+        *In C++, when using ADLX interfaces as smart pointers, there is no need to call @ref DOX_IADLXInterface_Release because smart pointers call it in their internal implementation. @ENG_END_DOX
+        *
+        *@copydoc IADLXDisplayServices2_REQ_TABLE
+        *
+        */
+        virtual ADLX_RESULT ADLX_STD_CALL GetDisplayConnectivityExperience(IADLXDisplay* pDisplay, IADLXDisplayConnectivityExperience** ppDisplayConnectivityExperience) = 0;
+    };  //IADLXDisplayServices2
+    //----------------------------------------------------------------------------------------------
+    typedef IADLXInterfacePtr_T<IADLXDisplayServices2> IADLXDisplayServices2Ptr;
+} // namespace adlx
+#else //__cplusplus
+ADLX_DECLARE_IID(IADLXDisplayServices2, L"IADLXDisplayServices2")
+typedef struct IADLXDisplayServices2 IADLXDisplayServices2;
+
+typedef struct IADLXDisplayConnectivityExperience IADLXDisplayConnectivityExperience;
+
+typedef struct IADLXDisplayServices2Vtbl
+{
+    //IADLXInterface
+    adlx_long(ADLX_STD_CALL* Acquire)(IADLXDisplayServices2* pThis);
+    adlx_long(ADLX_STD_CALL* Release)(IADLXDisplayServices2* pThis);
+    ADLX_RESULT(ADLX_STD_CALL* QueryInterface)(IADLXDisplayServices2* pThis, const wchar_t* interfaceId, void** ppInterface);
+
+    //IADLXDisplayServices
+    ADLX_RESULT(ADLX_STD_CALL* GetNumberOfDisplays)(IADLXDisplayServices2* pThis, adlx_uint* numDisplays);
+    ADLX_RESULT(ADLX_STD_CALL* GetDisplays)(IADLXDisplayServices2* pThis, IADLXDisplayList** ppDisplays);
+    ADLX_RESULT(ADLX_STD_CALL* Get3DLUT)(IADLXDisplayServices2* pThis, IADLXDisplay* pDisplay, IADLXDisplay3DLUT** ppDisp3DLUT);
+    ADLX_RESULT(ADLX_STD_CALL* GetGamut)(IADLXDisplayServices2* pThis, IADLXDisplay* pDisplay, IADLXDisplayGamut** ppDispGamut);
+    ADLX_RESULT(ADLX_STD_CALL* GetGamma)(IADLXDisplayServices2* pThis, IADLXDisplay* pDisplay, IADLXDisplayGamma** ppDispGamma);
+    ADLX_RESULT(ADLX_STD_CALL* GetDisplayChangedHandling)(IADLXDisplayServices2* pThis, IADLXDisplayChangedHandling** ppDisplayChangedHandling);
+    ADLX_RESULT(ADLX_STD_CALL* GetFreeSync)(IADLXDisplayServices2* pThis, IADLXDisplay* pDisplay, IADLXDisplayFreeSync** ppFreeSync);
+    ADLX_RESULT(ADLX_STD_CALL* GetVirtualSuperResolution)(IADLXDisplayServices2* pThis, IADLXDisplay* pDisplay, IADLXDisplayVSR** ppVSR);
+    ADLX_RESULT(ADLX_STD_CALL* GetGPUScaling)(IADLXDisplayServices2* pThis, IADLXDisplay* pDisplay, IADLXDisplayGPUScaling** ppGPUScaling);
+    ADLX_RESULT(ADLX_STD_CALL* GetScalingMode)(IADLXDisplayServices2* pThis, IADLXDisplay* pDisplay, IADLXDisplayScalingMode** ppScalingMode);
+    ADLX_RESULT(ADLX_STD_CALL* GetIntegerScaling)(IADLXDisplayServices2* pThis, IADLXDisplay* pDisplay, IADLXDisplayIntegerScaling** ppIntegerScaling);
+    ADLX_RESULT(ADLX_STD_CALL* GetColorDepth)(IADLXDisplayServices2* pThis, IADLXDisplay* pDisplay, IADLXDisplayColorDepth** ppColorDepth);
+    ADLX_RESULT(ADLX_STD_CALL* GetPixelFormat)(IADLXDisplayServices2* pThis, IADLXDisplay* pDisplay, IADLXDisplayPixelFormat** ppPixelFormat);
+    ADLX_RESULT(ADLX_STD_CALL* GetCustomColor)(IADLXDisplayServices2* pThis, IADLXDisplay* pDisplay, IADLXDisplayCustomColor** ppCustomColor);
+    ADLX_RESULT(ADLX_STD_CALL* GetHDCP)(IADLXDisplayServices2* pThis, IADLXDisplay* pDisplay, IADLXDisplayHDCP** ppHDCP);
+    ADLX_RESULT(ADLX_STD_CALL* GetCustomResolution)(IADLXDisplayServices2* pThis, IADLXDisplay* pDisplay, IADLXDisplayCustomResolution** ppCustomResolution);
+    ADLX_RESULT(ADLX_STD_CALL* GetVariBright)(IADLXDisplayServices2* pThis, IADLXDisplay* pDisplay, IADLXDisplayVariBright** ppVariBright);
+
+    //IADLXDisplayServices1
+    ADLX_RESULT(ADLX_STD_CALL* GetDisplayBlanking)(IADLXDisplayServices2* pThis, IADLXDisplay* pDisplay, IADLXDisplayBlanking** ppDisplayBlanking);
+
+    //IADLXDisplayServices2
+    ADLX_RESULT(ADLX_STD_CALL* GetDisplayConnectivityExperience)(IADLXDisplayServices2* pThis, IADLXDisplay* pDisplay, IADLXDisplayConnectivityExperience** ppDisplayConnectivityExperience);
+} IADLXDisplayServices2Vtbl;
+
+struct IADLXDisplayServices2 { const IADLXDisplayServices2Vtbl* pVtbl; };
+#endif
+
+#pragma endregion IADLXDisplayServices2
+
+#pragma region IADLXDisplaySettingsChangedEvent2
+#if defined (__cplusplus)
+namespace adlx
+{
+    class ADLX_NO_VTABLE IADLXDisplaySettingsChangedEvent2 : public IADLXDisplaySettingsChangedEvent1
+    {
+    public:
+        ADLX_DECLARE_IID(L"IADLXDisplaySettingsChangedEvent2")
+
+        /**
+        *@page DOX_IADLXDisplaySettingsChangedEvent2_IsConnectivityExperienceChanged IsConnectivityExperienceChanged
+        *@ENG_START_DOX @brief Checks if the DCE settings of the display are changed. @ENG_END_DOX
+        *
+        *@syntax
+        *@codeStart
+        * adlx_bool    IsDisplayConnectivityExperienceChanged ()
+        *@codeEnd
+        *
+        *@params
+        *N/A
+        *
+        *@retvalues
+        *@ENG_START_DOX
+        * If the DCE settings are changed, __true__ is returned. <br>
+        * If the DCE settings are not changed, __false__ is returned. @ENG_END_DOX
+        *
+        *
+        *@addinfo
+        *@ENG_START_DOX
+        * __Note:__ To obtain the display, use @ref DOX_IADLXDisplaySettingsChangedEvent_GetDisplay.
+        *@ENG_END_DOX
+        *
+        *@copydoc IADLXDisplaySettingsChangedEvent2_REQ_TABLE
+        */
+        virtual adlx_bool ADLX_STD_CALL IsDisplayConnectivityExperienceChanged() = 0;
+    }; //IADLXDisplaySettingsChangedEvent2
+    //----------------------------------------------------------------------------------------------
+    typedef IADLXInterfacePtr_T<IADLXDisplaySettingsChangedEvent2> IADLXDisplaySettingsChangedEvent2Ptr;
+} //namespace adlx
+#else //__cplusplus
+ADLX_DECLARE_IID(IADLXDisplaySettingsChangedEvent2, L"IADLXDisplaySettingsChangedEvent2")
+typedef struct IADLXDisplaySettingsChangedEvent2 IADLXDisplaySettingsChangedEvent2;
+
+typedef struct IADLXDisplaySettingsChangedEvent2Vtbl
+{
+    //IADLXInterface
+    adlx_long(ADLX_STD_CALL* Acquire)(IADLXDisplaySettingsChangedEvent2* pThis);
+    adlx_long(ADLX_STD_CALL* Release)(IADLXDisplaySettingsChangedEvent2* pThis);
+    ADLX_RESULT(ADLX_STD_CALL* QueryInterface)(IADLXDisplaySettingsChangedEvent2* pThis, const wchar_t* interfaceId, void** ppInterface);
+
+    //IADLXChangedEvent
+    ADLX_SYNC_ORIGIN(ADLX_STD_CALL* GetOrigin)(IADLXDisplaySettingsChangedEvent2* pThis);
+
+    // IADLXDisplaySettingsChangedEvent interface
+    ADLX_RESULT(ADLX_STD_CALL* GetDisplay)(IADLXDisplaySettingsChangedEvent2* pThis, IADLXDisplay** ppDisplay);
+    adlx_bool(ADLX_STD_CALL* IsFreeSyncChanged)(IADLXDisplaySettingsChangedEvent2* pThis);
+    adlx_bool(ADLX_STD_CALL* IsVSRChanged)(IADLXDisplaySettingsChangedEvent2* pThis);
+    adlx_bool(ADLX_STD_CALL* IsGPUScalingChanged)(IADLXDisplaySettingsChangedEvent2* pThis);
+    adlx_bool(ADLX_STD_CALL* IsScalingModeChanged)(IADLXDisplaySettingsChangedEvent2* pThis);
+    adlx_bool(ADLX_STD_CALL* IsIntegerScalingChanged)(IADLXDisplaySettingsChangedEvent2* pThis);
+    adlx_bool(ADLX_STD_CALL* IsColorDepthChanged)(IADLXDisplaySettingsChangedEvent2* pThis);
+    adlx_bool(ADLX_STD_CALL* IsPixelFormatChanged)(IADLXDisplaySettingsChangedEvent2* pThis);
+    adlx_bool(ADLX_STD_CALL* IsHDCPChanged)(IADLXDisplaySettingsChangedEvent2* pThis);
+    adlx_bool(ADLX_STD_CALL* IsCustomColorHueChanged)(IADLXDisplaySettingsChangedEvent2* pThis);
+    adlx_bool(ADLX_STD_CALL* IsCustomColorSaturationChanged)(IADLXDisplaySettingsChangedEvent2* pThis);
+    adlx_bool(ADLX_STD_CALL* IsCustomColorBrightnessChanged)(IADLXDisplaySettingsChangedEvent2* pThis);
+    adlx_bool(ADLX_STD_CALL* IsCustomColorTemperatureChanged)(IADLXDisplaySettingsChangedEvent2* pThis);
+    adlx_bool(ADLX_STD_CALL* IsCustomColorContrastChanged)(IADLXDisplaySettingsChangedEvent2* pThis);
+    adlx_bool(ADLX_STD_CALL* IsCustomResolutionChanged)(IADLXDisplaySettingsChangedEvent2* pThis);
+    adlx_bool(ADLX_STD_CALL* IsVariBrightChanged)(IADLXDisplaySettingsChangedEvent2* pThis);
+
+    // IADLXDisplaySettingsChangedEvent1 interface
+    adlx_bool(ADLX_STD_CALL* IsDisplayBlankingChanged)(IADLXDisplaySettingsChangedEvent2* pThis);
+
+    // IADLXDisplaySettingsChangedEvent2 interface
+    adlx_bool(ADLX_STD_CALL* IsDisplayConnectivityExperienceChanged)(IADLXDisplaySettingsChangedEvent2* pThis);
+
+
+} IADLXDisplaySettingsChangedEvent2Vtbl;
+
+struct IADLXDisplaySettingsChangedEvent2 { const IADLXDisplaySettingsChangedEvent2Vtbl* pVtbl; };
+#endif //__cplusplus
+#pragma endregion IADLXDisplaySettingsChangedEvent2
+
+#endif //ADLX_IDISPLAYS2_H

package/src/includes/adlx/IDisplays3.h

@@ -0,0 +1,256 @@
+//
+// Copyright (c) 2021 - 2025 Advanced Micro Devices, Inc. All rights reserved.
+//
+//-------------------------------------------------------------------------------------------------
+
+#ifndef ADLX_IDISPLAYS3_H
+#define ADLX_IDISPLAYS3_H
+#pragma once
+
+#include "IDisplays2.h"
+
+//-------------------------------------------------------------------------------------------------
+//IDisplays3.h - Interfaces for ADLX Display dynamic refresh rate control functionality
+
+#pragma region IADLXDisplayServices3
+
+#if defined (__cplusplus)
+namespace adlx
+{
+    class ADLX_NO_VTABLE IADLXDisplayDynamicRefreshRateControl;
+    class ADLX_NO_VTABLE IADLXDisplayFreeSyncColorAccuracy;
+    class ADLX_NO_VTABLE IADLXDisplayServices3 : public IADLXDisplayServices2
+    {
+    public:
+        ADLX_DECLARE_IID(L"IADLXDisplayServices3")
+
+        /**
+        *@page DOX_IADLXDisplayServices3_GetDynamicRefreshRateControl GetDynamicRefreshRateControl
+        *@ENG_START_DOX @brief Gets the reference counted Dynamic Refresh Rate Control interface for a display. @ENG_END_DOX
+        *
+        *@syntax
+        *@codeStart
+        * @ref ADLX_RESULT    GetDynamicRefreshRateControl (@ref DOX_IADLXDisplay* pDisplay, @ref DOX_IADLXDisplayDynamicRefreshRateControl** ppDRRC)
+        *@codeEnd
+        *
+        *@params
+        *@paramrow{1.,[in],pDisplay,@ref DOX_IADLXDisplay*,@ENG_START_DOX The pointer to the display interface. @ENG_END_DOX}
+        *@paramrow{2.,[out],ppDRRC,@ref DOX_IADLXDisplayDynamicRefreshRateControl**,@ENG_START_DOX The address of a pointer to the returned interface. If the interface is not successfully returned\, the method sets the dereferenced address __*ppDRRC__ to __nullptr__. @ENG_END_DOX}
+        *
+        *@retvalues
+        *@ENG_START_DOX
+        * If the interface is successfully returned, __ADLX_OK__ is returned. <br>
+        * If the interface is not successfully returned, 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 The returned interface must be discarded with @ref DOX_IADLXInterface_Release when it is no longer needed. @ENG_END_DOX
+        *
+        *@addinfo
+        *@ENG_START_DOX
+        *In C++, when using ADLX interfaces as smart pointers, there is no need to call @ref DOX_IADLXInterface_Release because smart pointers call it in their internal implementation. @ENG_END_DOX
+        *
+        *@copydoc IADLXDisplayServices3_REQ_TABLE
+        *
+        */
+        virtual ADLX_RESULT ADLX_STD_CALL GetDynamicRefreshRateControl (IADLXDisplay* pDisplay, IADLXDisplayDynamicRefreshRateControl** ppDRRC) = 0;
+
+        /**
+        *@page DOX_IADLXDisplayServices3_GetFreeSyncColorAccuracy GetFreeSyncColorAccuracy
+        *@ENG_START_DOX @brief Gets the reference counted FreeSync color accuracy interface for a display. @ENG_END_DOX
+        *
+        *@syntax
+        *@codeStart
+        * @ref ADLX_RESULT    GetFreeSyncColorAccuracy (@ref DOX_IADLXDisplay* pDisplay, @ref DOX_IADLXDisplayFreeSyncColorAccuracy** ppFSCA)
+        *@codeEnd
+        *
+        *@params
+        *@paramrow{1.,[in],pDisplay,@ref DOX_IADLXDisplay*,@ENG_START_DOX The pointer to the display interface. @ENG_END_DOX}
+        *@paramrow{2.,[out],ppFSCA,@ref DOX_IADLXDisplayFreeSyncColorAccuracy**,@ENG_START_DOX The address of a pointer to the returned interface. If the interface is not successfully returned\, the method sets the dereferenced address __*ppFSCA to __nullptr__. @ENG_END_DOX}
+        *
+        *@retvalues
+        *@ENG_START_DOX
+        * If the interface is successfully returned, __ADLX_OK__ is returned. <br>
+        * If the interface is not successfully returned, 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 The returned interface must be discarded with @ref DOX_IADLXInterface_Release when it is no longer needed. @ENG_END_DOX
+        *
+        *@addinfo
+        *@ENG_START_DOX
+        *In C++, when using ADLX interfaces as smart pointers, there is no need to call @ref DOX_IADLXInterface_Release because smart pointers call it in their internal implementation. @ENG_END_DOX
+        *
+        *@copydoc IADLXDisplayServices3_REQ_TABLE
+        *
+        */
+        virtual ADLX_RESULT ADLX_STD_CALL GetFreeSyncColorAccuracy(IADLXDisplay* pDisplay, IADLXDisplayFreeSyncColorAccuracy** ppFSCA) = 0;
+    };  //IADLXDisplayServices3
+    //----------------------------------------------------------------------------------------------
+    typedef IADLXInterfacePtr_T<IADLXDisplayServices3> IADLXDisplayServices3Ptr;
+} // namespace adlx
+#else //__cplusplus
+ADLX_DECLARE_IID(IADLXDisplayServices3, L"IADLXDisplayServices3")
+typedef struct IADLXDisplayServices3 IADLXDisplayServices3;
+
+typedef struct IADLXDisplayDynamicRefreshRateControl IADLXDisplayDynamicRefreshRateControl;
+typedef struct IADLXDisplayFreeSyncColorAccuracy IADLXDisplayFreeSyncColorAccuracy;
+
+
+typedef struct IADLXDisplayServices3Vtbl
+{
+    //IADLXInterface
+    adlx_long(ADLX_STD_CALL* Acquire)(IADLXDisplayServices3* pThis);
+    adlx_long(ADLX_STD_CALL* Release)(IADLXDisplayServices3* pThis);
+    ADLX_RESULT(ADLX_STD_CALL* QueryInterface)(IADLXDisplayServices3* pThis, const wchar_t* interfaceId, void** ppInterface);
+
+    //IADLXDisplayServices
+    ADLX_RESULT(ADLX_STD_CALL* GetNumberOfDisplays)(IADLXDisplayServices3* pThis, adlx_uint* numDisplays);
+    ADLX_RESULT(ADLX_STD_CALL* GetDisplays)(IADLXDisplayServices3* pThis, IADLXDisplayList** ppDisplays);
+    ADLX_RESULT(ADLX_STD_CALL* Get3DLUT)(IADLXDisplayServices3* pThis, IADLXDisplay* pDisplay, IADLXDisplay3DLUT** ppDisp3DLUT);
+    ADLX_RESULT(ADLX_STD_CALL* GetGamut)(IADLXDisplayServices3* pThis, IADLXDisplay* pDisplay, IADLXDisplayGamut** ppDispGamut);
+    ADLX_RESULT(ADLX_STD_CALL* GetGamma)(IADLXDisplayServices3* pThis, IADLXDisplay* pDisplay, IADLXDisplayGamma** ppDispGamma);
+    ADLX_RESULT(ADLX_STD_CALL* GetDisplayChangedHandling)(IADLXDisplayServices3* pThis, IADLXDisplayChangedHandling** ppDisplayChangedHandling);
+    ADLX_RESULT(ADLX_STD_CALL* GetFreeSync)(IADLXDisplayServices3* pThis, IADLXDisplay* pDisplay, IADLXDisplayFreeSync** ppFreeSync);
+    ADLX_RESULT(ADLX_STD_CALL* GetVirtualSuperResolution)(IADLXDisplayServices3* pThis, IADLXDisplay* pDisplay, IADLXDisplayVSR** ppVSR);
+    ADLX_RESULT(ADLX_STD_CALL* GetGPUScaling)(IADLXDisplayServices3* pThis, IADLXDisplay* pDisplay, IADLXDisplayGPUScaling** ppGPUScaling);
+    ADLX_RESULT(ADLX_STD_CALL* GetScalingMode)(IADLXDisplayServices3* pThis, IADLXDisplay* pDisplay, IADLXDisplayScalingMode** ppScalingMode);
+    ADLX_RESULT(ADLX_STD_CALL* GetIntegerScaling)(IADLXDisplayServices3* pThis, IADLXDisplay* pDisplay, IADLXDisplayIntegerScaling** ppIntegerScaling);
+    ADLX_RESULT(ADLX_STD_CALL* GetColorDepth)(IADLXDisplayServices3* pThis, IADLXDisplay* pDisplay, IADLXDisplayColorDepth** ppColorDepth);
+    ADLX_RESULT(ADLX_STD_CALL* GetPixelFormat)(IADLXDisplayServices3* pThis, IADLXDisplay* pDisplay, IADLXDisplayPixelFormat** ppPixelFormat);
+    ADLX_RESULT(ADLX_STD_CALL* GetCustomColor)(IADLXDisplayServices3* pThis, IADLXDisplay* pDisplay, IADLXDisplayCustomColor** ppCustomColor);
+    ADLX_RESULT(ADLX_STD_CALL* GetHDCP)(IADLXDisplayServices3* pThis, IADLXDisplay* pDisplay, IADLXDisplayHDCP** ppHDCP);
+    ADLX_RESULT(ADLX_STD_CALL* GetCustomResolution)(IADLXDisplayServices3* pThis, IADLXDisplay* pDisplay, IADLXDisplayCustomResolution** ppCustomResolution);
+    ADLX_RESULT(ADLX_STD_CALL* GetVariBright)(IADLXDisplayServices3* pThis, IADLXDisplay* pDisplay, IADLXDisplayVariBright** ppVariBright);
+
+    //IADLXDisplayServices1
+    ADLX_RESULT(ADLX_STD_CALL* GetDisplayBlanking)(IADLXDisplayServices3* pThis, IADLXDisplay* pDisplay, IADLXDisplayBlanking** ppDisplayBlanking);
+
+    //IADLXDisplayServices2
+    ADLX_RESULT(ADLX_STD_CALL* GetDisplayConnectivityExperience)(IADLXDisplayServices3* pThis, IADLXDisplay* pDisplay, IADLXDisplayConnectivityExperience** ppDisplayConnectivityExperience);
+
+    //IADLXDisplayServices3
+    ADLX_RESULT(ADLX_STD_CALL* GetDynamicRefreshRateControl)(IADLXDisplayServices3* pThis, IADLXDisplay* pDisplay, IADLXDisplayDynamicRefreshRateControl** ppDRRC);
+    ADLX_RESULT(ADLX_STD_CALL* GetFreeSyncColorAccuracy)(IADLXDisplayServices3* pThis, IADLXDisplay* pDisplay, IADLXDisplayFreeSyncColorAccuracy** ppFSCA);
+} IADLXDisplayServices3Vtbl;
+
+struct IADLXDisplayServices3 { const IADLXDisplayServices3Vtbl* pVtbl; };
+#endif
+
+#pragma endregion IADLXDisplayServices3
+
+#pragma region IADLXDisplaySettingsChangedEvent3
+#if defined (__cplusplus)
+namespace adlx
+{
+    class ADLX_NO_VTABLE IADLXDisplaySettingsChangedEvent3 : public IADLXDisplaySettingsChangedEvent2
+    {
+    public:
+        ADLX_DECLARE_IID(L"IADLXDisplaySettingsChangedEvent3")
+
+        /**
+        *@page DOX_IADLXDisplaySettingsChangedEvent3_IsDisplayDynamicRefreshRateControlChanged  IsDisplayDynamicRefreshRateControlChanged
+        *@ENG_START_DOX @brief Checks if the dynamic refresh rate control settings of the display are changed. @ENG_END_DOX
+        *
+        *@syntax
+        *@codeStart
+        * adlx_bool    IsDisplayDynamicRefreshRateControlChanged ()
+        *@codeEnd
+        *
+        *@params
+        *N/A
+        *
+        *@retvalues
+        *@ENG_START_DOX
+        * If the Dynamic Refresh Rate Control settings are changed, __true__ is returned. <br>
+        * If the Dynamic Refresh Rate Control settings are not changed, __false__ is returned. @ENG_END_DOX
+        *
+        *
+        *@addinfo
+        *@ENG_START_DOX
+        * __Note:__ To obtain the display, use @ref DOX_IADLXDisplaySettingsChangedEvent_GetDisplay.
+        *@ENG_END_DOX
+        *
+        *@copydoc IADLXDisplaySettingsChangedEvent3_REQ_TABLE
+        */
+        virtual adlx_bool ADLX_STD_CALL IsDisplayDynamicRefreshRateControlChanged () = 0;
+
+        /**
+        *@page DOX_IADLXDisplaySettingsChangedEvent3_IsFreeSyncColorAccuracyChanged  IsFreeSyncColorAccuracyChanged
+        *@ENG_START_DOX @brief Checks for changes to the configuration of the HDR media profile on a display. @ENG_END_DOX
+        *
+        *@syntax
+        *@codeStart
+        * adlx_bool    IsFreeSyncColorAccuracyChanged ()
+        *@codeEnd
+        *
+        *@params
+        *N/A
+        *
+        *@retvalues
+        *@ENG_START_DOX
+        * If the FreeSync color accuracy settings are changed, __true__ is returned. <br>
+        * If the FreeSync color accuracy settings are not changed, __false__ is returned. @ENG_END_DOX
+        *
+        *
+        *@addinfo
+        *@ENG_START_DOX
+        * __Note:__ To obtain the display, use @ref DOX_IADLXDisplaySettingsChangedEvent_GetDisplay.
+        *@ENG_END_DOX
+        *
+        *@copydoc IADLXDisplaySettingsChangedEvent3_REQ_TABLE
+        */
+        virtual adlx_bool ADLX_STD_CALL IsFreeSyncColorAccuracyChanged() = 0;
+    }; //IADLXDisplaySettingsChangedEvent3
+    //----------------------------------------------------------------------------------------------
+    typedef IADLXInterfacePtr_T<IADLXDisplaySettingsChangedEvent3> IADLXDisplaySettingsChangedEvent3Ptr;
+} //namespace adlx
+#else //__cplusplus
+ADLX_DECLARE_IID(IADLXDisplaySettingsChangedEvent3, L"IADLXDisplaySettingsChangedEvent3")
+typedef struct IADLXDisplaySettingsChangedEvent3 IADLXDisplaySettingsChangedEvent3;
+
+typedef struct IADLXDisplaySettingsChangedEvent3Vtbl
+{
+    //IADLXInterface
+    adlx_long(ADLX_STD_CALL* Acquire)(IADLXDisplaySettingsChangedEvent3* pThis);
+    adlx_long(ADLX_STD_CALL* Release)(IADLXDisplaySettingsChangedEvent3* pThis);
+    ADLX_RESULT(ADLX_STD_CALL* QueryInterface)(IADLXDisplaySettingsChangedEvent3* pThis, const wchar_t* interfaceId, void** ppInterface);
+
+    //IADLXChangedEvent
+    ADLX_SYNC_ORIGIN(ADLX_STD_CALL* GetOrigin)(IADLXDisplaySettingsChangedEvent3* pThis);
+
+    // IADLXDisplaySettingsChangedEvent interface
+    ADLX_RESULT(ADLX_STD_CALL* GetDisplay)(IADLXDisplaySettingsChangedEvent3* pThis, IADLXDisplay** ppDisplay);
+    adlx_bool(ADLX_STD_CALL* IsFreeSyncChanged)(IADLXDisplaySettingsChangedEvent3* pThis);
+    adlx_bool(ADLX_STD_CALL* IsVSRChanged)(IADLXDisplaySettingsChangedEvent3* pThis);
+    adlx_bool(ADLX_STD_CALL* IsGPUScalingChanged)(IADLXDisplaySettingsChangedEvent3* pThis);
+    adlx_bool(ADLX_STD_CALL* IsScalingModeChanged)(IADLXDisplaySettingsChangedEvent3* pThis);
+    adlx_bool(ADLX_STD_CALL* IsIntegerScalingChanged)(IADLXDisplaySettingsChangedEvent3* pThis);
+    adlx_bool(ADLX_STD_CALL* IsColorDepthChanged)(IADLXDisplaySettingsChangedEvent3* pThis);
+    adlx_bool(ADLX_STD_CALL* IsPixelFormatChanged)(IADLXDisplaySettingsChangedEvent3* pThis);
+    adlx_bool(ADLX_STD_CALL* IsHDCPChanged)(IADLXDisplaySettingsChangedEvent3* pThis);
+    adlx_bool(ADLX_STD_CALL* IsCustomColorHueChanged)(IADLXDisplaySettingsChangedEvent3* pThis);
+    adlx_bool(ADLX_STD_CALL* IsCustomColorSaturationChanged)(IADLXDisplaySettingsChangedEvent3* pThis);
+    adlx_bool(ADLX_STD_CALL* IsCustomColorBrightnessChanged)(IADLXDisplaySettingsChangedEvent3* pThis);
+    adlx_bool(ADLX_STD_CALL* IsCustomColorTemperatureChanged)(IADLXDisplaySettingsChangedEvent3* pThis);
+    adlx_bool(ADLX_STD_CALL* IsCustomColorContrastChanged)(IADLXDisplaySettingsChangedEvent3* pThis);
+    adlx_bool(ADLX_STD_CALL* IsCustomResolutionChanged)(IADLXDisplaySettingsChangedEvent3* pThis);
+    adlx_bool(ADLX_STD_CALL* IsVariBrightChanged)(IADLXDisplaySettingsChangedEvent3* pThis);
+
+    // IADLXDisplaySettingsChangedEvent1 interface
+    adlx_bool(ADLX_STD_CALL* IsDisplayBlankingChanged)(IADLXDisplaySettingsChangedEvent3* pThis);
+
+    // IADLXDisplaySettingsChangedEvent2 interface
+    adlx_bool(ADLX_STD_CALL* IsDisplayConnectivityExperienceChanged)(IADLXDisplaySettingsChangedEvent3* pThis);
+
+    // IADLXDisplaySettingsChangedEvent3 interface
+    adlx_bool(ADLX_STD_CALL* IsDisplayDynamicRefreshRateControlChanged)(IADLXDisplaySettingsChangedEvent3* pThis);
+    adlx_bool(ADLX_STD_CALL* IsFreeSyncColorAccuracyChanged)(IADLXDisplaySettingsChangedEvent3* pThis);
+
+} IADLXDisplaySettingsChangedEvent3Vtbl;
+
+struct IADLXDisplaySettingsChangedEvent3 { const IADLXDisplaySettingsChangedEvent3Vtbl* pVtbl; };
+#endif //__cplusplus
+#pragma endregion IADLXDisplaySettingsChangedEvent3
+
+#endif //ADLX_IDISPLAYS3_H