IntelArc/igcl_api.h

   1 //===========================================================================
   2 // Copyright (C) 2022-23 Intel Corporation
   3 // This software and the related documents are Intel copyrighted materials, and
   4 // your use of them is governed by the express license under which they were
   5 // provided to you ("License"). Unless the License provides otherwise, you may
   6 // not use, modify, copy, publish, distribute, disclose or transmit this software
   7 // or the related documents without Intel's prior written permission. This software
   8 // and the related documents are provided as is, with no express or implied
   9 // warranties, other than those that are expressly stated in the License.
  10 //--------------------------------------------------------------------------
  11
  12 /**
  13  *
  14  * @file ctl_api.h
  15  * @version v1-r1
  16  *
  17  */
  18 #ifndef _CTL_API_H
  19 #define _CTL_API_H
  20 #if defined(__cplusplus)
  21 #pragma once
  22 #endif
  23
  24 // standard headers
  25 #include <stdint.h>
  26 #include <stddef.h>
  27
  28 #if defined(__cplusplus)
  29 extern "C" {
  30 #endif
  31
  32 // Intel 'ctlApi' common types
  33 #if !defined(__GNUC__)
  34 #pragma region common
  35 #endif
  36 ///////////////////////////////////////////////////////////////////////////////
  37 #ifndef CTL_MAKE_VERSION
  38 /// @brief Generates generic ::'ctlApi' API versions
  39 #define CTL_MAKE_VERSION( _major, _minor )  (( _major << 16 )|( _minor & 0x0000ffff))
  40 #endif // CTL_MAKE_VERSION
  41
  42 ///////////////////////////////////////////////////////////////////////////////
  43 #ifndef CTL_MAJOR_VERSION
  44 /// @brief Extracts ::'ctlApi' API major version
  45 #define CTL_MAJOR_VERSION( _ver )  ( _ver >> 16 )
  46 #endif // CTL_MAJOR_VERSION
  47
  48 ///////////////////////////////////////////////////////////////////////////////
  49 #ifndef CTL_MINOR_VERSION
  50 /// @brief Extracts ::'ctlApi' API minor version
  51 #define CTL_MINOR_VERSION( _ver )  ( _ver & 0x0000ffff )
  52 #endif // CTL_MINOR_VERSION
  53
  54 ///////////////////////////////////////////////////////////////////////////////
  55 #ifndef CTL_IMPL_MAJOR_VERSION
  56 /// @brief ::'ctlApi' API major version of this implementation
  57 #define CTL_IMPL_MAJOR_VERSION  1
  58 #endif // CTL_IMPL_MAJOR_VERSION
  59
  60 ///////////////////////////////////////////////////////////////////////////////
  61 #ifndef CTL_IMPL_MINOR_VERSION
  62 /// @brief ::'ctlApi' API minor version of this implementation
  63 #define CTL_IMPL_MINOR_VERSION  1
  64 #endif // CTL_IMPL_MINOR_VERSION
  65
  66 ///////////////////////////////////////////////////////////////////////////////
  67 #ifndef CTL_IMPL_VERSION
  68 /// @brief ::'ctlApi' API version of this implementation
  69 #define CTL_IMPL_VERSION  CTL_MAKE_VERSION( CTL_IMPL_MAJOR_VERSION, CTL_IMPL_MINOR_VERSION )
  70 #endif // CTL_IMPL_VERSION
  71
  72 ///////////////////////////////////////////////////////////////////////////////
  73 #ifndef CTL_APICALL
  74 #if defined(_WIN32)
  75 /// @brief Calling convention for all API functions
  76 #define CTL_APICALL  __cdecl
  77 #else
  78 #define CTL_APICALL
  79 #endif // defined(_WIN32)
  80 #endif // CTL_APICALL
  81
  82 ///////////////////////////////////////////////////////////////////////////////
  83 #ifndef CTL_APIEXPORT
  84 #if defined(_WIN32)
  85 /// @brief Microsoft-specific dllexport storage-class attribute
  86 #define CTL_APIEXPORT  __declspec(dllexport)
  87 #else
  88 #define CTL_APIEXPORT
  89 #endif // defined(_WIN32)
  90 #endif // CTL_APIEXPORT
  91
  92 ///////////////////////////////////////////////////////////////////////////////
  93 #ifndef CTL_DLLEXPORT
  94 #if defined(_WIN32)
  95 /// @brief Microsoft-specific dllexport storage-class attribute
  96 #define CTL_DLLEXPORT  __declspec(dllexport)
  97 #endif // defined(_WIN32)
  98 #endif // CTL_DLLEXPORT
  99
 100 ///////////////////////////////////////////////////////////////////////////////
 101 #ifndef CTL_DLLEXPORT
 102 #if __GNUC__ >= 4
 103 /// @brief GCC-specific dllexport storage-class attribute
 104 #define CTL_DLLEXPORT  __attribute__ ((visibility ("default")))
 105 #else
 106 #define CTL_DLLEXPORT
 107 #endif // __GNUC__ >= 4
 108 #endif // CTL_DLLEXPORT
 109
 110 ///////////////////////////////////////////////////////////////////////////////
 111 #ifndef CTL_BIT
 112 /// @brief Generic macro for enumerator bit masks
 113 #define CTL_BIT( _i )  ( 1 << _i )
 114 #endif // CTL_BIT
 115
 116 ///////////////////////////////////////////////////////////////////////////////
 117 /// @brief Supported initialization flags
 118 typedef uint32_t ctl_init_flags_t;
 119 typedef enum _ctl_init_flag_t
 120 {
 121     CTL_INIT_FLAG_USE_LEVEL_ZERO = CTL_BIT(0),      ///< Use Level0 or not. This is usually required for telemetry,
 122                                                     ///< performance, frequency related APIs
 123     CTL_INIT_FLAG_MAX = 0x80000000
 124
 125 } ctl_init_flag_t;
 126
 127 ///////////////////////////////////////////////////////////////////////////////
 128 /// @brief Version information
 129 typedef uint32_t ctl_version_info_t;
 130
 131 ///////////////////////////////////////////////////////////////////////////////
 132 /// @brief Handle of a control API instance
 133 typedef struct _ctl_api_handle_t *ctl_api_handle_t;
 134
 135 ///////////////////////////////////////////////////////////////////////////////
 136 /// @brief Handle of a device adapter instance
 137 typedef struct _ctl_device_adapter_handle_t *ctl_device_adapter_handle_t;
 138
 139 ///////////////////////////////////////////////////////////////////////////////
 140 /// @brief Handle of a device temperature sensor
 141 typedef struct _ctl_temp_handle_t *ctl_temp_handle_t;
 142
 143 ///////////////////////////////////////////////////////////////////////////////
 144 /// @brief Handle for a device frequency domain
 145 typedef struct _ctl_freq_handle_t *ctl_freq_handle_t;
 146
 147 ///////////////////////////////////////////////////////////////////////////////
 148 /// @brief Handle of a power device.
 149 typedef struct _ctl_pwr_handle_t *ctl_pwr_handle_t;
 150
 151 ///////////////////////////////////////////////////////////////////////////////
 152 /// @brief Handle of a device fan
 153 typedef struct _ctl_fan_handle_t *ctl_fan_handle_t;
 154
 155 ///////////////////////////////////////////////////////////////////////////////
 156 /// @brief Handle of a device memory module
 157 typedef struct _ctl_mem_handle_t *ctl_mem_handle_t;
 158
 159 ///////////////////////////////////////////////////////////////////////////////
 160 /// @brief Handle of a device engine group
 161 typedef struct _ctl_engine_handle_t *ctl_engine_handle_t;
 162
 163 ///////////////////////////////////////////////////////////////////////////////
 164 /// @brief Base for all properties types
 165 typedef struct _ctl_base_interface_t
 166 {
 167     uint32_t Size;                                  ///< [in] size of this structure
 168     uint8_t Version;                                ///< [in] version of this structure
 169
 170 } ctl_base_interface_t;
 171
 172 ///////////////////////////////////////////////////////////////////////////////
 173 /// @brief Value type
 174 typedef enum _ctl_property_value_type_t
 175 {
 176     CTL_PROPERTY_VALUE_TYPE_BOOL = 0,               ///< Boolean
 177     CTL_PROPERTY_VALUE_TYPE_FLOAT = 1,              ///< Float
 178     CTL_PROPERTY_VALUE_TYPE_INT32 = 2,              ///< Int32
 179     CTL_PROPERTY_VALUE_TYPE_UINT32 = 3,             ///< Unsigned Int32
 180     CTL_PROPERTY_VALUE_TYPE_ENUM = 4,               ///< Enum
 181     CTL_PROPERTY_VALUE_TYPE_CUSTOM = 5,             ///< Custom argument
 182     CTL_PROPERTY_VALUE_TYPE_MAX
 183
 184 } ctl_property_value_type_t;
 185
 186 ///////////////////////////////////////////////////////////////////////////////
 187 /// @brief Property range details, a generic struct to hold min/max/step size
 188 ///        information of various feature properties
 189 typedef struct _ctl_property_range_info_t
 190 {
 191     float min_possible_value;                       ///< [out] Minimum possible value
 192     float max_possible_value;                       ///< [out] Maximum possible value
 193     float step_size;                                ///< [out] Step size possible
 194     float default_value;                            ///< [out] Default value
 195
 196 } ctl_property_range_info_t;
 197
 198 ///////////////////////////////////////////////////////////////////////////////
 199 /// @brief Property range details of integer type, a generic struct to hold
 200 ///        min/max/step size information of various feature properties
 201 typedef struct _ctl_property_range_info_int_t
 202 {
 203     int32_t min_possible_value;                     ///< [out] Minimum possible value
 204     int32_t max_possible_value;                     ///< [out] Maximum possible value
 205     int32_t step_size;                              ///< [out] Step size possible
 206     int32_t default_value;                          ///< [out] Default value
 207
 208 } ctl_property_range_info_int_t;
 209
 210 ///////////////////////////////////////////////////////////////////////////////
 211 /// @brief Property range details of unsigned integer type, a generic struct to
 212 ///        hold min/max/step size information of various feature properties
 213 typedef struct _ctl_property_range_info_uint_t
 214 {
 215     uint32_t min_possible_value;                    ///< [out] Minimum possible value
 216     uint32_t max_possible_value;                    ///< [out] Maximum possible value
 217     uint32_t step_size;                             ///< [out] Step size possible
 218     uint32_t default_value;                         ///< [out] Default value
 219
 220 } ctl_property_range_info_uint_t;
 221
 222 ///////////////////////////////////////////////////////////////////////////////
 223 /// @brief Bool feature details
 224 typedef struct _ctl_property_info_boolean_t
 225 {
 226     bool DefaultState;                              ///< [out] Default state
 227
 228 } ctl_property_info_boolean_t;
 229
 230 ///////////////////////////////////////////////////////////////////////////////
 231 /// @brief Bool feature for get/set
 232 typedef struct _ctl_property_boolean_t
 233 {
 234     bool Enable;                                    ///< [in,out] Enable
 235
 236 } ctl_property_boolean_t;
 237
 238 ///////////////////////////////////////////////////////////////////////////////
 239 /// @brief Enumeration feature details
 240 typedef struct _ctl_property_info_enum_t
 241 {
 242     uint64_t SupportedTypes;                        ///< [out] Supported possible values represented as a bitmask
 243     uint32_t DefaultType;                           ///< [out] Default type
 244
 245 } ctl_property_info_enum_t;
 246
 247 ///////////////////////////////////////////////////////////////////////////////
 248 /// @brief Enumeration feature for get/set
 249 typedef struct _ctl_property_enum_t
 250 {
 251     uint32_t EnableType;                            ///< [in,out] Enable with specific type
 252
 253 } ctl_property_enum_t;
 254
 255 ///////////////////////////////////////////////////////////////////////////////
 256 /// @brief Float feature details
 257 typedef struct _ctl_property_info_float_t
 258 {
 259     bool DefaultEnable;                             ///< [in,out] DefaultEnable
 260     ctl_property_range_info_t RangeInfo;            ///< [out] Min/max/default/step details
 261
 262 } ctl_property_info_float_t;
 263
 264 ///////////////////////////////////////////////////////////////////////////////
 265 /// @brief Float feature for get/set
 266 typedef struct _ctl_property_float_t
 267 {
 268     bool Enable;                                    ///< [in,out] Enable
 269     float Value;                                    ///< [in,out] Value
 270
 271 } ctl_property_float_t;
 272
 273 ///////////////////////////////////////////////////////////////////////////////
 274 /// @brief Int32 feature details
 275 typedef struct _ctl_property_info_int_t
 276 {
 277     bool DefaultEnable;                             ///< [in,out] DefaultEnable
 278     ctl_property_range_info_int_t RangeInfo;        ///< [out] Min/max/default/step details
 279
 280 } ctl_property_info_int_t;
 281
 282 ///////////////////////////////////////////////////////////////////////////////
 283 /// @brief Int32 feature for get/set
 284 typedef struct _ctl_property_int_t
 285 {
 286     bool Enable;                                    ///< [in,out] Enable
 287     int32_t Value;                                  ///< [in,out] Value
 288
 289 } ctl_property_int_t;
 290
 291 ///////////////////////////////////////////////////////////////////////////////
 292 /// @brief Int32 feature details
 293 typedef struct _ctl_property_info_uint_t
 294 {
 295     bool DefaultEnable;                             ///< [in,out] DefaultEnable
 296     ctl_property_range_info_uint_t RangeInfo;       ///< [out] Min/max/default/step details
 297
 298 } ctl_property_info_uint_t;
 299
 300 ///////////////////////////////////////////////////////////////////////////////
 301 /// @brief Int32 feature for get/set
 302 typedef struct _ctl_property_uint_t
 303 {
 304     bool Enable;                                    ///< [in,out] Enable
 305     uint32_t Value;                                 ///< [in,out] Value
 306
 307 } ctl_property_uint_t;
 308
 309 ///////////////////////////////////////////////////////////////////////////////
 310 /// @brief Feature element details, union of bool/float/enum property_info
 311 ///        structs. Used for feature specific capability check
 312 typedef union _ctl_property_info_t
 313 {
 314     ctl_property_info_boolean_t BoolType;           ///< [in,out] Boolean type fields
 315     ctl_property_info_float_t FloatType;            ///< [in,out] Float type fields
 316     ctl_property_info_int_t IntType;                ///< [in,out] Int type fields
 317     ctl_property_info_enum_t EnumType;              ///< [in,out] Enum type fields
 318     ctl_property_info_uint_t UIntType;              ///< [in,out] Unsigned Int type fields
 319
 320 } ctl_property_info_t;
 321
 322 ///////////////////////////////////////////////////////////////////////////////
 323 /// @brief Feature element details, union of bool/float/enum property structs.
 324 ///        Used for get/set calls
 325 typedef union _ctl_property_t
 326 {
 327     ctl_property_boolean_t BoolType;                ///< [in,out] Boolean type fields
 328     ctl_property_float_t FloatType;                 ///< [in,out] Float type fields
 329     ctl_property_int_t IntType;                     ///< [in,out] Int type fields
 330     ctl_property_enum_t EnumType;                   ///< [in,out] Enum type fields
 331     ctl_property_uint_t UIntType;                   ///< [in,out] Unsigned Int type fields
 332
 333 } ctl_property_t;
 334
 335 ///////////////////////////////////////////////////////////////////////////////
 336 /// @brief Defines Return/Error codes.
 337 ///        All generic error (bit30) codes are between 0x40000000-0x4000FFFF.
 338 ///        All 3D (bit 29) specific error codes are between 0x60000000-0x6000FFFF.
 339 ///        All media (bit 28) specific error codes are between 0x50000000-0x5000FFFF.
 340 ///        All display (bit 27) specific error codes are between 0x48000000-0x4800FFFF
 341 ///        All core (bit 26) specific error codes are between 0x44000000-0x4400FFFF
 342 ///        Success result code with additional info are between 0x00000001-0x0000FFFF.
 343 typedef enum _ctl_result_t
 344 {
 345     CTL_RESULT_SUCCESS = 0x00000000,                ///< success
 346     CTL_RESULT_SUCCESS_STILL_OPEN_BY_ANOTHER_CALLER = 0x00000001,   ///< success but still open by another caller
 347     CTL_RESULT_ERROR_SUCCESS_END = 0x0000FFFF,      ///< "Success group error code end value, not to be used
 348                                                     ///< "
 349     CTL_RESULT_ERROR_GENERIC_START = 0x40000000,    ///< Generic error code starting value, not to be used
 350     CTL_RESULT_ERROR_NOT_INITIALIZED = 0x40000001,  ///< Result not initialized
 351     CTL_RESULT_ERROR_ALREADY_INITIALIZED = 0x40000002,  ///< Already initialized
 352     CTL_RESULT_ERROR_DEVICE_LOST = 0x40000003,      ///< Device hung, reset, was removed, or driver update occurred
 353     CTL_RESULT_ERROR_OUT_OF_HOST_MEMORY = 0x40000004,   ///< Insufficient host memory to satisfy call
 354     CTL_RESULT_ERROR_OUT_OF_DEVICE_MEMORY = 0x40000005, ///< Insufficient device memory to satisfy call
 355     CTL_RESULT_ERROR_INSUFFICIENT_PERMISSIONS = 0x40000006, ///< Access denied due to permission level
 356     CTL_RESULT_ERROR_NOT_AVAILABLE = 0x40000007,    ///< Resource was removed
 357     CTL_RESULT_ERROR_UNINITIALIZED = 0x40000008,    ///< Library not initialized
 358     CTL_RESULT_ERROR_UNSUPPORTED_VERSION = 0x40000009,  ///< Generic error code for unsupported versions
 359     CTL_RESULT_ERROR_UNSUPPORTED_FEATURE = 0x4000000a,  ///< Generic error code for unsupported features
 360     CTL_RESULT_ERROR_INVALID_ARGUMENT = 0x4000000b, ///< Generic error code for invalid arguments
 361     CTL_RESULT_ERROR_INVALID_API_HANDLE = 0x4000000c,   ///< API handle in invalid
 362     CTL_RESULT_ERROR_INVALID_NULL_HANDLE = 0x4000000d,  ///< Handle argument is not valid
 363     CTL_RESULT_ERROR_INVALID_NULL_POINTER = 0x4000000e, ///< Pointer argument may not be nullptr
 364     CTL_RESULT_ERROR_INVALID_SIZE = 0x4000000f,     ///< Size argument is invalid (e.g., must not be zero)
 365     CTL_RESULT_ERROR_UNSUPPORTED_SIZE = 0x40000010, ///< Size argument is not supported by the device (e.g., too large)
 366     CTL_RESULT_ERROR_UNSUPPORTED_IMAGE_FORMAT = 0x40000011, ///< Image format is not supported by the device
 367     CTL_RESULT_ERROR_DATA_READ = 0x40000012,        ///< Data read error
 368     CTL_RESULT_ERROR_DATA_WRITE = 0x40000013,       ///< Data write error
 369     CTL_RESULT_ERROR_DATA_NOT_FOUND = 0x40000014,   ///< Data not found error
 370     CTL_RESULT_ERROR_NOT_IMPLEMENTED = 0x40000015,  ///< Function not implemented
 371     CTL_RESULT_ERROR_OS_CALL = 0x40000016,          ///< Operating system call failure
 372     CTL_RESULT_ERROR_KMD_CALL = 0x40000017,         ///< Kernel mode driver call failure
 373     CTL_RESULT_ERROR_UNLOAD = 0x40000018,           ///< Library unload failure
 374     CTL_RESULT_ERROR_ZE_LOADER = 0x40000019,        ///< Level0 loader not found
 375     CTL_RESULT_ERROR_INVALID_OPERATION_TYPE = 0x4000001a,   ///< Invalid operation type
 376     CTL_RESULT_ERROR_NULL_OS_INTERFACE = 0x4000001b,///< Null OS interface
 377     CTL_RESULT_ERROR_NULL_OS_ADAPATER_HANDLE = 0x4000001c,  ///< Null OS adapter handle
 378     CTL_RESULT_ERROR_NULL_OS_DISPLAY_OUTPUT_HANDLE = 0x4000001d,///< Null display output handle
 379     CTL_RESULT_ERROR_WAIT_TIMEOUT = 0x4000001e,     ///< Timeout in Wait function
 380     CTL_RESULT_ERROR_PERSISTANCE_NOT_SUPPORTED = 0x4000001f,///< Persistance not supported
 381     CTL_RESULT_ERROR_PLATFORM_NOT_SUPPORTED = 0x40000020,   ///< Platform not supported
 382     CTL_RESULT_ERROR_UNKNOWN_APPLICATION_UID = 0x40000021,  ///< Unknown Appplicaion UID in Initialization call
 383     CTL_RESULT_ERROR_INVALID_ENUMERATION = 0x40000022,  ///< The enum is not valid
 384     CTL_RESULT_ERROR_FILE_DELETE = 0x40000023,      ///< Error in file delete operation
 385     CTL_RESULT_ERROR_RESET_DEVICE_REQUIRED = 0x40000024,///< The device requires a reset.
 386     CTL_RESULT_ERROR_FULL_REBOOT_REQUIRED = 0x40000025, ///< The device requires a full reboot.
 387     CTL_RESULT_ERROR_LOAD = 0x40000026,             ///< Library load failure
 388     CTL_RESULT_ERROR_UNKNOWN = 0x4000FFFF,          ///< Unknown or internal error
 389     CTL_RESULT_ERROR_RETRY_OPERATION = 0x40010000,  ///< Operation failed, retry previous operation again
 390     CTL_RESULT_ERROR_GENERIC_END = 0x4000FFFF,      ///< "Generic error code end value, not to be used
 391                                                     ///< "
 392     CTL_RESULT_ERROR_CORE_START = 0x44000000,       ///< Core error code starting value, not to be used
 393     CTL_RESULT_ERROR_CORE_OVERCLOCK_NOT_SUPPORTED = 0x44000001, ///< The Overclock is not supported.
 394     CTL_RESULT_ERROR_CORE_OVERCLOCK_VOLTAGE_OUTSIDE_RANGE = 0x44000002, ///< The Voltage exceeds the acceptable min/max.
 395     CTL_RESULT_ERROR_CORE_OVERCLOCK_FREQUENCY_OUTSIDE_RANGE = 0x44000003,   ///< The Frequency exceeds the acceptable min/max.
 396     CTL_RESULT_ERROR_CORE_OVERCLOCK_POWER_OUTSIDE_RANGE = 0x44000004,   ///< The Power exceeds the acceptable min/max.
 397     CTL_RESULT_ERROR_CORE_OVERCLOCK_TEMPERATURE_OUTSIDE_RANGE = 0x44000005, ///< The Power exceeds the acceptable min/max.
 398     CTL_RESULT_ERROR_CORE_OVERCLOCK_IN_VOLTAGE_LOCKED_MODE = 0x44000006,///< The Overclock is in voltage locked mode.
 399     CTL_RESULT_ERROR_CORE_OVERCLOCK_RESET_REQUIRED = 0x44000007,///< It indicates that the requested change will not be applied until the
 400                                                     ///< device is reset.
 401     CTL_RESULT_ERROR_CORE_OVERCLOCK_WAIVER_NOT_SET = 0x44000008,///< The $OverclockWaiverSet function has not been called.
 402     CTL_RESULT_ERROR_CORE_END = 0x0440FFFF,         ///< "Core error code end value, not to be used
 403                                                     ///< "
 404     CTL_RESULT_ERROR_3D_START = 0x60000000,         ///< 3D error code starting value, not to be used
 405     CTL_RESULT_ERROR_3D_END = 0x6000FFFF,           ///< "3D error code end value, not to be used
 406                                                     ///< "
 407     CTL_RESULT_ERROR_MEDIA_START = 0x50000000,      ///< Media error code starting value, not to be used
 408     CTL_RESULT_ERROR_MEDIA_END = 0x5000FFFF,        ///< "Media error code end value, not to be used
 409                                                     ///< "
 410     CTL_RESULT_ERROR_DISPLAY_START = 0x48000000,    ///< Display error code starting value, not to be used
 411     CTL_RESULT_ERROR_INVALID_AUX_ACCESS_FLAG = 0x48000001,  ///< Invalid flag for Aux access
 412     CTL_RESULT_ERROR_INVALID_SHARPNESS_FILTER_FLAG = 0x48000002,///< Invalid flag for Sharpness
 413     CTL_RESULT_ERROR_DISPLAY_NOT_ATTACHED = 0x48000003, ///< Error for Display not attached
 414     CTL_RESULT_ERROR_DISPLAY_NOT_ACTIVE = 0x48000004,   ///< Error for display attached but not active
 415     CTL_RESULT_ERROR_INVALID_POWERFEATURE_OPTIMIZATION_FLAG = 0x48000005,   ///< Error for invalid power optimization flag
 416     CTL_RESULT_ERROR_INVALID_POWERSOURCE_TYPE_FOR_DPST = 0x48000006,///< DPST is supported only in DC Mode
 417     CTL_RESULT_ERROR_INVALID_PIXTX_GET_CONFIG_QUERY_TYPE = 0x48000007,  ///< Invalid query type for pixel transformation get configuration
 418     CTL_RESULT_ERROR_INVALID_PIXTX_SET_CONFIG_OPERATION_TYPE = 0x48000008,  ///< Invalid operation type for pixel transformation set configuration
 419     CTL_RESULT_ERROR_INVALID_SET_CONFIG_NUMBER_OF_SAMPLES = 0x48000009, ///< Invalid number of samples for pixel transformation set configuration
 420     CTL_RESULT_ERROR_INVALID_PIXTX_BLOCK_ID = 0x4800000a,   ///< Invalid block id for pixel transformation
 421     CTL_RESULT_ERROR_INVALID_PIXTX_BLOCK_TYPE = 0x4800000b, ///< Invalid block type for pixel transformation
 422     CTL_RESULT_ERROR_INVALID_PIXTX_BLOCK_NUMBER = 0x4800000c,   ///< Invalid block number for pixel transformation
 423     CTL_RESULT_ERROR_INSUFFICIENT_PIXTX_BLOCK_CONFIG_MEMORY = 0x4800000d,   ///< Insufficient memery allocated for BlockConfigs
 424     CTL_RESULT_ERROR_3DLUT_INVALID_PIPE = 0x4800000e,   ///< Invalid pipe for 3dlut
 425     CTL_RESULT_ERROR_3DLUT_INVALID_DATA = 0x4800000f,   ///< Invalid 3dlut data
 426     CTL_RESULT_ERROR_3DLUT_NOT_SUPPORTED_IN_HDR = 0x48000010,   ///< 3dlut not supported in HDR
 427     CTL_RESULT_ERROR_3DLUT_INVALID_OPERATION = 0x48000011,  ///< Invalid 3dlut operation
 428     CTL_RESULT_ERROR_3DLUT_UNSUCCESSFUL = 0x48000012,   ///< 3dlut call unsuccessful
 429     CTL_RESULT_ERROR_AUX_DEFER = 0x48000013,        ///< AUX defer failure
 430     CTL_RESULT_ERROR_AUX_TIMEOUT = 0x48000014,      ///< AUX timeout failure
 431     CTL_RESULT_ERROR_AUX_INCOMPLETE_WRITE = 0x48000015, ///< AUX incomplete write failure
 432     CTL_RESULT_ERROR_I2C_AUX_STATUS_UNKNOWN = 0x48000016,   ///< I2C/AUX unkonown failure
 433     CTL_RESULT_ERROR_I2C_AUX_UNSUCCESSFUL = 0x48000017, ///< I2C/AUX unsuccessful
 434     CTL_RESULT_ERROR_LACE_INVALID_DATA_ARGUMENT_PASSED = 0x48000018,///< Lace Incorrrect AggressivePercent data or LuxVsAggressive Map data
 435                                                     ///< passed by user
 436     CTL_RESULT_ERROR_EXTERNAL_DISPLAY_ATTACHED = 0x48000019,///< External Display is Attached hence fail the Display Switch
 437     CTL_RESULT_ERROR_CUSTOM_MODE_STANDARD_CUSTOM_MODE_EXISTS = 0x4800001a,  ///< Standard custom mode exists
 438     CTL_RESULT_ERROR_CUSTOM_MODE_NON_CUSTOM_MATCHING_MODE_EXISTS = 0x4800001b,  ///< Non custom matching mode exists
 439     CTL_RESULT_ERROR_CUSTOM_MODE_INSUFFICIENT_MEMORY = 0x4800001c,  ///< Custom mode insufficent memory
 440     CTL_RESULT_ERROR_DISPLAY_END = 0x4800FFFF,      ///< "Display error code end value, not to be used
 441                                                     ///< "
 442     CTL_RESULT_MAX
 443
 444 } ctl_result_t;
 445
 446 ///////////////////////////////////////////////////////////////////////////////
 447 #ifndef CTL_MAX_DEVICE_NAME_LEN
 448 /// @brief Maximum IPC handle size
 449 #define CTL_MAX_DEVICE_NAME_LEN  100
 450 #endif // CTL_MAX_DEVICE_NAME_LEN
 451
 452 ///////////////////////////////////////////////////////////////////////////////
 453 #ifndef CTL_MAX_RESERVED_SIZE
 454 /// @brief Maximum reserved size for future members.
 455 #define CTL_MAX_RESERVED_SIZE  116
 456 #endif // CTL_MAX_RESERVED_SIZE
 457
 458 ///////////////////////////////////////////////////////////////////////////////
 459 /// @brief General Physical Units.
 460 typedef enum _ctl_units_t
 461 {
 462     CTL_UNITS_FREQUENCY_MHZ = 0,                    ///< Type is Frequency with units in MHz.
 463     CTL_UNITS_OPERATIONS_GTS = 1,                   ///< Type is Frequency with units in GT/s (gigatransfers per second).
 464     CTL_UNITS_OPERATIONS_MTS = 2,                   ///< Type is Frequency with units in MT/s (megatransfers per second).
 465     CTL_UNITS_VOLTAGE_VOLTS = 3,                    ///< Type is Voltage with units in Volts.
 466     CTL_UNITS_POWER_WATTS = 4,                      ///< Type is Power with units in Watts.
 467     CTL_UNITS_TEMPERATURE_CELSIUS = 5,              ///< Type is Temperature with units in Celsius.
 468     CTL_UNITS_ENERGY_JOULES = 6,                    ///< Type is Energy with units in Joules.
 469     CTL_UNITS_TIME_SECONDS = 7,                     ///< Type is Time with units in Seconds.
 470     CTL_UNITS_MEMORY_BYTES = 8,                     ///< Type is Memory with units in Bytes.
 471     CTL_UNITS_ANGULAR_SPEED_RPM = 9,                ///< Type is Angular Speed with units in Revolutions per Minute.
 472     CTL_UNITS_UNKNOWN = 0x4800FFFF,                 ///< Type of units unknown.
 473     CTL_UNITS_MAX
 474
 475 } ctl_units_t;
 476
 477 ///////////////////////////////////////////////////////////////////////////////
 478 /// @brief General Data Types.
 479 typedef enum _ctl_data_type_t
 480 {
 481     CTL_DATA_TYPE_INT8 = 0,                         ///< The data type is 8 bit signed integer.
 482     CTL_DATA_TYPE_UINT8 = 1,                        ///< The data type is 8 bit unsigned integer.
 483     CTL_DATA_TYPE_INT16 = 2,                        ///< The data type is 16 bit signed integer.
 484     CTL_DATA_TYPE_UINT16 = 3,                       ///< The data type is 16 bit unsigned integer.
 485     CTL_DATA_TYPE_INT32 = 4,                        ///< The data type is 32 bit signed integer.
 486     CTL_DATA_TYPE_UINT32 = 5,                       ///< The data type is 32 bit unsigned integer.
 487     CTL_DATA_TYPE_INT64 = 6,                        ///< The data type is 64 bit signed integer.
 488     CTL_DATA_TYPE_UINT64 = 7,                       ///< The data type is 64 bit unsigned integer.
 489     CTL_DATA_TYPE_FLOAT = 8,                        ///< The data type is 32 bit floating point.
 490     CTL_DATA_TYPE_DOUBLE = 9,                       ///< The data type is 64 bit floating point.
 491     CTL_DATA_TYPE_STRING_ASCII = 10,                ///< The data type is an array of 8 bit unsigned integers.
 492     CTL_DATA_TYPE_STRING_UTF16 = 11,                ///< The data type is an array of 16 bit unsigned integers.
 493     CTL_DATA_TYPE_STRING_UTF132 = 12,               ///< The data type is an array of 32 bit unsigned integers.
 494     CTL_DATA_TYPE_UNKNOWN = 0x4800FFFF,             ///< The data type is unknown.
 495     CTL_DATA_TYPE_MAX
 496
 497 } ctl_data_type_t;
 498
 499 ///////////////////////////////////////////////////////////////////////////////
 500 /// @brief Union for Generic Data.
 501 ///
 502 /// @details
 503 ///     - The telemetry data items could be of different types.
 504 ///     - Refer to ::ctl_data_type_t to find the current type.
 505 typedef union _ctl_data_value_t
 506 {
 507     int8_t data8;                                   ///< [out] The data type is 8 bit signed integer.
 508     uint8_t datau8;                                 ///< [out] The data type is 8 bit unsigned integer.
 509     int16_t data16;                                 ///< [out] The data type is 16 bit signed integer.
 510     uint16_t datau16;                               ///< [out] The data type is 16 bit unsigned integer.
 511     int32_t data32;                                 ///< [out] The data type is 32 bit signed integer.
 512     uint32_t datau32;                               ///< [out] The data type is 32 bit unsigned integer.
 513     int64_t data64;                                 ///< [out] The data type is 64 bit signed integer.
 514     uint64_t datau64;                               ///< [out] The data type is 64 bit unsigned integer.
 515     float datafloat;                                ///< [out] The data type is 32 bit floating point.
 516     double datadouble;                              ///< [out] The data type is 64 bit floating point.
 517
 518 } ctl_data_value_t;
 519
 520 ///////////////////////////////////////////////////////////////////////////////
 521 /// @brief Base for all properties types
 522 typedef struct _ctl_base_properties_t
 523 {
 524     uint32_t Size;                                  ///< [in] size of this structure
 525     uint8_t Version;                                ///< [in] version of this structure
 526
 527 } ctl_base_properties_t;
 528
 529 ///////////////////////////////////////////////////////////////////////////////
 530 /// @brief Application Unique ID
 531 typedef struct _ctl_application_id_t
 532 {
 533     uint32_t Data1;                                 ///< [in] Data1
 534     uint16_t Data2;                                 ///< [in] Data2
 535     uint16_t Data3;                                 ///< [in] Data3
 536     uint8_t Data4[8];                               ///< [in] Data4
 537
 538 } ctl_application_id_t;
 539
 540 ///////////////////////////////////////////////////////////////////////////////
 541 /// @brief Init arguments
 542 typedef struct _ctl_init_args_t
 543 {
 544     uint32_t Size;                                  ///< [in] size of this structure
 545     uint8_t Version;                                ///< [in] version of this structure
 546     ctl_version_info_t AppVersion;                  ///< [in][release] App's IGCL version
 547     ctl_init_flags_t flags;                         ///< [in][release] Caller version
 548     ctl_version_info_t SupportedVersion;            ///< [out][release] IGCL implementation version
 549     ctl_application_id_t ApplicationUID;            ///< [in] Application Provided Unique ID.Application can pass all 0's as
 550                                                     ///< the default ID
 551
 552 } ctl_init_args_t;
 553
 554 ///////////////////////////////////////////////////////////////////////////////
 555 /// @brief Reserved struct
 556 typedef struct _ctl_reserved_args_t
 557 {
 558     uint32_t Size;                                  ///< [in] size of this structure
 559     uint8_t Version;                                ///< [in] version of this structure
 560     void* pSpecialArg;                              ///< [in] Reserved struct
 561     uint32_t ArgSize;                               ///< [in] struct size
 562
 563 } ctl_reserved_args_t;
 564
 565 ///////////////////////////////////////////////////////////////////////////////
 566 /// @brief Reserved base struct
 567 typedef struct _ctl_reserved_args_base_t
 568 {
 569     ctl_application_id_t ReservedFuncID;            ///< [in] Unique ID for reserved/special function
 570
 571 } ctl_reserved_args_base_t;
 572
 573 ///////////////////////////////////////////////////////////////////////////////
 574 /// @brief Reserved - Unlock function capability
 575 typedef struct _ctl_unlock_capability_t
 576 {
 577     ctl_application_id_t ReservedFuncID;            ///< [in] Unique ID for reserved/special function
 578     ctl_application_id_t UnlockCapsID;              ///< [in] Unique ID to unlock a specific function
 579
 580 } ctl_unlock_capability_t;
 581
 582 ///////////////////////////////////////////////////////////////////////////////
 583 /// @brief Used by loader like modules to specify runtime implementation details
 584 typedef struct _ctl_runtime_path_args_t
 585 {
 586     uint32_t Size;                                  ///< [in] size of this structure
 587     uint8_t Version;                                ///< [in] version of this structure
 588     ctl_application_id_t UnlockID;                  ///< [in] Unique ID for reserved/special function
 589     wchar_t* pRuntimePath;                          ///< [in] Path to runtime DLL
 590     uint16_t DeviceID;                              ///< [in] Device ID of interest to caller. pRuntimePath should not be NULL.
 591     uint8_t RevID;                                  ///< [in] Revision ID of interest to caller. pRuntimePath should not be
 592                                                     ///< NULL.
 593
 594 } ctl_runtime_path_args_t;
 595
 596 ///////////////////////////////////////////////////////////////////////////////
 597 /// @brief Control Api Init
 598 ///
 599 /// @details
 600 ///     - Control Api Init
 601 ///
 602 /// @returns
 603 ///     - CTL_RESULT_SUCCESS
 604 ///     - CTL_RESULT_ERROR_UNINITIALIZED
 605 ///     - CTL_RESULT_ERROR_DEVICE_LOST
 606 ///     - CTL_RESULT_ERROR_INVALID_NULL_POINTER
 607 ///         + `nullptr == pInitDesc`
 608 ///         + `nullptr == phAPIHandle`
 609 ///     - ::CTL_RESULT_ERROR_UNSUPPORTED_VERSION - "Unsupported version"
 610 CTL_APIEXPORT ctl_result_t CTL_APICALL
 611 ctlInit(
 612     ctl_init_args_t* pInitDesc,                     ///< [in][out] App's control API version
 613     ctl_api_handle_t* phAPIHandle                   ///< [in][out][release] Control API handle
 614     );
 615
 616 ///////////////////////////////////////////////////////////////////////////////
 617 /// @brief Control Api Destroy
 618 ///
 619 /// @details
 620 ///     - Control Api Close
 621 ///
 622 /// @returns
 623 ///     - CTL_RESULT_SUCCESS
 624 ///     - CTL_RESULT_ERROR_UNINITIALIZED
 625 ///     - CTL_RESULT_ERROR_DEVICE_LOST
 626 ///     - CTL_RESULT_ERROR_INVALID_NULL_HANDLE
 627 ///         + `nullptr == hAPIHandle`
 628 ///     - ::CTL_RESULT_ERROR_UNSUPPORTED_VERSION - "Unsupported version"
 629 CTL_APIEXPORT ctl_result_t CTL_APICALL
 630 ctlClose(
 631     ctl_api_handle_t hAPIHandle                     ///< [in][release] Control API implementation handle obtained during init
 632                                                     ///< call
 633     );
 634
 635 ///////////////////////////////////////////////////////////////////////////////
 636 /// @brief Runtime path
 637 ///
 638 /// @details
 639 ///     - Control Api set runtime path. Optional call from a loader which allows
 640 ///       the loaded runtime to enumerate only the adapters which the specified
 641 ///       runtime is responsible for. This is done usually by a loader or by
 642 ///       callers who know how to get the specific runtime of interest. This
 643 ///       call right now is reserved for use by Intel components.
 644 ///
 645 /// @returns
 646 ///     - CTL_RESULT_SUCCESS
 647 ///     - CTL_RESULT_ERROR_UNINITIALIZED
 648 ///     - CTL_RESULT_ERROR_DEVICE_LOST
 649 ///     - CTL_RESULT_ERROR_INVALID_NULL_POINTER
 650 ///         + `nullptr == pArgs`
 651 ///     - ::CTL_RESULT_ERROR_UNSUPPORTED_VERSION - "Unsupported version"
 652 CTL_APIEXPORT ctl_result_t CTL_APICALL
 653 ctlSetRuntimePath(
 654     ctl_runtime_path_args_t* pArgs                  ///< [in] Runtime path
 655     );
 656
 657 ///////////////////////////////////////////////////////////////////////////////
 658 /// @brief Supported Functions
 659 typedef uint32_t ctl_supported_functions_flags_t;
 660 typedef enum _ctl_supported_functions_flag_t
 661 {
 662     CTL_SUPPORTED_FUNCTIONS_FLAG_DISPLAY = CTL_BIT(0),  ///< [out] Is Display supported
 663     CTL_SUPPORTED_FUNCTIONS_FLAG_3D = CTL_BIT(1),   ///< [out] Is 3D supported
 664     CTL_SUPPORTED_FUNCTIONS_FLAG_MEDIA = CTL_BIT(2),///< [out] Is Media supported
 665     CTL_SUPPORTED_FUNCTIONS_FLAG_MAX = 0x80000000
 666
 667 } ctl_supported_functions_flag_t;
 668
 669 ///////////////////////////////////////////////////////////////////////////////
 670 /// @brief Firmware version
 671 typedef struct _ctl_firmware_version_t
 672 {
 673     uint64_t major_version;                         ///< [out] Major version
 674     uint64_t minor_version;                         ///< [out] Minor version
 675     uint64_t build_number;                          ///< [out] Build number
 676
 677 } ctl_firmware_version_t;
 678
 679 ///////////////////////////////////////////////////////////////////////////////
 680 /// @brief DeviceType
 681 typedef enum _ctl_device_type_t
 682 {
 683     CTL_DEVICE_TYPE_GRAPHICS = 1,                   ///< Graphics Device type
 684     CTL_DEVICE_TYPE_SYSTEM = 2,                     ///< System Device type
 685     CTL_DEVICE_TYPE_MAX
 686
 687 } ctl_device_type_t;
 688
 689 ///////////////////////////////////////////////////////////////////////////////
 690 /// @brief Adapter Properties
 691 typedef uint32_t ctl_adapter_properties_flags_t;
 692 typedef enum _ctl_adapter_properties_flag_t
 693 {
 694     CTL_ADAPTER_PROPERTIES_FLAG_INTEGRATED = CTL_BIT(0),///< [out] Is Integrated Graphics adapter
 695     CTL_ADAPTER_PROPERTIES_FLAG_MAX = 0x80000000
 696
 697 } ctl_adapter_properties_flag_t;
 698
 699 ///////////////////////////////////////////////////////////////////////////////
 700 /// @brief Device Adapter properties
 701 typedef struct _ctl_device_adapter_properties_t
 702 {
 703     uint32_t Size;                                  ///< [in] size of this structure
 704     uint8_t Version;                                ///< [in] version of this structure
 705     void* pDeviceID;                                ///< [in,out] OS specific Device ID
 706     uint32_t device_id_size;                        ///< [in] size of the device ID
 707     ctl_device_type_t device_type;                  ///< [out] Device Type
 708     ctl_supported_functions_flags_t supported_subfunction_flags;///< [out] Supported functions
 709     uint64_t driver_version;                        ///< [out] Driver version
 710     ctl_firmware_version_t firmware_version;        ///< [out] Firmware version
 711     uint32_t pci_vendor_id;                         ///< [out] PCI Vendor ID
 712     uint32_t pci_device_id;                         ///< [out] PCI Device ID
 713     uint32_t rev_id;                                ///< [out] PCI Revision ID
 714     uint32_t num_eus_per_sub_slice;                 ///< [out] Number of EUs per sub-slice
 715     uint32_t num_sub_slices_per_slice;              ///< [out] Number of sub-slices per slice
 716     uint32_t num_slices;                            ///< [out] Number of slices
 717     char name[CTL_MAX_DEVICE_NAME_LEN];             ///< [out] Device name
 718     ctl_adapter_properties_flags_t graphics_adapter_properties; ///< [out] Graphics Adapter Properties
 719     uint32_t Frequency;                             ///< [out] Clock frequency for this device. Supported only for Version > 0
 720     uint16_t pci_subsys_id;                         ///< [out] PCI SubSys ID, Supported only for Version > 1
 721     uint16_t pci_subsys_vendor_id;                  ///< [out] PCI SubSys Vendor ID, Supported only for Version > 1
 722     char reserved[CTL_MAX_RESERVED_SIZE];           ///< [out] Reserved
 723
 724 } ctl_device_adapter_properties_t;
 725
 726 ///////////////////////////////////////////////////////////////////////////////
 727 /// @brief OperationType
 728 typedef enum _ctl_operation_type_t
 729 {
 730     CTL_OPERATION_TYPE_READ = 1,                    ///< Read operation
 731     CTL_OPERATION_TYPE_WRITE = 2,                   ///< Write operation
 732     CTL_OPERATION_TYPE_MAX
 733
 734 } ctl_operation_type_t;
 735
 736 ///////////////////////////////////////////////////////////////////////////////
 737 /// @brief Generic Structure for Void* datatypes
 738 typedef struct _ctl_generic_void_datatype_t
 739 {
 740     void* pData;                                    ///< [in,out]void pointer to memory
 741     uint32_t size;                                  ///< [in,out]size of the allocated memory
 742
 743 } ctl_generic_void_datatype_t;
 744
 745 ///////////////////////////////////////////////////////////////////////////////
 746 /// @brief Generic Structure for Revision datatypes
 747 typedef struct _ctl_revision_datatype_t
 748 {
 749     uint8_t major_version;                          ///< [in,out]Major Version
 750     uint8_t minor_version;                          ///< [in,out]Minor Version
 751     uint8_t revision_version;                       ///< [in,out]Revision Version
 752
 753 } ctl_revision_datatype_t;
 754
 755 ///////////////////////////////////////////////////////////////////////////////
 756 /// @brief Property Type flags
 757 typedef uint32_t ctl_property_type_flags_t;
 758 typedef enum _ctl_property_type_flag_t
 759 {
 760     CTL_PROPERTY_TYPE_FLAG_DISPLAY = CTL_BIT(0),    ///< Display type. Supported scenarios: Sharpness/gamma/CSC
 761     CTL_PROPERTY_TYPE_FLAG_3D = CTL_BIT(1),         ///< 3D type. Supported scenarios: All set calls via IGCL's 3D APIs
 762     CTL_PROPERTY_TYPE_FLAG_MEDIA = CTL_BIT(2),      ///< Media type. Supported scenarios: All set calls via IGCL's media APIs
 763     CTL_PROPERTY_TYPE_FLAG_CORE = CTL_BIT(3),       ///< For future: Core graphic event types like clocking, frequency etc.
 764     CTL_PROPERTY_TYPE_FLAG_MAX = 0x80000000
 765
 766 } ctl_property_type_flag_t;
 767
 768 ///////////////////////////////////////////////////////////////////////////////
 769 /// @brief Arguments related to wait for a property change function
 770 typedef struct _ctl_wait_property_change_args_t
 771 {
 772     uint32_t Size;                                  ///< [in] size of this structure
 773     uint8_t Version;                                ///< [in] version of this structure
 774     ctl_property_type_flags_t PropertyType;         ///< [in] Type of the property
 775     uint32_t TimeOutMilliSec;                       ///< [in][release] Time-out interval in milliseconds. Specify 0xFFFFFFFF if
 776                                                     ///< time-out is not desired
 777     uint32_t EventMiscFlags;                        ///< [in][release] Event flags for future use
 778     void* pReserved;                                ///< [in][release] Reserved for future use
 779     uint64_t ReservedOutFlags;                      ///< [out] Reserved out argument for future use
 780
 781 } ctl_wait_property_change_args_t;
 782
 783 ///////////////////////////////////////////////////////////////////////////////
 784 /// @brief Display orientation (rotation)
 785 typedef enum _ctl_display_orientation_t
 786 {
 787     CTL_DISPLAY_ORIENTATION_0 = 0,                  ///< 0 Degree
 788     CTL_DISPLAY_ORIENTATION_90 = 1,                 ///< 90 Degree
 789     CTL_DISPLAY_ORIENTATION_180 = 2,                ///< 180 Degree
 790     CTL_DISPLAY_ORIENTATION_270 = 3,                ///< 270 Degree
 791     CTL_DISPLAY_ORIENTATION_MAX
 792
 793 } ctl_display_orientation_t;
 794
 795 ///////////////////////////////////////////////////////////////////////////////
 796 /// @brief Rectangle
 797 typedef struct _ctl_rect_t
 798 {
 799     int32_t Left;                                   ///< [in,out] Left
 800     int32_t Top;                                    ///< [in,out] Top
 801     int32_t Right;                                  ///< [in,out] Right
 802     int32_t Bottom;                                 ///< [in,out] Bottom
 803
 804 } ctl_rect_t;
 805
 806 ///////////////////////////////////////////////////////////////////////////////
 807 /// @brief Wait for a property change. Note that this is a blocking call
 808 ///
 809 /// @details
 810 ///     - Wait for a property change in display, 3d, media etc.
 811 ///
 812 /// @returns
 813 ///     - CTL_RESULT_SUCCESS
 814 ///     - CTL_RESULT_ERROR_UNINITIALIZED
 815 ///     - CTL_RESULT_ERROR_DEVICE_LOST
 816 ///     - CTL_RESULT_ERROR_INVALID_NULL_HANDLE
 817 ///         + `nullptr == hDeviceAdapter`
 818 ///     - CTL_RESULT_ERROR_INVALID_NULL_POINTER
 819 ///         + `nullptr == pArgs`
 820 ///     - ::CTL_RESULT_ERROR_UNSUPPORTED_VERSION - "Unsupported version"
 821 CTL_APIEXPORT ctl_result_t CTL_APICALL
 822 ctlWaitForPropertyChange(
 823     ctl_device_adapter_handle_t hDeviceAdapter,     ///< [in][release] handle to control device adapter
 824     ctl_wait_property_change_args_t* pArgs          ///< [in] Argument containing information about which property changes to
 825                                                     ///< listen for
 826     );
 827
 828 ///////////////////////////////////////////////////////////////////////////////
 829 /// @brief Reserved function
 830 ///
 831 /// @details
 832 ///     - Reserved function
 833 ///
 834 /// @returns
 835 ///     - CTL_RESULT_SUCCESS
 836 ///     - CTL_RESULT_ERROR_UNINITIALIZED
 837 ///     - CTL_RESULT_ERROR_DEVICE_LOST
 838 ///     - CTL_RESULT_ERROR_INVALID_NULL_HANDLE
 839 ///         + `nullptr == hDeviceAdapter`
 840 ///     - CTL_RESULT_ERROR_INVALID_NULL_POINTER
 841 ///         + `nullptr == pArgs`
 842 ///     - ::CTL_RESULT_ERROR_UNSUPPORTED_VERSION - "Unsupported version"
 843 CTL_APIEXPORT ctl_result_t CTL_APICALL
 844 ctlReservedCall(
 845     ctl_device_adapter_handle_t hDeviceAdapter,     ///< [in][release] handle to control device adapter
 846     ctl_reserved_args_t* pArgs                      ///< [in] Argument containing information
 847     );
 848
 849 ///////////////////////////////////////////////////////////////////////////////
 850 /// @brief Forward-declare ctl_base_interface_t
 851 typedef struct _ctl_base_interface_t ctl_base_interface_t;
 852
 853 ///////////////////////////////////////////////////////////////////////////////
 854 /// @brief Forward-declare ctl_property_range_info_t
 855 typedef struct _ctl_property_range_info_t ctl_property_range_info_t;
 856
 857 ///////////////////////////////////////////////////////////////////////////////
 858 /// @brief Forward-declare ctl_property_range_info_int_t
 859 typedef struct _ctl_property_range_info_int_t ctl_property_range_info_int_t;
 860
 861 ///////////////////////////////////////////////////////////////////////////////
 862 /// @brief Forward-declare ctl_property_range_info_uint_t
 863 typedef struct _ctl_property_range_info_uint_t ctl_property_range_info_uint_t;
 864
 865 ///////////////////////////////////////////////////////////////////////////////
 866 /// @brief Forward-declare ctl_property_info_boolean_t
 867 typedef struct _ctl_property_info_boolean_t ctl_property_info_boolean_t;
 868
 869 ///////////////////////////////////////////////////////////////////////////////
 870 /// @brief Forward-declare ctl_property_boolean_t
 871 typedef struct _ctl_property_boolean_t ctl_property_boolean_t;
 872
 873 ///////////////////////////////////////////////////////////////////////////////
 874 /// @brief Forward-declare ctl_property_info_enum_t
 875 typedef struct _ctl_property_info_enum_t ctl_property_info_enum_t;
 876
 877 ///////////////////////////////////////////////////////////////////////////////
 878 /// @brief Forward-declare ctl_property_enum_t
 879 typedef struct _ctl_property_enum_t ctl_property_enum_t;
 880
 881 ///////////////////////////////////////////////////////////////////////////////
 882 /// @brief Forward-declare ctl_property_info_float_t
 883 typedef struct _ctl_property_info_float_t ctl_property_info_float_t;
 884
 885 ///////////////////////////////////////////////////////////////////////////////
 886 /// @brief Forward-declare ctl_property_float_t
 887 typedef struct _ctl_property_float_t ctl_property_float_t;
 888
 889 ///////////////////////////////////////////////////////////////////////////////
 890 /// @brief Forward-declare ctl_property_info_int_t
 891 typedef struct _ctl_property_info_int_t ctl_property_info_int_t;
 892
 893 ///////////////////////////////////////////////////////////////////////////////
 894 /// @brief Forward-declare ctl_property_int_t
 895 typedef struct _ctl_property_int_t ctl_property_int_t;
 896
 897 ///////////////////////////////////////////////////////////////////////////////
 898 /// @brief Forward-declare ctl_property_info_uint_t
 899 typedef struct _ctl_property_info_uint_t ctl_property_info_uint_t;
 900
 901 ///////////////////////////////////////////////////////////////////////////////
 902 /// @brief Forward-declare ctl_property_uint_t
 903 typedef struct _ctl_property_uint_t ctl_property_uint_t;
 904
 905 ///////////////////////////////////////////////////////////////////////////////
 906 /// @brief Forward-declare ctl_base_properties_t
 907 typedef struct _ctl_base_properties_t ctl_base_properties_t;
 908
 909 ///////////////////////////////////////////////////////////////////////////////
 910 /// @brief Forward-declare ctl_application_id_t
 911 typedef struct _ctl_application_id_t ctl_application_id_t;
 912
 913 ///////////////////////////////////////////////////////////////////////////////
 914 /// @brief Forward-declare ctl_init_args_t
 915 typedef struct _ctl_init_args_t ctl_init_args_t;
 916
 917 ///////////////////////////////////////////////////////////////////////////////
 918 /// @brief Forward-declare ctl_reserved_args_t
 919 typedef struct _ctl_reserved_args_t ctl_reserved_args_t;
 920
 921 ///////////////////////////////////////////////////////////////////////////////
 922 /// @brief Forward-declare ctl_reserved_args_base_t
 923 typedef struct _ctl_reserved_args_base_t ctl_reserved_args_base_t;
 924
 925 ///////////////////////////////////////////////////////////////////////////////
 926 /// @brief Forward-declare ctl_unlock_capability_t
 927 typedef struct _ctl_unlock_capability_t ctl_unlock_capability_t;
 928
 929 ///////////////////////////////////////////////////////////////////////////////
 930 /// @brief Forward-declare ctl_runtime_path_args_t
 931 typedef struct _ctl_runtime_path_args_t ctl_runtime_path_args_t;
 932
 933 ///////////////////////////////////////////////////////////////////////////////
 934 /// @brief Forward-declare ctl_firmware_version_t
 935 typedef struct _ctl_firmware_version_t ctl_firmware_version_t;
 936
 937 ///////////////////////////////////////////////////////////////////////////////
 938 /// @brief Forward-declare ctl_device_adapter_properties_t
 939 typedef struct _ctl_device_adapter_properties_t ctl_device_adapter_properties_t;
 940
 941 ///////////////////////////////////////////////////////////////////////////////
 942 /// @brief Forward-declare ctl_generic_void_datatype_t
 943 typedef struct _ctl_generic_void_datatype_t ctl_generic_void_datatype_t;
 944
 945 ///////////////////////////////////////////////////////////////////////////////
 946 /// @brief Forward-declare ctl_revision_datatype_t
 947 typedef struct _ctl_revision_datatype_t ctl_revision_datatype_t;
 948
 949 ///////////////////////////////////////////////////////////////////////////////
 950 /// @brief Forward-declare ctl_wait_property_change_args_t
 951 typedef struct _ctl_wait_property_change_args_t ctl_wait_property_change_args_t;
 952
 953 ///////////////////////////////////////////////////////////////////////////////
 954 /// @brief Forward-declare ctl_rect_t
 955 typedef struct _ctl_rect_t ctl_rect_t;
 956
 957 ///////////////////////////////////////////////////////////////////////////////
 958 /// @brief Forward-declare ctl_endurance_gaming_caps_t
 959 typedef struct _ctl_endurance_gaming_caps_t ctl_endurance_gaming_caps_t;
 960
 961 ///////////////////////////////////////////////////////////////////////////////
 962 /// @brief Forward-declare ctl_endurance_gaming_t
 963 typedef struct _ctl_endurance_gaming_t ctl_endurance_gaming_t;
 964
 965 ///////////////////////////////////////////////////////////////////////////////
 966 /// @brief Forward-declare ctl_endurance_gaming2_t
 967 typedef struct _ctl_endurance_gaming2_t ctl_endurance_gaming2_t;
 968
 969 ///////////////////////////////////////////////////////////////////////////////
 970 /// @brief Forward-declare ctl_adaptivesync_caps_t
 971 typedef struct _ctl_adaptivesync_caps_t ctl_adaptivesync_caps_t;
 972
 973 ///////////////////////////////////////////////////////////////////////////////
 974 /// @brief Forward-declare ctl_adaptivesync_getset_t
 975 typedef struct _ctl_adaptivesync_getset_t ctl_adaptivesync_getset_t;
 976
 977 ///////////////////////////////////////////////////////////////////////////////
 978 /// @brief Forward-declare ctl_3d_app_profiles_caps_t
 979 typedef struct _ctl_3d_app_profiles_caps_t ctl_3d_app_profiles_caps_t;
 980
 981 ///////////////////////////////////////////////////////////////////////////////
 982 /// @brief Forward-declare ctl_3d_app_profiles_t
 983 typedef struct _ctl_3d_app_profiles_t ctl_3d_app_profiles_t;
 984
 985 ///////////////////////////////////////////////////////////////////////////////
 986 /// @brief Forward-declare ctl_3d_tier_details_t
 987 typedef struct _ctl_3d_tier_details_t ctl_3d_tier_details_t;
 988
 989 ///////////////////////////////////////////////////////////////////////////////
 990 /// @brief Forward-declare ctl_3d_feature_details_t
 991 typedef struct _ctl_3d_feature_details_t ctl_3d_feature_details_t;
 992
 993 ///////////////////////////////////////////////////////////////////////////////
 994 /// @brief Forward-declare ctl_3d_feature_caps_t
 995 typedef struct _ctl_3d_feature_caps_t ctl_3d_feature_caps_t;
 996
 997 ///////////////////////////////////////////////////////////////////////////////
 998 /// @brief Forward-declare ctl_3d_feature_getset_t
 999 typedef struct _ctl_3d_feature_getset_t ctl_3d_feature_getset_t;
1000
1001 ///////////////////////////////////////////////////////////////////////////////
1002 /// @brief Forward-declare ctl_kmd_load_features_t
1003 typedef struct _ctl_kmd_load_features_t ctl_kmd_load_features_t;
1004
1005 ///////////////////////////////////////////////////////////////////////////////
1006 /// @brief Forward-declare ctl_display_timing_t
1007 typedef struct _ctl_display_timing_t ctl_display_timing_t;
1008
1009 ///////////////////////////////////////////////////////////////////////////////
1010 /// @brief Forward-declare ctl_display_properties_t
1011 typedef struct _ctl_display_properties_t ctl_display_properties_t;
1012
1013 ///////////////////////////////////////////////////////////////////////////////
1014 /// @brief Forward-declare ctl_adapter_display_encoder_properties_t
1015 typedef struct _ctl_adapter_display_encoder_properties_t ctl_adapter_display_encoder_properties_t;
1016
1017 ///////////////////////////////////////////////////////////////////////////////
1018 /// @brief Forward-declare ctl_sharpness_filter_properties_t
1019 typedef struct _ctl_sharpness_filter_properties_t ctl_sharpness_filter_properties_t;
1020
1021 ///////////////////////////////////////////////////////////////////////////////
1022 /// @brief Forward-declare ctl_sharpness_caps_t
1023 typedef struct _ctl_sharpness_caps_t ctl_sharpness_caps_t;
1024
1025 ///////////////////////////////////////////////////////////////////////////////
1026 /// @brief Forward-declare ctl_sharpness_settings_t
1027 typedef struct _ctl_sharpness_settings_t ctl_sharpness_settings_t;
1028
1029 ///////////////////////////////////////////////////////////////////////////////
1030 /// @brief Forward-declare ctl_i2c_access_args_t
1031 typedef struct _ctl_i2c_access_args_t ctl_i2c_access_args_t;
1032
1033 ///////////////////////////////////////////////////////////////////////////////
1034 /// @brief Forward-declare ctl_aux_access_args_t
1035 typedef struct _ctl_aux_access_args_t ctl_aux_access_args_t;
1036
1037 ///////////////////////////////////////////////////////////////////////////////
1038 /// @brief Forward-declare ctl_power_optimization_caps_t
1039 typedef struct _ctl_power_optimization_caps_t ctl_power_optimization_caps_t;
1040
1041 ///////////////////////////////////////////////////////////////////////////////
1042 /// @brief Forward-declare ctl_power_optimization_lrr_t
1043 typedef struct _ctl_power_optimization_lrr_t ctl_power_optimization_lrr_t;
1044
1045 ///////////////////////////////////////////////////////////////////////////////
1046 /// @brief Forward-declare ctl_power_optimization_psr_t
1047 typedef struct _ctl_power_optimization_psr_t ctl_power_optimization_psr_t;
1048
1049 ///////////////////////////////////////////////////////////////////////////////
1050 /// @brief Forward-declare ctl_power_optimization_dpst_t
1051 typedef struct _ctl_power_optimization_dpst_t ctl_power_optimization_dpst_t;
1052
1053 ///////////////////////////////////////////////////////////////////////////////
1054 /// @brief Forward-declare ctl_power_optimization_settings_t
1055 typedef struct _ctl_power_optimization_settings_t ctl_power_optimization_settings_t;
1056
1057 ///////////////////////////////////////////////////////////////////////////////
1058 /// @brief Forward-declare ctl_set_brightness_t
1059 typedef struct _ctl_set_brightness_t ctl_set_brightness_t;
1060
1061 ///////////////////////////////////////////////////////////////////////////////
1062 /// @brief Forward-declare ctl_get_brightness_t
1063 typedef struct _ctl_get_brightness_t ctl_get_brightness_t;
1064
1065 ///////////////////////////////////////////////////////////////////////////////
1066 /// @brief Forward-declare ctl_pixtx_color_primaries_t
1067 typedef struct _ctl_pixtx_color_primaries_t ctl_pixtx_color_primaries_t;
1068
1069 ///////////////////////////////////////////////////////////////////////////////
1070 /// @brief Forward-declare ctl_pixtx_pixel_format_t
1071 typedef struct _ctl_pixtx_pixel_format_t ctl_pixtx_pixel_format_t;
1072
1073 ///////////////////////////////////////////////////////////////////////////////
1074 /// @brief Forward-declare ctl_pixtx_1dlut_config_t
1075 typedef struct _ctl_pixtx_1dlut_config_t ctl_pixtx_1dlut_config_t;
1076
1077 ///////////////////////////////////////////////////////////////////////////////
1078 /// @brief Forward-declare ctl_pixtx_matrix_config_t
1079 typedef struct _ctl_pixtx_matrix_config_t ctl_pixtx_matrix_config_t;
1080
1081 ///////////////////////////////////////////////////////////////////////////////
1082 /// @brief Forward-declare ctl_pixtx_3dlut_sample_t
1083 typedef struct _ctl_pixtx_3dlut_sample_t ctl_pixtx_3dlut_sample_t;
1084
1085 ///////////////////////////////////////////////////////////////////////////////
1086 /// @brief Forward-declare ctl_pixtx_3dlut_config_t
1087 typedef struct _ctl_pixtx_3dlut_config_t ctl_pixtx_3dlut_config_t;
1088
1089 ///////////////////////////////////////////////////////////////////////////////
1090 /// @brief Forward-declare ctl_pixtx_block_config_t
1091 typedef struct _ctl_pixtx_block_config_t ctl_pixtx_block_config_t;
1092
1093 ///////////////////////////////////////////////////////////////////////////////
1094 /// @brief Forward-declare ctl_pixtx_pipe_get_config_t
1095 typedef struct _ctl_pixtx_pipe_get_config_t ctl_pixtx_pipe_get_config_t;
1096
1097 ///////////////////////////////////////////////////////////////////////////////
1098 /// @brief Forward-declare ctl_pixtx_pipe_set_config_t
1099 typedef struct _ctl_pixtx_pipe_set_config_t ctl_pixtx_pipe_set_config_t;
1100
1101 ///////////////////////////////////////////////////////////////////////////////
1102 /// @brief Forward-declare ctl_panel_descriptor_access_args_t
1103 typedef struct _ctl_panel_descriptor_access_args_t ctl_panel_descriptor_access_args_t;
1104
1105 ///////////////////////////////////////////////////////////////////////////////
1106 /// @brief Forward-declare ctl_retro_scaling_settings_t
1107 typedef struct _ctl_retro_scaling_settings_t ctl_retro_scaling_settings_t;
1108
1109 ///////////////////////////////////////////////////////////////////////////////
1110 /// @brief Forward-declare ctl_retro_scaling_caps_t
1111 typedef struct _ctl_retro_scaling_caps_t ctl_retro_scaling_caps_t;
1112
1113 ///////////////////////////////////////////////////////////////////////////////
1114 /// @brief Forward-declare ctl_scaling_caps_t
1115 typedef struct _ctl_scaling_caps_t ctl_scaling_caps_t;
1116
1117 ///////////////////////////////////////////////////////////////////////////////
1118 /// @brief Forward-declare ctl_scaling_settings_t
1119 typedef struct _ctl_scaling_settings_t ctl_scaling_settings_t;
1120
1121 ///////////////////////////////////////////////////////////////////////////////
1122 /// @brief Forward-declare ctl_lace_lux_aggr_map_entry_t
1123 typedef struct _ctl_lace_lux_aggr_map_entry_t ctl_lace_lux_aggr_map_entry_t;
1124
1125 ///////////////////////////////////////////////////////////////////////////////
1126 /// @brief Forward-declare ctl_lace_lux_aggr_map_t
1127 typedef struct _ctl_lace_lux_aggr_map_t ctl_lace_lux_aggr_map_t;
1128
1129 ///////////////////////////////////////////////////////////////////////////////
1130 /// @brief Forward-declare ctl_lace_config_t
1131 typedef struct _ctl_lace_config_t ctl_lace_config_t;
1132
1133 ///////////////////////////////////////////////////////////////////////////////
1134 /// @brief Forward-declare ctl_sw_psr_settings_t
1135 typedef struct _ctl_sw_psr_settings_t ctl_sw_psr_settings_t;
1136
1137 ///////////////////////////////////////////////////////////////////////////////
1138 /// @brief Forward-declare ctl_intel_arc_sync_monitor_params_t
1139 typedef struct _ctl_intel_arc_sync_monitor_params_t ctl_intel_arc_sync_monitor_params_t;
1140
1141 ///////////////////////////////////////////////////////////////////////////////
1142 /// @brief Forward-declare ctl_mux_properties_t
1143 typedef struct _ctl_mux_properties_t ctl_mux_properties_t;
1144
1145 ///////////////////////////////////////////////////////////////////////////////
1146 /// @brief Forward-declare ctl_intel_arc_sync_profile_params_t
1147 typedef struct _ctl_intel_arc_sync_profile_params_t ctl_intel_arc_sync_profile_params_t;
1148
1149 ///////////////////////////////////////////////////////////////////////////////
1150 /// @brief Forward-declare ctl_edid_management_args_t
1151 typedef struct _ctl_edid_management_args_t ctl_edid_management_args_t;
1152
1153 ///////////////////////////////////////////////////////////////////////////////
1154 /// @brief Forward-declare ctl_get_set_custom_mode_args_t
1155 typedef struct _ctl_get_set_custom_mode_args_t ctl_get_set_custom_mode_args_t;
1156
1157 ///////////////////////////////////////////////////////////////////////////////
1158 /// @brief Forward-declare ctl_custom_src_mode_t
1159 typedef struct _ctl_custom_src_mode_t ctl_custom_src_mode_t;
1160
1161 ///////////////////////////////////////////////////////////////////////////////
1162 /// @brief Forward-declare ctl_child_display_target_mode_t
1163 typedef struct _ctl_child_display_target_mode_t ctl_child_display_target_mode_t;
1164
1165 ///////////////////////////////////////////////////////////////////////////////
1166 /// @brief Forward-declare ctl_combined_display_child_info_t
1167 typedef struct _ctl_combined_display_child_info_t ctl_combined_display_child_info_t;
1168
1169 ///////////////////////////////////////////////////////////////////////////////
1170 /// @brief Forward-declare ctl_combined_display_args_t
1171 typedef struct _ctl_combined_display_args_t ctl_combined_display_args_t;
1172
1173 ///////////////////////////////////////////////////////////////////////////////
1174 /// @brief Forward-declare ctl_genlock_display_info_t
1175 typedef struct _ctl_genlock_display_info_t ctl_genlock_display_info_t;
1176
1177 ///////////////////////////////////////////////////////////////////////////////
1178 /// @brief Forward-declare ctl_genlock_target_mode_list_t
1179 typedef struct _ctl_genlock_target_mode_list_t ctl_genlock_target_mode_list_t;
1180
1181 ///////////////////////////////////////////////////////////////////////////////
1182 /// @brief Forward-declare ctl_genlock_topology_t
1183 typedef struct _ctl_genlock_topology_t ctl_genlock_topology_t;
1184
1185 ///////////////////////////////////////////////////////////////////////////////
1186 /// @brief Forward-declare ctl_genlock_args_t
1187 typedef struct _ctl_genlock_args_t ctl_genlock_args_t;
1188
1189 ///////////////////////////////////////////////////////////////////////////////
1190 /// @brief Forward-declare ctl_engine_properties_t
1191 typedef struct _ctl_engine_properties_t ctl_engine_properties_t;
1192
1193 ///////////////////////////////////////////////////////////////////////////////
1194 /// @brief Forward-declare ctl_engine_stats_t
1195 typedef struct _ctl_engine_stats_t ctl_engine_stats_t;
1196
1197 ///////////////////////////////////////////////////////////////////////////////
1198 /// @brief Forward-declare ctl_fan_speed_t
1199 typedef struct _ctl_fan_speed_t ctl_fan_speed_t;
1200
1201 ///////////////////////////////////////////////////////////////////////////////
1202 /// @brief Forward-declare ctl_fan_temp_speed_t
1203 typedef struct _ctl_fan_temp_speed_t ctl_fan_temp_speed_t;
1204
1205 ///////////////////////////////////////////////////////////////////////////////
1206 /// @brief Forward-declare ctl_fan_speed_table_t
1207 typedef struct _ctl_fan_speed_table_t ctl_fan_speed_table_t;
1208
1209 ///////////////////////////////////////////////////////////////////////////////
1210 /// @brief Forward-declare ctl_fan_properties_t
1211 typedef struct _ctl_fan_properties_t ctl_fan_properties_t;
1212
1213 ///////////////////////////////////////////////////////////////////////////////
1214 /// @brief Forward-declare ctl_fan_config_t
1215 typedef struct _ctl_fan_config_t ctl_fan_config_t;
1216
1217 ///////////////////////////////////////////////////////////////////////////////
1218 /// @brief Forward-declare ctl_freq_properties_t
1219 typedef struct _ctl_freq_properties_t ctl_freq_properties_t;
1220
1221 ///////////////////////////////////////////////////////////////////////////////
1222 /// @brief Forward-declare ctl_freq_range_t
1223 typedef struct _ctl_freq_range_t ctl_freq_range_t;
1224
1225 ///////////////////////////////////////////////////////////////////////////////
1226 /// @brief Forward-declare ctl_freq_state_t
1227 typedef struct _ctl_freq_state_t ctl_freq_state_t;
1228
1229 ///////////////////////////////////////////////////////////////////////////////
1230 /// @brief Forward-declare ctl_freq_throttle_time_t
1231 typedef struct _ctl_freq_throttle_time_t ctl_freq_throttle_time_t;
1232
1233 ///////////////////////////////////////////////////////////////////////////////
1234 /// @brief Forward-declare ctl_video_processing_super_resolution_info_t
1235 typedef struct _ctl_video_processing_super_resolution_info_t ctl_video_processing_super_resolution_info_t;
1236
1237 ///////////////////////////////////////////////////////////////////////////////
1238 /// @brief Forward-declare ctl_video_processing_super_resolution_t
1239 typedef struct _ctl_video_processing_super_resolution_t ctl_video_processing_super_resolution_t;
1240
1241 ///////////////////////////////////////////////////////////////////////////////
1242 /// @brief Forward-declare ctl_video_processing_noise_reduction_info_t
1243 typedef struct _ctl_video_processing_noise_reduction_info_t ctl_video_processing_noise_reduction_info_t;
1244
1245 ///////////////////////////////////////////////////////////////////////////////
1246 /// @brief Forward-declare ctl_video_processing_noise_reduction_t
1247 typedef struct _ctl_video_processing_noise_reduction_t ctl_video_processing_noise_reduction_t;
1248
1249 ///////////////////////////////////////////////////////////////////////////////
1250 /// @brief Forward-declare ctl_video_processing_adaptive_contrast_enhancement_info_t
1251 typedef struct _ctl_video_processing_adaptive_contrast_enhancement_info_t ctl_video_processing_adaptive_contrast_enhancement_info_t;
1252
1253 ///////////////////////////////////////////////////////////////////////////////
1254 /// @brief Forward-declare ctl_video_processing_adaptive_contrast_enhancement_t
1255 typedef struct _ctl_video_processing_adaptive_contrast_enhancement_t ctl_video_processing_adaptive_contrast_enhancement_t;
1256
1257 ///////////////////////////////////////////////////////////////////////////////
1258 /// @brief Forward-declare ctl_video_processing_standard_color_correction_info_t
1259 typedef struct _ctl_video_processing_standard_color_correction_info_t ctl_video_processing_standard_color_correction_info_t;
1260
1261 ///////////////////////////////////////////////////////////////////////////////
1262 /// @brief Forward-declare ctl_video_processing_standard_color_correction_t
1263 typedef struct _ctl_video_processing_standard_color_correction_t ctl_video_processing_standard_color_correction_t;
1264
1265 ///////////////////////////////////////////////////////////////////////////////
1266 /// @brief Forward-declare ctl_video_processing_total_color_correction_info_t
1267 typedef struct _ctl_video_processing_total_color_correction_info_t ctl_video_processing_total_color_correction_info_t;
1268
1269 ///////////////////////////////////////////////////////////////////////////////
1270 /// @brief Forward-declare ctl_video_processing_total_color_correction_t
1271 typedef struct _ctl_video_processing_total_color_correction_t ctl_video_processing_total_color_correction_t;
1272
1273 ///////////////////////////////////////////////////////////////////////////////
1274 /// @brief Forward-declare ctl_video_processing_feature_details_t
1275 typedef struct _ctl_video_processing_feature_details_t ctl_video_processing_feature_details_t;
1276
1277 ///////////////////////////////////////////////////////////////////////////////
1278 /// @brief Forward-declare ctl_video_processing_feature_caps_t
1279 typedef struct _ctl_video_processing_feature_caps_t ctl_video_processing_feature_caps_t;
1280
1281 ///////////////////////////////////////////////////////////////////////////////
1282 /// @brief Forward-declare ctl_video_processing_feature_getset_t
1283 typedef struct _ctl_video_processing_feature_getset_t ctl_video_processing_feature_getset_t;
1284
1285 ///////////////////////////////////////////////////////////////////////////////
1286 /// @brief Forward-declare ctl_mem_properties_t
1287 typedef struct _ctl_mem_properties_t ctl_mem_properties_t;
1288
1289 ///////////////////////////////////////////////////////////////////////////////
1290 /// @brief Forward-declare ctl_mem_state_t
1291 typedef struct _ctl_mem_state_t ctl_mem_state_t;
1292
1293 ///////////////////////////////////////////////////////////////////////////////
1294 /// @brief Forward-declare ctl_mem_bandwidth_t
1295 typedef struct _ctl_mem_bandwidth_t ctl_mem_bandwidth_t;
1296
1297 ///////////////////////////////////////////////////////////////////////////////
1298 /// @brief Forward-declare ctl_oc_telemetry_item_t
1299 typedef struct _ctl_oc_telemetry_item_t ctl_oc_telemetry_item_t;
1300
1301 ///////////////////////////////////////////////////////////////////////////////
1302 /// @brief Forward-declare ctl_oc_control_info_t
1303 typedef struct _ctl_oc_control_info_t ctl_oc_control_info_t;
1304
1305 ///////////////////////////////////////////////////////////////////////////////
1306 /// @brief Forward-declare ctl_oc_properties_t
1307 typedef struct _ctl_oc_properties_t ctl_oc_properties_t;
1308
1309 ///////////////////////////////////////////////////////////////////////////////
1310 /// @brief Forward-declare ctl_oc_vf_pair_t
1311 typedef struct _ctl_oc_vf_pair_t ctl_oc_vf_pair_t;
1312
1313 ///////////////////////////////////////////////////////////////////////////////
1314 /// @brief Forward-declare ctl_psu_info_t
1315 typedef struct _ctl_psu_info_t ctl_psu_info_t;
1316
1317 ///////////////////////////////////////////////////////////////////////////////
1318 /// @brief Forward-declare ctl_power_telemetry_t
1319 typedef struct _ctl_power_telemetry_t ctl_power_telemetry_t;
1320
1321 ///////////////////////////////////////////////////////////////////////////////
1322 /// @brief Forward-declare ctl_pci_address_t
1323 typedef struct _ctl_pci_address_t ctl_pci_address_t;
1324
1325 ///////////////////////////////////////////////////////////////////////////////
1326 /// @brief Forward-declare ctl_pci_speed_t
1327 typedef struct _ctl_pci_speed_t ctl_pci_speed_t;
1328
1329 ///////////////////////////////////////////////////////////////////////////////
1330 /// @brief Forward-declare ctl_pci_properties_t
1331 typedef struct _ctl_pci_properties_t ctl_pci_properties_t;
1332
1333 ///////////////////////////////////////////////////////////////////////////////
1334 /// @brief Forward-declare ctl_pci_state_t
1335 typedef struct _ctl_pci_state_t ctl_pci_state_t;
1336
1337 ///////////////////////////////////////////////////////////////////////////////
1338 /// @brief Forward-declare ctl_power_properties_t
1339 typedef struct _ctl_power_properties_t ctl_power_properties_t;
1340
1341 ///////////////////////////////////////////////////////////////////////////////
1342 /// @brief Forward-declare ctl_power_energy_counter_t
1343 typedef struct _ctl_power_energy_counter_t ctl_power_energy_counter_t;
1344
1345 ///////////////////////////////////////////////////////////////////////////////
1346 /// @brief Forward-declare ctl_power_sustained_limit_t
1347 typedef struct _ctl_power_sustained_limit_t ctl_power_sustained_limit_t;
1348
1349 ///////////////////////////////////////////////////////////////////////////////
1350 /// @brief Forward-declare ctl_power_burst_limit_t
1351 typedef struct _ctl_power_burst_limit_t ctl_power_burst_limit_t;
1352
1353 ///////////////////////////////////////////////////////////////////////////////
1354 /// @brief Forward-declare ctl_power_peak_limit_t
1355 typedef struct _ctl_power_peak_limit_t ctl_power_peak_limit_t;
1356
1357 ///////////////////////////////////////////////////////////////////////////////
1358 /// @brief Forward-declare ctl_power_limits_t
1359 typedef struct _ctl_power_limits_t ctl_power_limits_t;
1360
1361 ///////////////////////////////////////////////////////////////////////////////
1362 /// @brief Forward-declare ctl_energy_threshold_t
1363 typedef struct _ctl_energy_threshold_t ctl_energy_threshold_t;
1364
1365 ///////////////////////////////////////////////////////////////////////////////
1366 /// @brief Forward-declare ctl_temp_properties_t
1367 typedef struct _ctl_temp_properties_t ctl_temp_properties_t;
1368
1369
1370
1371 #if !defined(__GNUC__)
1372 #pragma endregion // common
1373 #endif
1374 // Intel 'ctlApi' for Device Adapter
1375 #if !defined(__GNUC__)
1376 #pragma region 3D
1377 #endif
1378 ///////////////////////////////////////////////////////////////////////////////
1379 /// @brief Feature type
1380 typedef enum _ctl_3d_feature_t
1381 {
1382     CTL_3D_FEATURE_FRAME_PACING = 0,                ///< Frame pacing. Contains generic enum type fields
1383     CTL_3D_FEATURE_ENDURANCE_GAMING = 1,            ///< Endurance gaming. Contains generic integer type fields. Value will be
1384                                                     ///< interpreted as the max FPS to be used when in DC mode globally or per
1385                                                     ///< application
1386     CTL_3D_FEATURE_FRAME_LIMIT = 2,                 ///< Frame limit for games. Contains generic integer type fields. Value
1387                                                     ///< will be interpreted as the max FPS to be used independent of system
1388                                                     ///< power state
1389     CTL_3D_FEATURE_ANISOTROPIC = 3,                 ///< ANISOTROPIC. Contains generic enum type fields
1390     CTL_3D_FEATURE_CMAA = 4,                        ///< CMAA. Contains generic enum type fields
1391     CTL_3D_FEATURE_TEXTURE_FILTERING_QUALITY = 5,   ///< Texture filtering quality. Contains generic enum type fields
1392     CTL_3D_FEATURE_ADAPTIVE_TESSELLATION = 6,       ///< Adaptive tessellation quality. Contains generic integer type fields
1393     CTL_3D_FEATURE_SHARPENING_FILTER = 7,           ///< Sharpening Filter. Contains generic integer type fields
1394     CTL_3D_FEATURE_MSAA = 8,                        ///< Msaa. Contains generic enum type fields
1395     CTL_3D_FEATURE_GAMING_FLIP_MODES = 9,           ///< Various Gaming flip modes like speed frame, smooth sync & force async
1396                                                     ///< flip. Contains generic enum type fields
1397     CTL_3D_FEATURE_ADAPTIVE_SYNC_PLUS = 10,         ///< Adaptive sync plus. Refer custom field ::ctl_adaptivesync_caps_t &
1398                                                     ///< ::ctl_adaptivesync_getset_t
1399     CTL_3D_FEATURE_APP_PROFILES = 11,               ///< Game Compatibility & Performance Profiles. Refer custom field
1400                                                     ///< ::ctl_3d_app_profiles_caps_t & ::ctl_3d_app_profiles_t
1401     CTL_3D_FEATURE_APP_PROFILE_DETAILS = 12,        ///< Game Profile Customization. Refer custom field ::ctl_3d_tier_details_t
1402     CTL_3D_FEATURE_EMULATED_TYPED_64BIT_ATOMICS = 13,   ///< Emulated Typed 64bit Atomics support in DG2
1403     CTL_3D_FEATURE_MAX
1404
1405 } ctl_3d_feature_t;
1406
1407 ///////////////////////////////////////////////////////////////////////////////
1408 /// @brief 3D feature misc flags
1409 typedef uint32_t ctl_3d_feature_misc_flags_t;
1410 typedef enum _ctl_3d_feature_misc_flag_t
1411 {
1412     CTL_3D_FEATURE_MISC_FLAG_DX11 = CTL_BIT(0),     ///< Feature supported on DX11
1413     CTL_3D_FEATURE_MISC_FLAG_DX12 = CTL_BIT(1),     ///< Feature supported on DX12
1414     CTL_3D_FEATURE_MISC_FLAG_VULKAN = CTL_BIT(2),   ///< Feature supported on VULKAN
1415     CTL_3D_FEATURE_MISC_FLAG_LIVE_CHANGE = CTL_BIT(3),  ///< User can change feature live without restarting the game
1416     CTL_3D_FEATURE_MISC_FLAG_MAX = 0x80000000
1417
1418 } ctl_3d_feature_misc_flag_t;
1419
1420 ///////////////////////////////////////////////////////////////////////////////
1421 /// @brief Anisotropic values possible
1422 typedef enum _ctl_3d_anisotropic_types_t
1423 {
1424     CTL_3D_ANISOTROPIC_TYPES_APP_CHOICE = 0,        ///< Application choice
1425     CTL_3D_ANISOTROPIC_TYPES_2X = 2,                ///< 2X
1426     CTL_3D_ANISOTROPIC_TYPES_4X = 4,                ///< 4X
1427     CTL_3D_ANISOTROPIC_TYPES_8X = 8,                ///< 8X
1428     CTL_3D_ANISOTROPIC_TYPES_16X = 16,              ///< 16X
1429     CTL_3D_ANISOTROPIC_TYPES_MAX
1430
1431 } ctl_3d_anisotropic_types_t;
1432
1433 ///////////////////////////////////////////////////////////////////////////////
1434 /// @brief Texture filtering values possible
1435 typedef enum _ctl_3d_texture_filtering_quality_types_t
1436 {
1437     CTL_3D_TEXTURE_FILTERING_QUALITY_TYPES_PERFORMANCE = 0, ///< Performance
1438     CTL_3D_TEXTURE_FILTERING_QUALITY_TYPES_BALANCED = 1,///< Balanced
1439     CTL_3D_TEXTURE_FILTERING_QUALITY_TYPES_QUALITY = 2, ///< Quality
1440     CTL_3D_TEXTURE_FILTERING_QUALITY_TYPES_MAX
1441
1442 } ctl_3d_texture_filtering_quality_types_t;
1443
1444 ///////////////////////////////////////////////////////////////////////////////
1445 /// @brief Frame pacing values possible
1446 typedef enum _ctl_3d_frame_pacing_types_t
1447 {
1448     CTL_3D_FRAME_PACING_TYPES_DISABLE = 0,          ///< Disable
1449     CTL_3D_FRAME_PACING_TYPES_ENABLE_MODE_FRAME_NO_SMOOTHENING = 1, ///< Enable with scheduler without any frame smoothening
1450     CTL_3D_FRAME_PACING_TYPES_ENABLE_MODE_FRAME_MAX_SMOOTHENING = 2,///< Enable with scheduler with maximum smoothness
1451     CTL_3D_FRAME_PACING_TYPES_ENABLE_MODE_COMPETITIVE_GAMING = 3,   ///< Enable with scheduler in competitive gaming mode
1452     CTL_3D_FRAME_PACING_TYPES_MAX
1453
1454 } ctl_3d_frame_pacing_types_t;
1455
1456 ///////////////////////////////////////////////////////////////////////////////
1457 /// @brief Endurance Gaming control possible
1458 typedef enum _ctl_3d_endurance_gaming_control_t
1459 {
1460     CTL_3D_ENDURANCE_GAMING_CONTROL_TURN_OFF = 0,   ///< Endurance Gaming disable
1461     CTL_3D_ENDURANCE_GAMING_CONTROL_TURN_ON = 1,    ///< Endurance Gaming enable
1462     CTL_3D_ENDURANCE_GAMING_CONTROL_AUTO = 2,       ///< Endurance Gaming auto
1463     CTL_3D_ENDURANCE_GAMING_CONTROL_MAX
1464
1465 } ctl_3d_endurance_gaming_control_t;
1466
1467 ///////////////////////////////////////////////////////////////////////////////
1468 /// @brief Endurance Gaming modes possible
1469 typedef enum _ctl_3d_endurance_gaming_mode_t
1470 {
1471     CTL_3D_ENDURANCE_GAMING_MODE_BETTER_PERFORMANCE = 0,///< Endurance Gaming better performance mode
1472     CTL_3D_ENDURANCE_GAMING_MODE_BALANCED = 1,      ///< Endurance Gaming balanced mode
1473     CTL_3D_ENDURANCE_GAMING_MODE_MAXIMUM_BATTERY = 2,   ///< Endurance Gaming maximum battery mode
1474     CTL_3D_ENDURANCE_GAMING_MODE_MAX
1475
1476 } ctl_3d_endurance_gaming_mode_t;
1477
1478 ///////////////////////////////////////////////////////////////////////////////
1479 /// @brief Cmaa values possible
1480 typedef enum _ctl_3d_cmaa_types_t
1481 {
1482     CTL_3D_CMAA_TYPES_TURN_OFF = 0,                 ///< Turn off
1483     CTL_3D_CMAA_TYPES_OVERRIDE_MSAA = 1,            ///< Override MSAA
1484     CTL_3D_CMAA_TYPES_ENHANCE_APPLICATION = 2,      ///< Enhance Application
1485     CTL_3D_CMAA_TYPES_MAX
1486
1487 } ctl_3d_cmaa_types_t;
1488
1489 ///////////////////////////////////////////////////////////////////////////////
1490 /// @brief Adaptive Tessellation
1491 typedef enum _ctl_3d_adaptive_tessellation_types_t
1492 {
1493     CTL_3D_ADAPTIVE_TESSELLATION_TYPES_TURN_OFF = 0,///< Turn off
1494     CTL_3D_ADAPTIVE_TESSELLATION_TYPES_TURN_ON = 1, ///< Turn on
1495     CTL_3D_ADAPTIVE_TESSELLATION_TYPES_MAX
1496
1497 } ctl_3d_adaptive_tessellation_types_t;
1498
1499 ///////////////////////////////////////////////////////////////////////////////
1500 /// @brief Sharpening filter values possible
1501 typedef enum _ctl_3d_sharpening_filter_types_t
1502 {
1503     CTL_3D_SHARPENING_FILTER_TYPES_TURN_OFF = 0,    ///< Turn off
1504     CTL_3D_SHARPENING_FILTER_TYPES_TURN_ON = 1,     ///< Turn on
1505     CTL_3D_SHARPENING_FILTER_TYPES_MAX
1506
1507 } ctl_3d_sharpening_filter_types_t;
1508
1509 ///////////////////////////////////////////////////////////////////////////////
1510 /// @brief MSAA values possible
1511 typedef enum _ctl_3d_msaa_types_t
1512 {
1513     CTL_3D_MSAA_TYPES_APP_CHOICE = 0,               ///< Application choice
1514     CTL_3D_MSAA_TYPES_DISABLED = 1,                 ///< Disabled. MSAA count 1
1515     CTL_3D_MSAA_TYPES_2X = 2,                       ///< 2X
1516     CTL_3D_MSAA_TYPES_4X = 4,                       ///< 4X
1517     CTL_3D_MSAA_TYPES_8X = 8,                       ///< 8X
1518     CTL_3D_MSAA_TYPES_16X = 16,                     ///< 16X
1519     CTL_3D_MSAA_TYPES_MAX
1520
1521 } ctl_3d_msaa_types_t;
1522
1523 ///////////////////////////////////////////////////////////////////////////////
1524 /// @brief Gaming flip modes
1525 typedef uint32_t ctl_gaming_flip_mode_flags_t;
1526 typedef enum _ctl_gaming_flip_mode_flag_t
1527 {
1528     CTL_GAMING_FLIP_MODE_FLAG_APPLICATION_DEFAULT = CTL_BIT(0), ///< Application Default
1529     CTL_GAMING_FLIP_MODE_FLAG_VSYNC_OFF = CTL_BIT(1),   ///< Convert all sync flips to async on the next possible scanline.
1530     CTL_GAMING_FLIP_MODE_FLAG_VSYNC_ON = CTL_BIT(2),///< Convert all async flips to sync flips.
1531     CTL_GAMING_FLIP_MODE_FLAG_SMOOTH_SYNC = CTL_BIT(3), ///< Reduce tearing effect with async flips
1532     CTL_GAMING_FLIP_MODE_FLAG_SPEED_FRAME = CTL_BIT(4), ///< Application unaware triple buffering
1533     CTL_GAMING_FLIP_MODE_FLAG_CAPPED_FPS = CTL_BIT(5),  ///< Limit the game FPS to panel RR
1534     CTL_GAMING_FLIP_MODE_FLAG_MAX = 0x80000000
1535
1536 } ctl_gaming_flip_mode_flag_t;
1537
1538 ///////////////////////////////////////////////////////////////////////////////
1539 /// @brief Endurance Gaming caps
1540 typedef struct _ctl_endurance_gaming_caps_t
1541 {
1542     ctl_property_info_enum_t EGControlCaps;         ///< [out] Endurance Gaming control capability
1543     ctl_property_info_enum_t EGModeCaps;            ///< [out] Endurance Gaming mode capability
1544
1545 } ctl_endurance_gaming_caps_t;
1546
1547 ///////////////////////////////////////////////////////////////////////////////
1548 /// @brief Endurance Gaming Get/Set
1549 typedef struct _ctl_endurance_gaming_t
1550 {
1551     ctl_3d_endurance_gaming_control_t EGControl;    ///< [in,out] Endurance Gaming control - Off/On/Auto
1552     ctl_3d_endurance_gaming_mode_t EGMode;          ///< [in,out] Endurance Gaming mode - Better Performance/Balanced/Maximum
1553                                                     ///< Battery
1554
1555 } ctl_endurance_gaming_t;
1556
1557 ///////////////////////////////////////////////////////////////////////////////
1558 /// @brief Endurance Gaming version2 Get/Set
1559 typedef struct _ctl_endurance_gaming2_t
1560 {
1561     ctl_3d_endurance_gaming_control_t EGControl;    ///< [in,out] Endurance Gaming control - Off/On/Auto
1562     ctl_3d_endurance_gaming_mode_t EGMode;          ///< [in,out] Endurance Gaming mode - Better Performance/Balanced/Maximum
1563                                                     ///< Battery
1564     bool IsFPRequired;                              ///< [out] Is frame pacing required, dynamic state
1565     double TargetFPS;                               ///< [out] Target FPS for frame pacing
1566     double RefreshRate;                             ///< [out] Refresh rate used to calculate target fps
1567     uint32_t Reserved[4];                           ///< [out] Reserved fields
1568
1569 } ctl_endurance_gaming2_t;
1570
1571 ///////////////////////////////////////////////////////////////////////////////
1572 /// @brief Adaptive sync plus caps
1573 typedef struct _ctl_adaptivesync_caps_t
1574 {
1575     bool AdaptiveBalanceSupported;                  ///< [out] Adaptive balance supported
1576     ctl_property_info_float_t AdaptiveBalanceStrengthCaps;  ///< [out] Strength of adaptive balance algorithm - min/max/steps/default
1577
1578 } ctl_adaptivesync_caps_t;
1579
1580 ///////////////////////////////////////////////////////////////////////////////
1581 /// @brief Adaptive sync plus
1582 typedef struct _ctl_adaptivesync_getset_t
1583 {
1584     bool AdaptiveSync;                              ///< [in,out] Adaptive sync. Note that in Windows, OS controls state of
1585                                                     ///< adaptive sync and which game gets the feature using it's own policies
1586     bool AdaptiveBalance;                           ///< [in,out] Adaptive balance
1587     bool AllowAsyncForHighFPS;                      ///< [in,out] Allow async flips when FPS is higher than max refresh rate of
1588                                                     ///< the panel
1589     float AdaptiveBalanceStrength;                  ///< [in,out] Adaptive balance strength
1590
1591 } ctl_adaptivesync_getset_t;
1592
1593 ///////////////////////////////////////////////////////////////////////////////
1594 /// @brief Game tier types
1595 typedef uint32_t ctl_3d_tier_type_flags_t;
1596 typedef enum _ctl_3d_tier_type_flag_t
1597 {
1598     CTL_3D_TIER_TYPE_FLAG_COMPATIBILITY = CTL_BIT(0),   ///< Compatibility Tier
1599     CTL_3D_TIER_TYPE_FLAG_PERFORMANCE = CTL_BIT(1), ///< Performance Tier
1600     CTL_3D_TIER_TYPE_FLAG_MAX = 0x80000000
1601
1602 } ctl_3d_tier_type_flag_t;
1603
1604 ///////////////////////////////////////////////////////////////////////////////
1605 /// @brief Game tiers
1606 typedef uint32_t ctl_3d_tier_profile_flags_t;
1607 typedef enum _ctl_3d_tier_profile_flag_t
1608 {
1609     CTL_3D_TIER_PROFILE_FLAG_TIER_1 = CTL_BIT(0),   ///< Tier 1 Profile
1610     CTL_3D_TIER_PROFILE_FLAG_TIER_2 = CTL_BIT(1),   ///< Tier 2 Profile
1611     CTL_3D_TIER_PROFILE_FLAG_TIER_RECOMMENDED = CTL_BIT(30),///< Recommended Tier Profile. If set other tier values shouldn't be set
1612     CTL_3D_TIER_PROFILE_FLAG_MAX = 0x80000000
1613
1614 } ctl_3d_tier_profile_flag_t;
1615
1616 ///////////////////////////////////////////////////////////////////////////////
1617 /// @brief Game Profile Capabilities. Typically these remain the same across
1618 ///        games.
1619 typedef struct _ctl_3d_app_profiles_caps_t
1620 {
1621     ctl_3d_tier_type_flags_t SupportedTierTypes;    ///< [out] Tier of interest for capability check
1622     uint64_t Reserved;                              ///< [in,out] Reserved for future
1623
1624 } ctl_3d_app_profiles_caps_t;
1625
1626 ///////////////////////////////////////////////////////////////////////////////
1627 /// @brief Game Profile tiers
1628 typedef struct _ctl_3d_app_profiles_t
1629 {
1630     ctl_3d_tier_type_flag_t TierType;               ///< [in] Tier type
1631     ctl_3d_tier_profile_flags_t SupportedTierProfiles;  ///< [out] Supported tier profiles bitmask
1632     ctl_3d_tier_profile_flags_t DefaultEnabledTierProfiles; ///< [out] Default tiers which driver will enable if there is no user
1633                                                     ///< specific setting for global or per application
1634     ctl_3d_tier_profile_flags_t CustomizationSupportedTierProfiles; ///< [out] Tiers supporting customization - reserved for future
1635     ctl_3d_tier_profile_flags_t EnabledTierProfiles;///< [in,out] Tier profile(s) to be enabled/disabled in the case of a set
1636                                                     ///< call. For a get call this will return the currently enabled tiers
1637     ctl_3d_tier_profile_flags_t CustomizationEnabledTierProfiles;   ///< [in,out] Tier profile(s) which are customized. Caller shall call
1638                                                     ///< ::ctl_3d_tier_details_t to get specifics if any.
1639     uint64_t Reserved;                              ///< [in,out] Reserved for future
1640
1641 } ctl_3d_app_profiles_t;
1642
1643 ///////////////////////////////////////////////////////////////////////////////
1644 /// @brief Game Profile tiers details
1645 typedef struct _ctl_3d_tier_details_t
1646 {
1647     ctl_3d_tier_type_flag_t TierType;               ///< [in] Tier type
1648     ctl_3d_tier_profile_flag_t TierProfile;         ///< [in] Tier profile(s) for get/set details
1649     uint64_t Reserved[4];                           ///< [in,out] Reserved for future
1650
1651 } ctl_3d_tier_details_t;
1652
1653 ///////////////////////////////////////////////////////////////////////////////
1654 /// @brief Emulated Typed 64bit Atomics
1655 typedef enum _ctl_emulated_typed_64bit_atomics_types_t
1656 {
1657     CTL_EMULATED_TYPED_64BIT_ATOMICS_TYPES_DEFAULT = 0, ///< Default settings is based on workload/driver decision.
1658     CTL_EMULATED_TYPED_64BIT_ATOMICS_TYPES_TURN_ON = 1, ///< Force Turn on
1659     CTL_EMULATED_TYPED_64BIT_ATOMICS_TYPES_TURN_OFF = 2,///< Force Turn off
1660     CTL_EMULATED_TYPED_64BIT_ATOMICS_TYPES_MAX
1661
1662 } ctl_emulated_typed_64bit_atomics_types_t;
1663
1664 ///////////////////////////////////////////////////////////////////////////////
1665 /// @brief 3D feature capability details which will have range/supported and
1666 ///        default values
1667 typedef struct _ctl_3d_feature_details_t
1668 {
1669     ctl_3d_feature_t FeatureType;                   ///< [out] 3D feature type
1670     ctl_property_value_type_t ValueType;            ///< [out] Type of value
1671     ctl_property_info_t Value;                      ///< [out] Union of various type of values for 3D features. For enum types
1672                                                     ///< this can be anisotropic/frame pacing etc. This member is valid iff
1673                                                     ///< ValueType is not CTL_PROPERTY_VALUE_TYPE_CUSTOM
1674     int32_t CustomValueSize;                        ///< [in] CustomValue buffer size. Typically for a feature requiring custom
1675                                                     ///< struct, caller will know of it upfront and can provide the right size
1676                                                     ///< info here
1677     void* pCustomValue;                             ///< [in,out] Pointer to a custom structure. Caller should allocate this
1678                                                     ///< buffer with known custom feature structure size. This member is valid
1679                                                     ///< iff ValueType is CTL_PROPERTY_VALUE_TYPE_CUSTOM
1680     bool PerAppSupport;                             ///< [out] Flag indicating whether the feature is supported per application
1681                                                     ///< or not
1682     int64_t ConflictingFeatures;                    ///< [out] Mask of ::ctl_3d_feature_t values which can't be enabled along
1683                                                     ///< with the mentioned FeatureType. If this is 0, it meant the feature
1684                                                     ///< doesn't have any conflicts with other features
1685     int16_t FeatureMiscSupport;                     ///< [out] 3D Feature Miscellaneous support flags. This will be based on
1686                                                     ///< ::ctl_3d_feature_misc_flags_t
1687     int16_t Reserved;                               ///< [out] Reserved
1688     int16_t Reserved1;                              ///< [out] Reserved
1689     int16_t Reserved2;                              ///< [out] Reserved
1690
1691 } ctl_3d_feature_details_t;
1692
1693 ///////////////////////////////////////////////////////////////////////////////
1694 /// @brief 3D feature which are controllable
1695 typedef struct _ctl_3d_feature_caps_t
1696 {
1697     uint32_t Size;                                  ///< [in] size of this structure
1698     uint8_t Version;                                ///< [in] version of this structure
1699     uint32_t NumSupportedFeatures;                  ///< [in,out] Number of elements in supported features array
1700     ctl_3d_feature_details_t* pFeatureDetails;      ///< [in,out] Array of feature details
1701
1702 } ctl_3d_feature_caps_t;
1703
1704 ///////////////////////////////////////////////////////////////////////////////
1705 /// @brief 3D feature for get/set
1706 typedef struct _ctl_3d_feature_getset_t
1707 {
1708     uint32_t Size;                                  ///< [in] size of this structure
1709     uint8_t Version;                                ///< [in] version of this structure
1710     ctl_3d_feature_t FeatureType;                   ///< [in] Features interested in
1711     char* ApplicationName;                          ///< [in] Application name for which the property type is applicable. If
1712                                                     ///< this is an empty string then this will get/set global settings for the
1713                                                     ///< given adapter. Note that this should contain only the name of the
1714                                                     ///< application and not the system specific path
1715     int8_t ApplicationNameLength;                   ///< [in] Length of ApplicationName string
1716     bool bSet;                                      ///< [in] Set this if it's a set call
1717     ctl_property_value_type_t ValueType;            ///< [in] Type of value. Caller has to ensure it provides the right value
1718                                                     ///< type which decides how one read the union structure below
1719     ctl_property_t Value;                           ///< [in,out] Union of various type of values for 3D features. For enum
1720                                                     ///< types this can be anisotropic/frame pacing etc. This member is valid
1721                                                     ///< iff ValueType is not CTL_PROPERTY_VALUE_TYPE_CUSTOM
1722     int32_t CustomValueSize;                        ///< [in] CustomValue buffer size. Typically for a feature requiring custom
1723                                                     ///< struct, caller will know of it upfront and cn provide the right size
1724                                                     ///< info here
1725     void* pCustomValue;                             ///< [in,out] Pointer to a custom structure. Caller should allocate this
1726                                                     ///< buffer with known custom feature structure size. This member is valid
1727                                                     ///< iff ValueType is CTL_PROPERTY_VALUE_TYPE_CUSTOM
1728
1729 } ctl_3d_feature_getset_t;
1730
1731 ///////////////////////////////////////////////////////////////////////////////
1732 /// @brief Load KMD gaming features. Restricted function
1733 typedef struct _ctl_kmd_load_features_t
1734 {
1735     ctl_application_id_t ReservedFuncID;            ///< [in] Unique ID for reserved/special function
1736     bool bLoad;                                     ///< [in] If set, will load known KMD features. If not set will reset known
1737                                                     ///< KMD features to default
1738     int64_t SubsetFeatureMask;                      ///< [in,out] Mask indicating the subset of KMD features within
1739                                                     ///< ::ctl_3d_feature_t values. Default of 0 indicate all KMD features
1740     char* ApplicationName;                          ///< [in] Application name for which the KMD properties are loaded for. If
1741                                                     ///< this is an empty string then this will load global settings for the
1742                                                     ///< given adapter. Note that this should contain only the name of the
1743                                                     ///< application and not the system specific path
1744     int8_t ApplicationNameLength;                   ///< [in] Length of ApplicationName string
1745
1746 } ctl_kmd_load_features_t;
1747
1748 ///////////////////////////////////////////////////////////////////////////////
1749 /// @brief Get 3D capabilities
1750 ///
1751 /// @details
1752 ///     - The application gets 3D properties
1753 ///
1754 /// @returns
1755 ///     - CTL_RESULT_SUCCESS
1756 ///     - CTL_RESULT_ERROR_UNINITIALIZED
1757 ///     - CTL_RESULT_ERROR_DEVICE_LOST
1758 ///     - CTL_RESULT_ERROR_INVALID_NULL_HANDLE
1759 ///         + `nullptr == hDAhandle`
1760 ///     - CTL_RESULT_ERROR_INVALID_NULL_POINTER
1761 ///         + `nullptr == pFeatureCaps`
1762 ///     - ::CTL_RESULT_ERROR_UNSUPPORTED_VERSION - "Unsupported version"
1763 CTL_APIEXPORT ctl_result_t CTL_APICALL
1764 ctlGetSupported3DCapabilities(
1765     ctl_device_adapter_handle_t hDAhandle,          ///< [in][release] Handle to display adapter
1766     ctl_3d_feature_caps_t* pFeatureCaps             ///< [in,out][release] 3D properties
1767     );
1768
1769 ///////////////////////////////////////////////////////////////////////////////
1770 /// @brief Get/Set 3D feature
1771 ///
1772 /// @details
1773 ///     - 3D feature details
1774 ///
1775 /// @returns
1776 ///     - CTL_RESULT_SUCCESS
1777 ///     - CTL_RESULT_ERROR_UNINITIALIZED
1778 ///     - CTL_RESULT_ERROR_DEVICE_LOST
1779 ///     - CTL_RESULT_ERROR_INVALID_NULL_HANDLE
1780 ///         + `nullptr == hDAhandle`
1781 ///     - CTL_RESULT_ERROR_INVALID_NULL_POINTER
1782 ///         + `nullptr == pFeature`
1783 ///     - ::CTL_RESULT_ERROR_UNSUPPORTED_VERSION - "Unsupported version"
1784 CTL_APIEXPORT ctl_result_t CTL_APICALL
1785 ctlGetSet3DFeature(
1786     ctl_device_adapter_handle_t hDAhandle,          ///< [in][release] Handle to display adapter
1787     ctl_3d_feature_getset_t* pFeature               ///< [in][release] 3D feature get/set parameter
1788     );
1789
1790
1791 #if !defined(__GNUC__)
1792 #pragma endregion // 3D
1793 #endif
1794 // Intel 'ctlApi' for Device Adapter
1795 #if !defined(__GNUC__)
1796 #pragma region display
1797 #endif
1798 ///////////////////////////////////////////////////////////////////////////////
1799 /// @brief Handle of a display output instance
1800 typedef struct _ctl_display_output_handle_t *ctl_display_output_handle_t;
1801
1802 ///////////////////////////////////////////////////////////////////////////////
1803 /// @brief Check Driver version
1804 ///
1805 /// @details
1806 ///     - The application checks driver version
1807 ///
1808 /// @returns
1809 ///     - CTL_RESULT_SUCCESS
1810 ///     - CTL_RESULT_ERROR_UNINITIALIZED
1811 ///     - CTL_RESULT_ERROR_DEVICE_LOST
1812 ///     - CTL_RESULT_ERROR_INVALID_NULL_HANDLE
1813 ///         + `nullptr == hDeviceAdapter`
1814 ///     - ::CTL_RESULT_ERROR_UNSUPPORTED_VERSION - "Unsupported version"
1815 CTL_APIEXPORT ctl_result_t CTL_APICALL
1816 ctlCheckDriverVersion(
1817     ctl_device_adapter_handle_t hDeviceAdapter,     ///< [in][release] handle to control device adapter
1818     ctl_version_info_t version_info                 ///< [in][release] Driver version info
1819     );
1820
1821 ///////////////////////////////////////////////////////////////////////////////
1822 /// @brief Enumerate devices
1823 ///
1824 /// @details
1825 ///     - The application enumerates all device adapters in the system
1826 ///
1827 /// @returns
1828 ///     - CTL_RESULT_SUCCESS
1829 ///     - CTL_RESULT_ERROR_UNINITIALIZED
1830 ///     - CTL_RESULT_ERROR_DEVICE_LOST
1831 ///     - CTL_RESULT_ERROR_INVALID_NULL_HANDLE
1832 ///         + `nullptr == hAPIHandle`
1833 ///     - CTL_RESULT_ERROR_INVALID_NULL_POINTER
1834 ///         + `nullptr == pCount`
1835 ///     - ::CTL_RESULT_ERROR_UNSUPPORTED_VERSION - "Unsupported version"
1836 CTL_APIEXPORT ctl_result_t CTL_APICALL
1837 ctlEnumerateDevices(
1838     ctl_api_handle_t hAPIHandle,                    ///< [in][release] Applications should pass the Control API handle returned
1839                                                     ///< by the CtlInit function
1840     uint32_t* pCount,                               ///< [in,out][release] pointer to the number of device instances. If count
1841                                                     ///< is zero, then the api will update the value with the total
1842                                                     ///< number of drivers available. If count is non-zero, then the api will
1843                                                     ///< only retrieve the number of drivers.
1844                                                     ///< If count is larger than the number of drivers available, then the api
1845                                                     ///< will update the value with the correct number of drivers available.
1846     ctl_device_adapter_handle_t* phDevices          ///< [in,out][optional][release][range(0, *pCount)] array of driver
1847                                                     ///< instance handles
1848     );
1849
1850 ///////////////////////////////////////////////////////////////////////////////
1851 /// @brief Enumerate display outputs
1852 ///
1853 /// @details
1854 ///     - Enumerates display output capabilities
1855 ///
1856 /// @returns
1857 ///     - CTL_RESULT_SUCCESS
1858 ///     - CTL_RESULT_ERROR_UNINITIALIZED
1859 ///     - CTL_RESULT_ERROR_DEVICE_LOST
1860 ///     - CTL_RESULT_ERROR_INVALID_NULL_HANDLE
1861 ///         + `nullptr == hDeviceAdapter`
1862 ///     - CTL_RESULT_ERROR_INVALID_NULL_POINTER
1863 ///         + `nullptr == pCount`
1864 ///     - ::CTL_RESULT_ERROR_UNSUPPORTED_VERSION - "Unsupported version"
1865 CTL_APIEXPORT ctl_result_t CTL_APICALL
1866 ctlEnumerateDisplayOutputs(
1867     ctl_device_adapter_handle_t hDeviceAdapter,     ///< [in][release] handle to control device adapter
1868     uint32_t* pCount,                               ///< [in,out][release] pointer to the number of display output instances.
1869                                                     ///< If count is zero, then the api will update the value with the total
1870                                                     ///< number of outputs available. If count is non-zero, then the api will
1871                                                     ///< only retrieve the number of outputs.
1872                                                     ///< If count is larger than the number of drivers available, then the api
1873                                                     ///< will update the value with the correct number of drivers available.
1874     ctl_display_output_handle_t* phDisplayOutputs   ///< [in,out][optional][release][range(0, *pCount)] array of display output
1875                                                     ///< instance handles
1876     );
1877
1878 ///////////////////////////////////////////////////////////////////////////////
1879 /// @brief OS specific Display identifiers
1880 typedef union _ctl_os_display_encoder_identifier_t
1881 {
1882     uint32_t WindowsDisplayEncoderID;               ///< [out] Windows OS Display encoder ID
1883     ctl_generic_void_datatype_t DisplayEncoderID;   ///< [out] Display encoder ID for non-windows OS
1884
1885 } ctl_os_display_encoder_identifier_t;
1886
1887 ///////////////////////////////////////////////////////////////////////////////
1888 /// @brief Various display types
1889 typedef enum _ctl_display_output_types_t
1890 {
1891     CTL_DISPLAY_OUTPUT_TYPES_INVALID = 0,           ///< Invalid
1892     CTL_DISPLAY_OUTPUT_TYPES_DISPLAYPORT = 1,       ///< DisplayPort
1893     CTL_DISPLAY_OUTPUT_TYPES_HDMI = 2,              ///< HDMI
1894     CTL_DISPLAY_OUTPUT_TYPES_DVI = 3,               ///< DVI
1895     CTL_DISPLAY_OUTPUT_TYPES_MIPI = 4,              ///< MIPI
1896     CTL_DISPLAY_OUTPUT_TYPES_CRT = 5,               ///< CRT
1897     CTL_DISPLAY_OUTPUT_TYPES_MAX
1898
1899 } ctl_display_output_types_t;
1900
1901 ///////////////////////////////////////////////////////////////////////////////
1902 /// @brief Supported output bits per color (bpc) bitmasks
1903 typedef uint32_t ctl_output_bpc_flags_t;
1904 typedef enum _ctl_output_bpc_flag_t
1905 {
1906     CTL_OUTPUT_BPC_FLAG_6BPC = CTL_BIT(0),          ///< [out] Is 6bpc supported
1907     CTL_OUTPUT_BPC_FLAG_8BPC = CTL_BIT(1),          ///< [out] Is 8bpc supported
1908     CTL_OUTPUT_BPC_FLAG_10BPC = CTL_BIT(2),         ///< [out] Is 10bpc supported
1909     CTL_OUTPUT_BPC_FLAG_12BPC = CTL_BIT(3),         ///< [out] Is 12bpc supported
1910     CTL_OUTPUT_BPC_FLAG_MAX = 0x80000000
1911
1912 } ctl_output_bpc_flag_t;
1913
1914 ///////////////////////////////////////////////////////////////////////////////
1915 /// @brief Display output features. This will indicate only the high level
1916 ///        capabilities
1917 typedef uint32_t ctl_std_display_feature_flags_t;
1918 typedef enum _ctl_std_display_feature_flag_t
1919 {
1920     CTL_STD_DISPLAY_FEATURE_FLAG_HDCP = CTL_BIT(0), ///< [out] Is HDCP supported
1921     CTL_STD_DISPLAY_FEATURE_FLAG_HD_AUDIO = CTL_BIT(1), ///< [out] Is HD Audio supported
1922     CTL_STD_DISPLAY_FEATURE_FLAG_PSR = CTL_BIT(2),  ///< [out] Is VESA PSR supported
1923     CTL_STD_DISPLAY_FEATURE_FLAG_ADAPTIVESYNC_VRR = CTL_BIT(3), ///< [out] Is VESA Adaptive Sync or HDMI VRR supported
1924     CTL_STD_DISPLAY_FEATURE_FLAG_VESA_COMPRESSION = CTL_BIT(4), ///< [out] Is display compression (VESA DSC) supported
1925     CTL_STD_DISPLAY_FEATURE_FLAG_HDR = CTL_BIT(5),  ///< [out] Is HDR supported
1926     CTL_STD_DISPLAY_FEATURE_FLAG_HDMI_QMS = CTL_BIT(6), ///< [out] Is HDMI QMS supported
1927     CTL_STD_DISPLAY_FEATURE_FLAG_MAX = 0x80000000
1928
1929 } ctl_std_display_feature_flag_t;
1930
1931 ///////////////////////////////////////////////////////////////////////////////
1932 /// @brief Advanced Graphics Features provided by Intel Graphics Adapter. This
1933 ///        will indicate only the high level capabilities
1934 typedef uint32_t ctl_intel_display_feature_flags_t;
1935 typedef enum _ctl_intel_display_feature_flag_t
1936 {
1937     CTL_INTEL_DISPLAY_FEATURE_FLAG_DPST = CTL_BIT(0),   ///< [out] Is DPST supported
1938     CTL_INTEL_DISPLAY_FEATURE_FLAG_LACE = CTL_BIT(1),   ///< [out] Is LACE supported
1939     CTL_INTEL_DISPLAY_FEATURE_FLAG_DRRS = CTL_BIT(2),   ///< [out] Is DRRS supported
1940     CTL_INTEL_DISPLAY_FEATURE_FLAG_MAX = 0x80000000
1941
1942 } ctl_intel_display_feature_flag_t;
1943
1944 ///////////////////////////////////////////////////////////////////////////////
1945 /// @brief Attached Display Mux Type
1946 typedef enum _ctl_attached_display_mux_type_t
1947 {
1948     CTL_ATTACHED_DISPLAY_MUX_TYPE_NATIVE = 0,       ///< [out] Native DP / HDMI
1949     CTL_ATTACHED_DISPLAY_MUX_TYPE_THUNDERBOLT = 1,  ///< [out] Thunderbolt
1950     CTL_ATTACHED_DISPLAY_MUX_TYPE_TYPE_C = 2,       ///< [out] USB Type C
1951     CTL_ATTACHED_DISPLAY_MUX_TYPE_USB4 = 3,         ///< [out] USB4
1952     CTL_ATTACHED_DISPLAY_MUX_TYPE_MAX
1953
1954 } ctl_attached_display_mux_type_t;
1955
1956 ///////////////////////////////////////////////////////////////////////////////
1957 /// @brief Signal Standard
1958 typedef enum _ctl_signal_standard_type_t
1959 {
1960     CTL_SIGNAL_STANDARD_TYPE_UNKNOWN = 0,           ///< [out] Unknown Signal Standard
1961     CTL_SIGNAL_STANDARD_TYPE_CUSTOM = 1,            ///< [out] Custom added timing
1962     CTL_SIGNAL_STANDARD_TYPE_DMT = 2,               ///< [out] DMT timing
1963     CTL_SIGNAL_STANDARD_TYPE_GTF = 3,               ///< [out] GTF Timing
1964     CTL_SIGNAL_STANDARD_TYPE_CVT = 4,               ///< [out] CVT Timing
1965     CTL_SIGNAL_STANDARD_TYPE_CTA = 5,               ///< [out] CTA Timing
1966     CTL_SIGNAL_STANDARD_TYPE_MAX
1967
1968 } ctl_signal_standard_type_t;
1969
1970 ///////////////////////////////////////////////////////////////////////////////
1971 /// @brief Protocol Converter Location
1972 typedef uint32_t ctl_protocol_converter_location_flags_t;
1973 typedef enum _ctl_protocol_converter_location_flag_t
1974 {
1975     CTL_PROTOCOL_CONVERTER_LOCATION_FLAG_ONBOARD = CTL_BIT(0),  ///< [out] OnBoard Protocol Converter
1976     CTL_PROTOCOL_CONVERTER_LOCATION_FLAG_EXTERNAL = CTL_BIT(1), ///< [out] External Dongle
1977     CTL_PROTOCOL_CONVERTER_LOCATION_FLAG_MAX = 0x80000000
1978
1979 } ctl_protocol_converter_location_flag_t;
1980
1981 ///////////////////////////////////////////////////////////////////////////////
1982 /// @brief [out] Display Output configuration related flags which indicate how
1983 ///        the output pixel stream drive the panel
1984 typedef uint32_t ctl_display_config_flags_t;
1985 typedef enum _ctl_display_config_flag_t
1986 {
1987     CTL_DISPLAY_CONFIG_FLAG_DISPLAY_ACTIVE = CTL_BIT(0),///< [out] DisplayActive 0: InActive 1: Active
1988     CTL_DISPLAY_CONFIG_FLAG_DISPLAY_ATTACHED = CTL_BIT(1),  ///< [out] DisplayAttached.This Bit indicates if any dongle/display/hub is
1989                                                     ///< attached to the encoder. 0: Not Attached 1: Attached
1990     CTL_DISPLAY_CONFIG_FLAG_IS_DONGLE_CONNECTED_TO_ENCODER = CTL_BIT(2),///< [out] This BIT will be set if a dongle/hub/onboard protocol converter
1991                                                     ///< , is attached to the encoder
1992     CTL_DISPLAY_CONFIG_FLAG_DITHERING_ENABLED = CTL_BIT(3), ///< [out] This BIT will be set if dithering is enabled on the encoder
1993     CTL_DISPLAY_CONFIG_FLAG_MAX = 0x80000000
1994
1995 } ctl_display_config_flag_t;
1996
1997 ///////////////////////////////////////////////////////////////////////////////
1998 /// @brief [out] Encoder configuration related flags which indicate how the
1999 ///        output pixel stream drive the panel
2000 typedef uint32_t ctl_encoder_config_flags_t;
2001 typedef enum _ctl_encoder_config_flag_t
2002 {
2003     CTL_ENCODER_CONFIG_FLAG_INTERNAL_DISPLAY = CTL_BIT(0),  ///< [out] Internal connection or not
2004     CTL_ENCODER_CONFIG_FLAG_VESA_TILED_DISPLAY = CTL_BIT(1),///< [out] VESA DisplayID based tiled display which is driven by either
2005                                                     ///< multiple physical connections (DisplayPort SST) or virtual streams
2006                                                     ///< (DisplayPort MST)
2007     CTL_ENCODER_CONFIG_FLAG_TYPEC_CAPABLE = CTL_BIT(2), ///< [out] This is set if encoder supports type c display
2008     CTL_ENCODER_CONFIG_FLAG_TBT_CAPABLE = CTL_BIT(3),   ///< [out] This is set if encoder supports Thunderbolt display
2009     CTL_ENCODER_CONFIG_FLAG_DITHERING_SUPPORTED = CTL_BIT(4),   ///< [out] This BIT will be set if encoder supports dithering
2010     CTL_ENCODER_CONFIG_FLAG_VIRTUAL_DISPLAY = CTL_BIT(5),   ///< [out] This BIT will be set if this is a virtual display.Hardware based
2011                                                     ///< features will not be applicable to this display.For collage display
2012                                                     ///< this will be set for the virtual output created by driver. For split
2013                                                     ///< display this will be set for the virtual split displays created out of
2014                                                     ///< one single physical display
2015     CTL_ENCODER_CONFIG_FLAG_HIDDEN_DISPLAY = CTL_BIT(6),///< [out] This BIT will be set if display is hidden from OS
2016     CTL_ENCODER_CONFIG_FLAG_COLLAGE_DISPLAY = CTL_BIT(7),   ///< [out] This BIT will be set if this is a collage display
2017     CTL_ENCODER_CONFIG_FLAG_SPLIT_DISPLAY = CTL_BIT(8), ///< [out] This BIT will be set if this is a split display
2018     CTL_ENCODER_CONFIG_FLAG_COMPANION_DISPLAY = CTL_BIT(9), ///< [out] This BIT will be set if this is a companion display
2019     CTL_ENCODER_CONFIG_FLAG_MAX = 0x80000000
2020
2021 } ctl_encoder_config_flag_t;
2022
2023 ///////////////////////////////////////////////////////////////////////////////
2024 /// @brief Display Timing
2025 typedef struct _ctl_display_timing_t
2026 {
2027     uint32_t Size;                                  ///< [in] size of this structure
2028     uint8_t Version;                                ///< [in] version of this structure
2029     uint64_t PixelClock;                            ///< [out] Pixel Clock in Hz
2030     uint32_t HActive;                               ///< [out] Horizontal Active
2031     uint32_t VActive;                               ///< [out] Vertical Active
2032     uint32_t HTotal;                                ///< [out] Horizontal Total
2033     uint32_t VTotal;                                ///< [out] Vertical Total
2034     uint32_t HBlank;                                ///< [out] Horizontal Blank
2035     uint32_t VBlank;                                ///< [out] Vertical Blank
2036     uint32_t HSync;                                 ///< [out] Horizontal Blank
2037     uint32_t VSync;                                 ///< [out] Vertical Blank
2038     float RefreshRate;                              ///< [out] Refresh Rate
2039     ctl_signal_standard_type_t SignalStandard;      ///< [out] Signal Standard
2040     uint8_t VicId;                                  ///< [out] VIC ID for CTA timings
2041
2042 } ctl_display_timing_t;
2043
2044 ///////////////////////////////////////////////////////////////////////////////
2045 /// @brief This structure will contain the properties of the display currently
2046 ///        attached to the encoder.
2047 typedef struct _ctl_display_properties_t
2048 {
2049     uint32_t Size;                                  ///< [in] size of this structure
2050     uint8_t Version;                                ///< [in] version of this structure
2051     ctl_os_display_encoder_identifier_t Os_display_encoder_handle;  ///< [out] OS specific Display ID
2052     ctl_display_output_types_t Type;                ///< [out] Device Type from display HW stand point. If a DisplayPort
2053                                                     ///< protocol converter is involved, this will indicate it's DisplayPort.
2054                                                     ///< The protocol converter's output will be available from
2055                                                     ///< ProtocolConverterOutput field
2056     ctl_attached_display_mux_type_t AttachedDisplayMuxType; ///< [out] Attached Display Mux Type
2057     ctl_display_output_types_t ProtocolConverterOutput; ///< [out] Protocol output type which can be used if config flags indicate
2058                                                     ///< it's a protocol converter. If it's not a protocol converter this will
2059                                                     ///< be set to CTL_DISPLAY_OUTPUT_TYPES_INVALID
2060     ctl_revision_datatype_t SupportedSpec;          ///< [out] Supported industry spec version.
2061     ctl_output_bpc_flags_t SupportedOutputBPCFlags; ///< [out] Supported output bits per color. Refer ::ctl_output_bpc_flag_t.
2062                                                     ///< This is independent of RGB or YCbCr output.This is the max BPC
2063                                                     ///< supported.BPC will vary per mode based on restrictions like bandwidth
2064                                                     ///< and monitor support
2065     ctl_protocol_converter_location_flags_t ProtocolConverterType;  ///< [out] Currently Active Protocol Converter. Refer
2066                                                     ///< ::ctl_protocol_converter_location_flag_t
2067     ctl_display_config_flags_t DisplayConfigFlags;  ///< [out] Output configuration related flags which indicate how the output
2068                                                     ///< pixel stream drive the panel. Refer ::ctl_display_config_flag_t
2069     ctl_std_display_feature_flags_t FeatureEnabledFlags;///< [out] Enabled Display features.Refer ::ctl_std_display_feature_flag_t.
2070     ctl_std_display_feature_flags_t FeatureSupportedFlags;  ///< [out] Display Supported feature.Refer ::ctl_std_display_feature_flag_t
2071     ctl_intel_display_feature_flags_t AdvancedFeatureEnabledFlags;  ///< [out] Enabled advanced feature.Refer
2072                                                     ///< ::ctl_intel_display_feature_flag_t.
2073     ctl_intel_display_feature_flags_t AdvancedFeatureSupportedFlags;///< [out] Supported advanced feature.Refer
2074                                                     ///< ::ctl_intel_display_feature_flag_t.
2075     ctl_display_timing_t Display_Timing_Info;       ///< [out] Applied Timing on the Display
2076     uint32_t ReservedFields[16];                    ///< [out] Reserved field of 64 bytes
2077
2078 } ctl_display_properties_t;
2079
2080 ///////////////////////////////////////////////////////////////////////////////
2081 /// @brief Adapter's display encoder properties
2082 typedef struct _ctl_adapter_display_encoder_properties_t
2083 {
2084     uint32_t Size;                                  ///< [in] size of this structure
2085     uint8_t Version;                                ///< [in] version of this structure
2086     ctl_os_display_encoder_identifier_t Os_display_encoder_handle;  ///< [out] OS specific Display ID
2087     ctl_display_output_types_t Type;                ///< [out] Device Type from display HW stand point. If a DisplayPort
2088                                                     ///< protocol converter is involved, this will indicate it's DisplayPort.
2089                                                     ///< The protocol converter's output will be available from
2090                                                     ///< ProtocolConverterOutput field
2091     bool IsOnBoardProtocolConverterOutputPresent;   ///< [out] Protocol output type which can be used if it's a protocol
2092                                                     ///< converter. If it's not a protocol converter this will be set to
2093                                                     ///< CTL_DISPLAY_OUTPUT_TYPES_INVALID
2094     ctl_revision_datatype_t SupportedSpec;          ///< [out] Supported industry spec version
2095     ctl_output_bpc_flags_t SupportedOutputBPCFlags; ///< [out] Supported output bits per color. Refer ::ctl_output_bpc_flag_t.
2096                                                     ///< This is independent of RGB or YCbCr output.This is the max BPC
2097                                                     ///< supported.BPC will vary per mode based on restrictions like bandwidth
2098                                                     ///< and monitor support
2099     ctl_encoder_config_flags_t EncoderConfigFlags;  ///< [out] Output configuration related flags which indicate how the output
2100                                                     ///< pixel stream drive the panel. Refer ::ctl_encoder_config_flag_t
2101                                                     ///< Note:
2102                                                     ///<    Virtual = 1: This indicates that its a software display. Hardware
2103                                                     ///< based features will not be applicable to this display.
2104                                                     ///<    Collage=1,Virtual=1: Indicates the fake display output created by
2105                                                     ///< driver which has the combined resolution of multiple physical displays
2106                                                     ///< involved in collage configuration
2107                                                     ///<    Collage=1,Virtual=0: Indicates the child physical displays involved
2108                                                     ///< in a collage configuration. These are real physical outputs
2109                                                     ///<    Split=1,Virtual=1  : Indicates the fake display output created by
2110                                                     ///< driver which occupies a portion of a real physical display
2111                                                     ///<    Split=1,Virtual=0  : Indicates the physical display which got split
2112                                                     ///< to form multiple split displays
2113                                                     ///<    Split=1,Collage=1  : Invalid combination
2114     ctl_std_display_feature_flags_t FeatureSupportedFlags;  ///< [out] Adapter Supported feature flags. Refer
2115                                                     ///< ::ctl_std_display_feature_flag_t
2116     ctl_intel_display_feature_flags_t AdvancedFeatureSupportedFlags;///< [out] Advanced Features Supported by the Adapter. Refer
2117                                                     ///< ::ctl_intel_display_feature_flag_t
2118     uint32_t ReservedFields[16];                    ///< [out] Reserved field of 64 bytes
2119
2120 } ctl_adapter_display_encoder_properties_t;
2121
2122 ///////////////////////////////////////////////////////////////////////////////
2123 /// @brief Get Device Properties
2124 ///
2125 /// @details
2126 ///     - The application gets device properties
2127 ///
2128 /// @returns
2129 ///     - CTL_RESULT_SUCCESS
2130 ///     - CTL_RESULT_ERROR_UNINITIALIZED
2131 ///     - CTL_RESULT_ERROR_DEVICE_LOST
2132 ///     - CTL_RESULT_ERROR_INVALID_NULL_HANDLE
2133 ///         + `nullptr == hDAhandle`
2134 ///     - CTL_RESULT_ERROR_INVALID_NULL_POINTER
2135 ///         + `nullptr == pProperties`
2136 ///     - ::CTL_RESULT_ERROR_UNSUPPORTED_VERSION - "Unsupported version"
2137 CTL_APIEXPORT ctl_result_t CTL_APICALL
2138 ctlGetDeviceProperties(
2139     ctl_device_adapter_handle_t hDAhandle,          ///< [in][release] Handle to control device adapter
2140     ctl_device_adapter_properties_t* pProperties    ///< [in,out][release] Query result for device properties
2141     );
2142
2143 ///////////////////////////////////////////////////////////////////////////////
2144 /// @brief Get Display  Properties
2145 ///
2146 /// @details
2147 ///     - The application gets display  properties
2148 ///
2149 /// @returns
2150 ///     - CTL_RESULT_SUCCESS
2151 ///     - CTL_RESULT_ERROR_UNINITIALIZED
2152 ///     - CTL_RESULT_ERROR_DEVICE_LOST
2153 ///     - CTL_RESULT_ERROR_INVALID_NULL_HANDLE
2154 ///         + `nullptr == hDisplayOutput`
2155 ///     - CTL_RESULT_ERROR_INVALID_NULL_POINTER
2156 ///         + `nullptr == pProperties`
2157 ///     - ::CTL_RESULT_ERROR_UNSUPPORTED_VERSION - "Unsupported version"
2158 CTL_APIEXPORT ctl_result_t CTL_APICALL
2159 ctlGetDisplayProperties(
2160     ctl_display_output_handle_t hDisplayOutput,     ///< [in][release] Handle to display output
2161     ctl_display_properties_t* pProperties           ///< [in,out][release] Query result for display  properties
2162     );
2163
2164 ///////////////////////////////////////////////////////////////////////////////
2165 /// @brief Get Adapter Display encoder  Properties
2166 ///
2167 /// @details
2168 ///     - The application gets the graphic adapters display encoder properties
2169 ///
2170 /// @returns
2171 ///     - CTL_RESULT_SUCCESS
2172 ///     - CTL_RESULT_ERROR_UNINITIALIZED
2173 ///     - CTL_RESULT_ERROR_DEVICE_LOST
2174 ///     - CTL_RESULT_ERROR_INVALID_NULL_HANDLE
2175 ///         + `nullptr == hDisplayOutput`
2176 ///     - CTL_RESULT_ERROR_INVALID_NULL_POINTER
2177 ///         + `nullptr == pProperties`
2178 ///     - ::CTL_RESULT_ERROR_UNSUPPORTED_VERSION - "Unsupported version"
2179 CTL_APIEXPORT ctl_result_t CTL_APICALL
2180 ctlGetAdaperDisplayEncoderProperties(
2181     ctl_display_output_handle_t hDisplayOutput,     ///< [in][release] Handle to display output
2182     ctl_adapter_display_encoder_properties_t* pProperties   ///< [in,out][release] Query result for adapter display encoder properties
2183     );
2184
2185 ///////////////////////////////////////////////////////////////////////////////
2186 /// @brief Get Level0 Device handle
2187 ///
2188 /// @details
2189 ///     - The application gets OneAPI Level0 Device handles
2190 ///
2191 /// @returns
2192 ///     - CTL_RESULT_SUCCESS
2193 ///     - CTL_RESULT_ERROR_UNINITIALIZED
2194 ///     - CTL_RESULT_ERROR_DEVICE_LOST
2195 ///     - CTL_RESULT_ERROR_INVALID_NULL_HANDLE
2196 ///         + `nullptr == hDAhandle`
2197 ///     - CTL_RESULT_ERROR_INVALID_NULL_POINTER
2198 ///         + `nullptr == pZeDevice`
2199 ///         + `nullptr == hInstance`
2200 ///     - ::CTL_RESULT_ERROR_UNSUPPORTED_VERSION - "Unsupported version"
2201 CTL_APIEXPORT ctl_result_t CTL_APICALL
2202 ctlGetZeDevice(
2203     ctl_device_adapter_handle_t hDAhandle,          ///< [in][release] Handle to display adapter
2204     void* pZeDevice,                                ///< [out][release] ze_device handle
2205     void** hInstance                                ///< [out][release] Module instance which caller can use to get export
2206                                                     ///< functions directly
2207     );
2208
2209 ///////////////////////////////////////////////////////////////////////////////
2210 /// @brief Various sharpness filter types
2211 typedef uint32_t ctl_sharpness_filter_type_flags_t;
2212 typedef enum _ctl_sharpness_filter_type_flag_t
2213 {
2214     CTL_SHARPNESS_FILTER_TYPE_FLAG_NON_ADAPTIVE = CTL_BIT(0),   ///< Non-adaptive sharpness
2215     CTL_SHARPNESS_FILTER_TYPE_FLAG_ADAPTIVE = CTL_BIT(1),   ///< Adaptive sharpness
2216     CTL_SHARPNESS_FILTER_TYPE_FLAG_MAX = 0x80000000
2217
2218 } ctl_sharpness_filter_type_flag_t;
2219
2220 ///////////////////////////////////////////////////////////////////////////////
2221 /// @brief Sharpness filter properties
2222 typedef struct _ctl_sharpness_filter_properties_t
2223 {
2224     ctl_sharpness_filter_type_flags_t FilterType;   ///< [out] Filter type. Refer ::ctl_sharpness_filter_type_flag_t
2225     ctl_property_range_info_t FilterDetails;        ///< [out] Min, max & step size information
2226
2227 } ctl_sharpness_filter_properties_t;
2228
2229 ///////////////////////////////////////////////////////////////////////////////
2230 /// @brief Various sharpness filter types
2231 typedef struct _ctl_sharpness_caps_t
2232 {
2233     uint32_t Size;                                  ///< [in] size of this structure
2234     uint8_t Version;                                ///< [in] version of this structure
2235     ctl_sharpness_filter_type_flags_t SupportedFilterFlags; ///< [out] Supported sharpness filters for a given display output. Refer
2236                                                     ///< ::ctl_sharpness_filter_type_flag_t
2237     uint8_t NumFilterTypes;                         ///< [out] Number of elements in filter properties array
2238     ctl_sharpness_filter_properties_t* pFilterProperty; ///< [in,out] Array of filter properties structure describing supported
2239                                                     ///< filter capabilities. Caller should provide a pre-allocated memory for
2240                                                     ///< this.
2241
2242 } ctl_sharpness_caps_t;
2243
2244 ///////////////////////////////////////////////////////////////////////////////
2245 /// @brief Current sharpness setting
2246 typedef struct _ctl_sharpness_settings_t
2247 {
2248     uint32_t Size;                                  ///< [in] size of this structure
2249     uint8_t Version;                                ///< [in] version of this structure
2250     bool Enable;                                    ///< [in,out] Current or new state of sharpness setting
2251     ctl_sharpness_filter_type_flags_t FilterType;   ///< [in,out] Current or new filter to be set. Refer
2252                                                     ///< ::ctl_sharpness_filter_type_flag_t
2253     float Intensity;                                ///< [in,out] Setting intensity to be applied
2254
2255 } ctl_sharpness_settings_t;
2256
2257 ///////////////////////////////////////////////////////////////////////////////
2258 /// @brief Get Sharpness capability
2259 ///
2260 /// @details
2261 ///     - Returns sharpness capability
2262 ///
2263 /// @returns
2264 ///     - CTL_RESULT_SUCCESS
2265 ///     - CTL_RESULT_ERROR_UNINITIALIZED
2266 ///     - CTL_RESULT_ERROR_DEVICE_LOST
2267 ///     - CTL_RESULT_ERROR_INVALID_NULL_HANDLE
2268 ///         + `nullptr == hDisplayOutput`
2269 ///     - CTL_RESULT_ERROR_INVALID_NULL_POINTER
2270 ///         + `nullptr == pSharpnessCaps`
2271 ///     - ::CTL_RESULT_ERROR_UNSUPPORTED_VERSION - "Unsupported version"
2272 CTL_APIEXPORT ctl_result_t CTL_APICALL
2273 ctlGetSharpnessCaps(
2274     ctl_display_output_handle_t hDisplayOutput,     ///< [in][release] Handle to display output
2275     ctl_sharpness_caps_t* pSharpnessCaps            ///< [in,out][release] Query result for sharpness capability
2276     );
2277
2278 ///////////////////////////////////////////////////////////////////////////////
2279 /// @brief Get Sharpness setting
2280 ///
2281 /// @details
2282 ///     - Returns current sharpness settings
2283 ///
2284 /// @returns
2285 ///     - CTL_RESULT_SUCCESS
2286 ///     - CTL_RESULT_ERROR_UNINITIALIZED
2287 ///     - CTL_RESULT_ERROR_DEVICE_LOST
2288 ///     - CTL_RESULT_ERROR_INVALID_NULL_HANDLE
2289 ///         + `nullptr == hDisplayOutput`
2290 ///     - CTL_RESULT_ERROR_INVALID_NULL_POINTER
2291 ///         + `nullptr == pSharpnessSettings`
2292 ///     - ::CTL_RESULT_ERROR_UNSUPPORTED_VERSION - "Unsupported version"
2293 CTL_APIEXPORT ctl_result_t CTL_APICALL
2294 ctlGetCurrentSharpness(
2295     ctl_display_output_handle_t hDisplayOutput,     ///< [in][release] Handle to display output
2296     ctl_sharpness_settings_t* pSharpnessSettings    ///< [in,out][release] Query result for sharpness current settings
2297     );
2298
2299 ///////////////////////////////////////////////////////////////////////////////
2300 /// @brief Set Sharpness setting
2301 ///
2302 /// @details
2303 ///     - Set current sharpness settings
2304 ///
2305 /// @returns
2306 ///     - CTL_RESULT_SUCCESS
2307 ///     - CTL_RESULT_ERROR_UNINITIALIZED
2308 ///     - CTL_RESULT_ERROR_DEVICE_LOST
2309 ///     - CTL_RESULT_ERROR_INVALID_NULL_HANDLE
2310 ///         + `nullptr == hDisplayOutput`
2311 ///     - CTL_RESULT_ERROR_INVALID_NULL_POINTER
2312 ///         + `nullptr == pSharpnessSettings`
2313 ///     - ::CTL_RESULT_ERROR_UNSUPPORTED_VERSION - "Unsupported version"
2314 CTL_APIEXPORT ctl_result_t CTL_APICALL
2315 ctlSetCurrentSharpness(
2316     ctl_display_output_handle_t hDisplayOutput,     ///< [in][release] Handle to display output
2317     ctl_sharpness_settings_t* pSharpnessSettings    ///< [in][release] Set sharpness current settings
2318     );
2319
2320 ///////////////////////////////////////////////////////////////////////////////
2321 #ifndef CTL_I2C_MAX_DATA_SIZE
2322 /// @brief I2C Maximum data size
2323 #define CTL_I2C_MAX_DATA_SIZE  0x0080
2324 #endif // CTL_I2C_MAX_DATA_SIZE
2325
2326 ///////////////////////////////////////////////////////////////////////////////
2327 /// @brief I2CFlags bitmasks
2328 typedef uint32_t ctl_i2c_flags_t;
2329 typedef enum _ctl_i2c_flag_t
2330 {
2331     CTL_I2C_FLAG_ATOMICI2C = CTL_BIT(0),            ///< Force Atomic I2C
2332     CTL_I2C_FLAG_MAX = 0x80000000
2333
2334 } ctl_i2c_flag_t;
2335
2336 ///////////////////////////////////////////////////////////////////////////////
2337 /// @brief I2C access arguments
2338 typedef struct _ctl_i2c_access_args_t
2339 {
2340     uint32_t Size;                                  ///< [in] size of this structure
2341     uint8_t Version;                                ///< [in] version of this structure
2342     uint32_t DataSize;                              ///< [in,out] Valid data size
2343     uint32_t Address;                               ///< [in] Adreess to read or write
2344     ctl_operation_type_t OpType;                    ///< [in] Operation type, 1 for Read, 2 for Write, for Write operation, App
2345                                                     ///< needs to run with admin privileges
2346     uint32_t Offset;                                ///< [in] Offset
2347     ctl_i2c_flags_t Flags;                          ///< [in] I2C Flags. Refer ::ctl_i2c_flag_t
2348     uint64_t RAD;                                   ///< [in] RAD, For Future use, to be used for branch devices, Interface
2349                                                     ///< will be provided to get RAD
2350     uint8_t Data[CTL_I2C_MAX_DATA_SIZE];            ///< [in,out] Data array
2351
2352 } ctl_i2c_access_args_t;
2353
2354 ///////////////////////////////////////////////////////////////////////////////
2355 /// @brief I2C Access
2356 ///
2357 /// @details
2358 ///     - The application does I2C aceess
2359 ///
2360 /// @returns
2361 ///     - CTL_RESULT_SUCCESS
2362 ///     - CTL_RESULT_ERROR_UNINITIALIZED
2363 ///     - CTL_RESULT_ERROR_DEVICE_LOST
2364 ///     - CTL_RESULT_ERROR_INVALID_NULL_HANDLE
2365 ///         + `nullptr == hDisplayOutput`
2366 ///     - CTL_RESULT_ERROR_INVALID_NULL_POINTER
2367 ///         + `nullptr == pI2cAccessArgs`
2368 ///     - ::CTL_RESULT_ERROR_UNSUPPORTED_VERSION - "Unsupported version"
2369 ///     - ::CTL_RESULT_ERROR_INVALID_OPERATION_TYPE - "Invalid operation type"
2370 ///     - ::CTL_RESULT_ERROR_INVALID_SIZE - "Invalid I2C data size"
2371 ///     - ::CTL_RESULT_ERROR_INSUFFICIENT_PERMISSIONS - "Insufficient permissions"
2372 ///     - ::CTL_RESULT_ERROR_INVALID_NULL_POINTER - "Invalid null pointer"
2373 ///     - ::CTL_RESULT_ERROR_NULL_OS_DISPLAY_OUTPUT_HANDLE - "Null OS display output handle"
2374 ///     - ::CTL_RESULT_ERROR_NULL_OS_INTERFACE - "Null OS interface"
2375 ///     - ::CTL_RESULT_ERROR_NULL_OS_ADAPATER_HANDLE - "Null OS adapter handle"
2376 ///     - ::CTL_RESULT_ERROR_KMD_CALL - "Kernal mode driver call failure"
2377 CTL_APIEXPORT ctl_result_t CTL_APICALL
2378 ctlI2CAccess(
2379     ctl_display_output_handle_t hDisplayOutput,     ///< [in] Handle to display output
2380     ctl_i2c_access_args_t* pI2cAccessArgs           ///< [in,out] I2c access arguments
2381     );
2382
2383 ///////////////////////////////////////////////////////////////////////////////
2384 #ifndef CTL_AUX_MAX_DATA_SIZE
2385 /// @brief Aux Maximum data size
2386 #define CTL_AUX_MAX_DATA_SIZE  132
2387 #endif // CTL_AUX_MAX_DATA_SIZE
2388
2389 ///////////////////////////////////////////////////////////////////////////////
2390 /// @brief AUX Flags bitmasks
2391 typedef uint32_t ctl_aux_flags_t;
2392 typedef enum _ctl_aux_flag_t
2393 {
2394     CTL_AUX_FLAG_NATIVE_AUX = CTL_BIT(0),           ///< For Native AUX operation
2395     CTL_AUX_FLAG_I2C_AUX = CTL_BIT(1),              ///< For I2C AUX operation
2396     CTL_AUX_FLAG_I2C_AUX_MOT = CTL_BIT(2),          ///< For I2C AUX MOT operation
2397     CTL_AUX_FLAG_MAX = 0x80000000
2398
2399 } ctl_aux_flag_t;
2400
2401 ///////////////////////////////////////////////////////////////////////////////
2402 /// @brief AUX access arguments
2403 typedef struct _ctl_aux_access_args_t
2404 {
2405     uint32_t Size;                                  ///< [in] size of this structure
2406     uint8_t Version;                                ///< [in] version of this structure
2407     ctl_operation_type_t OpType;                    ///< [in] Operation type, 1 for Read, 2 for Write, for Write operation, App
2408                                                     ///< needs to run with admin privileges
2409     ctl_aux_flags_t Flags;                          ///< [in] Aux Flags. Refer ::ctl_aux_flag_t
2410     uint32_t Address;                               ///< [in] Adreess to read or write
2411     uint64_t RAD;                                   ///< [in] RAD, For Future use, to be used for branch devices, Interface
2412                                                     ///< will be provided to get RAD
2413     uint32_t PortID;                                ///< [in] Port ID, For Future use, to be used for SST tiled devices
2414     uint32_t DataSize;                              ///< [in,out] Valid data size
2415     uint8_t Data[CTL_AUX_MAX_DATA_SIZE];            ///< [in,out] Data array
2416
2417 } ctl_aux_access_args_t;
2418
2419 ///////////////////////////////////////////////////////////////////////////////
2420 /// @brief Aux Access
2421 ///
2422 /// @details
2423 ///     - The application does Aux aceess, PSR needs to be disabled for AUX
2424 ///       call.
2425 ///
2426 /// @returns
2427 ///     - CTL_RESULT_SUCCESS
2428 ///     - CTL_RESULT_ERROR_UNINITIALIZED
2429 ///     - CTL_RESULT_ERROR_DEVICE_LOST
2430 ///     - CTL_RESULT_ERROR_INVALID_NULL_HANDLE
2431 ///         + `nullptr == hDisplayOutput`
2432 ///     - CTL_RESULT_ERROR_INVALID_NULL_POINTER
2433 ///         + `nullptr == pAuxAccessArgs`
2434 ///     - ::CTL_RESULT_ERROR_UNSUPPORTED_VERSION - "Unsupported version"
2435 ///     - ::CTL_RESULT_ERROR_INVALID_OPERATION_TYPE - "Invalid operation type"
2436 ///     - ::CTL_RESULT_ERROR_INVALID_SIZE - "Invalid AUX data size"
2437 ///     - ::CTL_RESULT_ERROR_INSUFFICIENT_PERMISSIONS - "Insufficient permissions"
2438 ///     - ::CTL_RESULT_ERROR_INVALID_NULL_POINTER - "Invalid null pointer"
2439 ///     - ::CTL_RESULT_ERROR_NULL_OS_DISPLAY_OUTPUT_HANDLE - "Null OS display output handle"
2440 ///     - ::CTL_RESULT_ERROR_NULL_OS_INTERFACE - "Null OS interface"
2441 ///     - ::CTL_RESULT_ERROR_NULL_OS_ADAPATER_HANDLE - "Null OS adapter handle"
2442 ///     - ::CTL_RESULT_ERROR_INVALID_AUX_ACCESS_FLAG - "Invalid flag for AUX access"
2443 ///     - ::CTL_RESULT_ERROR_KMD_CALL - "Kernal mode driver call failure"
2444 CTL_APIEXPORT ctl_result_t CTL_APICALL
2445 ctlAUXAccess(
2446     ctl_display_output_handle_t hDisplayOutput,     ///< [in] Handle to display output
2447     ctl_aux_access_args_t* pAuxAccessArgs           ///< [in,out] Aux access arguments
2448     );
2449
2450 ///////////////////////////////////////////////////////////////////////////////
2451 /// @brief Power saving features (Each individual feature's set & get call can be
2452 ///        called only once at a time)
2453 typedef uint32_t ctl_power_optimization_flags_t;
2454 typedef enum _ctl_power_optimization_flag_t
2455 {
2456     CTL_POWER_OPTIMIZATION_FLAG_FBC = CTL_BIT(0),   ///< Frame buffer compression
2457     CTL_POWER_OPTIMIZATION_FLAG_PSR = CTL_BIT(1),   ///< Panel self refresh
2458     CTL_POWER_OPTIMIZATION_FLAG_DPST = CTL_BIT(2),  ///< Display power saving technology (Panel technology dependent)
2459     CTL_POWER_OPTIMIZATION_FLAG_LRR = CTL_BIT(3),   ///< Low refresh rate (LRR/ALRR/UBRR), UBRR is supported only for IGCC and
2460                                                     ///< NDA clients. UBZRR and UBLRR both can not be enabled at the same time,
2461                                                     ///< only one can be enabled at a given time
2462     CTL_POWER_OPTIMIZATION_FLAG_MAX = 0x80000000
2463
2464 } ctl_power_optimization_flag_t;
2465
2466 ///////////////////////////////////////////////////////////////////////////////
2467 /// @brief GPU/Panel/TCON dependent power optimization technology
2468 typedef uint32_t ctl_power_optimization_dpst_flags_t;
2469 typedef enum _ctl_power_optimization_dpst_flag_t
2470 {
2471     CTL_POWER_OPTIMIZATION_DPST_FLAG_BKLT = CTL_BIT(0), ///< Intel DPST with Backlight control
2472     CTL_POWER_OPTIMIZATION_DPST_FLAG_PANEL_CABC = CTL_BIT(1),   ///< Panel TCON specific Content Adaptive Control mechanism
2473     CTL_POWER_OPTIMIZATION_DPST_FLAG_OPST = CTL_BIT(2), ///< Intel OLED Power Saving Technology
2474     CTL_POWER_OPTIMIZATION_DPST_FLAG_ELP = CTL_BIT(3),  ///< TCON based Edge Luminance Profile
2475     CTL_POWER_OPTIMIZATION_DPST_FLAG_EPSM = CTL_BIT(4), ///< Extra power saving mode
2476     CTL_POWER_OPTIMIZATION_DPST_FLAG_MAX = 0x80000000
2477
2478 } ctl_power_optimization_dpst_flag_t;
2479
2480 ///////////////////////////////////////////////////////////////////////////////
2481 /// @brief Power Source
2482 typedef enum _ctl_power_source_t
2483 {
2484     CTL_POWER_SOURCE_AC = 0,                        ///< Power Source AC
2485     CTL_POWER_SOURCE_DC = 1,                        ///< Power Source DC
2486     CTL_POWER_SOURCE_MAX
2487
2488 } ctl_power_source_t;
2489
2490 ///////////////////////////////////////////////////////////////////////////////
2491 /// @brief Power Optimization Plan
2492 typedef enum _ctl_power_optimization_plan_t
2493 {
2494     CTL_POWER_OPTIMIZATION_PLAN_BALANCED = 0,       ///< Balanced mode
2495     CTL_POWER_OPTIMIZATION_PLAN_HIGH_PERFORMANCE = 1,   ///< High Performance Mode
2496     CTL_POWER_OPTIMIZATION_PLAN_POWER_SAVER = 2,    ///< Power Saver Mode
2497     CTL_POWER_OPTIMIZATION_PLAN_MAX
2498
2499 } ctl_power_optimization_plan_t;
2500
2501 ///////////////////////////////////////////////////////////////////////////////
2502 /// @brief Type of low refresh rate feature
2503 typedef uint32_t ctl_power_optimization_lrr_flags_t;
2504 typedef enum _ctl_power_optimization_lrr_flag_t
2505 {
2506     CTL_POWER_OPTIMIZATION_LRR_FLAG_LRR10 = CTL_BIT(0), ///< LRR 1.0
2507     CTL_POWER_OPTIMIZATION_LRR_FLAG_LRR20 = CTL_BIT(1), ///< LRR 2.0
2508     CTL_POWER_OPTIMIZATION_LRR_FLAG_LRR25 = CTL_BIT(2), ///< LRR 2.5
2509     CTL_POWER_OPTIMIZATION_LRR_FLAG_ALRR = CTL_BIT(3),  ///< Autonomous LRR
2510     CTL_POWER_OPTIMIZATION_LRR_FLAG_UBLRR = CTL_BIT(4), ///< User based low refresh rate
2511     CTL_POWER_OPTIMIZATION_LRR_FLAG_UBZRR = CTL_BIT(5), ///< User based zero refresh rate
2512     CTL_POWER_OPTIMIZATION_LRR_FLAG_MAX = 0x80000000
2513
2514 } ctl_power_optimization_lrr_flag_t;
2515
2516 ///////////////////////////////////////////////////////////////////////////////
2517 /// @brief Power optimization caps
2518 typedef struct _ctl_power_optimization_caps_t
2519 {
2520     uint32_t Size;                                  ///< [in] size of this structure
2521     uint8_t Version;                                ///< [in] version of this structure
2522     ctl_power_optimization_flags_t SupportedFeatures;   ///< [out] Supported power optimization features. Refer
2523                                                     ///< ::ctl_power_optimization_flag_t
2524
2525 } ctl_power_optimization_caps_t;
2526
2527 ///////////////////////////////////////////////////////////////////////////////
2528 /// @brief Get Power optimization features
2529 ///
2530 /// @details
2531 ///     - Returns power optimization capabilities
2532 ///
2533 /// @returns
2534 ///     - CTL_RESULT_SUCCESS
2535 ///     - CTL_RESULT_ERROR_UNINITIALIZED
2536 ///     - CTL_RESULT_ERROR_DEVICE_LOST
2537 ///     - CTL_RESULT_ERROR_INVALID_NULL_HANDLE
2538 ///         + `nullptr == hDisplayOutput`
2539 ///     - CTL_RESULT_ERROR_INVALID_NULL_POINTER
2540 ///         + `nullptr == pPowerOptimizationCaps`
2541 ///     - ::CTL_RESULT_ERROR_UNSUPPORTED_VERSION - "Unsupported version"
2542 CTL_APIEXPORT ctl_result_t CTL_APICALL
2543 ctlGetPowerOptimizationCaps(
2544     ctl_display_output_handle_t hDisplayOutput,     ///< [in][release] Handle to display output
2545     ctl_power_optimization_caps_t* pPowerOptimizationCaps   ///< [in,out][release] Query result for power optimization features
2546     );
2547
2548 ///////////////////////////////////////////////////////////////////////////////
2549 /// @brief LRR detailed settings
2550 typedef struct _ctl_power_optimization_lrr_t
2551 {
2552     uint32_t Size;                                  ///< [in] size of this structure
2553     uint8_t Version;                                ///< [in] version of this structure
2554     ctl_power_optimization_lrr_flags_t SupportedLRRTypes;   ///< [out] LRR type(s). Refer ::ctl_power_optimization_lrr_flag_t
2555     ctl_power_optimization_lrr_flags_t CurrentLRRTypes; ///< [in,out] Current enabled LRR type(s) or the LRR type(s) to set to.
2556                                                     ///< Refer ::ctl_power_optimization_lrr_flag_t
2557     bool bRequirePSRDisable;                        ///< [out] Require PSR disable for any change in the selected LRR feature.
2558                                                     ///< Caller can re-enable PSR once the respective LRR feature is
2559                                                     ///< enable/disabled. E.g. for UBRR based on platform this flag may not be
2560                                                     ///< set in which case caller doesn't need to do an explicit PSR disable
2561     uint16_t LowRR;                                 ///< [out] Lowest RR used for LRR functionality if known to source
2562
2563 } ctl_power_optimization_lrr_t;
2564
2565 ///////////////////////////////////////////////////////////////////////////////
2566 /// @brief PSR detailed settings
2567 typedef struct _ctl_power_optimization_psr_t
2568 {
2569     uint32_t Size;                                  ///< [in] size of this structure
2570     uint8_t Version;                                ///< [in] version of this structure
2571     uint8_t PSRVersion;                             ///< [in,out] A value of 1 means PSR1, 2 means PSR2
2572     bool FullFetchUpdate;                           ///< [in,out] Full fetch and update
2573
2574 } ctl_power_optimization_psr_t;
2575
2576 ///////////////////////////////////////////////////////////////////////////////
2577 /// @brief DPST detailed settings
2578 typedef struct _ctl_power_optimization_dpst_t
2579 {
2580     uint32_t Size;                                  ///< [in] size of this structure
2581     uint8_t Version;                                ///< [in] version of this structure
2582     uint8_t MinLevel;                               ///< [out] Minimum supported aggressiveness level
2583     uint8_t MaxLevel;                               ///< [out] Maximum supported aggressiveness level
2584     uint8_t Level;                                  ///< [in,out] Current aggressiveness level to be set
2585     ctl_power_optimization_dpst_flags_t SupportedFeatures;  ///< [out] Supported features
2586     ctl_power_optimization_dpst_flags_t EnabledFeatures;///< [in,out] Features enabled or to be enabled
2587
2588 } ctl_power_optimization_dpst_t;
2589
2590 ///////////////////////////////////////////////////////////////////////////////
2591 /// @brief Feature specific power optimization data
2592 typedef union _ctl_power_optimization_feature_specific_info_t
2593 {
2594     ctl_power_optimization_lrr_t LRRInfo;           ///< [out] LRR info
2595     ctl_power_optimization_psr_t PSRInfo;           ///< [in,out] PSR info
2596     ctl_power_optimization_dpst_t DPSTInfo;         ///< [in,out] DPST info
2597
2598 } ctl_power_optimization_feature_specific_info_t;
2599
2600 ///////////////////////////////////////////////////////////////////////////////
2601 /// @brief Power optimization settings
2602 typedef struct _ctl_power_optimization_settings_t
2603 {
2604     uint32_t Size;                                  ///< [in] size of this structure
2605     uint8_t Version;                                ///< [in] version of this structure
2606     ctl_power_optimization_plan_t PowerOptimizationPlan;///< [in] Power optimization power plan (max power/max perf/balanced)
2607     ctl_power_optimization_flags_t PowerOptimizationFeature;///< [in] Power optimization feature interested in. Refer
2608                                                     ///< ::ctl_power_optimization_flag_t
2609     bool Enable;                                    ///< [in,out] Enable state
2610     ctl_power_optimization_feature_specific_info_t FeatureSpecificData; ///< [in,out] Data specific to the feature caller is interested in
2611     ctl_power_source_t PowerSource;                 ///< [in] AC/DC
2612
2613 } ctl_power_optimization_settings_t;
2614
2615 ///////////////////////////////////////////////////////////////////////////////
2616 /// @brief Brightness settings for SET call
2617 typedef struct _ctl_set_brightness_t
2618 {
2619     uint32_t Size;                                  ///< [in] size of this structure
2620     uint8_t Version;                                ///< [in] version of this structure
2621     uint32_t TargetBrightness;                      ///< [in] The brightness level that the display need to transitioning to in
2622                                                     ///< milli-percentage. Range is 0-100000 (100%)
2623     uint32_t SmoothTransitionTimeInMs;              ///< [in] Transition Time for brightness to take effect in milli-seconds.
2624                                                     ///< If its 0 then it will be an immediate change. Maximum possible value
2625                                                     ///< is 1000ms.
2626     uint32_t ReservedFields[4];                     ///< [in] Reserved for future use
2627
2628 } ctl_set_brightness_t;
2629
2630 ///////////////////////////////////////////////////////////////////////////////
2631 /// @brief Brightness settings for GET call
2632 typedef struct _ctl_get_brightness_t
2633 {
2634     uint32_t Size;                                  ///< [in] size of this structure
2635     uint8_t Version;                                ///< [in] version of this structure
2636     uint32_t TargetBrightness;                      ///< [out] The brightness level that the display is currently transitioning
2637                                                     ///< to in milli-percentage. If not in a transition, this should equal the
2638                                                     ///< current brightness. Range is 0-100000 (100%)
2639     uint32_t CurrentBrightness;                     ///< [out] The current brightness level of the display in milli-percentage
2640     uint32_t ReservedFields[4];                     ///< [out] Reserved for future use
2641
2642 } ctl_get_brightness_t;
2643
2644 ///////////////////////////////////////////////////////////////////////////////
2645 /// @brief Get Power optimization setting
2646 ///
2647 /// @details
2648 ///     - Returns power optimization setting for a specific feature
2649 ///
2650 /// @returns
2651 ///     - CTL_RESULT_SUCCESS
2652 ///     - CTL_RESULT_ERROR_UNINITIALIZED
2653 ///     - CTL_RESULT_ERROR_DEVICE_LOST
2654 ///     - CTL_RESULT_ERROR_INVALID_NULL_HANDLE
2655 ///         + `nullptr == hDisplayOutput`
2656 ///     - CTL_RESULT_ERROR_INVALID_NULL_POINTER
2657 ///         + `nullptr == pPowerOptimizationSettings`
2658 ///     - ::CTL_RESULT_ERROR_UNSUPPORTED_VERSION - "Unsupported version"
2659 ///     - ::CTL_RESULT_ERROR_INVALID_POWERFEATURE_OPTIMIZATION_FLAG - "Unsupported PowerOptimizationFeature"
2660 ///     - ::CTL_RESULT_ERROR_INVALID_POWERSOURCE_TYPE_FOR_DPST - "DPST is supported only in DC Mode"
2661 CTL_APIEXPORT ctl_result_t CTL_APICALL
2662 ctlGetPowerOptimizationSetting(
2663     ctl_display_output_handle_t hDisplayOutput,     ///< [in][release] Handle to display output
2664     ctl_power_optimization_settings_t* pPowerOptimizationSettings   ///< [in,out][release] Power optimization data to be fetched
2665     );
2666
2667 ///////////////////////////////////////////////////////////////////////////////
2668 /// @brief Set Power optimization setting
2669 ///
2670 /// @details
2671 ///     - Set power optimization setting for a specific feature
2672 ///
2673 /// @returns
2674 ///     - CTL_RESULT_SUCCESS
2675 ///     - CTL_RESULT_ERROR_UNINITIALIZED
2676 ///     - CTL_RESULT_ERROR_DEVICE_LOST
2677 ///     - CTL_RESULT_ERROR_INVALID_NULL_HANDLE
2678 ///         + `nullptr == hDisplayOutput`
2679 ///     - CTL_RESULT_ERROR_INVALID_NULL_POINTER
2680 ///         + `nullptr == pPowerOptimizationSettings`
2681 ///     - ::CTL_RESULT_ERROR_UNSUPPORTED_VERSION - "Unsupported version"
2682 ///     - ::CTL_RESULT_ERROR_INVALID_POWERFEATURE_OPTIMIZATION_FLAG - "Unsupported PowerOptimizationFeature"
2683 ///     - ::CTL_RESULT_ERROR_INVALID_POWERSOURCE_TYPE_FOR_DPST - "DPST is supported only in DC Mode"
2684 CTL_APIEXPORT ctl_result_t CTL_APICALL
2685 ctlSetPowerOptimizationSetting(
2686     ctl_display_output_handle_t hDisplayOutput,     ///< [in][release] Handle to display output
2687     ctl_power_optimization_settings_t* pPowerOptimizationSettings   ///< [in][release] Power optimization data to be applied
2688     );
2689
2690 ///////////////////////////////////////////////////////////////////////////////
2691 /// @brief Set Brightness on companion display
2692 ///
2693 /// @details
2694 ///     - Set Brightness for a target display. Currently support is only for
2695 ///       companion display.
2696 ///
2697 /// @returns
2698 ///     - CTL_RESULT_SUCCESS
2699 ///     - CTL_RESULT_ERROR_UNINITIALIZED
2700 ///     - CTL_RESULT_ERROR_DEVICE_LOST
2701 ///     - CTL_RESULT_ERROR_INVALID_NULL_HANDLE
2702 ///         + `nullptr == hDisplayOutput`
2703 ///     - CTL_RESULT_ERROR_INVALID_NULL_POINTER
2704 ///         + `nullptr == pSetBrightnessSetting`
2705 ///     - ::CTL_RESULT_ERROR_UNSUPPORTED_VERSION - "Unsupported version"
2706 ///     - ::CTL_RESULT_ERROR_INVALID_ARGUMENT - "Invalid Brightness data passed as argument"
2707 ///     - ::CTL_RESULT_ERROR_DISPLAY_NOT_ACTIVE - "Display not active"
2708 ///     - ::CTL_RESULT_ERROR_INVALID_OPERATION_TYPE - "Currently Brightness API is supported only on companion display"
2709 CTL_APIEXPORT ctl_result_t CTL_APICALL
2710 ctlSetBrightnessSetting(
2711     ctl_display_output_handle_t hDisplayOutput,     ///< [in][release] Handle to display output
2712     ctl_set_brightness_t* pSetBrightnessSetting     ///< [in][release] Brightness settings to be applied
2713     );
2714
2715 ///////////////////////////////////////////////////////////////////////////////
2716 /// @brief Get Brightness setting
2717 ///
2718 /// @details
2719 ///     - Get Brightness for a target display. Currently support is only for
2720 ///       companion display.
2721 ///
2722 /// @returns
2723 ///     - CTL_RESULT_SUCCESS
2724 ///     - CTL_RESULT_ERROR_UNINITIALIZED
2725 ///     - CTL_RESULT_ERROR_DEVICE_LOST
2726 ///     - CTL_RESULT_ERROR_INVALID_NULL_HANDLE
2727 ///         + `nullptr == hDisplayOutput`
2728 ///     - CTL_RESULT_ERROR_INVALID_NULL_POINTER
2729 ///         + `nullptr == pGetBrightnessSetting`
2730 ///     - ::CTL_RESULT_ERROR_UNSUPPORTED_VERSION - "Unsupported version"
2731 ///     - ::CTL_RESULT_ERROR_DISPLAY_NOT_ACTIVE - "Display not active"
2732 ///     - ::CTL_RESULT_ERROR_INVALID_OPERATION_TYPE - "Currently Brightness API is supported only on companion display"
2733 CTL_APIEXPORT ctl_result_t CTL_APICALL
2734 ctlGetBrightnessSetting(
2735     ctl_display_output_handle_t hDisplayOutput,     ///< [in][release] Handle to display output
2736     ctl_get_brightness_t* pGetBrightnessSetting     ///< [out][release] Brightness settings data to be fetched
2737     );
2738
2739 ///////////////////////////////////////////////////////////////////////////////
2740 #ifndef CTL_MAX_NUM_SAMPLES_PER_CHANNEL_1D_LUT
2741 /// @brief Maximum number of samples per channel 1D LUT
2742 #define CTL_MAX_NUM_SAMPLES_PER_CHANNEL_1D_LUT  8192
2743 #endif // CTL_MAX_NUM_SAMPLES_PER_CHANNEL_1D_LUT
2744
2745 ///////////////////////////////////////////////////////////////////////////////
2746 /// @brief Pixtx pipe set configuration flags bitmasks
2747 typedef uint32_t ctl_pixtx_pipe_set_config_flags_t;
2748 typedef enum _ctl_pixtx_pipe_set_config_flag_t
2749 {
2750     CTL_PIXTX_PIPE_SET_CONFIG_FLAG_PERSIST_ACROSS_POWER_EVENTS = CTL_BIT(0),///< For maintaining persistance across power events
2751     CTL_PIXTX_PIPE_SET_CONFIG_FLAG_MAX = 0x80000000
2752
2753 } ctl_pixtx_pipe_set_config_flag_t;
2754
2755 ///////////////////////////////////////////////////////////////////////////////
2756 /// @brief Pixel transformation block types
2757 typedef enum _ctl_pixtx_block_type_t
2758 {
2759     CTL_PIXTX_BLOCK_TYPE_1D_LUT = 1,                ///< Block type 1D LUT
2760     CTL_PIXTX_BLOCK_TYPE_3D_LUT = 2,                ///< Block type 3D LUT
2761     CTL_PIXTX_BLOCK_TYPE_3X3_MATRIX = 3,            ///< Block type 3x3 matrix
2762     CTL_PIXTX_BLOCK_TYPE_3X3_MATRIX_AND_OFFSETS = 4,///< Block type 3x3 matrix and offsets
2763     CTL_PIXTX_BLOCK_TYPE_MAX
2764
2765 } ctl_pixtx_block_type_t;
2766
2767 ///////////////////////////////////////////////////////////////////////////////
2768 /// @brief Pixel transformation LUT sampling types
2769 typedef enum _ctl_pixtx_lut_sampling_type_t
2770 {
2771     CTL_PIXTX_LUT_SAMPLING_TYPE_UNIFORM = 0,        ///< Uniform LUT sampling
2772     CTL_PIXTX_LUT_SAMPLING_TYPE_NONUNIFORM = 1,     ///< Non uniform LUT sampling, Required mainly in HDR mode
2773     CTL_PIXTX_LUT_SAMPLING_TYPE_MAX
2774
2775 } ctl_pixtx_lut_sampling_type_t;
2776
2777 ///////////////////////////////////////////////////////////////////////////////
2778 /// @brief Configuration query types
2779 typedef enum _ctl_pixtx_config_query_type_t
2780 {
2781     CTL_PIXTX_CONFIG_QUERY_TYPE_CAPABILITY = 0,     ///< Get complete pixel processing pipeline capability
2782     CTL_PIXTX_CONFIG_QUERY_TYPE_CURRENT = 1,        ///< Get the configuration set through last set call
2783     CTL_PIXTX_CONFIG_QUERY_TYPE_MAX
2784
2785 } ctl_pixtx_config_query_type_t;
2786
2787 ///////////////////////////////////////////////////////////////////////////////
2788 /// @brief Configuration operation types
2789 typedef enum _ctl_pixtx_config_opertaion_type_t
2790 {
2791     CTL_PIXTX_CONFIG_OPERTAION_TYPE_RESTORE_DEFAULT = 1,///< Restore block by block or entire pipe line. Use NumBlocks = 0 to
2792                                                     ///< restore all.
2793     CTL_PIXTX_CONFIG_OPERTAION_TYPE_SET_CUSTOM = 2, ///< Custom LUT or matrix can be set thorugh this option.
2794     CTL_PIXTX_CONFIG_OPERTAION_TYPE_MAX
2795
2796 } ctl_pixtx_config_opertaion_type_t;
2797
2798 ///////////////////////////////////////////////////////////////////////////////
2799 /// @brief Pixel transformation gamma encoding types
2800 typedef enum _ctl_pixtx_gamma_encoding_type_t
2801 {
2802     CTL_PIXTX_GAMMA_ENCODING_TYPE_SRGB = 0,         ///< Gamma encoding SRGB
2803     CTL_PIXTX_GAMMA_ENCODING_TYPE_REC709 = 1,       ///< Gamma encoding REC709, Applicable for REC2020 as well
2804     CTL_PIXTX_GAMMA_ENCODING_TYPE_ST2084 = 2,       ///< Gamma encoding ST2084
2805     CTL_PIXTX_GAMMA_ENCODING_TYPE_HLG = 3,          ///< Gamma encoding HLG
2806     CTL_PIXTX_GAMMA_ENCODING_TYPE_LINEAR = 4,       ///< Gamma encoding linear
2807     CTL_PIXTX_GAMMA_ENCODING_TYPE_MAX
2808
2809 } ctl_pixtx_gamma_encoding_type_t;
2810
2811 ///////////////////////////////////////////////////////////////////////////////
2812 /// @brief Pixel transformation color space types
2813 typedef enum _ctl_pixtx_color_space_t
2814 {
2815     CTL_PIXTX_COLOR_SPACE_REC709 = 0,               ///< Color space REC709
2816     CTL_PIXTX_COLOR_SPACE_REC2020 = 1,              ///< Color space REC2020
2817     CTL_PIXTX_COLOR_SPACE_ADOBE_RGB = 2,            ///< Color space AdobeRGB
2818     CTL_PIXTX_COLOR_SPACE_P3_D65 = 3,               ///< Color space P3_D65
2819     CTL_PIXTX_COLOR_SPACE_P3_DCI = 4,               ///< Color space P3_DCI
2820     CTL_PIXTX_COLOR_SPACE_P3_D60 = 5,               ///< Color space P3_D60
2821     CTL_PIXTX_COLOR_SPACE_CUSTOM = 0xFFFF,          ///< Color space custom, Refer ::ctl_pixtx_color_primaries_t for color
2822                                                     ///< primary details
2823     CTL_PIXTX_COLOR_SPACE_MAX
2824
2825 } ctl_pixtx_color_space_t;
2826
2827 ///////////////////////////////////////////////////////////////////////////////
2828 /// @brief Pixel transformation color model types
2829 typedef enum _ctl_pixtx_color_model_t
2830 {
2831     CTL_PIXTX_COLOR_MODEL_RGB_FR = 0,               ///< Color model RGB full range
2832     CTL_PIXTX_COLOR_MODEL_RGB_LR = 1,               ///< Color model RGB limited range
2833     CTL_PIXTX_COLOR_MODEL_YCBCR_422_FR = 2,         ///< Color model YCBCR 422 full range
2834     CTL_PIXTX_COLOR_MODEL_YCBCR_422_LR = 3,         ///< Color model YCBCR 422 limited range
2835     CTL_PIXTX_COLOR_MODEL_YCBCR_420_FR = 4,         ///< Color model YCBCR 420 full range
2836     CTL_PIXTX_COLOR_MODEL_YCBCR_420_LR = 5,         ///< Color model YCBCR 420 limited range
2837     CTL_PIXTX_COLOR_MODEL_MAX
2838
2839 } ctl_pixtx_color_model_t;
2840
2841 ///////////////////////////////////////////////////////////////////////////////
2842 /// @brief Pixel transformation color primaries
2843 typedef struct _ctl_pixtx_color_primaries_t
2844 {
2845     uint32_t Size;                                  ///< [in] size of this structure
2846     uint8_t Version;                                ///< [in] version of this structure
2847     double xR;                                      ///< [out] CIE1931 x value with maximum red pixel value
2848     double yR;                                      ///< [out] CIE1931 y value with maximum red pixel value
2849     double xG;                                      ///< [out] CIE1931 x value with maximum green pixel value
2850     double yG;                                      ///< [out] CIE1931 y value with maximum green pixel value
2851     double xB;                                      ///< [out] CIE1931 x value with maximum blue pixel value
2852     double yB;                                      ///< [out] CIE1931 y value with maximum blue pixel value
2853     double xW;                                      ///< [out] CIE1931 x value with maximum white pixel value
2854     double yW;                                      ///< [out] CIE1931 y value with maximum white pixel value
2855
2856 } ctl_pixtx_color_primaries_t;
2857
2858 ///////////////////////////////////////////////////////////////////////////////
2859 /// @brief Pixel transformation pixel format
2860 typedef struct _ctl_pixtx_pixel_format_t
2861 {
2862     uint32_t Size;                                  ///< [in] size of this structure
2863     uint8_t Version;                                ///< [in] version of this structure
2864     uint32_t BitsPerColor;                          ///< [out] Bits per color, It Will be 16 for FP16 case
2865     bool IsFloat;                                   ///< [out] Will be set for FP16 or other floating point encoding schemes
2866     ctl_pixtx_gamma_encoding_type_t EncodingType;   ///< [out] Encoding type
2867     ctl_pixtx_color_space_t ColorSpace;             ///< [out] Color space
2868     ctl_pixtx_color_model_t ColorModel;             ///< [out] Color model
2869     ctl_pixtx_color_primaries_t ColorPrimaries;     ///< [out] Color primaries, Used mainly for custom color space
2870     double MaxBrightness;                           ///< [out] Maximum brightness of pixel values. If no input is given,
2871                                                     ///< default will be set to sRGB during set call. If panel capability is
2872                                                     ///< not known get call will default to sRGB.
2873     double MinBrightness;                           ///< [out] Minimum brightness of pixel values
2874
2875 } ctl_pixtx_pixel_format_t;
2876
2877 ///////////////////////////////////////////////////////////////////////////////
2878 /// @brief Pixel transformation 1D LUT configuration
2879 typedef struct _ctl_pixtx_1dlut_config_t
2880 {
2881     uint32_t Size;                                  ///< [in] size of this structure
2882     uint8_t Version;                                ///< [in] version of this structure
2883     ctl_pixtx_lut_sampling_type_t SamplingType;     ///< [in,out] Blocks with non-uniform sampling capability support unifrom
2884                                                     ///< sampling also but not vice versa.
2885     uint32_t NumSamplesPerChannel;                  ///< [in,out] Number of samples per channel. Resampled internally based on
2886                                                     ///< HW capability for uniformly sampled LUT.Maximum supported value is
2887                                                     ///< ::CTL_MAX_NUM_SAMPLES_PER_CHANNEL_1D_LUT Caller needs to use exact
2888                                                     ///< sampling position given in pSamplePositions for non-uniformly sampled
2889                                                     ///< LUTs.
2890     uint32_t NumChannels;                           ///< [in,out] Number of channels, 1 for Grey scale LUT, 3 for RGB LUT
2891     double* pSampleValues;                          ///< [in,out] Pointer to sample values, R array followed by G and B arrays
2892                                                     ///< in case of multi-channel LUT. Allocation size for pSampleValues should
2893                                                     ///< be NumSamplesPerChannel * NumChannels * sizeof(double)
2894     double* pSamplePositions;                       ///< [out] LUT (same for all channels) to represent sampling positions for
2895                                                     ///< non-uniformly sampled LUTs.Can be NULL in case uniformly sampled LUTs
2896
2897 } ctl_pixtx_1dlut_config_t;
2898
2899 ///////////////////////////////////////////////////////////////////////////////
2900 /// @brief Pixel transformation matrix configuration
2901 typedef struct _ctl_pixtx_matrix_config_t
2902 {
2903     uint32_t Size;                                  ///< [in] size of this structure
2904     uint8_t Version;                                ///< [in] version of this structure
2905     double PreOffsets[3];                           ///< [in,out] Pre offsets
2906     double PostOffsets[3];                          ///< [in,out] Post offsets
2907     double Matrix[3][3];                            ///< [in,out] 3x3 Matrix
2908
2909 } ctl_pixtx_matrix_config_t;
2910
2911 ///////////////////////////////////////////////////////////////////////////////
2912 /// @brief Pixel transformation 3D LUT sample. Samples are converted to integer
2913 ///        based on underlying HW capabilities. Hence slight precision loss will
2914 ///        be observed while getting sample values.
2915 typedef struct _ctl_pixtx_3dlut_sample_t
2916 {
2917     double Red;                                     ///< [in,out] Red output value
2918     double Green;                                   ///< [in,out] Green output value
2919     double Blue;                                    ///< [in,out] Blue output value
2920
2921 } ctl_pixtx_3dlut_sample_t;
2922
2923 ///////////////////////////////////////////////////////////////////////////////
2924 /// @brief Pixel transformation 3D LUT configuration
2925 typedef struct _ctl_pixtx_3dlut_config_t
2926 {
2927     uint32_t Size;                                  ///< [in] size of this structure
2928     uint8_t Version;                                ///< [in] version of this structure
2929     uint32_t NumSamplesPerChannel;                  ///< [in,out] Number of samples per channel
2930     ctl_pixtx_3dlut_sample_t* pSampleValues;        ///< [in,out] Pointer to sample values, R in outer most loop followed by G
2931                                                     ///< and B
2932
2933 } ctl_pixtx_3dlut_config_t;
2934
2935 ///////////////////////////////////////////////////////////////////////////////
2936 /// @brief Pixel transformation configuration
2937 typedef union _ctl_pixtx_config_t
2938 {
2939     ctl_pixtx_1dlut_config_t OneDLutConfig;         ///< [in,out] 1D LUT configuration
2940     ctl_pixtx_3dlut_config_t ThreeDLutConfig;       ///< [in,out] 3D LUT configuration
2941     ctl_pixtx_matrix_config_t MatrixConfig;         ///< [in,out] Matrix configuration
2942
2943 } ctl_pixtx_config_t;
2944
2945 ///////////////////////////////////////////////////////////////////////////////
2946 /// @brief Pixel transformation block configuration
2947 typedef struct _ctl_pixtx_block_config_t
2948 {
2949     uint32_t Size;                                  ///< [in] size of this structure
2950     uint8_t Version;                                ///< [in] version of this structure
2951     uint32_t BlockId;                               ///< [in,out] Unique ID for each pixel processing block. Id for a block is
2952                                                     ///< fixed for a platform.
2953     ctl_pixtx_block_type_t BlockType;               ///< [in,out] Block type
2954     ctl_pixtx_config_t Config;                      ///< [in,out] Configuration
2955
2956 } ctl_pixtx_block_config_t;
2957
2958 ///////////////////////////////////////////////////////////////////////////////
2959 /// @brief Pixel transformation pipe get configuration
2960 typedef struct _ctl_pixtx_pipe_get_config_t
2961 {
2962     uint32_t Size;                                  ///< [in] size of this structure
2963     uint8_t Version;                                ///< [in] version of this structure
2964     ctl_pixtx_config_query_type_t QueryType;        ///< [in] Query operation type
2965     ctl_pixtx_pixel_format_t InputPixelFormat;      ///< [out] Input pixel format
2966     ctl_pixtx_pixel_format_t OutputPixelFormat;     ///< [out] Output pixel format
2967     uint32_t NumBlocks;                             ///< [out] Number of blocks
2968     ctl_pixtx_block_config_t* pBlockConfigs;        ///< [out] Pointer to specific configs
2969
2970 } ctl_pixtx_pipe_get_config_t;
2971
2972 ///////////////////////////////////////////////////////////////////////////////
2973 /// @brief Pixel transformation pipe set configuration
2974 typedef struct _ctl_pixtx_pipe_set_config_t
2975 {
2976     uint32_t Size;                                  ///< [in] size of this structure
2977     uint8_t Version;                                ///< [in] version of this structure
2978     ctl_pixtx_config_opertaion_type_t OpertaionType;///< [in] Set operation type
2979     ctl_pixtx_pipe_set_config_flags_t Flags;        ///< [in] Config flags. Refer ::ctl_pixtx_pipe_set_config_flag_t
2980     uint32_t NumBlocks;                             ///< [in] Number of blocks
2981     ctl_pixtx_block_config_t* pBlockConfigs;        ///< [in,out] Array of block specific configs
2982
2983 } ctl_pixtx_pipe_set_config_t;
2984
2985 ///////////////////////////////////////////////////////////////////////////////
2986 /// @brief Pixel transformation get pipe configuration
2987 ///
2988 /// @details
2989 ///     - The application does pixel transformation get pipe configuration
2990 ///
2991 /// @returns
2992 ///     - CTL_RESULT_SUCCESS
2993 ///     - CTL_RESULT_ERROR_UNINITIALIZED
2994 ///     - CTL_RESULT_ERROR_DEVICE_LOST
2995 ///     - CTL_RESULT_ERROR_INVALID_NULL_HANDLE
2996 ///         + `nullptr == hDisplayOutput`
2997 ///     - CTL_RESULT_ERROR_INVALID_NULL_POINTER
2998 ///         + `nullptr == pPixTxGetConfigArgs`
2999 ///     - ::CTL_RESULT_ERROR_UNSUPPORTED_VERSION - "Unsupported version"
3000 ///     - ::CTL_RESULT_ERROR_INSUFFICIENT_PERMISSIONS - "Insufficient permissions"
3001 ///     - ::CTL_RESULT_ERROR_INVALID_NULL_POINTER - "Invalid null pointer"
3002 ///     - ::CTL_RESULT_ERROR_NULL_OS_DISPLAY_OUTPUT_HANDLE - "Null OS display output handle"
3003 ///     - ::CTL_RESULT_ERROR_NULL_OS_INTERFACE - "Null OS interface"
3004 ///     - ::CTL_RESULT_ERROR_NULL_OS_ADAPATER_HANDLE - "Null OS adapter handle"
3005 ///     - ::CTL_RESULT_ERROR_KMD_CALL - "Kernal mode driver call failure"
3006 ///     - ::CTL_RESULT_ERROR_INVALID_PIXTX_GET_CONFIG_QUERY_TYPE - "Invalid query type"
3007 ///     - ::CTL_RESULT_ERROR_INVALID_PIXTX_BLOCK_ID - "Invalid block id"
3008 ///     - ::CTL_RESULT_ERROR_INSUFFICIENT_PIXTX_BLOCK_CONFIG_MEMORY - "Insufficient memery allocated for BlockConfigs"
3009 ///     - ::CTL_RESULT_ERROR_3DLUT_INVALID_PIPE - "Invalid pipe for 3dlut"
3010 ///     - ::CTL_RESULT_ERROR_3DLUT_INVALID_DATA - "Invalid 3dlut data"
3011 ///     - ::CTL_RESULT_ERROR_3DLUT_NOT_SUPPORTED_IN_HDR - "3dlut not supported in HDR"
3012 ///     - ::CTL_RESULT_ERROR_3DLUT_INVALID_OPERATION - "Invalid 3dlut operation"
3013 ///     - ::CTL_RESULT_ERROR_3DLUT_UNSUCCESSFUL - "3dlut call unsuccessful"
3014 CTL_APIEXPORT ctl_result_t CTL_APICALL
3015 ctlPixelTransformationGetConfig(
3016     ctl_display_output_handle_t hDisplayOutput,     ///< [in] Handle to display output
3017     ctl_pixtx_pipe_get_config_t* pPixTxGetConfigArgs///< [in,out] Pixel transformation get pipe configiguration arguments
3018     );
3019
3020 ///////////////////////////////////////////////////////////////////////////////
3021 /// @brief Pixel transformation set pipe configuration
3022 ///
3023 /// @details
3024 ///     - The application does pixel transformation set pipe configuration
3025 ///
3026 /// @returns
3027 ///     - CTL_RESULT_SUCCESS
3028 ///     - CTL_RESULT_ERROR_UNINITIALIZED
3029 ///     - CTL_RESULT_ERROR_DEVICE_LOST
3030 ///     - CTL_RESULT_ERROR_INVALID_NULL_HANDLE
3031 ///         + `nullptr == hDisplayOutput`
3032 ///     - CTL_RESULT_ERROR_INVALID_NULL_POINTER
3033 ///         + `nullptr == pPixTxSetConfigArgs`
3034 ///     - ::CTL_RESULT_ERROR_UNSUPPORTED_VERSION - "Unsupported version"
3035 ///     - ::CTL_RESULT_ERROR_INSUFFICIENT_PERMISSIONS - "Insufficient permissions"
3036 ///     - ::CTL_RESULT_ERROR_INVALID_NULL_POINTER - "Invalid null pointer"
3037 ///     - ::CTL_RESULT_ERROR_NULL_OS_DISPLAY_OUTPUT_HANDLE - "Null OS display output handle"
3038 ///     - ::CTL_RESULT_ERROR_NULL_OS_INTERFACE - "Null OS interface"
3039 ///     - ::CTL_RESULT_ERROR_NULL_OS_ADAPATER_HANDLE - "Null OS adapter handle"
3040 ///     - ::CTL_RESULT_ERROR_KMD_CALL - "Kernal mode driver call failure"
3041 ///     - ::CTL_RESULT_ERROR_INVALID_PIXTX_SET_CONFIG_OPERATION_TYPE - "Invalid operation type"
3042 ///     - ::CTL_RESULT_ERROR_INVALID_SET_CONFIG_NUMBER_OF_SAMPLES - "Invalid number of samples"
3043 ///     - ::CTL_RESULT_ERROR_INVALID_PIXTX_BLOCK_ID - "Invalid block id"
3044 ///     - ::CTL_RESULT_ERROR_PERSISTANCE_NOT_SUPPORTED - "Persistance not supported"
3045 ///     - ::CTL_RESULT_ERROR_3DLUT_INVALID_PIPE - "Invalid pipe for 3dlut"
3046 ///     - ::CTL_RESULT_ERROR_3DLUT_INVALID_DATA - "Invalid 3dlut data"
3047 ///     - ::CTL_RESULT_ERROR_3DLUT_NOT_SUPPORTED_IN_HDR - "3dlut not supported in HDR"
3048 ///     - ::CTL_RESULT_ERROR_3DLUT_INVALID_OPERATION - "Invalid 3dlut operation"
3049 ///     - ::CTL_RESULT_ERROR_3DLUT_UNSUCCESSFUL - "3dlut call unsuccessful"
3050 CTL_APIEXPORT ctl_result_t CTL_APICALL
3051 ctlPixelTransformationSetConfig(
3052     ctl_display_output_handle_t hDisplayOutput,     ///< [in] Handle to display output
3053     ctl_pixtx_pipe_set_config_t* pPixTxSetConfigArgs///< [in,out] Pixel transformation set pipe configiguration arguments
3054     );
3055
3056 ///////////////////////////////////////////////////////////////////////////////
3057 /// @brief Panel descriptor access arguments
3058 typedef struct _ctl_panel_descriptor_access_args_t
3059 {
3060     uint32_t Size;                                  ///< [in] size of this structure
3061     uint8_t Version;                                ///< [in] version of this structure
3062     ctl_operation_type_t OpType;                    ///< [in] Operation type, 1 for Read, 2 for Write. App needs to run with
3063                                                     ///< admin privileges for Write operation, Currently only Read operation is
3064                                                     ///< supported
3065     uint32_t BlockNumber;                           ///< [in] Block number, Need to provide only if acccessing EDID
3066     uint32_t DescriptorDataSize;                    ///< [in] Descriptor data size, Should be 0 for querying the size and
3067                                                     ///< should be DescriptorDataSize derived from query call otherwise
3068     uint8_t* pDescriptorData;                       ///< [in,out] Panel descriptor data
3069
3070 } ctl_panel_descriptor_access_args_t;
3071
3072 ///////////////////////////////////////////////////////////////////////////////
3073 /// @brief Panel Descriptor Access
3074 ///
3075 /// @details
3076 ///     - The application does EDID or Display ID access
3077 ///
3078 /// @returns
3079 ///     - CTL_RESULT_SUCCESS
3080 ///     - CTL_RESULT_ERROR_UNINITIALIZED
3081 ///     - CTL_RESULT_ERROR_DEVICE_LOST
3082 ///     - CTL_RESULT_ERROR_INVALID_NULL_HANDLE
3083 ///         + `nullptr == hDisplayOutput`
3084 ///     - CTL_RESULT_ERROR_INVALID_NULL_POINTER
3085 ///         + `nullptr == pPanelDescriptorAccessArgs`
3086 ///     - ::CTL_RESULT_ERROR_UNSUPPORTED_VERSION - "Unsupported version"
3087 ///     - ::CTL_RESULT_ERROR_INVALID_OPERATION_TYPE - "Invalid operation type"
3088 ///     - ::CTL_RESULT_ERROR_INSUFFICIENT_PERMISSIONS - "Insufficient permissions"
3089 ///     - ::CTL_RESULT_ERROR_INVALID_NULL_POINTER - "Invalid null pointer"
3090 ///     - ::CTL_RESULT_ERROR_NULL_OS_DISPLAY_OUTPUT_HANDLE - "Null OS display output handle"
3091 ///     - ::CTL_RESULT_ERROR_NULL_OS_INTERFACE - "Null OS interface"
3092 ///     - ::CTL_RESULT_ERROR_NULL_OS_ADAPATER_HANDLE - "Null OS adapter handle"
3093 ///     - ::CTL_RESULT_ERROR_KMD_CALL - "Kernal mode driver call failure"
3094 CTL_APIEXPORT ctl_result_t CTL_APICALL
3095 ctlPanelDescriptorAccess(
3096     ctl_display_output_handle_t hDisplayOutput,     ///< [in] Handle to display output
3097     ctl_panel_descriptor_access_args_t* pPanelDescriptorAccessArgs  ///< [in,out] Panel descriptor access arguments
3098     );
3099
3100 ///////////////////////////////////////////////////////////////////////////////
3101 /// @brief  Retro Scaling Types
3102 typedef uint32_t ctl_retro_scaling_type_flags_t;
3103 typedef enum _ctl_retro_scaling_type_flag_t
3104 {
3105     CTL_RETRO_SCALING_TYPE_FLAG_INTEGER = CTL_BIT(0),   ///< Integer Scaling
3106     CTL_RETRO_SCALING_TYPE_FLAG_NEAREST_NEIGHBOUR = CTL_BIT(1), ///< Nearest Neighbour Scaling
3107     CTL_RETRO_SCALING_TYPE_FLAG_MAX = 0x80000000
3108
3109 } ctl_retro_scaling_type_flag_t;
3110
3111 ///////////////////////////////////////////////////////////////////////////////
3112 /// @brief Set/Get Retro Scaling Type
3113 typedef struct _ctl_retro_scaling_settings_t
3114 {
3115     uint32_t Size;                                  ///< [in] size of this structure
3116     uint8_t Version;                                ///< [in] version of this structure
3117     bool Get;                                       ///< [in][release] Set to true to get current scaling . Set to False to Set
3118                                                     ///< the scaling
3119     bool Enable;                                    ///< [in,out] State of the scaler
3120     ctl_retro_scaling_type_flags_t RetroScalingType;///< [out] Requested retro scaling types. Refer
3121                                                     ///< ::ctl_retro_scaling_type_flag_t
3122
3123 } ctl_retro_scaling_settings_t;
3124
3125 ///////////////////////////////////////////////////////////////////////////////
3126 /// @brief Retro Scaling caps
3127 typedef struct _ctl_retro_scaling_caps_t
3128 {
3129     uint32_t Size;                                  ///< [in] size of this structure
3130     uint8_t Version;                                ///< [in] version of this structure
3131     ctl_retro_scaling_type_flags_t SupportedRetroScaling;   ///< [out] Supported retro scaling types
3132
3133 } ctl_retro_scaling_caps_t;
3134
3135 ///////////////////////////////////////////////////////////////////////////////
3136 /// @brief Get Supported Retro Scaling Types
3137 ///
3138 /// @details
3139 ///     - Returns supported retro scaling capabilities
3140 ///
3141 /// @returns
3142 ///     - CTL_RESULT_SUCCESS
3143 ///     - CTL_RESULT_ERROR_UNINITIALIZED
3144 ///     - CTL_RESULT_ERROR_DEVICE_LOST
3145 ///     - CTL_RESULT_ERROR_INVALID_NULL_HANDLE
3146 ///         + `nullptr == hDAhandle`
3147 ///     - CTL_RESULT_ERROR_INVALID_NULL_POINTER
3148 ///         + `nullptr == pRetroScalingCaps`
3149 ///     - ::CTL_RESULT_ERROR_UNSUPPORTED_VERSION - "Unsupported version"
3150 CTL_APIEXPORT ctl_result_t CTL_APICALL
3151 ctlGetSupportedRetroScalingCapability(
3152     ctl_device_adapter_handle_t hDAhandle,          ///< [in][release] Handle to adapter
3153     ctl_retro_scaling_caps_t* pRetroScalingCaps     ///< [in,out][release] Query result for supported retro scaling types
3154     );
3155
3156 ///////////////////////////////////////////////////////////////////////////////
3157 /// @brief Get/Set Retro Scaling
3158 ///
3159 /// @details
3160 ///     - Get or Set the status of retro scaling.This Api will do a physical
3161 ///       modeset resulting in flash on the screen
3162 ///
3163 /// @returns
3164 ///     - CTL_RESULT_SUCCESS
3165 ///     - CTL_RESULT_ERROR_UNINITIALIZED
3166 ///     - CTL_RESULT_ERROR_DEVICE_LOST
3167 ///     - CTL_RESULT_ERROR_INVALID_NULL_HANDLE
3168 ///         + `nullptr == hDAhandle`
3169 ///     - CTL_RESULT_ERROR_INVALID_NULL_POINTER
3170 ///         + `nullptr == pGetSetRetroScalingType`
3171 ///     - ::CTL_RESULT_ERROR_UNSUPPORTED_VERSION - "Unsupported version"
3172 CTL_APIEXPORT ctl_result_t CTL_APICALL
3173 ctlGetSetRetroScaling(
3174     ctl_device_adapter_handle_t hDAhandle,          ///< [in][release] Handle to adapter
3175     ctl_retro_scaling_settings_t* pGetSetRetroScalingType   ///< [in,out][release] Get or Set the retro scaling type
3176     );
3177
3178 ///////////////////////////////////////////////////////////////////////////////
3179 /// @brief Scaling Types
3180 typedef uint32_t ctl_scaling_type_flags_t;
3181 typedef enum _ctl_scaling_type_flag_t
3182 {
3183     CTL_SCALING_TYPE_FLAG_IDENTITY = CTL_BIT(0),    ///< No scaling is applied and display manages scaling itself when possible
3184     CTL_SCALING_TYPE_FLAG_CENTERED = CTL_BIT(1),    ///< Source is not scaled but place in the center of the target display
3185     CTL_SCALING_TYPE_FLAG_STRETCHED = CTL_BIT(2),   ///< Source is stretched to fit the target size
3186     CTL_SCALING_TYPE_FLAG_ASPECT_RATIO_CENTERED_MAX = CTL_BIT(3),   ///< The aspect ratio is maintained with the source centered
3187     CTL_SCALING_TYPE_FLAG_CUSTOM = CTL_BIT(4),      ///< None of the standard types match this .Additional parameters are
3188                                                     ///< required which should be set via a private driver interface
3189     CTL_SCALING_TYPE_FLAG_MAX = 0x80000000
3190
3191 } ctl_scaling_type_flag_t;
3192
3193 ///////////////////////////////////////////////////////////////////////////////
3194 /// @brief Scaling caps
3195 typedef struct _ctl_scaling_caps_t
3196 {
3197     uint32_t Size;                                  ///< [in] size of this structure
3198     uint8_t Version;                                ///< [in] version of this structure
3199     ctl_scaling_type_flags_t SupportedScaling;      ///< [out] Supported scaling types. Refer ::ctl_scaling_type_flag_t
3200
3201 } ctl_scaling_caps_t;
3202
3203 ///////////////////////////////////////////////////////////////////////////////
3204 /// @brief Set/Get Scaling type
3205 typedef struct _ctl_scaling_settings_t
3206 {
3207     uint32_t Size;                                  ///< [in] size of this structure
3208     uint8_t Version;                                ///< [in] version of this structure
3209     bool Enable;                                    ///< [in,out] State of the scaler
3210     ctl_scaling_type_flags_t ScalingType;           ///< [in,out] Requested scaling types. Refer ::ctl_scaling_type_flag_t
3211     uint32_t CustomScalingX;                        ///< [in,out] Custom Scaling X resolution
3212     uint32_t CustomScalingY;                        ///< [in,out] Custom Scaling Y resolution
3213     bool HardwareModeSet;                           ///< [in] Flag to indicate hardware modeset should be done to apply the
3214                                                     ///< scaling.Setting this to true would result in a flash on the screen. If
3215                                                     ///< this flag is set to false , API will request the OS to do a virtual
3216                                                     ///< modeset , but the OS can ignore this request and do a hardware modeset
3217                                                     ///< in some instances
3218
3219 } ctl_scaling_settings_t;
3220
3221 ///////////////////////////////////////////////////////////////////////////////
3222 /// @brief Get Supported Scaling Types
3223 ///
3224 /// @details
3225 ///     - Returns supported scaling capabilities
3226 ///
3227 /// @returns
3228 ///     - CTL_RESULT_SUCCESS
3229 ///     - CTL_RESULT_ERROR_UNINITIALIZED
3230 ///     - CTL_RESULT_ERROR_DEVICE_LOST
3231 ///     - CTL_RESULT_ERROR_INVALID_NULL_HANDLE
3232 ///         + `nullptr == hDisplayOutput`
3233 ///     - CTL_RESULT_ERROR_INVALID_NULL_POINTER
3234 ///         + `nullptr == pScalingCaps`
3235 ///     - ::CTL_RESULT_ERROR_UNSUPPORTED_VERSION - "Unsupported version"
3236 CTL_APIEXPORT ctl_result_t CTL_APICALL
3237 ctlGetSupportedScalingCapability(
3238     ctl_display_output_handle_t hDisplayOutput,     ///< [in][release] Handle to display output
3239     ctl_scaling_caps_t* pScalingCaps                ///< [in,out][release] Query result for supported scaling types
3240     );
3241
3242 ///////////////////////////////////////////////////////////////////////////////
3243 /// @brief Get Current Scaling
3244 ///
3245 /// @details
3246 ///     - Returns current active scaling
3247 ///
3248 /// @returns
3249 ///     - CTL_RESULT_SUCCESS
3250 ///     - CTL_RESULT_ERROR_UNINITIALIZED
3251 ///     - CTL_RESULT_ERROR_DEVICE_LOST
3252 ///     - CTL_RESULT_ERROR_INVALID_NULL_HANDLE
3253 ///         + `nullptr == hDisplayOutput`
3254 ///     - CTL_RESULT_ERROR_INVALID_NULL_POINTER
3255 ///         + `nullptr == pGetCurrentScalingType`
3256 ///     - ::CTL_RESULT_ERROR_UNSUPPORTED_VERSION - "Unsupported version"
3257 CTL_APIEXPORT ctl_result_t CTL_APICALL
3258 ctlGetCurrentScaling(
3259     ctl_display_output_handle_t hDisplayOutput,     ///< [in][release] Handle to display output
3260     ctl_scaling_settings_t* pGetCurrentScalingType  ///< [in,out][release] Query result for active scaling types
3261     );
3262
3263 ///////////////////////////////////////////////////////////////////////////////
3264 /// @brief Set Scaling Type
3265 ///
3266 /// @details
3267 ///     - Returns current active scaling
3268 ///
3269 /// @returns
3270 ///     - CTL_RESULT_SUCCESS
3271 ///     - CTL_RESULT_ERROR_UNINITIALIZED
3272 ///     - CTL_RESULT_ERROR_DEVICE_LOST
3273 ///     - CTL_RESULT_ERROR_INVALID_NULL_HANDLE
3274 ///         + `nullptr == hDisplayOutput`
3275 ///     - CTL_RESULT_ERROR_INVALID_NULL_POINTER
3276 ///         + `nullptr == pSetScalingType`
3277 ///     - ::CTL_RESULT_ERROR_UNSUPPORTED_VERSION - "Unsupported version"
3278 CTL_APIEXPORT ctl_result_t CTL_APICALL
3279 ctlSetCurrentScaling(
3280     ctl_display_output_handle_t hDisplayOutput,     ///< [in][release] Handle to display output
3281     ctl_scaling_settings_t* pSetScalingType         ///< [in,out][release] Set scaling types
3282     );
3283
3284 ///////////////////////////////////////////////////////////////////////////////
3285 /// @brief Ambient light based enhancement table entry
3286 typedef struct _ctl_lace_lux_aggr_map_entry_t
3287 {
3288     uint32_t Lux;                                   ///< [in,out] Ambient lux
3289     uint8_t AggressivenessPercent;                  ///< [in,out] Pixel boost agressiveness
3290
3291 } ctl_lace_lux_aggr_map_entry_t;
3292
3293 ///////////////////////////////////////////////////////////////////////////////
3294 /// @brief Ambient light based enhancement table
3295 typedef struct _ctl_lace_lux_aggr_map_t
3296 {
3297     uint32_t MaxNumEntries;                         ///< [out] Max Number of entries in mapping table supported
3298     uint32_t NumEntries;                            ///< [in,out] Number of entries in the given mapping table
3299     ctl_lace_lux_aggr_map_entry_t* pLuxToAggrMappingTable;  ///< [in] Max number of Entries which can be passed in
3300                                                     ///< LuxToAggrMappingTable
3301
3302 } ctl_lace_lux_aggr_map_t;
3303
3304 ///////////////////////////////////////////////////////////////////////////////
3305 /// @brief Data specific to the mode caller is interested in
3306 typedef union _ctl_lace_aggr_config_t
3307 {
3308     uint8_t FixedAggressivenessLevelPercent;        ///< [in,out] Fixed aggressiveness level, applicable for
3309                                                     ///< CTL_LACE_MODE_FIXED_AGGR_LEVEL
3310     ctl_lace_lux_aggr_map_t AggrLevelMap;           ///< [in,out] Lux to enhancement mapping table, applicable for
3311                                                     ///< CTL_LACE_MODE_AMBIENT_ADAPTIVE
3312
3313 } ctl_lace_aggr_config_t;
3314
3315 ///////////////////////////////////////////////////////////////////////////////
3316 /// @brief Get Operations used for additional settings
3317 typedef uint32_t ctl_get_operation_flags_t;
3318 typedef enum _ctl_get_operation_flag_t
3319 {
3320     CTL_GET_OPERATION_FLAG_CURRENT = CTL_BIT(0),    ///< Get the details set through last set call
3321     CTL_GET_OPERATION_FLAG_DEFAULT = CTL_BIT(1),    ///< Get the driver default values
3322     CTL_GET_OPERATION_FLAG_CAPABILITY = CTL_BIT(2), ///< Get capability
3323     CTL_GET_OPERATION_FLAG_MAX = 0x80000000
3324
3325 } ctl_get_operation_flag_t;
3326
3327 ///////////////////////////////////////////////////////////////////////////////
3328 /// @brief Set Operations used for additional settings
3329 typedef enum _ctl_set_operation_t
3330 {
3331     CTL_SET_OPERATION_RESTORE_DEFAULT = 0,          ///< Restore default values
3332     CTL_SET_OPERATION_CUSTOM = 1,                   ///< Set custom values
3333     CTL_SET_OPERATION_MAX
3334
3335 } ctl_set_operation_t;
3336
3337 ///////////////////////////////////////////////////////////////////////////////
3338 /// @brief  Lace Trigger Modes
3339 typedef uint32_t ctl_lace_trigger_flags_t;
3340 typedef enum _ctl_lace_trigger_flag_t
3341 {
3342     CTL_LACE_TRIGGER_FLAG_AMBIENT_LIGHT = CTL_BIT(0),   ///< LACE enhancement depends on Ambient light
3343     CTL_LACE_TRIGGER_FLAG_FIXED_AGGRESSIVENESS = CTL_BIT(1),///< LACE enhancement is as per given fixed aggressiveness level
3344     CTL_LACE_TRIGGER_FLAG_MAX = 0x80000000
3345
3346 } ctl_lace_trigger_flag_t;
3347
3348 ///////////////////////////////////////////////////////////////////////////////
3349 /// @brief Set/Get LACE Config
3350 typedef struct _ctl_lace_config_t
3351 {
3352     uint32_t Size;                                  ///< [in] size of this structure
3353     uint8_t Version;                                ///< [in] version of this structure
3354     bool Enabled;                                   ///< [in,out] Enable or disable LACE feature
3355     ctl_get_operation_flags_t OpTypeGet;            ///< [in] Get Operations used for additional settings
3356     ctl_set_operation_t OpTypeSet;                  ///< [in] Set Operations used for additional settings
3357     ctl_lace_trigger_flags_t Trigger;               ///< [in,out] LACE operating mode to be Triggerd
3358     ctl_lace_aggr_config_t LaceConfig;              ///< [in,out] Data specific to the mode, caller is interested in
3359
3360 } ctl_lace_config_t;
3361
3362 ///////////////////////////////////////////////////////////////////////////////
3363 /// @brief Get LACE Config
3364 ///
3365 /// @details
3366 ///     - Returns current LACE Config
3367 ///
3368 /// @returns
3369 ///     - CTL_RESULT_SUCCESS
3370 ///     - CTL_RESULT_ERROR_UNINITIALIZED
3371 ///     - CTL_RESULT_ERROR_DEVICE_LOST
3372 ///     - CTL_RESULT_ERROR_INVALID_NULL_HANDLE
3373 ///         + `nullptr == hDisplayOutput`
3374 ///     - CTL_RESULT_ERROR_INVALID_NULL_POINTER
3375 ///         + `nullptr == pLaceConfig`
3376 ///     - ::CTL_RESULT_ERROR_UNSUPPORTED_VERSION - "Unsupported version"
3377 ///     - ::CTL_RESULT_ERROR_LACE_INVALID_DATA_ARGUMENT_PASSED - "Lace Incorrrect AggressivePercent data or LuxVsAggressive Map data passed by user"
3378 CTL_APIEXPORT ctl_result_t CTL_APICALL
3379 ctlGetLACEConfig(
3380     ctl_display_output_handle_t hDisplayOutput,     ///< [in] Handle to display output
3381     ctl_lace_config_t* pLaceConfig                  ///< [out]Lace configuration
3382     );
3383
3384 ///////////////////////////////////////////////////////////////////////////////
3385 /// @brief Sets LACE Config
3386 ///
3387 /// @details
3388 ///     - Sets LACE Config
3389 ///
3390 /// @returns
3391 ///     - CTL_RESULT_SUCCESS
3392 ///     - CTL_RESULT_ERROR_UNINITIALIZED
3393 ///     - CTL_RESULT_ERROR_DEVICE_LOST
3394 ///     - CTL_RESULT_ERROR_INVALID_NULL_HANDLE
3395 ///         + `nullptr == hDisplayOutput`
3396 ///     - CTL_RESULT_ERROR_INVALID_NULL_POINTER
3397 ///         + `nullptr == pLaceConfig`
3398 ///     - ::CTL_RESULT_ERROR_UNSUPPORTED_VERSION - "Unsupported version"
3399 ///     - ::CTL_RESULT_ERROR_LACE_INVALID_DATA_ARGUMENT_PASSED - "Lace Incorrrect AggressivePercent data or LuxVsAggressive Map data passed by user"
3400 CTL_APIEXPORT ctl_result_t CTL_APICALL
3401 ctlSetLACEConfig(
3402     ctl_display_output_handle_t hDisplayOutput,     ///< [in]Handle to display output
3403     ctl_lace_config_t* pLaceConfig                  ///< [in]Lace configuration
3404     );
3405
3406 ///////////////////////////////////////////////////////////////////////////////
3407 /// @brief Get Software PSR status/Set Software PSR settings
3408 typedef struct _ctl_sw_psr_settings_t
3409 {
3410     uint32_t Size;                                  ///< [in] size of this structure
3411     uint8_t Version;                                ///< [in] version of this structure
3412     bool Set;                                       ///< [in][release] Set to False to Get Software PSR status. Set to True to
3413                                                     ///< Enable/Disable Software PSR
3414     bool Supported;                                 ///< [out] When Get is True, returns if SW PSR is supported
3415     bool Enable;                                    ///< [in,out] When Get is True, returns current state of  Software PSR.
3416                                                     ///< When Get is False, Enables/Diasbles Software PSR
3417
3418 } ctl_sw_psr_settings_t;
3419
3420 ///////////////////////////////////////////////////////////////////////////////
3421 /// @brief Get Software PSR caps/Set software PSR State
3422 ///
3423 /// @details
3424 ///     - Returns Software PSR status or Sets Software PSR capabilities. This is
3425 ///       a reserved capability. By default, software PSR is not supported/will
3426 ///       not be enabled, need application to activate it, please contact Intel
3427 ///       for activation.
3428 ///
3429 /// @returns
3430 ///     - CTL_RESULT_SUCCESS
3431 ///     - CTL_RESULT_ERROR_UNINITIALIZED
3432 ///     - CTL_RESULT_ERROR_DEVICE_LOST
3433 ///     - CTL_RESULT_ERROR_INVALID_NULL_HANDLE
3434 ///         + `nullptr == hDisplayOutput`
3435 ///     - CTL_RESULT_ERROR_INVALID_NULL_POINTER
3436 ///         + `nullptr == pSoftwarePsrSetting`
3437 ///     - ::CTL_RESULT_ERROR_UNSUPPORTED_VERSION - "Unsupported version"
3438 CTL_APIEXPORT ctl_result_t CTL_APICALL
3439 ctlSoftwarePSR(
3440     ctl_display_output_handle_t hDisplayOutput,     ///< [in][release] Handle to display output
3441     ctl_sw_psr_settings_t* pSoftwarePsrSetting      ///< [in,out][release] Get Software PSR caps/state or Set Software PSR
3442                                                     ///< state
3443     );
3444
3445 ///////////////////////////////////////////////////////////////////////////////
3446 /// @brief Intel Arc Sync Monitor Params
3447 typedef struct _ctl_intel_arc_sync_monitor_params_t
3448 {
3449     uint32_t Size;                                  ///< [in] size of this structure
3450     uint8_t Version;                                ///< [in] version of this structure
3451     bool IsIntelArcSyncSupported;                   ///< [out] Intel Arc Sync support for the monitor
3452     float MinimumRefreshRateInHz;                   ///< [out] Minimum Intel Arc Sync refresh rate supported by the monitor
3453     float MaximumRefreshRateInHz;                   ///< [out] Maximum Intel Arc Sync refresh rate supported by the monitor
3454     uint32_t MaxFrameTimeIncreaseInUs;              ///< [out] Max frame time increase in micro seconds from DID2.1 Adaptive
3455                                                     ///< Sync block
3456     uint32_t MaxFrameTimeDecreaseInUs;              ///< [out] Max frame time decrease in micro seconds from DID2.1 Adaptive
3457                                                     ///< Sync block
3458
3459 } ctl_intel_arc_sync_monitor_params_t;
3460
3461 ///////////////////////////////////////////////////////////////////////////////
3462 /// @brief Get Intel Arc Sync information for monitor
3463 ///
3464 /// @details
3465 ///     - Returns Intel Arc Sync information for selected monitor
3466 ///
3467 /// @returns
3468 ///     - CTL_RESULT_SUCCESS
3469 ///     - CTL_RESULT_ERROR_UNINITIALIZED
3470 ///     - CTL_RESULT_ERROR_DEVICE_LOST
3471 ///     - CTL_RESULT_ERROR_INVALID_NULL_HANDLE
3472 ///         + `nullptr == hDisplayOutput`
3473 ///     - CTL_RESULT_ERROR_INVALID_NULL_POINTER
3474 ///         + `nullptr == pIntelArcSyncMonitorParams`
3475 ///     - ::CTL_RESULT_ERROR_UNSUPPORTED_VERSION - "Unsupported version"
3476 CTL_APIEXPORT ctl_result_t CTL_APICALL
3477 ctlGetIntelArcSyncInfoForMonitor(
3478     ctl_display_output_handle_t hDisplayOutput,     ///< [in][release] Handle to display output
3479     ctl_intel_arc_sync_monitor_params_t* pIntelArcSyncMonitorParams ///< [in,out][release] Intel Arc Sync params for monitor
3480     );
3481
3482 ///////////////////////////////////////////////////////////////////////////////
3483 /// @brief Handle of a MUX output instance
3484 typedef struct _ctl_mux_output_handle_t *ctl_mux_output_handle_t;
3485
3486 ///////////////////////////////////////////////////////////////////////////////
3487 /// @brief Enumerate Display MUX Devices on this system across adapters
3488 ///
3489 /// @details
3490 ///     - The application enumerates all MUX devices in the system
3491 ///
3492 /// @returns
3493 ///     - CTL_RESULT_SUCCESS
3494 ///     - CTL_RESULT_ERROR_UNINITIALIZED
3495 ///     - CTL_RESULT_ERROR_DEVICE_LOST
3496 ///     - CTL_RESULT_ERROR_INVALID_NULL_HANDLE
3497 ///         + `nullptr == hAPIHandle`
3498 ///     - CTL_RESULT_ERROR_INVALID_NULL_POINTER
3499 ///         + `nullptr == pCount`
3500 ///         + `nullptr == phMuxDevices`
3501 ///     - ::CTL_RESULT_ERROR_UNSUPPORTED_VERSION - "Unsupported version"
3502 CTL_APIEXPORT ctl_result_t CTL_APICALL
3503 ctlEnumerateMuxDevices(
3504     ctl_api_handle_t hAPIHandle,                    ///< [in][release] Applications should pass the Control API handle returned
3505                                                     ///< by the CtlInit function
3506     uint32_t* pCount,                               ///< [in,out][release] pointer to the number of MUX device instances. If
3507                                                     ///< input count is zero, then the api will update the value with the total
3508                                                     ///< number of MUX devices available and return the Count value. If input
3509                                                     ///< count is non-zero, then the api will only retrieve the number of MUX Devices.
3510                                                     ///< If count is larger than the number of MUX devices available, then the
3511                                                     ///< api will update the value with the correct number of MUX devices available.
3512     ctl_mux_output_handle_t* phMuxDevices           ///< [out][range(0, *pCount)] array of MUX device instance handles
3513     );
3514
3515 ///////////////////////////////////////////////////////////////////////////////
3516 /// @brief Display MUX device properties
3517 typedef struct _ctl_mux_properties_t
3518 {
3519     uint32_t Size;                                  ///< [in] size of this structure
3520     uint8_t Version;                                ///< [in] version of this structure
3521     uint8_t MuxId;                                  ///< [out] MUX ID of this MUX device enumerated
3522     uint32_t Count;                                 ///< [in,out] Pointer to the number of display output instances this MUX
3523                                                     ///< object can drive. If count is zero, then the api will update the value
3524                                                     ///< with the total
3525                                                     ///< number of outputs available. If count is non-zero, then the api will
3526                                                     ///< only retrieve the number of outputs.
3527                                                     ///< If count is larger than the number of display outputs MUX can drive,
3528                                                     ///< then the api will update the value with the correct number of display
3529                                                     ///< outputs MUX can driver.
3530     ctl_display_output_handle_t* phDisplayOutputs;  ///< [in,out][range(0, *pCount)] Array of display output instance handles
3531                                                     ///< this MUX device can drive
3532     uint8_t IndexOfDisplayOutputOwningMux;          ///< [out] [range(0, (Count-1))] This is the index into the
3533                                                     ///< phDisplayOutputs list to the display output which currently owns the
3534                                                     ///< MUX output. This doesn't mean display is active
3535
3536 } ctl_mux_properties_t;
3537
3538 ///////////////////////////////////////////////////////////////////////////////
3539 /// @brief Get Display Mux properties
3540 ///
3541 /// @details
3542 ///     - Get the propeties of the Mux device
3543 ///
3544 /// @returns
3545 ///     - CTL_RESULT_SUCCESS
3546 ///     - CTL_RESULT_ERROR_UNINITIALIZED
3547 ///     - CTL_RESULT_ERROR_DEVICE_LOST
3548 ///     - CTL_RESULT_ERROR_INVALID_NULL_HANDLE
3549 ///         + `nullptr == hMuxDevice`
3550 ///     - CTL_RESULT_ERROR_INVALID_NULL_POINTER
3551 ///         + `nullptr == pMuxProperties`
3552 ///     - ::CTL_RESULT_ERROR_UNSUPPORTED_VERSION - "Unsupported version"
3553 CTL_APIEXPORT ctl_result_t CTL_APICALL
3554 ctlGetMuxProperties(
3555     ctl_mux_output_handle_t hMuxDevice,             ///< [in] MUX device instance handle
3556     ctl_mux_properties_t* pMuxProperties            ///< [in,out] MUX device properties
3557     );
3558
3559 ///////////////////////////////////////////////////////////////////////////////
3560 /// @brief Switch Mux output
3561 ///
3562 /// @details
3563 ///     - Switches the MUX output
3564 ///
3565 /// @returns
3566 ///     - CTL_RESULT_SUCCESS
3567 ///     - CTL_RESULT_ERROR_UNINITIALIZED
3568 ///     - CTL_RESULT_ERROR_DEVICE_LOST
3569 ///     - CTL_RESULT_ERROR_INVALID_NULL_HANDLE
3570 ///         + `nullptr == hMuxDevice`
3571 ///         + `nullptr == hInactiveDisplayOutput`
3572 ///     - ::CTL_RESULT_ERROR_UNSUPPORTED_VERSION - "Unsupported version"
3573 CTL_APIEXPORT ctl_result_t CTL_APICALL
3574 ctlSwitchMux(
3575     ctl_mux_output_handle_t hMuxDevice,             ///< [in] MUX device instance handle
3576     ctl_display_output_handle_t hInactiveDisplayOutput  ///< [out] Input selection for this MUX, which if active will drive the
3577                                                     ///< output of this MUX device. This should be one of the display output
3578                                                     ///< handles reported under this MUX device's properties.
3579     );
3580
3581 ///////////////////////////////////////////////////////////////////////////////
3582 /// @brief Intel Arc Sync profile
3583 typedef enum _ctl_intel_arc_sync_profile_t
3584 {
3585     CTL_INTEL_ARC_SYNC_PROFILE_INVALID = 0,         ///< Invalid profile
3586     CTL_INTEL_ARC_SYNC_PROFILE_RECOMMENDED = 1,     ///< Default. Selects appropriate profile based on the monitor. COMPATIBLE
3587                                                     ///< profile is applied if profile is not available for the monitor
3588     CTL_INTEL_ARC_SYNC_PROFILE_EXCELLENT = 2,       ///< Unconstrained. Full VRR range of the monitor can be used
3589     CTL_INTEL_ARC_SYNC_PROFILE_GOOD = 3,            ///< Some minor range constraints, unlikely to effect user experience but
3590                                                     ///< can reduce flicker on some monitors
3591     CTL_INTEL_ARC_SYNC_PROFILE_COMPATIBLE = 4,      ///< Significant constraints that will reduce flicker considerably but are
3592                                                     ///< likely to cause some level of judder onscreen especially when refresh
3593                                                     ///< rates are changing rapidly
3594     CTL_INTEL_ARC_SYNC_PROFILE_OFF = 5,             ///< Disable Intel Arc Sync on this monitor. This disables variable rate
3595                                                     ///< flips on this monitor. All sync flips will occur at the OS requested
3596                                                     ///< refresh rate
3597     CTL_INTEL_ARC_SYNC_PROFILE_VESA = 6,            ///< Applies vesa specified constraints if the monitor has provided them,
3598                                                     ///< COMPATIBLE profile if not
3599     CTL_INTEL_ARC_SYNC_PROFILE_CUSTOM = 7,          ///< Unlocks controls to set a custom Intel Arc Sync profile
3600     CTL_INTEL_ARC_SYNC_PROFILE_MAX
3601
3602 } ctl_intel_arc_sync_profile_t;
3603
3604 ///////////////////////////////////////////////////////////////////////////////
3605 /// @brief Intel Arc Sync Profile Params
3606 typedef struct _ctl_intel_arc_sync_profile_params_t
3607 {
3608     uint32_t Size;                                  ///< [in] size of this structure
3609     uint8_t Version;                                ///< [in] version of this structure
3610     ctl_intel_arc_sync_profile_t IntelArcSyncProfile;   ///< [in,out] Intel Arc Sync profile used by driver. Refer
3611                                                     ///< ::ctl_intel_arc_sync_profile_t
3612     float MaxRefreshRateInHz;                       ///< [in,out] Maximum refresh rate utilized by the driver
3613     float MinRefreshRateInHz;                       ///< [in,out] Minimum refresh rate utilized by the driver
3614     uint32_t MaxFrameTimeIncreaseInUs;              ///< [in,out] Maximum frame time increase (in micro seconds) imposed by the
3615                                                     ///< driver
3616     uint32_t MaxFrameTimeDecreaseInUs;              ///< [in,out] Maximum frame time decrease (in micro seconds) imposed by the
3617                                                     ///< driver
3618
3619 } ctl_intel_arc_sync_profile_params_t;
3620
3621 ///////////////////////////////////////////////////////////////////////////////
3622 /// @brief Get Intel Arc Sync profile
3623 ///
3624 /// @details
3625 ///     - Returns Intel Arc Sync profile for selected monitor
3626 ///
3627 /// @returns
3628 ///     - CTL_RESULT_SUCCESS
3629 ///     - CTL_RESULT_ERROR_UNINITIALIZED
3630 ///     - CTL_RESULT_ERROR_DEVICE_LOST
3631 ///     - CTL_RESULT_ERROR_INVALID_NULL_HANDLE
3632 ///         + `nullptr == hDisplayOutput`
3633 ///     - CTL_RESULT_ERROR_INVALID_NULL_POINTER
3634 ///         + `nullptr == pIntelArcSyncProfileParams`
3635 ///     - ::CTL_RESULT_ERROR_UNSUPPORTED_VERSION - "Unsupported version"
3636 CTL_APIEXPORT ctl_result_t CTL_APICALL
3637 ctlGetIntelArcSyncProfile(
3638     ctl_display_output_handle_t hDisplayOutput,     ///< [in][release] Handle to display output
3639     ctl_intel_arc_sync_profile_params_t* pIntelArcSyncProfileParams ///< [in,out][release] Intel Arc Sync params for monitor
3640     );
3641
3642 ///////////////////////////////////////////////////////////////////////////////
3643 /// @brief Set Intel Arc Sync profile
3644 ///
3645 /// @details
3646 ///     - Sets Intel Arc Sync profile for selected monitor. In a mux situation,
3647 ///       this API should be called for all display IDs associated with a
3648 ///       physical display.
3649 ///
3650 /// @returns
3651 ///     - CTL_RESULT_SUCCESS
3652 ///     - CTL_RESULT_ERROR_UNINITIALIZED
3653 ///     - CTL_RESULT_ERROR_DEVICE_LOST
3654 ///     - CTL_RESULT_ERROR_INVALID_NULL_HANDLE
3655 ///         + `nullptr == hDisplayOutput`
3656 ///     - CTL_RESULT_ERROR_INVALID_NULL_POINTER
3657 ///         + `nullptr == pIntelArcSyncProfileParams`
3658 ///     - ::CTL_RESULT_ERROR_UNSUPPORTED_VERSION - "Unsupported version"
3659 CTL_APIEXPORT ctl_result_t CTL_APICALL
3660 ctlSetIntelArcSyncProfile(
3661     ctl_display_output_handle_t hDisplayOutput,     ///< [in][release] Handle to display output
3662     ctl_intel_arc_sync_profile_params_t* pIntelArcSyncProfileParams ///< [in][release] Intel Arc Sync params for monitor
3663     );
3664
3665 ///////////////////////////////////////////////////////////////////////////////
3666 /// @brief EDID Management operation type
3667 typedef enum _ctl_edid_management_optype_t
3668 {
3669     CTL_EDID_MANAGEMENT_OPTYPE_READ_EDID = 1,       ///< This operation type is to read an output's EDID. Set edid_type input
3670                                                     ///< arg to read MONITOR EDID or previously OVERRIDDEN EDID or CURRENT
3671                                                     ///< active EDID. Read EDID is a 2 pass call. First call with size = 0,
3672                                                     ///< pEdidBuf = nullptr to get the size, then call with allocated buffer to
3673                                                     ///< get the EDID data. READ operation is applicable for any normal, edid
3674                                                     ///< locked or edid overridden display output device.
3675     CTL_EDID_MANAGEMENT_OPTYPE_LOCK_EDID = 2,       ///< To make an output always connected with OVERRIDE or MONITOR EDID
3676                                                     ///< across reboots. When output isn't connected call with OVERRIDE EDID;
3677                                                     ///< when connected, either set OVERRIDE and provide pEdidBuf or set
3678                                                     ///< MONITOR and driver will use monitor's EDID. There is no change to EDID
3679                                                     ///< stored in Monitor. Cannot be called when override is active. Any OS
3680                                                     ///< EDID override will take precedence over IGCL override.
3681     CTL_EDID_MANAGEMENT_OPTYPE_UNLOCK_EDID = 3,     ///< To undo lock EDID operation, i.e. it makes output as detached in
3682                                                     ///< response to unplug. This operation removes past supplied EDID; output
3683                                                     ///< status is reported to OS as it is; output restores back to monitor's
3684                                                     ///< EDID when it is connected
3685     CTL_EDID_MANAGEMENT_OPTYPE_OVERRIDE_EDID = 4,   ///< To replace an output's EDID with supplied one (pEdidBuf) only when
3686                                                     ///< physical display is connected. There is no change to EDID stored in
3687                                                     ///< Monitor. Cannot apply this operation on locked output. When no output
3688                                                     ///< device attached, the supplied EDID will be persisted in driver for
3689                                                     ///< future use. Any OS EDID override will take precedence over IGCL
3690                                                     ///< override.
3691     CTL_EDID_MANAGEMENT_OPTYPE_UNDO_OVERRIDE_EDID = 5,  ///< To undo override EDID operation, that is remove previously overridden
3692                                                     ///< EDID on an output. Output restores back to monitor's EDID when it is
3693                                                     ///< connected
3694     CTL_EDID_MANAGEMENT_OPTYPE_MAX
3695
3696 } ctl_edid_management_optype_t;
3697
3698 ///////////////////////////////////////////////////////////////////////////////
3699 /// @brief EDID type. Used in LOCK_EDID and READ_EDID calls.
3700 typedef enum _ctl_edid_type_t
3701 {
3702     CTL_EDID_TYPE_CURRENT = 1,                      ///< [in] Used to return currently active EDID in READ_EDID call.
3703     CTL_EDID_TYPE_OVERRIDE = 2,                     ///< [in] Is it user supplied EDID. Used in LOCK_EDID call with Supplied
3704                                                     ///< EDID or in READ_EDID to get Supplied EDID.
3705     CTL_EDID_TYPE_MONITOR = 3,                      ///< [in] Is it Monitor's EDID. Used in LOCK_EDID and READ_EDID calls.
3706     CTL_EDID_TYPE_MAX
3707
3708 } ctl_edid_type_t;
3709
3710 ///////////////////////////////////////////////////////////////////////////////
3711 /// @brief Edid management operation Out Flags
3712 typedef uint32_t ctl_edid_management_out_flags_t;
3713 typedef enum _ctl_edid_management_out_flag_t
3714 {
3715     CTL_EDID_MANAGEMENT_OUT_FLAG_OS_CONN_NOTIFICATION = CTL_BIT(0), ///< [out] If OS was notified about a connection change. App will need to
3716                                                     ///< wait for the OS action to complete.
3717     CTL_EDID_MANAGEMENT_OUT_FLAG_SUPPLIED_EDID = CTL_BIT(1),///< [out] Is it previously supplied EDID, set for READ_EDID(CURRENT).
3718     CTL_EDID_MANAGEMENT_OUT_FLAG_MONITOR_EDID = CTL_BIT(2), ///< [out] Is it Monitor's EDID, set for READ_EDID(CURRENT).
3719     CTL_EDID_MANAGEMENT_OUT_FLAG_DISPLAY_CONNECTED = CTL_BIT(3),///< [out] Is Monitor physically connected
3720     CTL_EDID_MANAGEMENT_OUT_FLAG_MAX = 0x80000000
3721
3722 } ctl_edid_management_out_flag_t;
3723
3724 ///////////////////////////////////////////////////////////////////////////////
3725 /// @brief EDID management
3726 typedef struct _ctl_edid_management_args_t
3727 {
3728     uint32_t Size;                                  ///< [in] size of this structure
3729     uint8_t Version;                                ///< [in] version of this structure
3730     ctl_edid_management_optype_t OpType;            ///< [in] EDID managmeent operation type
3731     ctl_edid_type_t EdidType;                       ///< [in] EDID Type, Monitor or Supplied
3732     uint32_t EdidSize;                              ///< [in,out] EDID Size, should be 0 for querying the size of EDID, should
3733                                                     ///< be previously returned size to read EDID. if buffer isn't big enough
3734                                                     ///< to fit EDID, returns size of EDID bytes.
3735     uint8_t* pEdidBuf;                              ///< [in,out] buffer holding EDID data
3736     ctl_edid_management_out_flags_t OutFlags;       ///< [out] Output flags to inform about status of EDID management
3737                                                     ///< operations
3738
3739 } ctl_edid_management_args_t;
3740
3741 ///////////////////////////////////////////////////////////////////////////////
3742 /// @brief EDID Management allows managing an output's EDID or Plugged Status.
3743 ///
3744 /// @details
3745 ///     - To manage output's EDID or Display ID. Supports native DP SST and HDMI
3746 ///       Display types.
3747 ///
3748 /// @returns
3749 ///     - CTL_RESULT_SUCCESS
3750 ///     - CTL_RESULT_ERROR_UNINITIALIZED
3751 ///     - CTL_RESULT_ERROR_DEVICE_LOST
3752 ///     - CTL_RESULT_ERROR_INVALID_NULL_HANDLE
3753 ///         + `nullptr == hDisplayOutput`
3754 ///     - CTL_RESULT_ERROR_INVALID_NULL_POINTER
3755 ///         + `nullptr == pEdidManagementArgs`
3756 ///     - ::CTL_RESULT_ERROR_UNSUPPORTED_VERSION - "Unsupported version"
3757 ///     - ::CTL_RESULT_ERROR_INVALID_OPERATION_TYPE - "Invalid operation type"
3758 ///     - ::CTL_RESULT_ERROR_INVALID_NULL_POINTER - "Invalid null pointer"
3759 ///     - ::CTL_RESULT_ERROR_NULL_OS_DISPLAY_OUTPUT_HANDLE - "Null OS display output handle"
3760 ///     - ::CTL_RESULT_ERROR_NULL_OS_INTERFACE - "Null OS interface"
3761 ///     - ::CTL_RESULT_ERROR_NULL_OS_ADAPATER_HANDLE - "Null OS adapter handle"
3762 ///     - ::CTL_RESULT_ERROR_KMD_CALL - "Kernal mode driver call failure"
3763 ///     - ::CTL_RESULT_ERROR_INVALID_ARGUMENT - "Invalid combination of parameters"
3764 ///     - ::CTL_RESULT_ERROR_DISPLAY_NOT_ATTACHED - "Error for Output Device not attached"
3765 ///     - ::CTL_RESULT_ERROR_OUT_OF_DEVICE_MEMORY - "Insufficient device memory to satisfy call"
3766 ///     - ::CTL_RESULT_ERROR_DATA_NOT_FOUND - "Requested EDID data not present."
3767 CTL_APIEXPORT ctl_result_t CTL_APICALL
3768 ctlEdidManagement(
3769     ctl_display_output_handle_t hDisplayOutput,     ///< [in] Handle to display output
3770     ctl_edid_management_args_t* pEdidManagementArgs ///< [in,out] EDID management arguments
3771     );
3772
3773 ///////////////////////////////////////////////////////////////////////////////
3774 /// @brief Custom mode operation types
3775 typedef enum _ctl_custom_mode_operation_types_t
3776 {
3777     CTL_CUSTOM_MODE_OPERATION_TYPES_GET_CUSTOM_SOURCE_MODES = 0,///< Get details of all previous applied custom modes if any.
3778     CTL_CUSTOM_MODE_OPERATION_TYPES_ADD_CUSTOM_SOURCE_MODE = 1, ///< Add a new mode. Allows only single mode adition at a time.
3779     CTL_CUSTOM_MODE_OPERATION_TYPES_REMOVE_CUSTOM_SOURCE_MODES = 2, ///< Remove previously added custom mode. Allows single or multiple mode
3780                                                     ///< removal at a time.
3781     CTL_CUSTOM_MODE_OPERATION_TYPES_MAX
3782
3783 } ctl_custom_mode_operation_types_t;
3784
3785 ///////////////////////////////////////////////////////////////////////////////
3786 /// @brief Get/Set Custom Mode
3787 typedef struct _ctl_get_set_custom_mode_args_t
3788 {
3789     uint32_t Size;                                  ///< [in] size of this structure
3790     uint8_t Version;                                ///< [in] version of this structure
3791     ctl_custom_mode_operation_types_t CustomModeOpType; ///< [in] Custom mode operation type
3792     uint32_t NumOfModes;                            ///< [in,out] Number of Custom Src Modes to be added/removed/Read.
3793     ctl_custom_src_mode_t* pCustomSrcModeList;      ///< [in,out] Custom mode source list which holds source modes to be
3794                                                     ///< added/removed/Read.
3795
3796 } ctl_get_set_custom_mode_args_t;
3797
3798 ///////////////////////////////////////////////////////////////////////////////
3799 /// @brief Get/Set Custom Mode
3800 typedef struct _ctl_custom_src_mode_t
3801 {
3802     uint32_t SourceX;                               ///< [in,out] CustomMode Source X Size
3803     uint32_t SourceY;                               ///< [in,out] CustomMode Source Y Size
3804
3805 } ctl_custom_src_mode_t;
3806
3807 ///////////////////////////////////////////////////////////////////////////////
3808 /// @brief Get/Set Custom mode.
3809 ///
3810 /// @details
3811 ///     - To get or set custom mode.
3812 ///     - Add custom source mode operation supports only single mode additon at
3813 ///       a time.
3814 ///     - Remove custom source mode operation supports single or multiple mode
3815 ///       removal at a time.
3816 ///
3817 /// @returns
3818 ///     - CTL_RESULT_SUCCESS
3819 ///     - CTL_RESULT_ERROR_UNINITIALIZED
3820 ///     - CTL_RESULT_ERROR_DEVICE_LOST
3821 ///     - CTL_RESULT_ERROR_INVALID_NULL_HANDLE
3822 ///         + `nullptr == hDisplayOutput`
3823 ///     - CTL_RESULT_ERROR_INVALID_NULL_POINTER
3824 ///         + `nullptr == pCustomModeArgs`
3825 ///     - ::CTL_RESULT_ERROR_UNSUPPORTED_VERSION - "Unsupported version"
3826 ///     - ::CTL_RESULT_ERROR_INVALID_OPERATION_TYPE - "Invalid operation type"
3827 ///     - ::CTL_RESULT_ERROR_INVALID_NULL_POINTER - "Invalid null pointer"
3828 ///     - ::CTL_RESULT_ERROR_NULL_OS_DISPLAY_OUTPUT_HANDLE - "Null OS display output handle"
3829 ///     - ::CTL_RESULT_ERROR_NULL_OS_INTERFACE - "Null OS interface"
3830 ///     - ::CTL_RESULT_ERROR_NULL_OS_ADAPATER_HANDLE - "Null OS adapter handle"
3831 ///     - ::CTL_RESULT_ERROR_KMD_CALL - "Kernal mode driver call failure"
3832 ///     - ::CTL_RESULT_ERROR_INVALID_ARGUMENT - "Invalid combination of parameters"
3833 ///     - ::CTL_RESULT_ERROR_CUSTOM_MODE_STANDARD_CUSTOM_MODE_EXISTS - "Standard custom mode exists"
3834 ///     - ::CTL_RESULT_ERROR_CUSTOM_MODE_NON_CUSTOM_MATCHING_MODE_EXISTS - "Non custom matching mode exists"
3835 ///     - ::CTL_RESULT_ERROR_CUSTOM_MODE_INSUFFICIENT_MEMORY - "Custom mode insufficent memory"
3836 CTL_APIEXPORT ctl_result_t CTL_APICALL
3837 ctlGetSetCustomMode(
3838     ctl_display_output_handle_t hDisplayOutput,     ///< [in] Handle to display output
3839     ctl_get_set_custom_mode_args_t* pCustomModeArgs ///< [in,out] Custom mode arguments
3840     );
3841
3842 ///////////////////////////////////////////////////////////////////////////////
3843 /// @brief Combined Display operation type
3844 typedef enum _ctl_combined_display_optype_t
3845 {
3846     CTL_COMBINED_DISPLAY_OPTYPE_IS_SUPPORTED_CONFIG = 1,///< To check whether given outputs can form a combined display, no changes
3847                                                     ///< are applied
3848     CTL_COMBINED_DISPLAY_OPTYPE_ENABLE = 2,         ///< To setup and enable a combined display
3849     CTL_COMBINED_DISPLAY_OPTYPE_DISABLE = 3,        ///< To disable combined display
3850     CTL_COMBINED_DISPLAY_OPTYPE_QUERY_CONFIG = 4,   ///< To query combined display configuration
3851     CTL_COMBINED_DISPLAY_OPTYPE_MAX
3852
3853 } ctl_combined_display_optype_t;
3854
3855 ///////////////////////////////////////////////////////////////////////////////
3856 /// @brief Combined Display's child display target mode
3857 typedef struct _ctl_child_display_target_mode_t
3858 {
3859     uint32_t Width;                                 ///< [in,out] Width
3860     uint32_t Height;                                ///< [in,out] Height
3861     float RefreshRate;                              ///< [in,out] Refresh Rate
3862     uint32_t ReservedFields[4];                     ///< [out] Reserved field of 16 bytes
3863
3864 } ctl_child_display_target_mode_t;
3865
3866 ///////////////////////////////////////////////////////////////////////////////
3867 /// @brief Combined Display's child display information
3868 typedef struct _ctl_combined_display_child_info_t
3869 {
3870     ctl_display_output_handle_t hDisplayOutput;     ///< [in,out] Display output handle under combined display configuration
3871     ctl_rect_t FbSrc;                               ///< [in,out] FrameBuffer source's RECT within Combined Display respective
3872     ctl_rect_t FbPos;                               ///< [in,out] FrameBuffer target's RECT within output size
3873     ctl_display_orientation_t DisplayOrientation;   ///< [in,out] 0/180 Degree Display orientation (rotation)
3874     ctl_child_display_target_mode_t TargetMode;     ///< [in,out] Desired target mode (width, height, refresh)
3875
3876 } ctl_combined_display_child_info_t;
3877
3878 ///////////////////////////////////////////////////////////////////////////////
3879 /// @brief Combined Display arguments
3880 typedef struct _ctl_combined_display_args_t
3881 {
3882     uint32_t Size;                                  ///< [in] size of this structure
3883     uint8_t Version;                                ///< [in] version of this structure
3884     ctl_combined_display_optype_t OpType;           ///< [in] Combined display operation type
3885     bool IsSupported;                               ///< [out] Returns yes/no in response to IS_SUPPORTED_CONFIG command
3886     uint8_t NumOutputs;                             ///< [in,out] Number of outputs part of desired combined display
3887                                                     ///< configuration
3888     uint32_t CombinedDesktopWidth;                  ///< [in,out] Width of desired combined display configuration
3889     uint32_t CombinedDesktopHeight;                 ///< [in,out] Height of desired combined display configuration
3890     ctl_combined_display_child_info_t* pChildInfo;  ///< [in,out] List of child display information respective to each output
3891     ctl_display_output_handle_t hCombinedDisplayOutput; ///< [in,out] Handle to combined display output
3892
3893 } ctl_combined_display_args_t;
3894
3895 ///////////////////////////////////////////////////////////////////////////////
3896 /// @brief Get/Set Combined Display
3897 ///
3898 /// @details
3899 ///     - To get or set combined display.
3900 ///
3901 /// @returns
3902 ///     - CTL_RESULT_SUCCESS
3903 ///     - CTL_RESULT_ERROR_UNINITIALIZED
3904 ///     - CTL_RESULT_ERROR_DEVICE_LOST
3905 ///     - CTL_RESULT_ERROR_INVALID_NULL_HANDLE
3906 ///         + `nullptr == hDeviceAdapter`
3907 ///     - CTL_RESULT_ERROR_INVALID_NULL_POINTER
3908 ///         + `nullptr == pCombinedDisplayArgs`
3909 ///     - ::CTL_RESULT_ERROR_UNSUPPORTED_VERSION - "Unsupported version"
3910 ///     - ::CTL_RESULT_ERROR_INVALID_OPERATION_TYPE - "Invalid operation type"
3911 ///     - ::CTL_RESULT_ERROR_INSUFFICIENT_PERMISSIONS - "Insufficient permissions"
3912 ///     - ::CTL_RESULT_ERROR_INVALID_NULL_POINTER - "Invalid null pointer"
3913 ///     - ::CTL_RESULT_ERROR_NULL_OS_DISPLAY_OUTPUT_HANDLE - "Null OS display output handle"
3914 ///     - ::CTL_RESULT_ERROR_NULL_OS_INTERFACE - "Null OS interface"
3915 ///     - ::CTL_RESULT_ERROR_NULL_OS_ADAPATER_HANDLE - "Null OS adapter handle"
3916 ///     - ::CTL_RESULT_ERROR_KMD_CALL - "Kernel mode driver call failure"
3917 ///     - ::CTL_RESULT_ERROR_FEATURE_NOT_SUPPORTED - "Combined Display feature is not supported in this platform"
3918 CTL_APIEXPORT ctl_result_t CTL_APICALL
3919 ctlGetSetCombinedDisplay(
3920     ctl_device_adapter_handle_t hDeviceAdapter,     ///< [in][release] Handle to control device adapter
3921     ctl_combined_display_args_t* pCombinedDisplayArgs   ///< [in,out] Setup and get combined display arguments
3922     );
3923
3924 ///////////////////////////////////////////////////////////////////////////////
3925 /// @brief Display Genlock Operations
3926 typedef enum _ctl_genlock_operation_t
3927 {
3928     CTL_GENLOCK_OPERATION_GET_TIMING_DETAILS = 0,   ///< Get details of GENLOCK support and timing information
3929     CTL_GENLOCK_OPERATION_VALIDATE = 1,             ///< Driver to verify that the topology is Genlock capable
3930     CTL_GENLOCK_OPERATION_ENABLE = 2,               ///< Enable GENLOCK
3931     CTL_GENLOCK_OPERATION_DISABLE = 3,              ///< Disable GENLOCK
3932     CTL_GENLOCK_OPERATION_GET_TOPOLOGY = 4,         ///< Get details of the current Genlock topology that is applied
3933     CTL_GENLOCK_OPERATION_MAX
3934
3935 } ctl_genlock_operation_t;
3936
3937 ///////////////////////////////////////////////////////////////////////////////
3938 /// @brief Display Genlock Info
3939 typedef struct _ctl_genlock_display_info_t
3940 {
3941     ctl_display_output_handle_t hDisplayOutput;     ///< [in,out] Display output handle under Genlock topology
3942     bool IsPrimary;                                 ///< [in,out] Genlock Primary
3943
3944 } ctl_genlock_display_info_t;
3945
3946 ///////////////////////////////////////////////////////////////////////////////
3947 /// @brief Genlock Target Mode List
3948 typedef struct _ctl_genlock_target_mode_list_t
3949 {
3950     ctl_display_output_handle_t hDisplayOutput;     ///< [in] Display output handle for whom target mode list is required
3951     uint32_t NumModes;                              ///< [in,out] Number of supported Modes that is returned from a driver
3952     ctl_display_timing_t* pTargetModes;             ///< [out] Display Genlock operation and information
3953
3954 } ctl_genlock_target_mode_list_t;
3955
3956 ///////////////////////////////////////////////////////////////////////////////
3957 /// @brief Genlock Topology
3958 typedef struct _ctl_genlock_topology_t
3959 {
3960     uint8_t NumGenlockDisplays;                     ///< [in,out] Number of Genlock displays
3961     bool IsPrimaryGenlockSystem;                    ///< [in,out] Primary Genlock system
3962     ctl_display_timing_t CommonTargetMode;          ///< [in] Common target mode
3963     ctl_genlock_display_info_t* pGenlockDisplayInfo;///< [in,out] List of Genlock display info
3964     ctl_genlock_target_mode_list_t* pGenlockModeList;   ///< [out] List of Genlock target modes
3965
3966 } ctl_genlock_topology_t;
3967
3968 ///////////////////////////////////////////////////////////////////////////////
3969 /// @brief Display Genlock Arg type
3970 typedef struct _ctl_genlock_args_t
3971 {
3972     uint32_t Size;                                  ///< [in] size of this structure
3973     uint8_t Version;                                ///< [in] version of this structure
3974     ctl_genlock_operation_t Operation;              ///< [in] Display Genlock Operation
3975     ctl_genlock_topology_t GenlockTopology;         ///< [in,out] Display Genlock array of topology structures
3976     bool IsGenlockEnabled;                          ///< [out] Whether the feature is currently enabled or not
3977     bool IsGenlockPossible;                         ///< [out] Indicates if Genlock can be enabled/disabled with the given
3978                                                     ///< topology
3979
3980 } ctl_genlock_args_t;
3981
3982 ///////////////////////////////////////////////////////////////////////////////
3983 /// @brief Get/Set Display Genlock
3984 ///
3985 /// @details
3986 ///     - To get or set Display Genlock.
3987 ///
3988 /// @returns
3989 ///     - CTL_RESULT_SUCCESS
3990 ///     - CTL_RESULT_ERROR_UNINITIALIZED
3991 ///     - CTL_RESULT_ERROR_DEVICE_LOST
3992 ///     - CTL_RESULT_ERROR_INVALID_NULL_POINTER
3993 ///         + `nullptr == hDeviceAdapter`
3994 ///         + `nullptr == pGenlockArgs`
3995 ///         + `nullptr == hFailureDeviceAdapter`
3996 ///     - ::CTL_RESULT_ERROR_UNSUPPORTED_VERSION - "Unsupported version"
3997 ///     - ::CTL_RESULT_ERROR_INVALID_NULL_POINTER - "Invalid null pointer"
3998 ///     - ::CTL_RESULT_ERROR_NULL_OS_DISPLAY_OUTPUT_HANDLE - "Null OS display output handle"
3999 ///     - ::CTL_RESULT_ERROR_NULL_OS_INTERFACE - "Null OS interface"
4000 ///     - ::CTL_RESULT_ERROR_NULL_OS_ADAPATER_HANDLE - "Null OS adapter handle"
4001 ///     - ::CTL_RESULT_ERROR_INVALID_SIZE - "Invalid topology structure size"
4002 ///     - ::CTL_RESULT_ERROR_KMD_CALL - "Kernel mode driver call failure"
4003 CTL_APIEXPORT ctl_result_t CTL_APICALL
4004 ctlGetSetDisplayGenlock(
4005     ctl_device_adapter_handle_t* hDeviceAdapter,    ///< [in][release] Handle to control device adapter
4006     ctl_genlock_args_t** pGenlockArgs,              ///< [in,out] Display Genlock operation and information
4007     uint32_t AdapterCount,                          ///< [in] Number of device adapters
4008     ctl_device_adapter_handle_t* hFailureDeviceAdapter  ///< [out] Handle to address the failure device adapter in an error case
4009     );
4010
4011
4012 #if !defined(__GNUC__)
4013 #pragma endregion // display
4014 #endif
4015 // Intel 'ctlApi' for Device Adapter - Engine groups
4016 #if !defined(__GNUC__)
4017 #pragma region engine
4018 #endif
4019 ///////////////////////////////////////////////////////////////////////////////
4020 /// @brief Accelerator engine groups
4021 typedef enum _ctl_engine_group_t
4022 {
4023     CTL_ENGINE_GROUP_GT = 0,                        ///< Access information about all engines combined.
4024     CTL_ENGINE_GROUP_RENDER = 1,                    ///< Access information about all render and compute engines combined.
4025     CTL_ENGINE_GROUP_MEDIA = 2,                     ///< Access information about all media engines combined.
4026     CTL_ENGINE_GROUP_MAX
4027
4028 } ctl_engine_group_t;
4029
4030 ///////////////////////////////////////////////////////////////////////////////
4031 /// @brief Engine group properties
4032 typedef struct _ctl_engine_properties_t
4033 {
4034     uint32_t Size;                                  ///< [in] size of this structure
4035     uint8_t Version;                                ///< [in] version of this structure
4036     ctl_engine_group_t type;                        ///< [out] The engine group
4037
4038 } ctl_engine_properties_t;
4039
4040 ///////////////////////////////////////////////////////////////////////////////
4041 /// @brief Engine activity counters
4042 ///
4043 /// @details
4044 ///     - Percent utilization is calculated by taking two snapshots (s1, s2) and
4045 ///       using the equation: %util = (s2.activeTime - s1.activeTime) /
4046 ///       (s2.timestamp - s1.timestamp)
4047 typedef struct _ctl_engine_stats_t
4048 {
4049     uint32_t Size;                                  ///< [in] size of this structure
4050     uint8_t Version;                                ///< [in] version of this structure
4051     uint64_t activeTime;                            ///< [out] Monotonic counter for time in microseconds that this resource is
4052                                                     ///< actively running workloads.
4053     uint64_t timestamp;                             ///< [out] Monotonic timestamp counter in microseconds when activeTime
4054                                                     ///< counter was sampled.
4055                                                     ///< This timestamp should only be used to calculate delta time between
4056                                                     ///< snapshots of this structure.
4057                                                     ///< Never take the delta of this timestamp with the timestamp from a
4058                                                     ///< different structure since they are not guaranteed to have the same base.
4059                                                     ///< The absolute value of the timestamp is only valid during within the
4060                                                     ///< application and may be different on the next execution.
4061
4062 } ctl_engine_stats_t;
4063
4064 ///////////////////////////////////////////////////////////////////////////////
4065 /// @brief Get handle of engine groups
4066 ///
4067 /// @details
4068 ///     - The application may call this function from simultaneous threads.
4069 ///     - The implementation of this function should be lock-free.
4070 ///
4071 /// @returns
4072 ///     - CTL_RESULT_SUCCESS
4073 ///     - CTL_RESULT_ERROR_UNINITIALIZED
4074 ///     - CTL_RESULT_ERROR_DEVICE_LOST
4075 ///     - CTL_RESULT_ERROR_INVALID_NULL_HANDLE
4076 ///         + `nullptr == hDAhandle`
4077 ///     - CTL_RESULT_ERROR_INVALID_NULL_POINTER
4078 ///         + `nullptr == pCount`
4079 CTL_APIEXPORT ctl_result_t CTL_APICALL
4080 ctlEnumEngineGroups(
4081     ctl_device_adapter_handle_t hDAhandle,          ///< [in][release] Handle to adapter
4082     uint32_t* pCount,                               ///< [in,out] pointer to the number of components of this type.
4083                                                     ///< if count is zero, then the driver shall update the value with the
4084                                                     ///< total number of components of this type that are available.
4085                                                     ///< if count is greater than the number of components of this type that
4086                                                     ///< are available, then the driver shall update the value with the correct
4087                                                     ///< number of components.
4088     ctl_engine_handle_t* phEngine                   ///< [in,out][optional][range(0, *pCount)] array of handle of components of
4089                                                     ///< this type.
4090                                                     ///< if count is less than the number of components of this type that are
4091                                                     ///< available, then the driver shall only retrieve that number of
4092                                                     ///< component handles.
4093     );
4094
4095 ///////////////////////////////////////////////////////////////////////////////
4096 /// @brief Get engine group properties
4097 ///
4098 /// @details
4099 ///     - The application may call this function from simultaneous threads.
4100 ///     - The implementation of this function should be lock-free.
4101 ///
4102 /// @returns
4103 ///     - CTL_RESULT_SUCCESS
4104 ///     - CTL_RESULT_ERROR_UNINITIALIZED
4105 ///     - CTL_RESULT_ERROR_DEVICE_LOST
4106 ///     - CTL_RESULT_ERROR_INVALID_NULL_HANDLE
4107 ///         + `nullptr == hEngine`
4108 ///     - CTL_RESULT_ERROR_INVALID_NULL_POINTER
4109 ///         + `nullptr == pProperties`
4110 CTL_APIEXPORT ctl_result_t CTL_APICALL
4111 ctlEngineGetProperties(
4112     ctl_engine_handle_t hEngine,                    ///< [in] Handle for the component.
4113     ctl_engine_properties_t* pProperties            ///< [in,out] The properties for the specified engine group.
4114     );
4115
4116 ///////////////////////////////////////////////////////////////////////////////
4117 /// @brief Get the activity stats for an engine group
4118 ///
4119 /// @details
4120 ///     - The application may call this function from simultaneous threads.
4121 ///     - The implementation of this function should be lock-free.
4122 ///
4123 /// @returns
4124 ///     - CTL_RESULT_SUCCESS
4125 ///     - CTL_RESULT_ERROR_UNINITIALIZED
4126 ///     - CTL_RESULT_ERROR_DEVICE_LOST
4127 ///     - CTL_RESULT_ERROR_INVALID_NULL_HANDLE
4128 ///         + `nullptr == hEngine`
4129 ///     - CTL_RESULT_ERROR_INVALID_NULL_POINTER
4130 ///         + `nullptr == pStats`
4131 CTL_APIEXPORT ctl_result_t CTL_APICALL
4132 ctlEngineGetActivity(
4133     ctl_engine_handle_t hEngine,                    ///< [in] Handle for the component.
4134     ctl_engine_stats_t* pStats                      ///< [in,out] Will contain a snapshot of the engine group activity
4135                                                     ///< counters.
4136     );
4137
4138
4139 #if !defined(__GNUC__)
4140 #pragma endregion // engine
4141 #endif
4142 // Intel 'ctlApi' for Device Adapter- Fan management
4143 #if !defined(__GNUC__)
4144 #pragma region fan
4145 #endif
4146 ///////////////////////////////////////////////////////////////////////////////
4147 /// @brief Fan resource speed mode
4148 typedef enum _ctl_fan_speed_mode_t
4149 {
4150     CTL_FAN_SPEED_MODE_DEFAULT = 0,                 ///< The fan speed is operating using the hardware default settings
4151     CTL_FAN_SPEED_MODE_FIXED = 1,                   ///< The fan speed is currently set to a fixed value
4152     CTL_FAN_SPEED_MODE_TABLE = 2,                   ///< The fan speed is currently controlled dynamically by hardware based on
4153                                                     ///< a temp/speed table
4154     CTL_FAN_SPEED_MODE_MAX
4155
4156 } ctl_fan_speed_mode_t;
4157
4158 ///////////////////////////////////////////////////////////////////////////////
4159 /// @brief Fan speed units
4160 typedef enum _ctl_fan_speed_units_t
4161 {
4162     CTL_FAN_SPEED_UNITS_RPM = 0,                    ///< The fan speed is in units of revolutions per minute (rpm)
4163     CTL_FAN_SPEED_UNITS_PERCENT = 1,                ///< The fan speed is a percentage of the maximum speed of the fan
4164     CTL_FAN_SPEED_UNITS_MAX
4165
4166 } ctl_fan_speed_units_t;
4167
4168 ///////////////////////////////////////////////////////////////////////////////
4169 /// @brief Fan speed
4170 typedef struct _ctl_fan_speed_t
4171 {
4172     uint32_t Size;                                  ///< [in] size of this structure
4173     uint8_t Version;                                ///< [in] version of this structure
4174     int32_t speed;                                  ///< [in,out] The speed of the fan. On output, a value of -1 indicates that
4175                                                     ///< there is no fixed fan speed setting.
4176     ctl_fan_speed_units_t units;                    ///< [in,out] The units that the fan speed is expressed in. On output, if
4177                                                     ///< fan speed is -1 then units should be ignored.
4178
4179 } ctl_fan_speed_t;
4180
4181 ///////////////////////////////////////////////////////////////////////////////
4182 /// @brief Fan temperature/speed pair
4183 typedef struct _ctl_fan_temp_speed_t
4184 {
4185     uint32_t Size;                                  ///< [in] size of this structure
4186     uint8_t Version;                                ///< [in] version of this structure
4187     uint32_t temperature;                           ///< [in,out] Temperature in degrees Celsius.
4188     ctl_fan_speed_t speed;                          ///< [in,out] The speed of the fan
4189
4190 } ctl_fan_temp_speed_t;
4191
4192 ///////////////////////////////////////////////////////////////////////////////
4193 #ifndef CTL_FAN_TEMP_SPEED_PAIR_COUNT
4194 /// @brief Maximum number of fan temperature/speed pairs in the fan speed table.
4195 #define CTL_FAN_TEMP_SPEED_PAIR_COUNT  32
4196 #endif // CTL_FAN_TEMP_SPEED_PAIR_COUNT
4197
4198 ///////////////////////////////////////////////////////////////////////////////
4199 /// @brief Fan speed table
4200 typedef struct _ctl_fan_speed_table_t
4201 {
4202     uint32_t Size;                                  ///< [in] size of this structure
4203     uint8_t Version;                                ///< [in] version of this structure
4204     int32_t numPoints;                              ///< [in,out] The number of valid points in the fan speed table. 0 means
4205                                                     ///< that there is no fan speed table configured. -1 means that a fan speed
4206                                                     ///< table is not supported by the hardware.
4207     ctl_fan_temp_speed_t table[CTL_FAN_TEMP_SPEED_PAIR_COUNT];  ///< [in,out] Array of temperature/fan speed pairs. The table is ordered
4208                                                     ///< based on temperature from lowest to highest.
4209
4210 } ctl_fan_speed_table_t;
4211
4212 ///////////////////////////////////////////////////////////////////////////////
4213 /// @brief Fan properties
4214 typedef struct _ctl_fan_properties_t
4215 {
4216     uint32_t Size;                                  ///< [in] size of this structure
4217     uint8_t Version;                                ///< [in] version of this structure
4218     bool canControl;                                ///< [out] Indicates if software can control the fan speed assuming the
4219                                                     ///< user has permissions
4220     uint32_t supportedModes;                        ///< [out] Bitfield of supported fan configuration modes
4221                                                     ///< (1<<::ctl_fan_speed_mode_t)
4222     uint32_t supportedUnits;                        ///< [out] Bitfield of supported fan speed units
4223                                                     ///< (1<<::ctl_fan_speed_units_t)
4224     int32_t maxRPM;                                 ///< [out] The maximum RPM of the fan. A value of -1 means that this
4225                                                     ///< property is unknown.
4226     int32_t maxPoints;                              ///< [out] The maximum number of points in the fan temp/speed table. A
4227                                                     ///< value of -1 means that this fan doesn't support providing a temp/speed
4228                                                     ///< table.
4229
4230 } ctl_fan_properties_t;
4231
4232 ///////////////////////////////////////////////////////////////////////////////
4233 /// @brief Fan configuration
4234 typedef struct _ctl_fan_config_t
4235 {
4236     uint32_t Size;                                  ///< [in] size of this structure
4237     uint8_t Version;                                ///< [in] version of this structure
4238     ctl_fan_speed_mode_t mode;                      ///< [in,out] The fan speed mode (fixed, temp-speed table)
4239     ctl_fan_speed_t speedFixed;                     ///< [in,out] The current fixed fan speed setting
4240     ctl_fan_speed_table_t speedTable;               ///< [out] A table containing temperature/speed pairs
4241
4242 } ctl_fan_config_t;
4243
4244 ///////////////////////////////////////////////////////////////////////////////
4245 /// @brief Get handle of fans
4246 ///
4247 /// @details
4248 ///     - The application may call this function from simultaneous threads.
4249 ///     - The implementation of this function should be lock-free.
4250 ///
4251 /// @returns
4252 ///     - CTL_RESULT_SUCCESS
4253 ///     - CTL_RESULT_ERROR_UNINITIALIZED
4254 ///     - CTL_RESULT_ERROR_DEVICE_LOST
4255 ///     - CTL_RESULT_ERROR_INVALID_NULL_HANDLE
4256 ///         + `nullptr == hDAhandle`
4257 ///     - CTL_RESULT_ERROR_INVALID_NULL_POINTER
4258 ///         + `nullptr == pCount`
4259 CTL_APIEXPORT ctl_result_t CTL_APICALL
4260 ctlEnumFans(
4261     ctl_device_adapter_handle_t hDAhandle,          ///< [in][release] Handle to the adapter
4262     uint32_t* pCount,                               ///< [in,out] pointer to the number of components of this type.
4263                                                     ///< if count is zero, then the driver shall update the value with the
4264                                                     ///< total number of components of this type that are available.
4265                                                     ///< if count is greater than the number of components of this type that
4266                                                     ///< are available, then the driver shall update the value with the correct
4267                                                     ///< number of components.
4268     ctl_fan_handle_t* phFan                         ///< [in,out][optional][range(0, *pCount)] array of handle of components of
4269                                                     ///< this type.
4270                                                     ///< if count is less than the number of components of this type that are
4271                                                     ///< available, then the driver shall only retrieve that number of
4272                                                     ///< component handles.
4273     );
4274
4275 ///////////////////////////////////////////////////////////////////////////////
4276 /// @brief Get fan properties
4277 ///
4278 /// @details
4279 ///     - The application may call this function from simultaneous threads.
4280 ///     - The implementation of this function should be lock-free.
4281 ///
4282 /// @returns
4283 ///     - CTL_RESULT_SUCCESS
4284 ///     - CTL_RESULT_ERROR_UNINITIALIZED
4285 ///     - CTL_RESULT_ERROR_DEVICE_LOST
4286 ///     - CTL_RESULT_ERROR_INVALID_NULL_HANDLE
4287 ///         + `nullptr == hFan`
4288 ///     - CTL_RESULT_ERROR_INVALID_NULL_POINTER
4289 ///         + `nullptr == pProperties`
4290 CTL_APIEXPORT ctl_result_t CTL_APICALL
4291 ctlFanGetProperties(
4292     ctl_fan_handle_t hFan,                          ///< [in] Handle for the component.
4293     ctl_fan_properties_t* pProperties               ///< [in,out] Will contain the properties of the fan.
4294     );
4295
4296 ///////////////////////////////////////////////////////////////////////////////
4297 /// @brief Get fan configurations and the current fan speed mode (default, fixed,
4298 ///        temp-speed table)
4299 ///
4300 /// @details
4301 ///     - The application may call this function from simultaneous threads.
4302 ///     - The implementation of this function should be lock-free.
4303 ///
4304 /// @returns
4305 ///     - CTL_RESULT_SUCCESS
4306 ///     - CTL_RESULT_ERROR_UNINITIALIZED
4307 ///     - CTL_RESULT_ERROR_DEVICE_LOST
4308 ///     - CTL_RESULT_ERROR_INVALID_NULL_HANDLE
4309 ///         + `nullptr == hFan`
4310 ///     - CTL_RESULT_ERROR_INVALID_NULL_POINTER
4311 ///         + `nullptr == pConfig`
4312 CTL_APIEXPORT ctl_result_t CTL_APICALL
4313 ctlFanGetConfig(
4314     ctl_fan_handle_t hFan,                          ///< [in] Handle for the component.
4315     ctl_fan_config_t* pConfig                       ///< [in,out] Will contain the current configuration of the fan.
4316     );
4317
4318 ///////////////////////////////////////////////////////////////////////////////
4319 /// @brief Configure the fan to run with hardware factory settings (set mode to
4320 ///        ::CTL_FAN_SPEED_MODE_DEFAULT)
4321 ///
4322 /// @details
4323 ///     - The application may call this function from simultaneous threads.
4324 ///     - The implementation of this function should be lock-free.
4325 ///
4326 /// @returns
4327 ///     - CTL_RESULT_SUCCESS
4328 ///     - CTL_RESULT_ERROR_UNINITIALIZED
4329 ///     - CTL_RESULT_ERROR_DEVICE_LOST
4330 ///     - CTL_RESULT_ERROR_INVALID_NULL_HANDLE
4331 ///         + `nullptr == hFan`
4332 ///     - ::CTL_RESULT_ERROR_INSUFFICIENT_PERMISSIONS
4333 ///         + User does not have permissions to make these modifications.
4334 CTL_APIEXPORT ctl_result_t CTL_APICALL
4335 ctlFanSetDefaultMode(
4336     ctl_fan_handle_t hFan                           ///< [in] Handle for the component.
4337     );
4338
4339 ///////////////////////////////////////////////////////////////////////////////
4340 /// @brief Configure the fan to rotate at a fixed speed (set mode to
4341 ///        ::CTL_FAN_SPEED_MODE_FIXED)
4342 ///
4343 /// @details
4344 ///     - The application may call this function from simultaneous threads.
4345 ///     - The implementation of this function should be lock-free.
4346 ///
4347 /// @returns
4348 ///     - CTL_RESULT_SUCCESS
4349 ///     - CTL_RESULT_ERROR_UNINITIALIZED
4350 ///     - CTL_RESULT_ERROR_DEVICE_LOST
4351 ///     - CTL_RESULT_ERROR_INVALID_NULL_HANDLE
4352 ///         + `nullptr == hFan`
4353 ///     - CTL_RESULT_ERROR_INVALID_NULL_POINTER
4354 ///         + `nullptr == speed`
4355 ///     - ::CTL_RESULT_ERROR_INSUFFICIENT_PERMISSIONS
4356 ///         + User does not have permissions to make these modifications.
4357 ///     - ::CTL_RESULT_ERROR_UNSUPPORTED_FEATURE
4358 ///         + Fixing the fan speed not supported by the hardware or the fan speed units are not supported. See ::ctl_fan_properties_t.supportedModes and ::ctl_fan_properties_t.supportedUnits.
4359 CTL_APIEXPORT ctl_result_t CTL_APICALL
4360 ctlFanSetFixedSpeedMode(
4361     ctl_fan_handle_t hFan,                          ///< [in] Handle for the component.
4362     const ctl_fan_speed_t* speed                    ///< [in] The fixed fan speed setting
4363     );
4364
4365 ///////////////////////////////////////////////////////////////////////////////
4366 /// @brief Configure the fan to adjust speed based on a temperature/speed table
4367 ///        (set mode to ::CTL_FAN_SPEED_MODE_TABLE)
4368 ///
4369 /// @details
4370 ///     - The application may call this function from simultaneous threads.
4371 ///     - The implementation of this function should be lock-free.
4372 ///
4373 /// @returns
4374 ///     - CTL_RESULT_SUCCESS
4375 ///     - CTL_RESULT_ERROR_UNINITIALIZED
4376 ///     - CTL_RESULT_ERROR_DEVICE_LOST
4377 ///     - CTL_RESULT_ERROR_INVALID_NULL_HANDLE
4378 ///         + `nullptr == hFan`
4379 ///     - CTL_RESULT_ERROR_INVALID_NULL_POINTER
4380 ///         + `nullptr == speedTable`
4381 ///     - ::CTL_RESULT_ERROR_INSUFFICIENT_PERMISSIONS
4382 ///         + User does not have permissions to make these modifications.
4383 ///     - ::CTL_RESULT_ERROR_INVALID_ARGUMENT
4384 ///         + The temperature/speed pairs in the array are not sorted on temperature from lowest to highest.
4385 ///     - ::CTL_RESULT_ERROR_UNSUPPORTED_FEATURE
4386 ///         + Fan speed table not supported by the hardware or the fan speed units are not supported. See ::ctl_fan_properties_t.supportedModes and ::ctl_fan_properties_t.supportedUnits.
4387 CTL_APIEXPORT ctl_result_t CTL_APICALL
4388 ctlFanSetSpeedTableMode(
4389     ctl_fan_handle_t hFan,                          ///< [in] Handle for the component.
4390     const ctl_fan_speed_table_t* speedTable         ///< [in] A table containing temperature/speed pairs.
4391     );
4392
4393 ///////////////////////////////////////////////////////////////////////////////
4394 /// @brief Get current state of a fan - current mode and speed
4395 ///
4396 /// @details
4397 ///     - The application may call this function from simultaneous threads.
4398 ///     - The implementation of this function should be lock-free.
4399 ///
4400 /// @returns
4401 ///     - CTL_RESULT_SUCCESS
4402 ///     - CTL_RESULT_ERROR_UNINITIALIZED
4403 ///     - CTL_RESULT_ERROR_DEVICE_LOST
4404 ///     - CTL_RESULT_ERROR_INVALID_NULL_HANDLE
4405 ///         + `nullptr == hFan`
4406 ///     - CTL_RESULT_ERROR_INVALID_ENUMERATION
4407 ///         + `::CTL_FAN_SPEED_UNITS_PERCENT < units`
4408 ///     - CTL_RESULT_ERROR_INVALID_NULL_POINTER
4409 ///         + `nullptr == pSpeed`
4410 ///     - ::CTL_RESULT_ERROR_UNSUPPORTED_FEATURE
4411 ///         + The requested fan speed units are not supported. See ::ctl_fan_properties_t.supportedUnits.
4412 CTL_APIEXPORT ctl_result_t CTL_APICALL
4413 ctlFanGetState(
4414     ctl_fan_handle_t hFan,                          ///< [in] Handle for the component.
4415     ctl_fan_speed_units_t units,                    ///< [in] The units in which the fan speed should be returned.
4416     int32_t* pSpeed                                 ///< [in,out] Will contain the current speed of the fan in the units
4417                                                     ///< requested. A value of -1 indicates that the fan speed cannot be
4418                                                     ///< measured.
4419     );
4420
4421
4422 #if !defined(__GNUC__)
4423 #pragma endregion // fan
4424 #endif
4425 // Intel 'ctlApi' for Device Adapter - Frequency domains
4426 #if !defined(__GNUC__)
4427 #pragma region frequency
4428 #endif
4429 ///////////////////////////////////////////////////////////////////////////////
4430 /// @brief Frequency domains.
4431 typedef enum _ctl_freq_domain_t
4432 {
4433     CTL_FREQ_DOMAIN_GPU = 0,                        ///< GPU Core Domain.
4434     CTL_FREQ_DOMAIN_MEMORY = 1,                     ///< Local Memory Domain.
4435     CTL_FREQ_DOMAIN_MAX
4436
4437 } ctl_freq_domain_t;
4438
4439 ///////////////////////////////////////////////////////////////////////////////
4440 /// @brief Frequency properties
4441 typedef struct _ctl_freq_properties_t
4442 {
4443     uint32_t Size;                                  ///< [in] size of this structure
4444     uint8_t Version;                                ///< [in] version of this structure
4445     ctl_freq_domain_t type;                         ///< [out] The hardware block that this frequency domain controls (GPU,
4446                                                     ///< memory, ...)
4447     bool canControl;                                ///< [out] Indicates if software can control the frequency of this domain
4448                                                     ///< assuming the user has permissions
4449     double min;                                     ///< [out] The minimum hardware clock frequency in units of MHz.
4450     double max;                                     ///< [out] The maximum non-overclock hardware clock frequency in units of
4451                                                     ///< MHz.
4452
4453 } ctl_freq_properties_t;
4454
4455 ///////////////////////////////////////////////////////////////////////////////
4456 /// @brief Frequency range between which the hardware can operate. The limits can
4457 ///        be above or below the hardware limits - the hardware will clamp
4458 ///        appropriately.
4459 typedef struct _ctl_freq_range_t
4460 {
4461     uint32_t Size;                                  ///< [in] size of this structure
4462     uint8_t Version;                                ///< [in] version of this structure
4463     double min;                                     ///< [in,out] The min frequency in MHz below which hardware frequency
4464                                                     ///< management will not request frequencies. On input, setting to 0 will
4465                                                     ///< permit the frequency to go down to the hardware minimum. On output, a
4466                                                     ///< negative value indicates that no external minimum frequency limit is
4467                                                     ///< in effect.
4468     double max;                                     ///< [in,out] The max frequency in MHz above which hardware frequency
4469                                                     ///< management will not request frequencies. On input, setting to 0 or a
4470                                                     ///< very big number will permit the frequency to go all the way up to the
4471                                                     ///< hardware maximum. On output, a negative number indicates that no
4472                                                     ///< external maximum frequency limit is in effect.
4473
4474 } ctl_freq_range_t;
4475
4476 ///////////////////////////////////////////////////////////////////////////////
4477 /// @brief Frequency throttle reasons
4478 typedef uint32_t ctl_freq_throttle_reason_flags_t;
4479 typedef enum _ctl_freq_throttle_reason_flag_t
4480 {
4481     CTL_FREQ_THROTTLE_REASON_FLAG_AVE_PWR_CAP = CTL_BIT(0), ///< frequency throttled due to average power excursion (PL1)
4482     CTL_FREQ_THROTTLE_REASON_FLAG_BURST_PWR_CAP = CTL_BIT(1),   ///< frequency throttled due to burst power excursion (PL2)
4483     CTL_FREQ_THROTTLE_REASON_FLAG_CURRENT_LIMIT = CTL_BIT(2),   ///< frequency throttled due to current excursion (PL4)
4484     CTL_FREQ_THROTTLE_REASON_FLAG_THERMAL_LIMIT = CTL_BIT(3),   ///< frequency throttled due to thermal excursion (T > TjMax)
4485     CTL_FREQ_THROTTLE_REASON_FLAG_PSU_ALERT = CTL_BIT(4),   ///< frequency throttled due to power supply assertion
4486     CTL_FREQ_THROTTLE_REASON_FLAG_SW_RANGE = CTL_BIT(5),///< frequency throttled due to software supplied frequency range
4487     CTL_FREQ_THROTTLE_REASON_FLAG_HW_RANGE = CTL_BIT(6),///< frequency throttled due to a sub block that has a lower frequency
4488                                                     ///< range when it receives clocks
4489     CTL_FREQ_THROTTLE_REASON_FLAG_MAX = 0x80000000
4490
4491 } ctl_freq_throttle_reason_flag_t;
4492
4493 ///////////////////////////////////////////////////////////////////////////////
4494 /// @brief Frequency state
4495 typedef struct _ctl_freq_state_t
4496 {
4497     uint32_t Size;                                  ///< [in] size of this structure
4498     uint8_t Version;                                ///< [in] version of this structure
4499     double currentVoltage;                          ///< [out] Current voltage in Volts. A negative value indicates that this
4500                                                     ///< property is not known.
4501     double request;                                 ///< [out] The current frequency request in MHz. A negative value indicates
4502                                                     ///< that this property is not known.
4503     double tdp;                                     ///< [out] The maximum frequency in MHz supported under the current TDP
4504                                                     ///< conditions. This fluctuates dynamically based on the power and thermal
4505                                                     ///< limits of the part. A negative value indicates that this property is
4506                                                     ///< not known.
4507     double efficient;                               ///< [out] The efficient minimum frequency in MHz. A negative value
4508                                                     ///< indicates that this property is not known.
4509     double actual;                                  ///< [out] The resolved frequency in MHz. A negative value indicates that
4510                                                     ///< this property is not known.
4511     ctl_freq_throttle_reason_flags_t throttleReasons;   ///< [out] The reasons that the frequency is being limited by the hardware.
4512                                                     ///< Returns 0 (frequency not throttled) or a combination of ::ctl_freq_throttle_reason_flag_t.
4513
4514 } ctl_freq_state_t;
4515
4516 ///////////////////////////////////////////////////////////////////////////////
4517 /// @brief Frequency throttle time snapshot
4518 ///
4519 /// @details
4520 ///     - Percent time throttled is calculated by taking two snapshots (s1, s2)
4521 ///       and using the equation: %throttled = (s2.throttleTime -
4522 ///       s1.throttleTime) / (s2.timestamp - s1.timestamp)
4523 typedef struct _ctl_freq_throttle_time_t
4524 {
4525     uint32_t Size;                                  ///< [in] size of this structure
4526     uint8_t Version;                                ///< [in] version of this structure
4527     uint64_t throttleTime;                          ///< [out] The monotonic counter of time in microseconds that the frequency
4528                                                     ///< has been limited by the hardware.
4529     uint64_t timestamp;                             ///< [out] Microsecond timestamp when throttleTime was captured.
4530                                                     ///< This timestamp should only be used to calculate delta time between
4531                                                     ///< snapshots of this structure.
4532                                                     ///< Never take the delta of this timestamp with the timestamp from a
4533                                                     ///< different structure since they are not guaranteed to have the same base.
4534                                                     ///< The absolute value of the timestamp is only valid during within the
4535                                                     ///< application and may be different on the next execution.
4536
4537 } ctl_freq_throttle_time_t;
4538
4539 ///////////////////////////////////////////////////////////////////////////////
4540 /// @brief Get handle of frequency domains
4541 ///
4542 /// @details
4543 ///     - The application may call this function from simultaneous threads.
4544 ///     - The implementation of this function should be lock-free.
4545 ///
4546 /// @returns
4547 ///     - CTL_RESULT_SUCCESS
4548 ///     - CTL_RESULT_ERROR_UNINITIALIZED
4549 ///     - CTL_RESULT_ERROR_DEVICE_LOST
4550 ///     - CTL_RESULT_ERROR_INVALID_NULL_HANDLE
4551 ///         + `nullptr == hDAhandle`
4552 ///     - CTL_RESULT_ERROR_INVALID_NULL_POINTER
4553 ///         + `nullptr == pCount`
4554 CTL_APIEXPORT ctl_result_t CTL_APICALL
4555 ctlEnumFrequencyDomains(
4556     ctl_device_adapter_handle_t hDAhandle,          ///< [in][release] Handle to display adapter
4557     uint32_t* pCount,                               ///< [in,out] pointer to the number of components of this type.
4558                                                     ///< if count is zero, then the driver shall update the value with the
4559                                                     ///< total number of components of this type that are available.
4560                                                     ///< if count is greater than the number of components of this type that
4561                                                     ///< are available, then the driver shall update the value with the correct
4562                                                     ///< number of components.
4563     ctl_freq_handle_t* phFrequency                  ///< [in,out][optional][range(0, *pCount)] array of handle of components of
4564                                                     ///< this type.
4565                                                     ///< if count is less than the number of components of this type that are
4566                                                     ///< available, then the driver shall only retrieve that number of
4567                                                     ///< component handles.
4568     );
4569
4570 ///////////////////////////////////////////////////////////////////////////////
4571 /// @brief Get frequency properties - available frequencies
4572 ///
4573 /// @details
4574 ///     - The application may call this function from simultaneous threads.
4575 ///     - The implementation of this function should be lock-free.
4576 ///
4577 /// @returns
4578 ///     - CTL_RESULT_SUCCESS
4579 ///     - CTL_RESULT_ERROR_UNINITIALIZED
4580 ///     - CTL_RESULT_ERROR_DEVICE_LOST
4581 ///     - CTL_RESULT_ERROR_INVALID_NULL_HANDLE
4582 ///         + `nullptr == hFrequency`
4583 ///     - CTL_RESULT_ERROR_INVALID_NULL_POINTER
4584 ///         + `nullptr == pProperties`
4585 CTL_APIEXPORT ctl_result_t CTL_APICALL
4586 ctlFrequencyGetProperties(
4587     ctl_freq_handle_t hFrequency,                   ///< [in] Handle for the component.
4588     ctl_freq_properties_t* pProperties              ///< [in,out] The frequency properties for the specified domain.
4589     );
4590
4591 ///////////////////////////////////////////////////////////////////////////////
4592 /// @brief Get available non-overclocked hardware clock frequencies for the
4593 ///        frequency domain
4594 ///
4595 /// @details
4596 ///     - The list of available frequencies is returned in order of slowest to
4597 ///       fastest.
4598 ///     - The application may call this function from simultaneous threads.
4599 ///     - The implementation of this function should be lock-free.
4600 ///
4601 /// @returns
4602 ///     - CTL_RESULT_SUCCESS
4603 ///     - CTL_RESULT_ERROR_UNINITIALIZED
4604 ///     - CTL_RESULT_ERROR_DEVICE_LOST
4605 ///     - CTL_RESULT_ERROR_INVALID_NULL_HANDLE
4606 ///         + `nullptr == hFrequency`
4607 ///     - CTL_RESULT_ERROR_INVALID_NULL_POINTER
4608 ///         + `nullptr == pCount`
4609 CTL_APIEXPORT ctl_result_t CTL_APICALL
4610 ctlFrequencyGetAvailableClocks(
4611     ctl_freq_handle_t hFrequency,                   ///< [in] Device handle of the device.
4612     uint32_t* pCount,                               ///< [in,out] pointer to the number of frequencies.
4613                                                     ///< if count is zero, then the driver shall update the value with the
4614                                                     ///< total number of frequencies that are available.
4615                                                     ///< if count is greater than the number of frequencies that are available,
4616                                                     ///< then the driver shall update the value with the correct number of frequencies.
4617     double* phFrequency                             ///< [in,out][optional][range(0, *pCount)] array of frequencies in units of
4618                                                     ///< MHz and sorted from slowest to fastest.
4619                                                     ///< if count is less than the number of frequencies that are available,
4620                                                     ///< then the driver shall only retrieve that number of frequencies.
4621     );
4622
4623 ///////////////////////////////////////////////////////////////////////////////
4624 /// @brief Get current frequency limits
4625 ///
4626 /// @details
4627 ///     - The application may call this function from simultaneous threads.
4628 ///     - The implementation of this function should be lock-free.
4629 ///
4630 /// @returns
4631 ///     - CTL_RESULT_SUCCESS
4632 ///     - CTL_RESULT_ERROR_UNINITIALIZED
4633 ///     - CTL_RESULT_ERROR_DEVICE_LOST
4634 ///     - CTL_RESULT_ERROR_INVALID_NULL_HANDLE
4635 ///         + `nullptr == hFrequency`
4636 ///     - CTL_RESULT_ERROR_INVALID_NULL_POINTER
4637 ///         + `nullptr == pLimits`
4638 CTL_APIEXPORT ctl_result_t CTL_APICALL
4639 ctlFrequencyGetRange(
4640     ctl_freq_handle_t hFrequency,                   ///< [in] Handle for the component.
4641     ctl_freq_range_t* pLimits                       ///< [in,out] The range between which the hardware can operate for the
4642                                                     ///< specified domain.
4643     );
4644
4645 ///////////////////////////////////////////////////////////////////////////////
4646 /// @brief Set frequency range between which the hardware can operate.
4647 ///
4648 /// @details
4649 ///     - The application may call this function from simultaneous threads.
4650 ///     - The implementation of this function should be lock-free.
4651 ///
4652 /// @returns
4653 ///     - CTL_RESULT_SUCCESS
4654 ///     - CTL_RESULT_ERROR_UNINITIALIZED
4655 ///     - CTL_RESULT_ERROR_DEVICE_LOST
4656 ///     - CTL_RESULT_ERROR_INVALID_NULL_HANDLE
4657 ///         + `nullptr == hFrequency`
4658 ///     - CTL_RESULT_ERROR_INVALID_NULL_POINTER
4659 ///         + `nullptr == pLimits`
4660 ///     - ::CTL_RESULT_ERROR_INSUFFICIENT_PERMISSIONS
4661 ///         + User does not have permissions to make these modifications.
4662 CTL_APIEXPORT ctl_result_t CTL_APICALL
4663 ctlFrequencySetRange(
4664     ctl_freq_handle_t hFrequency,                   ///< [in] Handle for the component.
4665     const ctl_freq_range_t* pLimits                 ///< [in] The limits between which the hardware can operate for the
4666                                                     ///< specified domain.
4667     );
4668
4669 ///////////////////////////////////////////////////////////////////////////////
4670 /// @brief Get current frequency state - frequency request, actual frequency, TDP
4671 ///        limits
4672 ///
4673 /// @details
4674 ///     - The application may call this function from simultaneous threads.
4675 ///     - The implementation of this function should be lock-free.
4676 ///
4677 /// @returns
4678 ///     - CTL_RESULT_SUCCESS
4679 ///     - CTL_RESULT_ERROR_UNINITIALIZED
4680 ///     - CTL_RESULT_ERROR_DEVICE_LOST
4681 ///     - CTL_RESULT_ERROR_INVALID_NULL_HANDLE
4682 ///         + `nullptr == hFrequency`
4683 ///     - CTL_RESULT_ERROR_INVALID_NULL_POINTER
4684 ///         + `nullptr == pState`
4685 CTL_APIEXPORT ctl_result_t CTL_APICALL
4686 ctlFrequencyGetState(
4687     ctl_freq_handle_t hFrequency,                   ///< [in] Handle for the component.
4688     ctl_freq_state_t* pState                        ///< [in,out] Frequency state for the specified domain.
4689     );
4690
4691 ///////////////////////////////////////////////////////////////////////////////
4692 /// @brief Get frequency throttle time
4693 ///
4694 /// @details
4695 ///     - The application may call this function from simultaneous threads.
4696 ///     - The implementation of this function should be lock-free.
4697 ///
4698 /// @returns
4699 ///     - CTL_RESULT_SUCCESS
4700 ///     - CTL_RESULT_ERROR_UNINITIALIZED
4701 ///     - CTL_RESULT_ERROR_DEVICE_LOST
4702 ///     - CTL_RESULT_ERROR_INVALID_NULL_HANDLE
4703 ///         + `nullptr == hFrequency`
4704 ///     - CTL_RESULT_ERROR_INVALID_NULL_POINTER
4705 ///         + `nullptr == pThrottleTime`
4706 CTL_APIEXPORT ctl_result_t CTL_APICALL
4707 ctlFrequencyGetThrottleTime(
4708     ctl_freq_handle_t hFrequency,                   ///< [in] Handle for the component.
4709     ctl_freq_throttle_time_t* pThrottleTime         ///< [in,out] Will contain a snapshot of the throttle time counters for the
4710                                                     ///< specified domain.
4711     );
4712
4713
4714 #if !defined(__GNUC__)
4715 #pragma endregion // frequency
4716 #endif
4717 // Intel 'ctlApi' for Device Adapter
4718 #if !defined(__GNUC__)
4719 #pragma region media
4720 #endif
4721 ///////////////////////////////////////////////////////////////////////////////
4722 /// @brief Feature type
4723 typedef enum _ctl_video_processing_feature_t
4724 {
4725     CTL_VIDEO_PROCESSING_FEATURE_FILM_MODE_DETECTION = 0,   ///< Film mode detection.  Contains CTL_PROPERTY_VALUE_TYPE_BOOL ValueType.
4726     CTL_VIDEO_PROCESSING_FEATURE_NOISE_REDUCTION = 1,   ///< Noise reduction.  Contains CTL_PROPERTY_VALUE_TYPE_CUSTOM type field
4727                                                     ///< using struct ::ctl_video_processing_noise_reduction_t.
4728     CTL_VIDEO_PROCESSING_FEATURE_SHARPNESS = 2,     ///< Sharpness.  Contains CTL_PROPERTY_VALUE_TYPE_UINT32 ValueType.
4729     CTL_VIDEO_PROCESSING_FEATURE_ADAPTIVE_CONTRAST_ENHANCEMENT = 3, ///< Adaptive contrast enhancement.  Contains
4730                                                     ///< CTL_PROPERTY_VALUE_TYPE_CUSTOM type field using struct
4731                                                     ///< ::ctl_video_processing_adaptive_contrast_enhancement_t.
4732     CTL_VIDEO_PROCESSING_FEATURE_SUPER_RESOLUTION = 4,  ///< Super resolution.  Contains CTL_PROPERTY_VALUE_TYPE_CUSTOM ValueType
4733                                                     ///< using ::ctl_video_processing_super_resolution_t. By defaut, Super
4734                                                     ///< resolution is not active, need application to activate it, please
4735                                                     ///< contact Intel for super resolution activation.
4736     CTL_VIDEO_PROCESSING_FEATURE_STANDARD_COLOR_CORRECTION = 5, ///< Standard color correction.  Controls Hue, Saturation, Contrast,
4737                                                     ///< Brightness.  Contains CTL_PROPERTY_VALUE_TYPE_CUSTOM type field using
4738                                                     ///< struct ::ctl_video_processing_standard_color_correction_t.
4739     CTL_VIDEO_PROCESSING_FEATURE_TOTAL_COLOR_CORRECTION = 6,///< Total color correction.  Controls Red, Green, Blue, Yellow, Cyan,
4740                                                     ///< Magenta.  Contains CTL_PROPERTY_VALUE_TYPE_CUSTOM type field using
4741                                                     ///< struct ::ctl_video_processing_total_color_correction_t.
4742     CTL_VIDEO_PROCESSING_FEATURE_SKIN_TONE_ENHANCEMENT = 7, ///< Skin tone enhancement.  Contains CTL_PROPERTY_VALUE_TYPE_UINT32
4743                                                     ///< ValueType.
4744     CTL_VIDEO_PROCESSING_FEATURE_MAX
4745
4746 } ctl_video_processing_feature_t;
4747
4748 ///////////////////////////////////////////////////////////////////////////////
4749 /// @brief Super resolution values possible
4750 typedef uint32_t ctl_video_processing_super_resolution_flags_t;
4751 typedef enum _ctl_video_processing_super_resolution_flag_t
4752 {
4753     CTL_VIDEO_PROCESSING_SUPER_RESOLUTION_FLAG_DISABLE = CTL_BIT(0),///< Disable
4754     CTL_VIDEO_PROCESSING_SUPER_RESOLUTION_FLAG_ENABLE_DEFAULT_SCENARIO_MODE = CTL_BIT(1),   ///< Enable with default super resolution mode
4755     CTL_VIDEO_PROCESSING_SUPER_RESOLUTION_FLAG_ENABLE_CONFERENCE_SCENARIO_MODE = CTL_BIT(2),///< Super resolution mode targeted at video conference content
4756     CTL_VIDEO_PROCESSING_SUPER_RESOLUTION_FLAG_ENABLE_CAMERA_SCENARIO_MODE = CTL_BIT(3),///< Super resolution mode targeted at camera capture content (e.g.
4757                                                     ///< security camera)
4758     CTL_VIDEO_PROCESSING_SUPER_RESOLUTION_FLAG_MAX = 0x80000000
4759
4760 } ctl_video_processing_super_resolution_flag_t;
4761
4762 ///////////////////////////////////////////////////////////////////////////////
4763 /// @brief Super Resolution feature details structure to be used with
4764 ///        SUPER_RESOLUTION
4765 typedef struct _ctl_video_processing_super_resolution_info_t
4766 {
4767     uint32_t Size;                                  ///< [in] size of this structure
4768     uint8_t Version;                                ///< [in] version of this structure
4769     ctl_video_processing_super_resolution_flags_t super_resolution_flag;///< [in,out] SUPER_RESOLUTION flag
4770     ctl_property_info_uint_t super_resolution_range_in_width;   ///< [in,out] The range of input width information(min, max, default and
4771                                                     ///< step size)which super resolution is capable of supporting.
4772     ctl_property_info_uint_t super_resolution_range_in_height;  ///< [in,out] The range of input height information(min, max, default and
4773                                                     ///< step size)which super resolution is capable of supporting.
4774     uint32_t ReservedFields[16];                    ///< [out] Reserved field of 64 bytes
4775
4776 } ctl_video_processing_super_resolution_info_t;
4777
4778 ///////////////////////////////////////////////////////////////////////////////
4779 /// @brief Super Resolution Get/Set structure to be used with SUPER_RESOLUTION
4780 typedef struct _ctl_video_processing_super_resolution_t
4781 {
4782     uint32_t Size;                                  ///< [in] size of this structure
4783     uint8_t Version;                                ///< [in] version of this structure
4784     ctl_video_processing_super_resolution_flags_t super_resolution_flag;///< [in,out] SUPER_RESOLUTION flag
4785     bool super_resolution_max_in_enabled;           ///< [in,out] The enabling of maximum input width and height limition. If
4786                                                     ///< enabled, super resolution will always take effect if the input
4787                                                     ///< resolution is smaller than the below specified max resolution;
4788                                                     ///< otherwise, super_resolution_max_in_width and
4789                                                     ///< super_resolution_max_in_height will be ignored
4790     uint32_t super_resolution_max_in_width;         ///< [in,out] The maximum input width limition value setting which super
4791                                                     ///< resolution will be allowed to enabled.
4792     uint32_t super_resolution_max_in_height;        ///< [in,out] The maximum input height limiation value setting which super
4793                                                     ///< resolution will be allowed to enabled.
4794     bool super_resolution_reboot_reset;             ///< [in,out] Resetting of super resolution after rebooting.
4795     uint32_t ReservedFields[15];                    ///< [out] Reserved field of 60 bytes
4796     char ReservedBytes[3];                          ///< [out] Reserved field of 3 bytes
4797
4798 } ctl_video_processing_super_resolution_t;
4799
4800 ///////////////////////////////////////////////////////////////////////////////
4801 /// @brief Noise Reduction feature details structure to be used with
4802 ///        NOISE_REDUCTION
4803 typedef struct _ctl_video_processing_noise_reduction_info_t
4804 {
4805     uint32_t Size;                                  ///< [in] size of this structure
4806     uint8_t Version;                                ///< [in] version of this structure
4807     ctl_property_info_uint_t noise_reduction;       ///< [in,out] Noise reduction min, max, default and step size information
4808     bool noise_reduction_auto_detect_supported;     ///< [in,out] Noise reduction Auto Detect is supported; only valid if
4809                                                     ///< NOISE_REDUCTION is enabled.  If enabled, noise reduction level is
4810                                                     ///< automatically determined and set value is not used.
4811     ctl_property_info_boolean_t noise_reduction_auto_detect;///< [in,out] Noise reduction auto detect default information
4812     uint32_t ReservedFields[16];                    ///< [out] Reserved field of 64 bytes
4813
4814 } ctl_video_processing_noise_reduction_info_t;
4815
4816 ///////////////////////////////////////////////////////////////////////////////
4817 /// @brief Noise Reduction Get/Set structure to be used with NOISE_REDUCTION
4818 typedef struct _ctl_video_processing_noise_reduction_t
4819 {
4820     uint32_t Size;                                  ///< [in] size of this structure
4821     uint8_t Version;                                ///< [in] version of this structure
4822     ctl_property_uint_t noise_reduction;            ///< [in,out] Noise reduction enable and value setting
4823     ctl_property_boolean_t noise_reduction_auto_detect; ///< [in,out] Noise reduction auto detect setting
4824     uint32_t ReservedFields[16];                    ///< [out] Reserved field of 64 bytes
4825
4826 } ctl_video_processing_noise_reduction_t;
4827
4828 ///////////////////////////////////////////////////////////////////////////////
4829 /// @brief Adaptive Contrast Enhancement feature details structure to be used
4830 ///        with ADAPTIVE_CONTRAST_ENHANCEMENT
4831 typedef struct _ctl_video_processing_adaptive_contrast_enhancement_info_t
4832 {
4833     uint32_t Size;                                  ///< [in] size of this structure
4834     uint8_t Version;                                ///< [in] version of this structure
4835     ctl_property_info_uint_t adaptive_contrast_enhancement; ///< [in,out] Adaptive Contrast Enhancement min, max, default and step size
4836                                                     ///< information
4837     bool adaptive_contrast_enhancement_coexistence_supported;   ///< [in,out] Adaptive contrast enhancement coexistance is supported; only
4838                                                     ///< valid if ADAPTIVE_CONTRAST_ENHANCEMENT is enabled.  If enabled, Video
4839                                                     ///< adaptive contrast ehancement will be allowed to be enabled and coexist
4840                                                     ///< with Display adaptive contrast ehancement feature.
4841     ctl_property_info_boolean_t adaptive_contrast_enhancement_coexistence;  ///< [in,out] Adaptive contrast enhancement coexistence default information
4842     uint32_t ReservedFields[16];                    ///< [out] Reserved field of 64 bytes
4843
4844 } ctl_video_processing_adaptive_contrast_enhancement_info_t;
4845
4846 ///////////////////////////////////////////////////////////////////////////////
4847 /// @brief Adaptive Contrast Enhancement Get/Set structure to be used with
4848 ///        ADAPTIVE_CONTRAST_ENHANCEMENT
4849 typedef struct _ctl_video_processing_adaptive_contrast_enhancement_t
4850 {
4851     uint32_t Size;                                  ///< [in] size of this structure
4852     uint8_t Version;                                ///< [in] version of this structure
4853     ctl_property_uint_t adaptive_contrast_enhancement;  ///< [in,out] Adaptive Contrast Enhancement enable and value setting
4854     ctl_property_boolean_t adaptive_contrast_enhancement_coexistence;   ///< [in,out] Adaptive contrast enhancement coexistance setting
4855     uint32_t ReservedFields[16];                    ///< [out] Reserved field of 64 bytes
4856
4857 } ctl_video_processing_adaptive_contrast_enhancement_t;
4858
4859 ///////////////////////////////////////////////////////////////////////////////
4860 /// @brief Standard Color Correction feature details structure to be used with
4861 ///        STANDARD_COLOR_CORRECTION
4862 typedef struct _ctl_video_processing_standard_color_correction_info_t
4863 {
4864     uint32_t Size;                                  ///< [in] size of this structure
4865     uint8_t Version;                                ///< [in] version of this structure
4866     bool standard_color_correction_default_enable;  ///< [in,out] STANDARD_COLOR_CORRECTION default enable setting.  This
4867                                                     ///< global settings controls all of Hue, Saturation, Contrast, Brightness
4868                                                     ///< enabling.  Individual Enable controls shall be ignored.
4869     ctl_property_info_float_t brightness;           ///< [in,out] Brightness min, max, default and step size information
4870     ctl_property_info_float_t contrast;             ///< [in,out] Contrast min, max, default and step size information
4871     ctl_property_info_float_t hue;                  ///< [in,out] Hue min, max, default and step size information
4872     ctl_property_info_float_t saturation;           ///< [in,out] Saturation min, max, default and step size information
4873     uint32_t ReservedFields[16];                    ///< [out] Reserved field of 64 bytes
4874
4875 } ctl_video_processing_standard_color_correction_info_t;
4876
4877 ///////////////////////////////////////////////////////////////////////////////
4878 /// @brief Standard Color Correction Get/Set structure to be used with
4879 ///        STANDARD_COLOR_CORRECTION
4880 typedef struct _ctl_video_processing_standard_color_correction_t
4881 {
4882     uint32_t Size;                                  ///< [in] size of this structure
4883     uint8_t Version;                                ///< [in] version of this structure
4884     bool standard_color_correction_enable;          ///< [in,out] STANDARD_COLOR_CORRECTION enable setting.  This global
4885                                                     ///< setting controls all of Hue, Saturation, Contrast, Brightness
4886                                                     ///< enabling.
4887     float brightness;                               ///< [in,out] Brightness value
4888     float contrast;                                 ///< [in,out] Contrast value
4889     float hue;                                      ///< [in,out] Hue value
4890     float saturation;                               ///< [in,out] Saturation value
4891     uint32_t ReservedFields[16];                    ///< [out] Reserved field of 64 bytes
4892
4893 } ctl_video_processing_standard_color_correction_t;
4894
4895 ///////////////////////////////////////////////////////////////////////////////
4896 /// @brief Total Color Correction Get/Set structure to be used with
4897 ///        TOTAL_COLOR_CORRECTION
4898 typedef struct _ctl_video_processing_total_color_correction_info_t
4899 {
4900     uint32_t Size;                                  ///< [in] size of this structure
4901     uint8_t Version;                                ///< [in] version of this structure
4902     bool total_color_correction_default_enable;     ///< [in,out] TOTAL_COLOR_CORRECTION enable setting.  This global setting
4903                                                     ///< controls all of Red, Green, Blue, Yellow, Cyan, Magenta enabling.
4904                                                     ///< Individual Enable controls shall be ignored.
4905     ctl_property_info_uint_t red;                   ///< [in,out] Red min, max, default and step size information
4906     ctl_property_info_uint_t green;                 ///< [in,out] Green min, max, default and step size information
4907     ctl_property_info_uint_t blue;                  ///< [in,out] Blue min, max, default and step size information
4908     ctl_property_info_uint_t yellow;                ///< [in,out] Yellow min, max, default and step size information
4909     ctl_property_info_uint_t cyan;                  ///< [in,out] Cyan min, max, default and step size information
4910     ctl_property_info_uint_t magenta;               ///< [in,out] Magenta min, max, default and step size information
4911     uint32_t ReservedFields[16];                    ///< [out] Reserved field of 64 bytes
4912
4913 } ctl_video_processing_total_color_correction_info_t;
4914
4915 ///////////////////////////////////////////////////////////////////////////////
4916 /// @brief Total Color Correction Get/Set structure to be used with
4917 ///        TOTAL_COLOR_CORRECTION
4918 typedef struct _ctl_video_processing_total_color_correction_t
4919 {
4920     uint32_t Size;                                  ///< [in] size of this structure
4921     uint8_t Version;                                ///< [in] version of this structure
4922     bool total_color_correction_enable;             ///< [in,out] TOTAL_COLOR_CORRECTION enable setting.  This global setting
4923                                                     ///< controls all of Red, Green, Blue, Yellow, Cyan, Magenta enabling.
4924     uint32_t red;                                   ///< [in,out] Red value
4925     uint32_t green;                                 ///< [in,out] Green value
4926     uint32_t blue;                                  ///< [in,out] Blue value
4927     uint32_t yellow;                                ///< [in,out] Yellow value
4928     uint32_t cyan;                                  ///< [in,out] Cyan value
4929     uint32_t magenta;                               ///< [in,out] Magenta value
4930     uint32_t ReservedFields[16];                    ///< [out] Reserved field of 64 bytes
4931
4932 } ctl_video_processing_total_color_correction_t;
4933
4934 ///////////////////////////////////////////////////////////////////////////////
4935 /// @brief Video Processing feature details which will have range supported and
4936 ///        default values
4937 typedef struct _ctl_video_processing_feature_details_t
4938 {
4939     uint32_t Size;                                  ///< [in] size of this structure
4940     uint8_t Version;                                ///< [in] version of this structure
4941     ctl_video_processing_feature_t FeatureType;     ///< [out] Video processing feature type
4942     ctl_property_value_type_t ValueType;            ///< [out] Type of value
4943     ctl_property_info_t Value;                      ///< [out] Union of various type of values for Video Processing features.
4944                                                     ///< For enum types this can be noise reduction, color control etc. This
4945                                                     ///< member is valid iff ValueType is not CTL_PROPERTY_VALUE_TYPE_CUSTOM
4946     int32_t CustomValueSize;                        ///< [in] CustomValue buffer size
4947     void* pCustomValue;                             ///< [in,out] Pointer to a custom structure. Features that use CustomType,
4948                                                     ///< after the first query for all of the supported features the user needs
4949                                                     ///< to allocate this buffer and then query again just this specific
4950                                                     ///< feature for the structure to be filled in. Caller should allocate this
4951                                                     ///< buffer with known custom feature structure size. This member is valid
4952                                                     ///< iff ValueType is CTL_PROPERTY_VALUE_TYPE_CUSTOM.
4953     uint32_t ReservedFields[16];                    ///< [out] Reserved field of 64 bytes
4954
4955 } ctl_video_processing_feature_details_t;
4956
4957 ///////////////////////////////////////////////////////////////////////////////
4958 /// @brief Video Processing features which are controllable
4959 typedef struct _ctl_video_processing_feature_caps_t
4960 {
4961     uint32_t Size;                                  ///< [in] size of this structure
4962     uint8_t Version;                                ///< [in] version of this structure
4963     uint32_t NumSupportedFeatures;                  ///< [in,out] Number of elements in supported features array
4964     ctl_video_processing_feature_details_t* pFeatureDetails;///< [in,out] Array of supported features and their details
4965     uint32_t ReservedFields[16];                    ///< [out] Reserved field of 64 bytes
4966
4967 } ctl_video_processing_feature_caps_t;
4968
4969 ///////////////////////////////////////////////////////////////////////////////
4970 /// @brief Video Processing feature for get/set
4971 typedef struct _ctl_video_processing_feature_getset_t
4972 {
4973     uint32_t Size;                                  ///< [in] size of this structure
4974     uint8_t Version;                                ///< [in] version of this structure
4975     ctl_video_processing_feature_t FeatureType;     ///< [in] Features interested in
4976     char* ApplicationName;                          ///< [in] Application name for which the property type is applicable. If
4977                                                     ///< this is an empty string then this will get/set global settings for the
4978                                                     ///< given adapter. Note that this should contain only the name of the
4979                                                     ///< application and not the system specific path.  [This is not currently
4980                                                     ///< supported and should be an empty string.]
4981     int8_t ApplicationNameLength;                   ///< [in] Length of ApplicationName string
4982     bool bSet;                                      ///< [in] Set this if it's a set call
4983     ctl_property_value_type_t ValueType;            ///< [in] Type of value. Caller has to ensure it provides the right value
4984                                                     ///< type which decides how one read the union structure below
4985     ctl_property_t Value;                           ///< [in,out] Union of various type of values for Video Processing
4986                                                     ///< features. For enum types this can be noise reduction, color control
4987                                                     ///< etc. This member is valid iff ValueType is not
4988                                                     ///< CTL_PROPERTY_VALUE_TYPE_CUSTOM
4989     int32_t CustomValueSize;                        ///< [in] CustomValue buffer size.  For a feature requiring custom struct,
4990                                                     ///< caller will know of it upfront the struct to use based on the feautre
4991                                                     ///< and can provide the right size info here
4992     void* pCustomValue;                             ///< [in,out] Pointer to a custom structure. Caller should allocate this
4993                                                     ///< buffer with known custom feature structure size. This member is valid
4994                                                     ///< iff ValueType is CTL_PROPERTY_VALUE_TYPE_CUSTOM
4995     uint32_t ReservedFields[16];                    ///< [out] Reserved field of 64 bytes
4996
4997 } ctl_video_processing_feature_getset_t;
4998
4999 ///////////////////////////////////////////////////////////////////////////////
5000 /// @brief Get Video Processing capabilities
5001 ///
5002 /// @details
5003 ///     - The application gets Video Processing properties
5004 ///
5005 /// @returns
5006 ///     - CTL_RESULT_SUCCESS
5007 ///     - CTL_RESULT_ERROR_UNINITIALIZED
5008 ///     - CTL_RESULT_ERROR_DEVICE_LOST
5009 ///     - CTL_RESULT_ERROR_INVALID_NULL_HANDLE
5010 ///         + `nullptr == hDAhandle`
5011 ///     - CTL_RESULT_ERROR_INVALID_NULL_POINTER
5012 ///         + `nullptr == pFeatureCaps`
5013 ///     - ::CTL_RESULT_ERROR_UNSUPPORTED_VERSION - "Unsupported version"
5014 CTL_APIEXPORT ctl_result_t CTL_APICALL
5015 ctlGetSupportedVideoProcessingCapabilities(
5016     ctl_device_adapter_handle_t hDAhandle,          ///< [in][release] Handle to display adapter
5017     ctl_video_processing_feature_caps_t* pFeatureCaps   ///< [in,out][release] Video Processing properties
5018     );
5019
5020 ///////////////////////////////////////////////////////////////////////////////
5021 /// @brief Get/Set Video Processing feature details
5022 ///
5023 /// @details
5024 ///     - Video Processing feature details
5025 ///
5026 /// @returns
5027 ///     - CTL_RESULT_SUCCESS
5028 ///     - CTL_RESULT_ERROR_UNINITIALIZED
5029 ///     - CTL_RESULT_ERROR_DEVICE_LOST
5030 ///     - CTL_RESULT_ERROR_INVALID_NULL_HANDLE
5031 ///         + `nullptr == hDAhandle`
5032 ///     - CTL_RESULT_ERROR_INVALID_NULL_POINTER
5033 ///         + `nullptr == pFeature`
5034 ///     - ::CTL_RESULT_ERROR_UNSUPPORTED_VERSION - "Unsupported version"
5035 CTL_APIEXPORT ctl_result_t CTL_APICALL
5036 ctlGetSetVideoProcessingFeature(
5037     ctl_device_adapter_handle_t hDAhandle,          ///< [in][release] Handle to display adapter
5038     ctl_video_processing_feature_getset_t* pFeature ///< [in][release] Video Processing feature get/set parameter
5039     );
5040
5041
5042 #if !defined(__GNUC__)
5043 #pragma endregion // media
5044 #endif
5045 // Intel 'ctlApi' for Device Adapter - Memory management
5046 #if !defined(__GNUC__)
5047 #pragma region memory
5048 #endif
5049 ///////////////////////////////////////////////////////////////////////////////
5050 /// @brief Memory module types
5051 typedef enum _ctl_mem_type_t
5052 {
5053     CTL_MEM_TYPE_HBM = 0,                           ///< HBM memory
5054     CTL_MEM_TYPE_DDR = 1,                           ///< DDR memory
5055     CTL_MEM_TYPE_DDR3 = 2,                          ///< DDR3 memory
5056     CTL_MEM_TYPE_DDR4 = 3,                          ///< DDR4 memory
5057     CTL_MEM_TYPE_DDR5 = 4,                          ///< DDR5 memory
5058     CTL_MEM_TYPE_LPDDR = 5,                         ///< LPDDR memory
5059     CTL_MEM_TYPE_LPDDR3 = 6,                        ///< LPDDR3 memory
5060     CTL_MEM_TYPE_LPDDR4 = 7,                        ///< LPDDR4 memory
5061     CTL_MEM_TYPE_LPDDR5 = 8,                        ///< LPDDR5 memory
5062     CTL_MEM_TYPE_GDDR4 = 9,                         ///< GDDR4 memory
5063     CTL_MEM_TYPE_GDDR5 = 10,                        ///< GDDR5 memory
5064     CTL_MEM_TYPE_GDDR5X = 11,                       ///< GDDR5X memory
5065     CTL_MEM_TYPE_GDDR6 = 12,                        ///< GDDR6 memory
5066     CTL_MEM_TYPE_GDDR6X = 13,                       ///< GDDR6X memory
5067     CTL_MEM_TYPE_GDDR7 = 14,                        ///< GDDR7 memory
5068     CTL_MEM_TYPE_UNKNOWN = 15,                      ///< UNKNOWN memory
5069     CTL_MEM_TYPE_MAX
5070
5071 } ctl_mem_type_t;
5072
5073 ///////////////////////////////////////////////////////////////////////////////
5074 /// @brief Memory module location
5075 typedef enum _ctl_mem_loc_t
5076 {
5077     CTL_MEM_LOC_SYSTEM = 0,                         ///< System memory
5078     CTL_MEM_LOC_DEVICE = 1,                         ///< On board local device memory
5079     CTL_MEM_LOC_MAX
5080
5081 } ctl_mem_loc_t;
5082
5083 ///////////////////////////////////////////////////////////////////////////////
5084 /// @brief Memory properties
5085 typedef struct _ctl_mem_properties_t
5086 {
5087     uint32_t Size;                                  ///< [in] size of this structure
5088     uint8_t Version;                                ///< [in] version of this structure
5089     ctl_mem_type_t type;                            ///< [out] The memory type
5090     ctl_mem_loc_t location;                         ///< [out] Location of this memory (system, device)
5091     uint64_t physicalSize;                          ///< [out] Physical memory size in bytes. A value of 0 indicates that this
5092                                                     ///< property is not known. However, a call to ::ctlMemoryGetState() will
5093                                                     ///< correctly return the total size of usable memory.
5094     int32_t busWidth;                               ///< [out] Width of the memory bus. A value of -1 means that this property
5095                                                     ///< is unknown.
5096     int32_t numChannels;                            ///< [out] The number of memory channels. A value of -1 means that this
5097                                                     ///< property is unknown.
5098
5099 } ctl_mem_properties_t;
5100
5101 ///////////////////////////////////////////////////////////////////////////////
5102 /// @brief Memory state - health, allocated
5103 ///
5104 /// @details
5105 ///     - Percent allocation is given by 100 * (size - free / size.
5106 ///     - Percent free is given by 100 * free / size.
5107 typedef struct _ctl_mem_state_t
5108 {
5109     uint32_t Size;                                  ///< [in] size of this structure
5110     uint8_t Version;                                ///< [in] version of this structure
5111     uint64_t free;                                  ///< [out] The free memory in bytes
5112     uint64_t size;                                  ///< [out] The total allocatable memory in bytes (can be less than
5113                                                     ///< ::ctl_mem_properties_t.physicalSize)
5114
5115 } ctl_mem_state_t;
5116
5117 ///////////////////////////////////////////////////////////////////////////////
5118 /// @brief Memory bandwidth
5119 ///
5120 /// @details
5121 ///     - Percent bandwidth is calculated by taking two snapshots (s1, s2) and
5122 ///       using the equation: %bw = 10^6 * ((s2.readCounter - s1.readCounter) +
5123 ///       (s2.writeCounter - s1.writeCounter)) / (s2.maxBandwidth *
5124 ///       (s2.timestamp - s1.timestamp))
5125 typedef struct _ctl_mem_bandwidth_t
5126 {
5127     uint32_t Size;                                  ///< [in] size of this structure
5128     uint8_t Version;                                ///< [in] version of this structure
5129     uint64_t maxBandwidth;                          ///< [out] Current maximum bandwidth in units of bytes/sec
5130     uint64_t timestamp;                             ///< [out] The timestamp (in microseconds) when these measurements were sampled.
5131                                                     ///< This timestamp should only be used to calculate delta time between
5132                                                     ///< snapshots of this structure.
5133                                                     ///< Never take the delta of this timestamp with the timestamp from a
5134                                                     ///< different structure since they are not guaranteed to have the same base.
5135                                                     ///< The absolute value of the timestamp is only valid during within the
5136                                                     ///< application and may be different on the next execution.
5137     uint64_t readCounter;                           ///< [out] Total bytes read from memory. Supported only for Version > 0
5138     uint64_t writeCounter;                          ///< [out] Total bytes written to memory. Supported only for Version > 0
5139
5140 } ctl_mem_bandwidth_t;
5141
5142 ///////////////////////////////////////////////////////////////////////////////
5143 /// @brief Get handle of memory modules
5144 ///
5145 /// @details
5146 ///     - The application may call this function from simultaneous threads.
5147 ///     - The implementation of this function should be lock-free.
5148 ///
5149 /// @returns
5150 ///     - CTL_RESULT_SUCCESS
5151 ///     - CTL_RESULT_ERROR_UNINITIALIZED
5152 ///     - CTL_RESULT_ERROR_DEVICE_LOST
5153 ///     - CTL_RESULT_ERROR_INVALID_NULL_HANDLE
5154 ///         + `nullptr == hDAhandle`
5155 ///     - CTL_RESULT_ERROR_INVALID_NULL_POINTER
5156 ///         + `nullptr == pCount`
5157 CTL_APIEXPORT ctl_result_t CTL_APICALL
5158 ctlEnumMemoryModules(
5159     ctl_device_adapter_handle_t hDAhandle,          ///< [in][release] Handle to display adapter
5160     uint32_t* pCount,                               ///< [in,out] pointer to the number of components of this type.
5161                                                     ///< if count is zero, then the driver shall update the value with the
5162                                                     ///< total number of components of this type that are available.
5163                                                     ///< if count is greater than the number of components of this type that
5164                                                     ///< are available, then the driver shall update the value with the correct
5165                                                     ///< number of components.
5166     ctl_mem_handle_t* phMemory                      ///< [in,out][optional][range(0, *pCount)] array of handle of components of
5167                                                     ///< this type.
5168                                                     ///< if count is less than the number of components of this type that are
5169                                                     ///< available, then the driver shall only retrieve that number of
5170                                                     ///< component handles.
5171     );
5172
5173 ///////////////////////////////////////////////////////////////////////////////
5174 /// @brief Get memory properties
5175 ///
5176 /// @details
5177 ///     - The application may call this function from simultaneous threads.
5178 ///     - The implementation of this function should be lock-free.
5179 ///
5180 /// @returns
5181 ///     - CTL_RESULT_SUCCESS
5182 ///     - CTL_RESULT_ERROR_UNINITIALIZED
5183 ///     - CTL_RESULT_ERROR_DEVICE_LOST
5184 ///     - CTL_RESULT_ERROR_INVALID_NULL_HANDLE
5185 ///         + `nullptr == hMemory`
5186 ///     - CTL_RESULT_ERROR_INVALID_NULL_POINTER
5187 ///         + `nullptr == pProperties`
5188 CTL_APIEXPORT ctl_result_t CTL_APICALL
5189 ctlMemoryGetProperties(
5190     ctl_mem_handle_t hMemory,                       ///< [in] Handle for the component.
5191     ctl_mem_properties_t* pProperties               ///< [in,out] Will contain memory properties.
5192     );
5193
5194 ///////////////////////////////////////////////////////////////////////////////
5195 /// @brief Get memory state - health, allocated
5196 ///
5197 /// @details
5198 ///     - The application may call this function from simultaneous threads.
5199 ///     - The implementation of this function should be lock-free.
5200 ///
5201 /// @returns
5202 ///     - CTL_RESULT_SUCCESS
5203 ///     - CTL_RESULT_ERROR_UNINITIALIZED
5204 ///     - CTL_RESULT_ERROR_DEVICE_LOST
5205 ///     - CTL_RESULT_ERROR_INVALID_NULL_HANDLE
5206 ///         + `nullptr == hMemory`
5207 ///     - CTL_RESULT_ERROR_INVALID_NULL_POINTER
5208 ///         + `nullptr == pState`
5209 CTL_APIEXPORT ctl_result_t CTL_APICALL
5210 ctlMemoryGetState(
5211     ctl_mem_handle_t hMemory,                       ///< [in] Handle for the component.
5212     ctl_mem_state_t* pState                         ///< [in,out] Will contain the current health and allocated memory.
5213     );
5214
5215 ///////////////////////////////////////////////////////////////////////////////
5216 /// @brief Get memory bandwidth
5217 ///
5218 /// @details
5219 ///     - The application may call this function from simultaneous threads.
5220 ///     - The implementation of this function should be lock-free.
5221 ///
5222 /// @returns
5223 ///     - CTL_RESULT_SUCCESS
5224 ///     - CTL_RESULT_ERROR_UNINITIALIZED
5225 ///     - CTL_RESULT_ERROR_DEVICE_LOST
5226 ///     - CTL_RESULT_ERROR_INVALID_NULL_HANDLE
5227 ///         + `nullptr == hMemory`
5228 ///     - CTL_RESULT_ERROR_INVALID_NULL_POINTER
5229 ///         + `nullptr == pBandwidth`
5230 ///     - ::CTL_RESULT_ERROR_INSUFFICIENT_PERMISSIONS
5231 ///         + User does not have permissions to query this telemetry.
5232 CTL_APIEXPORT ctl_result_t CTL_APICALL
5233 ctlMemoryGetBandwidth(
5234     ctl_mem_handle_t hMemory,                       ///< [in] Handle for the component.
5235     ctl_mem_bandwidth_t* pBandwidth                 ///< [in,out] Will contain the current health, free memory, total memory
5236                                                     ///< size.
5237     );
5238
5239
5240 #if !defined(__GNUC__)
5241 #pragma endregion // memory
5242 #endif
5243 // Intel 'ctlApi' for Device Adapter - Overclock
5244 #if !defined(__GNUC__)
5245 #pragma region overclock
5246 #endif
5247 ///////////////////////////////////////////////////////////////////////////////
5248 /// @brief Telemetry Item for each telemetry property
5249 ///
5250 /// @details
5251 ///     - If the supported field is true, then the entire structure has valid
5252 ///       information.
5253 ///     - The ::ctl_data_value_t is of type ::ctl_data_type_t and units
5254 ///       ::ctl_units_t
5255 typedef struct _ctl_oc_telemetry_item_t
5256 {
5257     bool bSupported;                                ///< [out] Indicates if the value is supported.
5258     ctl_units_t units;                              ///< [out] Indicates the units of the value.
5259     ctl_data_type_t type;                           ///< [out] Indicates the data type.
5260     ctl_data_value_t value;                         ///< [out] The value of type ::ctl_data_type_t and units ::ctl_units_t.
5261
5262 } ctl_oc_telemetry_item_t;
5263
5264 ///////////////////////////////////////////////////////////////////////////////
5265 /// @brief Overclocking Control Information
5266 ///
5267 /// @details
5268 ///     - Whether the device supports overclocking.
5269 ///     - The
5270 ///       bSupported/bRelative/bReference/units/min/max/step/default/reference
5271 ///       values for the available overclock controls
5272 ///     - The idea is to facilitate the way the applications present overclock
5273 ///       settings to the user. If bSupported is false, the corresponding
5274 ///       overclock control is not supported
5275 ///     - The setting units will be an enum that enables the application to know
5276 ///       the units for the control setting e.g. MHz. The min and max settings
5277 ///       give the limits for the control.
5278 ///     - The step setting gives the minimum change in the control value (plus
5279 ///       or minus) - if a control is not changed by at least this amount, the
5280 ///       hardware may round up or down.
5281 ///     - The default values gives the manufacturing setting for the control.
5282 ///       Some controls such as frequency offset and voltage offset are
5283 ///       relative; in this case, bRelative will be true, otherwise the control
5284 ///       settings are absolute values.
5285 ///     - For relative controls and if bReference is true, the reference value
5286 ///       gives the absolute value at the default setting.
5287 ///     - If bReference is false, the absolute value of the default setting is
5288 ///       no not known and it is probably better to display the setting to users
5289 ///       as percentage offsets.
5290 typedef struct _ctl_oc_control_info_t
5291 {
5292     bool bSupported;                                ///< [out] Indicates if the values are known.
5293     bool bRelative;                                 ///< [out] Indicates if the values are meant to be taken as relative values
5294                                                     ///< instead of absolut values.
5295     bool bReference;                                ///< [out] For relative values, this indicates if a reference is available.
5296     ctl_units_t units;                              ///< [out] Units for the values.
5297     double min;                                     ///< [out] Minimum Value.
5298     double max;                                     ///< [out] Maximum Value.
5299     double step;                                    ///< [out] Step Value.
5300     double Default;                                 ///< [out] Default Value.
5301     double reference;                               ///< [out] Reference Value if the bReference is true.
5302
5303 } ctl_oc_control_info_t;
5304
5305 ///////////////////////////////////////////////////////////////////////////////
5306 /// @brief Overclock properties
5307 typedef struct _ctl_oc_properties_t
5308 {
5309     uint32_t Size;                                  ///< [in] size of this structure
5310     uint8_t Version;                                ///< [in] version of this structure
5311     bool bSupported;                                ///< [out] Indicates if the adapter supports overclocking.
5312     ctl_oc_control_info_t gpuFrequencyOffset;       ///< [out] related to function ::ctlOverclockGpuFrequencyOffsetSet
5313     ctl_oc_control_info_t gpuVoltageOffset;         ///< [out] related to function ::ctlOverclockGpuVoltageOffsetSet
5314     ctl_oc_control_info_t vramFrequencyOffset;      ///< [out] related to function ::ctlOverclockVramFrequencyOffsetSet
5315     ctl_oc_control_info_t vramVoltageOffset;        ///< [out] related to function ::ctlOverclockVramVoltageOffsetSet
5316     ctl_oc_control_info_t powerLimit;               ///< [out] related to function ::ctlOverclockPowerLimitSet
5317     ctl_oc_control_info_t temperatureLimit;         ///< [out] related to function ::ctlOverclockTemperatureLimitSet
5318
5319 } ctl_oc_properties_t;
5320
5321 ///////////////////////////////////////////////////////////////////////////////
5322 /// @brief Overclock Voltage Frequency Pair
5323 typedef struct _ctl_oc_vf_pair_t
5324 {
5325     uint32_t Size;                                  ///< [in] size of this structure
5326     uint8_t Version;                                ///< [in] version of this structure
5327     double Voltage;                                 ///< [in,out] Voltage component of the pair in mV.
5328     double Frequency;                               ///< [in,out] Frequency component of the pair in MHz.
5329
5330 } ctl_oc_vf_pair_t;
5331
5332 ///////////////////////////////////////////////////////////////////////////////
5333 #ifndef CTL_PSU_COUNT
5334 /// @brief Maximum number power supply units.
5335 #define CTL_PSU_COUNT  5
5336 #endif // CTL_PSU_COUNT
5337
5338 ///////////////////////////////////////////////////////////////////////////////
5339 /// @brief PSU Type.
5340 typedef enum _ctl_psu_type_t
5341 {
5342     CTL_PSU_TYPE_PSU_NONE = 0,                      ///< Type of the PSU is unknown.
5343     CTL_PSU_TYPE_PSU_PCIE = 1,                      ///< Type of the PSU is PCIe
5344     CTL_PSU_TYPE_PSU_6PIN = 2,                      ///< Type of the PSU is 6 PIN
5345     CTL_PSU_TYPE_PSU_8PIN = 3,                      ///< Type of the PSU is 8 PIN
5346     CTL_PSU_TYPE_MAX
5347
5348 } ctl_psu_type_t;
5349
5350 ///////////////////////////////////////////////////////////////////////////////
5351 /// @brief PSU Info
5352 typedef struct _ctl_psu_info_t
5353 {
5354     bool bSupported;                                ///< [out] Indicates if this PSU entry is supported.
5355     ctl_psu_type_t psuType;                         ///< [out] Type of the PSU.
5356     ctl_oc_telemetry_item_t energyCounter;          ///< [out] Snapshot of the monotonic energy counter maintained by hardware.
5357                                                     ///< It measures the total energy consumed this power source. By taking the
5358                                                     ///< delta between two snapshots and dividing by the delta time in seconds,
5359                                                     ///< an application can compute the average power.
5360     ctl_oc_telemetry_item_t voltage;                ///< [out] Instantaneous snapshot of the voltage of this power source.
5361
5362 } ctl_psu_info_t;
5363
5364 ///////////////////////////////////////////////////////////////////////////////
5365 #ifndef CTL_FAN_COUNT
5366 /// @brief Maximum number of Fans
5367 #define CTL_FAN_COUNT  5
5368 #endif // CTL_FAN_COUNT
5369
5370 ///////////////////////////////////////////////////////////////////////////////
5371 /// @brief Power Telemetry
5372 typedef struct _ctl_power_telemetry_t
5373 {
5374     uint32_t Size;                                  ///< [in] size of this structure
5375     uint8_t Version;                                ///< [in] version of this structure
5376     ctl_oc_telemetry_item_t timeStamp;              ///< [out] Snapshot of the timestamp counter that measures the total time
5377                                                     ///< since Jan 1, 1970 UTC. It is a decimal value in seconds with a minimum
5378                                                     ///< accuracy of 1 millisecond.
5379     ctl_oc_telemetry_item_t gpuEnergyCounter;       ///< [out] Snapshot of the monotonic energy counter maintained by hardware.
5380                                                     ///< It measures the total energy consumed by the GPU chip. By taking the
5381                                                     ///< delta between two snapshots and dividing by the delta time in seconds,
5382                                                     ///< an application can compute the average power.
5383     ctl_oc_telemetry_item_t gpuVoltage;             ///< [out] Instantaneous snapshot of the voltage feeding the GPU chip. It
5384                                                     ///< is measured at the power supply output - chip input will be lower.
5385     ctl_oc_telemetry_item_t gpuCurrentClockFrequency;   ///< [out] Instantaneous snapshot of the GPU chip frequency.
5386     ctl_oc_telemetry_item_t gpuCurrentTemperature;  ///< [out] Instantaneous snapshot of the GPU chip temperature, read from
5387                                                     ///< the sensor reporting the highest value.
5388     ctl_oc_telemetry_item_t globalActivityCounter;  ///< [out] Snapshot of the monotonic global activity counter. It measures
5389                                                     ///< the time in seconds (accurate down to 1 millisecond) that any GPU
5390                                                     ///< engine is busy. By taking the delta between two snapshots and dividing
5391                                                     ///< by the delta time in seconds, an application can compute the average
5392                                                     ///< percentage utilization of the GPU..
5393     ctl_oc_telemetry_item_t renderComputeActivityCounter;   ///< [out] Snapshot of the monotonic 3D/compute activity counter. It
5394                                                     ///< measures the time in seconds (accurate down to 1 millisecond) that any
5395                                                     ///< 3D render/compute engine is busy. By taking the delta between two
5396                                                     ///< snapshots and dividing by the delta time in seconds, an application
5397                                                     ///< can compute the average percentage utilization of all 3D
5398                                                     ///< render/compute blocks in the GPU.
5399     ctl_oc_telemetry_item_t mediaActivityCounter;   ///< [out] Snapshot of the monotonic media activity counter. It measures
5400                                                     ///< the time in seconds (accurate down to 1 millisecond) that any media
5401                                                     ///< engine is busy. By taking the delta between two snapshots and dividing
5402                                                     ///< by the delta time in seconds, an application can compute the average
5403                                                     ///< percentage utilization of all media blocks in the GPU.
5404     bool gpuPowerLimited;                           ///< [out] Instantaneous indication that the desired GPU frequency is being
5405                                                     ///< throttled because the GPU chip is exceeding the maximum power limits.
5406                                                     ///< Increasing the power limits using ::ctlOverclockPowerLimitSet() is one
5407                                                     ///< way to remove this limitation.
5408     bool gpuTemperatureLimited;                     ///< [out] Instantaneous indication that the desired GPU frequency is being
5409                                                     ///< throttled because the GPU chip is exceeding the temperature limits.
5410                                                     ///< Increasing the temperature limits using
5411                                                     ///< ::ctlOverclockTemperatureLimitSet() is one way to reduce this
5412                                                     ///< limitation. Improving the cooling solution is another way.
5413     bool gpuCurrentLimited;                         ///< [out] Instantaneous indication that the desired GPU frequency is being
5414                                                     ///< throttled because the GPU chip has exceeded the power supply current
5415                                                     ///< limits. A better power supply is required to reduce this limitation.
5416     bool gpuVoltageLimited;                         ///< [out] Instantaneous indication that the GPU frequency cannot be
5417                                                     ///< increased because the voltage limits have been reached. Increase the
5418                                                     ///< voltage offset using ::ctlOverclockGpuVoltageOffsetSet() is one way to
5419                                                     ///< reduce this limitation.
5420     bool gpuUtilizationLimited;                     ///< [out] Instantaneous indication that due to lower GPU utilization, the
5421                                                     ///< hardware has lowered the GPU frequency.
5422     ctl_oc_telemetry_item_t vramEnergyCounter;      ///< [out] Snapshot of the monotonic energy counter maintained by hardware.
5423                                                     ///< It measures the total energy consumed by the local memory modules. By
5424                                                     ///< taking the delta between two snapshots and dividing by the delta time
5425                                                     ///< in seconds, an application can compute the average power.
5426     ctl_oc_telemetry_item_t vramVoltage;            ///< [out] Instantaneous snapshot of the voltage feeding the memory
5427                                                     ///< modules.
5428     ctl_oc_telemetry_item_t vramCurrentClockFrequency;  ///< [out] Instantaneous snapshot of the raw clock frequency driving the
5429                                                     ///< memory modules.
5430     ctl_oc_telemetry_item_t vramCurrentEffectiveFrequency;  ///< [out] Instantaneous snapshot of the effective data transfer rate that
5431                                                     ///< the memory modules can sustain based on the current clock frequency..
5432     ctl_oc_telemetry_item_t vramReadBandwidthCounter;   ///< [out] Instantaneous snapshot of the monotonic counter that measures
5433                                                     ///< the read traffic from the memory modules. By taking the delta between
5434                                                     ///< two snapshots and dividing by the delta time in seconds, an
5435                                                     ///< application can compute the average read bandwidth.
5436     ctl_oc_telemetry_item_t vramWriteBandwidthCounter;  ///< [out] Instantaneous snapshot of the monotonic counter that measures
5437                                                     ///< the write traffic to the memory modules. By taking the delta between
5438                                                     ///< two snapshots and dividing by the delta time in seconds, an
5439                                                     ///< application can compute the average write bandwidth.
5440     ctl_oc_telemetry_item_t vramCurrentTemperature; ///< [out] Instantaneous snapshot of the GPU chip temperature, read from
5441                                                     ///< the sensor reporting the highest value.
5442     bool vramPowerLimited;                          ///< [out] Instantaneous indication that the memory frequency is being
5443                                                     ///< throttled because the memory modules are exceeding the maximum power
5444                                                     ///< limits.
5445     bool vramTemperatureLimited;                    ///< [out] Instantaneous indication that the memory frequency is being
5446                                                     ///< throttled because the memory modules are exceeding the temperature
5447                                                     ///< limits.
5448     bool vramCurrentLimited;                        ///< [out] Instantaneous indication that the memory frequency is being
5449                                                     ///< throttled because the memory modules have exceeded the power supply
5450                                                     ///< current limits.
5451     bool vramVoltageLimited;                        ///< [out] Instantaneous indication that the memory frequency cannot be
5452                                                     ///< increased because the voltage limits have been reached.
5453     bool vramUtilizationLimited;                    ///< [out] Instantaneous indication that due to lower memory traffic, the
5454                                                     ///< hardware has lowered the memory frequency.
5455     ctl_oc_telemetry_item_t totalCardEnergyCounter; ///< [out] Total Card Energy Counter.
5456     ctl_psu_info_t psu[CTL_PSU_COUNT];              ///< [out] PSU voltage and power.
5457     ctl_oc_telemetry_item_t fanSpeed[CTL_FAN_COUNT];///< [out] Fan speed.
5458
5459 } ctl_power_telemetry_t;
5460
5461 ///////////////////////////////////////////////////////////////////////////////
5462 /// @brief Get overclock properties - available properties.
5463 ///
5464 /// @returns
5465 ///     - CTL_RESULT_SUCCESS
5466 ///     - CTL_RESULT_ERROR_UNINITIALIZED
5467 ///     - CTL_RESULT_ERROR_DEVICE_LOST
5468 ///     - CTL_RESULT_ERROR_INVALID_NULL_HANDLE
5469 ///         + `nullptr == hDeviceHandle`
5470 ///     - CTL_RESULT_ERROR_INVALID_NULL_POINTER
5471 ///         + `nullptr == pOcProperties`
5472 CTL_APIEXPORT ctl_result_t CTL_APICALL
5473 ctlOverclockGetProperties(
5474     ctl_device_adapter_handle_t hDeviceHandle,      ///< [in][release] Handle to display adapter
5475     ctl_oc_properties_t* pOcProperties              ///< [in,out] The overclocking properties for the specified domain.
5476     );
5477
5478 ///////////////////////////////////////////////////////////////////////////////
5479 /// @brief Overclock Waiver - Warranty Waiver.
5480 ///
5481 /// @details
5482 ///     - Most of the overclock functions will return an error if the waiver is
5483 ///       not set. This is because most overclock settings will increase the
5484 ///       electric/thermal stress on the part and thus reduce its lifetime.
5485 ///     - By setting the waiver, the user is indicate that they are accepting a
5486 ///       reduction in the lifetime of the part.
5487 ///     - It is the responsibility of overclock applications to notify each user
5488 ///       at least once with a popup of the dangers and requiring acceptance.
5489 ///     - Only once the user has accepted should this function be called by the
5490 ///       application.
5491 ///     - It is acceptable for the application to cache the user choice and call
5492 ///       this function on future executions without issuing the popup.
5493 ///
5494 /// @returns
5495 ///     - CTL_RESULT_SUCCESS
5496 ///     - CTL_RESULT_ERROR_UNINITIALIZED
5497 ///     - CTL_RESULT_ERROR_DEVICE_LOST
5498 ///     - CTL_RESULT_ERROR_INVALID_NULL_HANDLE
5499 ///         + `nullptr == hDeviceHandle`
5500 CTL_APIEXPORT ctl_result_t CTL_APICALL
5501 ctlOverclockWaiverSet(
5502     ctl_device_adapter_handle_t hDeviceHandle       ///< [in][release] Handle to display adapter
5503     );
5504
5505 ///////////////////////////////////////////////////////////////////////////////
5506 /// @brief Get the Overclock Frequency Offset for the GPU in MHz.
5507 ///
5508 /// @details
5509 ///     - Determine the current frequency offset in effect (refer to
5510 ///       ::ctlOverclockGpuFrequencyOffsetSet() for details).
5511 ///     - The value returned may be different from the value that was previously
5512 ///       set by the application depending on hardware limitations or if the
5513 ///       function ::ctlOverclockGpuFrequencyOffsetSet() has been called or
5514 ///       another application that has changed the value.
5515 ///
5516 /// @returns
5517 ///     - CTL_RESULT_SUCCESS
5518 ///     - CTL_RESULT_ERROR_UNINITIALIZED
5519 ///     - CTL_RESULT_ERROR_DEVICE_LOST
5520 ///     - CTL_RESULT_ERROR_INVALID_NULL_HANDLE
5521 ///         + `nullptr == hDeviceHandle`
5522 ///     - CTL_RESULT_ERROR_INVALID_NULL_POINTER
5523 ///         + `nullptr == pOcFrequencyOffset`
5524 CTL_APIEXPORT ctl_result_t CTL_APICALL
5525 ctlOverclockGpuFrequencyOffsetGet(
5526     ctl_device_adapter_handle_t hDeviceHandle,      ///< [in][release] Handle to display adapter
5527     double* pOcFrequencyOffset                      ///< [in,out] The Turbo Overclocking Frequency Desired in MHz.
5528     );
5529
5530 ///////////////////////////////////////////////////////////////////////////////
5531 /// @brief Set the Overclock Frequency Offset for the GPU in MHZ.
5532 ///
5533 /// @details
5534 ///     - The purpose of this function is to increase/decrease the frequency at
5535 ///       which typical workloads will run within the same thermal budget.
5536 ///     - The frequency offset is expressed in units of ±1MHz.
5537 ///     - The actual operating frequency for each workload is not guaranteed to
5538 ///       change exactly by the specified offset.
5539 ///     - For positive frequency offsets, the factory maximum frequency may
5540 ///       increase by up to the specified amount.
5541 ///     - For negative frequency offsets, the overclock waiver must have been
5542 ///       set since this can result in running the part at voltages beyond the
5543 ///       part warrantee limits. An error is returned if the waiver has not been
5544 ///       set.
5545 ///     - Specifying large values for the frequency offset can lead to
5546 ///       instability. It is recommended that changes are made in small
5547 ///       increments and stability/performance measured running intense GPU
5548 ///       workloads before increasing further.
5549 ///     - This setting is not persistent through system reboots or driver
5550 ///       resets/hangs. It is up to the overclock application to reapply the
5551 ///       settings in those cases.
5552 ///     - This setting can cause system/device instability. It is up to the
5553 ///       overclock application to detect if the system has rebooted
5554 ///       unexpectedly or the device was restarted. When this occurs, the
5555 ///       application should not reapply the overclock settings automatically
5556 ///       but instead return to previously known good settings or notify the
5557 ///       user that the settings are not being applied.
5558 ///
5559 /// @returns
5560 ///     - CTL_RESULT_SUCCESS
5561 ///     - CTL_RESULT_ERROR_UNINITIALIZED
5562 ///     - CTL_RESULT_ERROR_DEVICE_LOST
5563 ///     - CTL_RESULT_ERROR_INVALID_NULL_HANDLE
5564 ///         + `nullptr == hDeviceHandle`
5565 CTL_APIEXPORT ctl_result_t CTL_APICALL
5566 ctlOverclockGpuFrequencyOffsetSet(
5567     ctl_device_adapter_handle_t hDeviceHandle,      ///< [in][release] Handle to display adapter
5568     double ocFrequencyOffset                        ///< [in] The Turbo Overclocking Frequency Desired in MHz.
5569     );
5570
5571 ///////////////////////////////////////////////////////////////////////////////
5572 /// @brief Get the Overclock Gpu Voltage Offset in mV.
5573 ///
5574 /// @details
5575 ///     - Determine the current voltage offset in effect on the hardware (refer
5576 ///       to ::ctlOverclockGpuVoltageOffsetSet for details).
5577 ///     - The value returned may be different from the value that was previously
5578 ///       set by the application depending on hardware limitations or if the
5579 ///       function ::ctlOverclockGpuVoltageOffsetSet has been called or another
5580 ///       application that has changed the value.
5581 ///
5582 /// @returns
5583 ///     - CTL_RESULT_SUCCESS
5584 ///     - CTL_RESULT_ERROR_UNINITIALIZED
5585 ///     - CTL_RESULT_ERROR_DEVICE_LOST
5586 ///     - CTL_RESULT_ERROR_INVALID_NULL_HANDLE
5587 ///         + `nullptr == hDeviceHandle`
5588 ///     - CTL_RESULT_ERROR_INVALID_NULL_POINTER
5589 ///         + `nullptr == pOcVoltageOffset`
5590 CTL_APIEXPORT ctl_result_t CTL_APICALL
5591 ctlOverclockGpuVoltageOffsetGet(
5592     ctl_device_adapter_handle_t hDeviceHandle,      ///< [in][release] Handle to display adapter
5593     double* pOcVoltageOffset                        ///< [in,out] The Turbo Overclocking Frequency Desired in mV.
5594     );
5595
5596 ///////////////////////////////////////////////////////////////////////////////
5597 /// @brief Set the Overclock Gpu Voltage Offset in mV.
5598 ///
5599 /// @details
5600 ///     - The purpose of this function is to attempt to run the GPU up to higher
5601 ///       voltages beyond the part warrantee limits. This can permit running at
5602 ///       even higher frequencies than can be obtained using the frequency
5603 ///       offset setting, but at the risk of reducing the lifetime of the part.
5604 ///     - The voltage offset is expressed in units of ±millivolts with values
5605 ///       permitted down to a resolution of 1 millivolt.
5606 ///     - The overclock waiver must be set before calling this function
5607 ///       otherwise and error will be returned.
5608 ///     - There is no guarantee that a workload can operate at the higher
5609 ///       frequencies permitted by this setting. Significantly more heat will be
5610 ///       generated at these high frequencies/voltages which will necessitate a
5611 ///       good cooling solution.
5612 ///
5613 /// @returns
5614 ///     - CTL_RESULT_SUCCESS
5615 ///     - CTL_RESULT_ERROR_UNINITIALIZED
5616 ///     - CTL_RESULT_ERROR_DEVICE_LOST
5617 ///     - CTL_RESULT_ERROR_INVALID_NULL_HANDLE
5618 ///         + `nullptr == hDeviceHandle`
5619 CTL_APIEXPORT ctl_result_t CTL_APICALL
5620 ctlOverclockGpuVoltageOffsetSet(
5621     ctl_device_adapter_handle_t hDeviceHandle,      ///< [in][release] Handle to display adapter
5622     double ocVoltageOffset                          ///< [in] The Turbo Overclocking Frequency Desired in mV.
5623     );
5624
5625 ///////////////////////////////////////////////////////////////////////////////
5626 /// @brief Gets the Locked GPU Voltage for Overclocking in mV.
5627 ///
5628 /// @details
5629 ///     - The purpose of this function is to determine if the current values of
5630 ///       the frequency/voltage lock.
5631 ///     - If the lock is not currently active, will return 0 for frequency and
5632 ///       voltage.
5633 ///     - Note that the operating frequency/voltage may be lower than these
5634 ///       settings if power/thermal limits are exceeded.
5635 ///
5636 /// @returns
5637 ///     - CTL_RESULT_SUCCESS
5638 ///     - CTL_RESULT_ERROR_UNINITIALIZED
5639 ///     - CTL_RESULT_ERROR_DEVICE_LOST
5640 ///     - CTL_RESULT_ERROR_INVALID_NULL_HANDLE
5641 ///         + `nullptr == hDeviceHandle`
5642 ///     - CTL_RESULT_ERROR_INVALID_NULL_POINTER
5643 ///         + `nullptr == pVfPair`
5644 CTL_APIEXPORT ctl_result_t CTL_APICALL
5645 ctlOverclockGpuLockGet(
5646     ctl_device_adapter_handle_t hDeviceHandle,      ///< [in][release] Handle to display adapter
5647     ctl_oc_vf_pair_t* pVfPair                       ///< [out] The current locked voltage and frequency.
5648     );
5649
5650 ///////////////////////////////////////////////////////////////////////////////
5651 /// @brief Locks the GPU voltage for Overclocking in mV.
5652 ///
5653 /// @details
5654 ///     - The purpose of this function is to provide an interface for scanners
5655 ///       to lock the frequency and voltage to fixed values.
5656 ///     - The frequency is expressed in units of MHz with a resolution of 1MHz.
5657 ///     - The voltage is expressed in units of ±millivolts with values
5658 ///       permitted down to a resolution of 1 millivolt.
5659 ///     - The overclock waiver must be set since fixing the voltage at a high
5660 ///       value puts unnecessary stress on the part.
5661 ///     - The actual frequency may reduce depending on power/thermal
5662 ///       limitations.
5663 ///     - Requesting a frequency and/or voltage of 0 will return the hardware to
5664 ///       dynamic frequency/voltage management with any previous frequency
5665 ///       offset or voltage offset settings reapplied.
5666 ///
5667 /// @returns
5668 ///     - CTL_RESULT_SUCCESS
5669 ///     - CTL_RESULT_ERROR_UNINITIALIZED
5670 ///     - CTL_RESULT_ERROR_DEVICE_LOST
5671 ///     - CTL_RESULT_ERROR_INVALID_NULL_HANDLE
5672 ///         + `nullptr == hDeviceHandle`
5673 CTL_APIEXPORT ctl_result_t CTL_APICALL
5674 ctlOverclockGpuLockSet(
5675     ctl_device_adapter_handle_t hDeviceHandle,      ///< [in][release] Handle to display adapter
5676     ctl_oc_vf_pair_t vFPair                         ///< [in] The current locked voltage and frequency.
5677     );
5678
5679 ///////////////////////////////////////////////////////////////////////////////
5680 /// @brief Get the current Vram Frequency Offset in GT/s.
5681 ///
5682 /// @details
5683 ///     - The purpose of this function is to return the current VRAM frequency
5684 ///       offset in units of GT/s.
5685 ///
5686 /// @returns
5687 ///     - CTL_RESULT_SUCCESS
5688 ///     - CTL_RESULT_ERROR_UNINITIALIZED
5689 ///     - CTL_RESULT_ERROR_DEVICE_LOST
5690 ///     - CTL_RESULT_ERROR_INVALID_NULL_HANDLE
5691 ///         + `nullptr == hDeviceHandle`
5692 ///     - CTL_RESULT_ERROR_INVALID_NULL_POINTER
5693 ///         + `nullptr == pOcFrequencyOffset`
5694 CTL_APIEXPORT ctl_result_t CTL_APICALL
5695 ctlOverclockVramFrequencyOffsetGet(
5696     ctl_device_adapter_handle_t hDeviceHandle,      ///< [in][release] Handle to display adapter
5697     double* pOcFrequencyOffset                      ///< [in,out] The current Memory Frequency in GT/s.
5698     );
5699
5700 ///////////////////////////////////////////////////////////////////////////////
5701 /// @brief Set the desired Vram frquency Offset in GT/s
5702 ///
5703 /// @details
5704 ///     - The purpose of this function is to increase/decrease the frequency of
5705 ///       VRAM.
5706 ///     - The frequency offset is expressed in units of GT/s with a minimum step
5707 ///       size given by ::ctlOverclockGetProperties.
5708 ///     - The actual operating frequency for each workload is not guaranteed to
5709 ///       change exactly by the specified offset.
5710 ///     - The waiver must be set using clibOverclockWaiverSet() before this
5711 ///       function can be called.
5712 ///     - This setting is not persistent through system reboots or driver
5713 ///       resets/hangs. It is up to the overclock application to reapply the
5714 ///       settings in those cases.
5715 ///     - This setting can cause system/device instability. It is up to the
5716 ///       overclock application to detect if the system has rebooted
5717 ///       unexpectedly or the device was restarted. When this occurs, the
5718 ///       application should not reapply the overclock settings automatically
5719 ///       but instead return to previously known good settings or notify the
5720 ///       user that the settings are not being applied.
5721 ///     - If the memory controller doesn't support changes to frequency on the
5722 ///       fly, one of the following return codes will be given:
5723 ///     - ::CTL_RESULT_ERROR_RESET_DEVICE_REQUIRED: The requested memory
5724 ///       overclock will be applied when the device is reset or the system is
5725 ///       rebooted. In this case, the overclock software should check if the
5726 ///       overclock request was applied after the reset/reboot. If it was and
5727 ///       when the overclock application shuts down gracefully and if the
5728 ///       overclock application wants the setting to be persistent, the
5729 ///       application should request the same overclock settings again so that
5730 ///       they will be applied on the next reset/reboot. If this is not done,
5731 ///       then every time the device is reset and overclock is requested, the
5732 ///       device needs to be reset a second time.
5733 ///     - ::CTL_RESULT_ERROR_FULL_REBOOT_REQUIRED: The requested memory
5734 ///       overclock will be applied when the system is rebooted. In this case,
5735 ///       the overclock software should check if the overclock request was
5736 ///       applied after the reboot. If it was and when the overclock application
5737 ///       shuts down gracefully and if the overclock application wants the
5738 ///       setting to be persistent, the application should request the same
5739 ///       overclock settings again so that they will be applied on the next
5740 ///       reset/reboot. If this is not done and the overclock setting is
5741 ///       requested after the reboot has occurred, a second reboot will be
5742 ///       required.
5743 ///
5744 /// @returns
5745 ///     - CTL_RESULT_SUCCESS
5746 ///     - CTL_RESULT_ERROR_UNINITIALIZED
5747 ///     - CTL_RESULT_ERROR_DEVICE_LOST
5748 ///     - CTL_RESULT_ERROR_INVALID_NULL_HANDLE
5749 ///         + `nullptr == hDeviceHandle`
5750 CTL_APIEXPORT ctl_result_t CTL_APICALL
5751 ctlOverclockVramFrequencyOffsetSet(
5752     ctl_device_adapter_handle_t hDeviceHandle,      ///< [in][release] Handle to display adapter
5753     double ocFrequencyOffset                        ///< [in] The desired Memory Frequency in GT/s.
5754     );
5755
5756 ///////////////////////////////////////////////////////////////////////////////
5757 /// @brief Get the Overclock Vram Voltage Offset in mV.
5758 ///
5759 /// @details
5760 ///     - The purpose of this function is to increase/decrease the voltage of
5761 ///       VRAM.
5762 ///     - The voltage offset is expressed in units of millivolts with a minimum
5763 ///       step size given by ::ctlOverclockGetProperties.
5764 ///     - The waiver must be set using ::ctlOverclockWaiverSet before this
5765 ///       function can be called.
5766 ///     - This setting is not persistent through system reboots or driver
5767 ///       resets/hangs. It is up to the overclock application to reapply the
5768 ///       settings in those cases.
5769 ///     - This setting can cause system/device instability. It is up to the
5770 ///       overclock application to detect if the system has rebooted
5771 ///       unexpectedly or the device was restarted. When this occurs, the
5772 ///       application should not reapply the overclock settings automatically
5773 ///       but instead return to previously known good settings or notify the
5774 ///       user that the settings are not being applied.
5775 ///     - If the memory controller doesn't support changes to voltage on the
5776 ///       fly, one of the following return codes will be given:
5777 ///     - ::CTL_RESULT_ERROR_RESET_DEVICE_REQUIRED: The requested memory
5778 ///       overclock will be applied when the device is reset or the system is
5779 ///       rebooted. In this case, the overclock software should check if the
5780 ///       overclock request was applied after the reset/reboot. If it was and
5781 ///       when the overclock application shuts down gracefully and if the
5782 ///       overclock application wants the setting to be persistent, the
5783 ///       application should request the same overclock settings again so that
5784 ///       they will be applied on the next reset/reboot. If this is not done,
5785 ///       then every time the device is reset and overclock is requested, the
5786 ///       device needs to be reset a second time.
5787 ///     - ::CTL_RESULT_ERROR_FULL_REBOOT_REQUIRED: The requested memory
5788 ///       overclock will be applied when the system is rebooted. In this case,
5789 ///       the overclock software should check if the overclock request was
5790 ///       applied after the reboot. If it was and when the overclock application
5791 ///       shuts down gracefully and if the overclock application wants the
5792 ///       setting to be persistent, the application should request the same
5793 ///       overclock settings again so that they will be applied on the next
5794 ///       reset/reboot. If this is not done and the overclock setting is
5795 ///       requested after the reboot has occurred, a second reboot will be
5796 ///       required.
5797 ///
5798 /// @returns
5799 ///     - CTL_RESULT_SUCCESS
5800 ///     - CTL_RESULT_ERROR_UNINITIALIZED
5801 ///     - CTL_RESULT_ERROR_DEVICE_LOST
5802 ///     - CTL_RESULT_ERROR_INVALID_NULL_HANDLE
5803 ///         + `nullptr == hDeviceHandle`
5804 ///     - CTL_RESULT_ERROR_INVALID_NULL_POINTER
5805 ///         + `nullptr == pVoltage`
5806 CTL_APIEXPORT ctl_result_t CTL_APICALL
5807 ctlOverclockVramVoltageOffsetGet(
5808     ctl_device_adapter_handle_t hDeviceHandle,      ///< [in][release] Handle to display adapter
5809     double* pVoltage                                ///< [out] The current locked voltage in mV.
5810     );
5811
5812 ///////////////////////////////////////////////////////////////////////////////
5813 /// @brief Set the Overclock Vram Voltage Offset in mV.
5814 ///
5815 /// @details
5816 ///     - The purpose of this function is to set the maximum sustained power
5817 ///       limit. If the average GPU power averaged over a few seconds exceeds
5818 ///       this value, the frequency of the GPU will be throttled.
5819 ///     - Set a value of 0 to disable this power limit. In this case, the GPU
5820 ///       frequency will not throttle due to average power but may hit other
5821 ///       limits.
5822 ///
5823 /// @returns
5824 ///     - CTL_RESULT_SUCCESS
5825 ///     - CTL_RESULT_ERROR_UNINITIALIZED
5826 ///     - CTL_RESULT_ERROR_DEVICE_LOST
5827 ///     - CTL_RESULT_ERROR_INVALID_NULL_HANDLE
5828 ///         + `nullptr == hDeviceHandle`
5829 CTL_APIEXPORT ctl_result_t CTL_APICALL
5830 ctlOverclockVramVoltageOffsetSet(
5831     ctl_device_adapter_handle_t hDeviceHandle,      ///< [in][release] Handle to display adapter
5832     double voltage                                  ///< [in] The voltage to be locked in mV.
5833     );
5834
5835 ///////////////////////////////////////////////////////////////////////////////
5836 /// @brief Get the sustained power limit in mW.
5837 ///
5838 /// @details
5839 ///     - The purpose of this function is to read the current sustained power
5840 ///       limit.
5841 ///     - A value of 0 means that the limit is disabled - the GPU frequency can
5842 ///       run as high as possible until other limits are hit.
5843 ///
5844 /// @returns
5845 ///     - CTL_RESULT_SUCCESS
5846 ///     - CTL_RESULT_ERROR_UNINITIALIZED
5847 ///     - CTL_RESULT_ERROR_DEVICE_LOST
5848 ///     - CTL_RESULT_ERROR_INVALID_NULL_HANDLE
5849 ///         + `nullptr == hDeviceHandle`
5850 ///     - CTL_RESULT_ERROR_INVALID_NULL_POINTER
5851 ///         + `nullptr == pSustainedPowerLimit`
5852 CTL_APIEXPORT ctl_result_t CTL_APICALL
5853 ctlOverclockPowerLimitGet(
5854     ctl_device_adapter_handle_t hDeviceHandle,      ///< [in][release] Handle to display adapter
5855     double* pSustainedPowerLimit                    ///< [in,out] The current sustained power limit in mW.
5856     );
5857
5858 ///////////////////////////////////////////////////////////////////////////////
5859 /// @brief Set the sustained power limit in mW.
5860 ///
5861 /// @details
5862 ///     - The purpose of this function is to set the maximum sustained power
5863 ///       limit. If the average GPU power averaged over a few seconds exceeds
5864 ///       this value, the frequency of the GPU will be throttled.
5865 ///     - Set a value of 0 to disable this power limit. In this case, the GPU
5866 ///       frequency will not throttle due to average power but may hit other
5867 ///       limits.
5868 ///
5869 /// @returns
5870 ///     - CTL_RESULT_SUCCESS
5871 ///     - CTL_RESULT_ERROR_UNINITIALIZED
5872 ///     - CTL_RESULT_ERROR_DEVICE_LOST
5873 ///     - CTL_RESULT_ERROR_INVALID_NULL_HANDLE
5874 ///         + `nullptr == hDeviceHandle`
5875 CTL_APIEXPORT ctl_result_t CTL_APICALL
5876 ctlOverclockPowerLimitSet(
5877     ctl_device_adapter_handle_t hDeviceHandle,      ///< [in][release] Handle to display adapter
5878     double sustainedPowerLimit                      ///< [in] The desired sustained power limit in mW.
5879     );
5880
5881 ///////////////////////////////////////////////////////////////////////////////
5882 /// @brief Get the current temperature limit in Celsius.
5883 ///
5884 /// @details
5885 ///     - The purpose of this function is to read the current thermal limit.
5886 ///
5887 /// @returns
5888 ///     - CTL_RESULT_SUCCESS
5889 ///     - CTL_RESULT_ERROR_UNINITIALIZED
5890 ///     - CTL_RESULT_ERROR_DEVICE_LOST
5891 ///     - CTL_RESULT_ERROR_INVALID_NULL_HANDLE
5892 ///         + `nullptr == hDeviceHandle`
5893 ///     - CTL_RESULT_ERROR_INVALID_NULL_POINTER
5894 ///         + `nullptr == pTemperatureLimit`
5895 CTL_APIEXPORT ctl_result_t CTL_APICALL
5896 ctlOverclockTemperatureLimitGet(
5897     ctl_device_adapter_handle_t hDeviceHandle,      ///< [in][release] Handle to display adapter
5898     double* pTemperatureLimit                       ///< [in,out] The current temperature limit in Celsius.
5899     );
5900
5901 ///////////////////////////////////////////////////////////////////////////////
5902 /// @brief Set the temperature limit in Celsius.
5903 ///
5904 /// @details
5905 ///     - The purpose of this function is to change the maximum thermal limit.
5906 ///       When the GPU temperature exceeds this value, the GPU frequency will be
5907 ///       throttled.
5908 ///
5909 /// @returns
5910 ///     - CTL_RESULT_SUCCESS
5911 ///     - CTL_RESULT_ERROR_UNINITIALIZED
5912 ///     - CTL_RESULT_ERROR_DEVICE_LOST
5913 ///     - CTL_RESULT_ERROR_INVALID_NULL_HANDLE
5914 ///         + `nullptr == hDeviceHandle`
5915 CTL_APIEXPORT ctl_result_t CTL_APICALL
5916 ctlOverclockTemperatureLimitSet(
5917     ctl_device_adapter_handle_t hDeviceHandle,      ///< [in][release] Handle to display adapter
5918     double temperatureLimit                         ///< [in] The desired temperature limit in Celsius.
5919     );
5920
5921 ///////////////////////////////////////////////////////////////////////////////
5922 /// @brief Get Power Telemetry.
5923 ///
5924 /// @details
5925 ///     - Limited rate of 50 ms, any call under 50 ms will return the same
5926 ///       information.
5927 ///
5928 /// @returns
5929 ///     - CTL_RESULT_SUCCESS
5930 ///     - CTL_RESULT_ERROR_UNINITIALIZED
5931 ///     - CTL_RESULT_ERROR_DEVICE_LOST
5932 ///     - CTL_RESULT_ERROR_INVALID_NULL_HANDLE
5933 ///         + `nullptr == hDeviceHandle`
5934 ///     - CTL_RESULT_ERROR_INVALID_NULL_POINTER
5935 ///         + `nullptr == pTelemetryInfo`
5936 CTL_APIEXPORT ctl_result_t CTL_APICALL
5937 ctlPowerTelemetryGet(
5938     ctl_device_adapter_handle_t hDeviceHandle,      ///< [in][release] Handle to display adapter
5939     ctl_power_telemetry_t* pTelemetryInfo           ///< [out] The overclocking properties for the specified domain.
5940     );
5941
5942
5943 #if !defined(__GNUC__)
5944 #pragma endregion // overclock
5945 #endif
5946 // Intel 'ctlApi' for Device Adapter - PCI Information
5947 #if !defined(__GNUC__)
5948 #pragma region pci
5949 #endif
5950 ///////////////////////////////////////////////////////////////////////////////
5951 /// @brief PCI address
5952 typedef struct _ctl_pci_address_t
5953 {
5954     uint32_t Size;                                  ///< [in] size of this structure
5955     uint8_t Version;                                ///< [in] version of this structure
5956     uint32_t domain;                                ///< [out] BDF domain
5957     uint32_t bus;                                   ///< [out] BDF bus
5958     uint32_t device;                                ///< [out] BDF device
5959     uint32_t function;                              ///< [out] BDF function
5960
5961 } ctl_pci_address_t;
5962
5963 ///////////////////////////////////////////////////////////////////////////////
5964 /// @brief PCI speed
5965 typedef struct _ctl_pci_speed_t
5966 {
5967     uint32_t Size;                                  ///< [in] size of this structure
5968     uint8_t Version;                                ///< [in] version of this structure
5969     int32_t gen;                                    ///< [out] The link generation. A value of -1 means that this property is
5970                                                     ///< unknown.
5971     int32_t width;                                  ///< [out] The number of lanes. A value of -1 means that this property is
5972                                                     ///< unknown.
5973     int64_t maxBandwidth;                           ///< [out] The maximum bandwidth in bytes/sec (sum of all lanes). A value
5974                                                     ///< of -1 means that this property is unknown.
5975
5976 } ctl_pci_speed_t;
5977
5978 ///////////////////////////////////////////////////////////////////////////////
5979 /// @brief Static PCI properties
5980 typedef struct _ctl_pci_properties_t
5981 {
5982     uint32_t Size;                                  ///< [in] size of this structure
5983     uint8_t Version;                                ///< [in] version of this structure
5984     ctl_pci_address_t address;                      ///< [out] The BDF address
5985     ctl_pci_speed_t maxSpeed;                       ///< [out] Fastest port configuration supported by the device (sum of all
5986                                                     ///< lanes)
5987     bool resizable_bar_supported;                   ///< [out] Support for Resizable Bar on this device.
5988     bool resizable_bar_enabled;                     ///< [out] Resizable Bar enabled on this device
5989
5990 } ctl_pci_properties_t;
5991
5992 ///////////////////////////////////////////////////////////////////////////////
5993 /// @brief Dynamic PCI state
5994 typedef struct _ctl_pci_state_t
5995 {
5996     uint32_t Size;                                  ///< [in] size of this structure
5997     uint8_t Version;                                ///< [in] version of this structure
5998     ctl_pci_speed_t speed;                          ///< [out] The current port configure speed
5999
6000 } ctl_pci_state_t;
6001
6002 ///////////////////////////////////////////////////////////////////////////////
6003 /// @brief Get PCI properties - address, max speed
6004 ///
6005 /// @details
6006 ///     - The application may call this function from simultaneous threads.
6007 ///     - The implementation of this function should be lock-free.
6008 ///
6009 /// @returns
6010 ///     - CTL_RESULT_SUCCESS
6011 ///     - CTL_RESULT_ERROR_UNINITIALIZED
6012 ///     - CTL_RESULT_ERROR_DEVICE_LOST
6013 ///     - CTL_RESULT_ERROR_INVALID_NULL_HANDLE
6014 ///         + `nullptr == hDAhandle`
6015 ///     - CTL_RESULT_ERROR_INVALID_NULL_POINTER
6016 ///         + `nullptr == pProperties`
6017 CTL_APIEXPORT ctl_result_t CTL_APICALL
6018 ctlPciGetProperties(
6019     ctl_device_adapter_handle_t hDAhandle,          ///< [in][release] Handle to display adapter
6020     ctl_pci_properties_t* pProperties               ///< [in,out] Will contain the PCI properties.
6021     );
6022
6023 ///////////////////////////////////////////////////////////////////////////////
6024 /// @brief Get current PCI state - current speed
6025 ///
6026 /// @details
6027 ///     - The application may call this function from simultaneous threads.
6028 ///     - The implementation of this function should be lock-free.
6029 ///
6030 /// @returns
6031 ///     - CTL_RESULT_SUCCESS
6032 ///     - CTL_RESULT_ERROR_UNINITIALIZED
6033 ///     - CTL_RESULT_ERROR_DEVICE_LOST
6034 ///     - CTL_RESULT_ERROR_INVALID_NULL_HANDLE
6035 ///         + `nullptr == hDAhandle`
6036 ///     - CTL_RESULT_ERROR_INVALID_NULL_POINTER
6037 ///         + `nullptr == pState`
6038 CTL_APIEXPORT ctl_result_t CTL_APICALL
6039 ctlPciGetState(
6040     ctl_device_adapter_handle_t hDAhandle,          ///< [in][release] Handle to display adapter
6041     ctl_pci_state_t* pState                         ///< [in,out] Will contain the PCI properties.
6042     );
6043
6044
6045 #if !defined(__GNUC__)
6046 #pragma endregion // pci
6047 #endif
6048 // Intel 'ctlApi' for Device Adapter - Power management
6049 #if !defined(__GNUC__)
6050 #pragma region power
6051 #endif
6052 ///////////////////////////////////////////////////////////////////////////////
6053 /// @brief Properties related to device power settings
6054 typedef struct _ctl_power_properties_t
6055 {
6056     uint32_t Size;                                  ///< [in] size of this structure
6057     uint8_t Version;                                ///< [in] version of this structure
6058     bool canControl;                                ///< [out] Software can change the power limits of this domain assuming the
6059                                                     ///< user has permissions.
6060     int32_t defaultLimit;                           ///< [out] The factory default TDP power limit of the part in milliwatts. A
6061                                                     ///< value of -1 means that this is not known.
6062     int32_t minLimit;                               ///< [out] The minimum power limit in milliwatts that can be requested.
6063     int32_t maxLimit;                               ///< [out] The maximum power limit in milliwatts that can be requested.
6064
6065 } ctl_power_properties_t;
6066
6067 ///////////////////////////////////////////////////////////////////////////////
6068 /// @brief Energy counter snapshot
6069 ///
6070 /// @details
6071 ///     - Average power is calculated by taking two snapshots (s1, s2) and using
6072 ///       the equation: PowerWatts = (s2.energy - s1.energy) / (s2.timestamp -
6073 ///       s1.timestamp)
6074 typedef struct _ctl_power_energy_counter_t
6075 {
6076     uint32_t Size;                                  ///< [in] size of this structure
6077     uint8_t Version;                                ///< [in] version of this structure
6078     uint64_t energy;                                ///< [out] The monotonic energy counter in microjoules.
6079     uint64_t timestamp;                             ///< [out] Microsecond timestamp when energy was captured.
6080                                                     ///< This timestamp should only be used to calculate delta time between
6081                                                     ///< snapshots of this structure.
6082                                                     ///< Never take the delta of this timestamp with the timestamp from a
6083                                                     ///< different structure since they are not guaranteed to have the same base.
6084                                                     ///< The absolute value of the timestamp is only valid during within the
6085                                                     ///< application and may be different on the next execution.
6086
6087 } ctl_power_energy_counter_t;
6088
6089 ///////////////////////////////////////////////////////////////////////////////
6090 /// @brief Sustained power limits
6091 ///
6092 /// @details
6093 ///     - The power controller (Punit) will throttle the operating frequency if
6094 ///       the power averaged over a window (typically seconds) exceeds this
6095 ///       limit.
6096 typedef struct _ctl_power_sustained_limit_t
6097 {
6098     bool enabled;                                   ///< [in,out] indicates if the limit is enabled (true) or ignored (false)
6099     int32_t power;                                  ///< [in,out] power limit in milliwatts
6100     int32_t interval;                               ///< [in,out] power averaging window (Tau) in milliseconds
6101
6102 } ctl_power_sustained_limit_t;
6103
6104 ///////////////////////////////////////////////////////////////////////////////
6105 /// @brief Burst power limit
6106 ///
6107 /// @details
6108 ///     - The power controller (Punit) will throttle the operating frequency of
6109 ///       the device if the power averaged over a few milliseconds exceeds a
6110 ///       limit known as PL2. Typically PL2 > PL1 so that it permits the
6111 ///       frequency to burst higher for short periods than would be otherwise
6112 ///       permitted by PL1.
6113 typedef struct _ctl_power_burst_limit_t
6114 {
6115     bool enabled;                                   ///< [in,out] indicates if the limit is enabled (true) or ignored (false)
6116     int32_t power;                                  ///< [in,out] power limit in milliwatts
6117
6118 } ctl_power_burst_limit_t;
6119
6120 ///////////////////////////////////////////////////////////////////////////////
6121 /// @brief Peak power limit
6122 ///
6123 /// @details
6124 ///     - The power controller (Punit) will preemptively throttle the operating
6125 ///       frequency of the device when the instantaneous power exceeds this
6126 ///       limit. The limit is known as PL4. It expresses the maximum power that
6127 ///       can be drawn from the power supply.
6128 ///     - If this power limit is removed or set too high, the power supply will
6129 ///       generate an interrupt when it detects an overcurrent condition and the
6130 ///       power controller will throttle the device frequencies down to min. It
6131 ///       is thus better to tune the PL4 value in order to avoid such
6132 ///       excursions.
6133 typedef struct _ctl_power_peak_limit_t
6134 {
6135     int32_t powerAC;                                ///< [in,out] power limit in milliwatts for the AC power source.
6136     int32_t powerDC;                                ///< [in,out] power limit in milliwatts for the DC power source. On input,
6137                                                     ///< this is ignored if the product does not have a battery. On output,
6138                                                     ///< this will be -1 if the product does not have a battery.
6139
6140 } ctl_power_peak_limit_t;
6141
6142 ///////////////////////////////////////////////////////////////////////////////
6143 /// @brief Power limits
6144 typedef struct _ctl_power_limits_t
6145 {
6146     uint32_t Size;                                  ///< [in] size of this structure
6147     uint8_t Version;                                ///< [in] version of this structure
6148     ctl_power_sustained_limit_t sustainedPowerLimit;///< [in,out] sustained power limit.
6149     ctl_power_burst_limit_t burstPowerLimit;        ///< [in,out] burst power limit.
6150     ctl_power_peak_limit_t peakPowerLimits;         ///< [in,out] peak power limit.
6151
6152 } ctl_power_limits_t;
6153
6154 ///////////////////////////////////////////////////////////////////////////////
6155 /// @brief Energy threshold
6156 ///
6157 /// @details
6158 ///     - .
6159 typedef struct _ctl_energy_threshold_t
6160 {
6161     uint32_t Size;                                  ///< [in] size of this structure
6162     uint8_t Version;                                ///< [in] version of this structure
6163     bool enable;                                    ///< [in,out] Indicates if the energy threshold is enabled.
6164     double threshold;                               ///< [in,out] The energy threshold in Joules. Will be 0.0 if no threshold
6165                                                     ///< has been set.
6166     uint32_t processId;                             ///< [in,out] The host process ID that set the energy threshold. Will be
6167                                                     ///< 0xFFFFFFFF if no threshold has been set.
6168
6169 } ctl_energy_threshold_t;
6170
6171 ///////////////////////////////////////////////////////////////////////////////
6172 /// @brief Get handle of power domains
6173 ///
6174 /// @details
6175 ///     - The application may call this function from simultaneous threads.
6176 ///     - The implementation of this function should be lock-free.
6177 ///
6178 /// @returns
6179 ///     - CTL_RESULT_SUCCESS
6180 ///     - CTL_RESULT_ERROR_UNINITIALIZED
6181 ///     - CTL_RESULT_ERROR_DEVICE_LOST
6182 ///     - CTL_RESULT_ERROR_INVALID_NULL_HANDLE
6183 ///         + `nullptr == hDAhandle`
6184 ///     - CTL_RESULT_ERROR_INVALID_NULL_POINTER
6185 ///         + `nullptr == pCount`
6186 CTL_APIEXPORT ctl_result_t CTL_APICALL
6187 ctlEnumPowerDomains(
6188     ctl_device_adapter_handle_t hDAhandle,          ///< [in][release] Handle to display adapter
6189     uint32_t* pCount,                               ///< [in,out] pointer to the number of components of this type.
6190                                                     ///< if count is zero, then the driver shall update the value with the
6191                                                     ///< total number of components of this type that are available.
6192                                                     ///< if count is greater than the number of components of this type that
6193                                                     ///< are available, then the driver shall update the value with the correct
6194                                                     ///< number of components.
6195     ctl_pwr_handle_t* phPower                       ///< [in,out][optional][range(0, *pCount)] array of handle of components of
6196                                                     ///< this type.
6197                                                     ///< if count is less than the number of components of this type that are
6198                                                     ///< available, then the driver shall only retrieve that number of
6199                                                     ///< component handles.
6200     );
6201
6202 ///////////////////////////////////////////////////////////////////////////////
6203 /// @brief Get properties related to a power domain
6204 ///
6205 /// @details
6206 ///     - The application may call this function from simultaneous threads.
6207 ///     - The implementation of this function should be lock-free.
6208 ///
6209 /// @returns
6210 ///     - CTL_RESULT_SUCCESS
6211 ///     - CTL_RESULT_ERROR_UNINITIALIZED
6212 ///     - CTL_RESULT_ERROR_DEVICE_LOST
6213 ///     - CTL_RESULT_ERROR_INVALID_NULL_HANDLE
6214 ///         + `nullptr == hPower`
6215 ///     - CTL_RESULT_ERROR_INVALID_NULL_POINTER
6216 ///         + `nullptr == pProperties`
6217 CTL_APIEXPORT ctl_result_t CTL_APICALL
6218 ctlPowerGetProperties(
6219     ctl_pwr_handle_t hPower,                        ///< [in] Handle for the component.
6220     ctl_power_properties_t* pProperties             ///< [in,out] Structure that will contain property data.
6221     );
6222
6223 ///////////////////////////////////////////////////////////////////////////////
6224 /// @brief Get energy counter
6225 ///
6226 /// @details
6227 ///     - The application may call this function from simultaneous threads.
6228 ///     - The implementation of this function should be lock-free.
6229 ///
6230 /// @returns
6231 ///     - CTL_RESULT_SUCCESS
6232 ///     - CTL_RESULT_ERROR_UNINITIALIZED
6233 ///     - CTL_RESULT_ERROR_DEVICE_LOST
6234 ///     - CTL_RESULT_ERROR_INVALID_NULL_HANDLE
6235 ///         + `nullptr == hPower`
6236 ///     - CTL_RESULT_ERROR_INVALID_NULL_POINTER
6237 ///         + `nullptr == pEnergy`
6238 CTL_APIEXPORT ctl_result_t CTL_APICALL
6239 ctlPowerGetEnergyCounter(
6240     ctl_pwr_handle_t hPower,                        ///< [in] Handle for the component.
6241     ctl_power_energy_counter_t* pEnergy             ///< [in,out] Will contain the latest snapshot of the energy counter and
6242                                                     ///< timestamp when the last counter value was measured.
6243     );
6244
6245 ///////////////////////////////////////////////////////////////////////////////
6246 /// @brief Get power limits
6247 ///
6248 /// @details
6249 ///     - The application may call this function from simultaneous threads.
6250 ///     - The implementation of this function should be lock-free.
6251 ///
6252 /// @returns
6253 ///     - CTL_RESULT_SUCCESS
6254 ///     - CTL_RESULT_ERROR_UNINITIALIZED
6255 ///     - CTL_RESULT_ERROR_DEVICE_LOST
6256 ///     - CTL_RESULT_ERROR_INVALID_NULL_HANDLE
6257 ///         + `nullptr == hPower`
6258 CTL_APIEXPORT ctl_result_t CTL_APICALL
6259 ctlPowerGetLimits(
6260     ctl_pwr_handle_t hPower,                        ///< [in] Handle for the component.
6261     ctl_power_limits_t* pPowerLimits                ///< [in,out][optional] Structure that will contain the power limits.
6262     );
6263
6264 ///////////////////////////////////////////////////////////////////////////////
6265 /// @brief Set power limits
6266 ///
6267 /// @details
6268 ///     - The application may call this function from simultaneous threads.
6269 ///     - The implementation of this function should be lock-free.
6270 ///
6271 /// @returns
6272 ///     - CTL_RESULT_SUCCESS
6273 ///     - CTL_RESULT_ERROR_UNINITIALIZED
6274 ///     - CTL_RESULT_ERROR_DEVICE_LOST
6275 ///     - CTL_RESULT_ERROR_INVALID_NULL_HANDLE
6276 ///         + `nullptr == hPower`
6277 ///     - ::CTL_RESULT_ERROR_INSUFFICIENT_PERMISSIONS
6278 ///         + User does not have permissions to make these modifications.
6279 ///     - ::CTL_RESULT_ERROR_NOT_AVAILABLE
6280 ///         + The device is in use, meaning that the GPU is under Over clocking, applying power limits under overclocking is not supported.
6281 CTL_APIEXPORT ctl_result_t CTL_APICALL
6282 ctlPowerSetLimits(
6283     ctl_pwr_handle_t hPower,                        ///< [in] Handle for the component.
6284     const ctl_power_limits_t* pPowerLimits          ///< [in][optional] Structure that will contain the power limits.
6285     );
6286
6287
6288 #if !defined(__GNUC__)
6289 #pragma endregion // power
6290 #endif
6291 // Intel 'ctlApi' for Device Adapter - Temperature Sensors
6292 #if !defined(__GNUC__)
6293 #pragma region temperature
6294 #endif
6295 ///////////////////////////////////////////////////////////////////////////////
6296 /// @brief Temperature sensors
6297 typedef enum _ctl_temp_sensors_t
6298 {
6299     CTL_TEMP_SENSORS_GLOBAL = 0,                    ///< The maximum temperature across all device sensors
6300     CTL_TEMP_SENSORS_GPU = 1,                       ///< The maximum temperature across all sensors in the GPU
6301     CTL_TEMP_SENSORS_MEMORY = 2,                    ///< The maximum temperature across all sensors in the local memory
6302     CTL_TEMP_SENSORS_GLOBAL_MIN = 3,                ///< The minimum temperature across all device sensors
6303     CTL_TEMP_SENSORS_GPU_MIN = 4,                   ///< The minimum temperature across all sensors in the GPU
6304     CTL_TEMP_SENSORS_MEMORY_MIN = 5,                ///< The minimum temperature across all sensors in the local device memory
6305     CTL_TEMP_SENSORS_MAX
6306
6307 } ctl_temp_sensors_t;
6308
6309 ///////////////////////////////////////////////////////////////////////////////
6310 /// @brief Temperature sensor properties
6311 typedef struct _ctl_temp_properties_t
6312 {
6313     uint32_t Size;                                  ///< [in] size of this structure
6314     uint8_t Version;                                ///< [in] version of this structure
6315     ctl_temp_sensors_t type;                        ///< [out] Which part of the device the temperature sensor measures
6316     double maxTemperature;                          ///< [out] Will contain the maximum temperature for the specific device in
6317                                                     ///< degrees Celsius.
6318
6319 } ctl_temp_properties_t;
6320
6321 ///////////////////////////////////////////////////////////////////////////////
6322 /// @brief Get handle of temperature sensors
6323 ///
6324 /// @details
6325 ///     - The application may call this function from simultaneous threads.
6326 ///     - The implementation of this function should be lock-free.
6327 ///
6328 /// @returns
6329 ///     - CTL_RESULT_SUCCESS
6330 ///     - CTL_RESULT_ERROR_UNINITIALIZED
6331 ///     - CTL_RESULT_ERROR_DEVICE_LOST
6332 ///     - CTL_RESULT_ERROR_INVALID_NULL_HANDLE
6333 ///         + `nullptr == hDAhandle`
6334 ///     - CTL_RESULT_ERROR_INVALID_NULL_POINTER
6335 ///         + `nullptr == pCount`
6336 CTL_APIEXPORT ctl_result_t CTL_APICALL
6337 ctlEnumTemperatureSensors(
6338     ctl_device_adapter_handle_t hDAhandle,          ///< [in][release] Handle to display adapter
6339     uint32_t* pCount,                               ///< [in,out] pointer to the number of components of this type.
6340                                                     ///< if count is zero, then the driver shall update the value with the
6341                                                     ///< total number of components of this type that are available.
6342                                                     ///< if count is greater than the number of components of this type that
6343                                                     ///< are available, then the driver shall update the value with the correct
6344                                                     ///< number of components.
6345     ctl_temp_handle_t* phTemperature                ///< [in,out][optional][range(0, *pCount)] array of handle of components of
6346                                                     ///< this type.
6347                                                     ///< if count is less than the number of components of this type that are
6348                                                     ///< available, then the driver shall only retrieve that number of
6349                                                     ///< component handles.
6350     );
6351
6352 ///////////////////////////////////////////////////////////////////////////////
6353 /// @brief Get temperature sensor properties
6354 ///
6355 /// @details
6356 ///     - The application may call this function from simultaneous threads.
6357 ///     - The implementation of this function should be lock-free.
6358 ///
6359 /// @returns
6360 ///     - CTL_RESULT_SUCCESS
6361 ///     - CTL_RESULT_ERROR_UNINITIALIZED
6362 ///     - CTL_RESULT_ERROR_DEVICE_LOST
6363 ///     - CTL_RESULT_ERROR_INVALID_NULL_HANDLE
6364 ///         + `nullptr == hTemperature`
6365 ///     - CTL_RESULT_ERROR_INVALID_NULL_POINTER
6366 ///         + `nullptr == pProperties`
6367 CTL_APIEXPORT ctl_result_t CTL_APICALL
6368 ctlTemperatureGetProperties(
6369     ctl_temp_handle_t hTemperature,                 ///< [in] Handle for the component.
6370     ctl_temp_properties_t* pProperties              ///< [in,out] Will contain the temperature sensor properties.
6371     );
6372
6373 ///////////////////////////////////////////////////////////////////////////////
6374 /// @brief Get the temperature from a specified sensor
6375 ///
6376 /// @details
6377 ///     - The application may call this function from simultaneous threads.
6378 ///     - The implementation of this function should be lock-free.
6379 ///
6380 /// @returns
6381 ///     - CTL_RESULT_SUCCESS
6382 ///     - CTL_RESULT_ERROR_UNINITIALIZED
6383 ///     - CTL_RESULT_ERROR_DEVICE_LOST
6384 ///     - CTL_RESULT_ERROR_INVALID_NULL_HANDLE
6385 ///         + `nullptr == hTemperature`
6386 ///     - CTL_RESULT_ERROR_INVALID_NULL_POINTER
6387 ///         + `nullptr == pTemperature`
6388 CTL_APIEXPORT ctl_result_t CTL_APICALL
6389 ctlTemperatureGetState(
6390     ctl_temp_handle_t hTemperature,                 ///< [in] Handle for the component.
6391     double* pTemperature                            ///< [in,out] Will contain the temperature read from the specified sensor
6392                                                     ///< in degrees Celsius.
6393     );
6394
6395
6396 #if !defined(__GNUC__)
6397 #pragma endregion // temperature
6398 #endif
6399
6400
6401 ///////////////////////////////////////////////////////////////////////////////
6402 /// @brief Function-pointer for ctlInit
6403 typedef ctl_result_t (CTL_APICALL *ctl_pfnInit_t)(
6404     ctl_init_args_t*,
6405     ctl_api_handle_t*
6406     );
6407
6408
6409 ///////////////////////////////////////////////////////////////////////////////
6410 /// @brief Function-pointer for ctlClose
6411 typedef ctl_result_t (CTL_APICALL *ctl_pfnClose_t)(
6412     ctl_api_handle_t
6413     );
6414
6415
6416 ///////////////////////////////////////////////////////////////////////////////
6417 /// @brief Function-pointer for ctlSetRuntimePath
6418 typedef ctl_result_t (CTL_APICALL *ctl_pfnSetRuntimePath_t)(
6419     ctl_runtime_path_args_t*
6420     );
6421
6422
6423 ///////////////////////////////////////////////////////////////////////////////
6424 /// @brief Function-pointer for ctlWaitForPropertyChange
6425 typedef ctl_result_t (CTL_APICALL *ctl_pfnWaitForPropertyChange_t)(
6426     ctl_device_adapter_handle_t,
6427     ctl_wait_property_change_args_t*
6428     );
6429
6430
6431 ///////////////////////////////////////////////////////////////////////////////
6432 /// @brief Function-pointer for ctlReservedCall
6433 typedef ctl_result_t (CTL_APICALL *ctl_pfnReservedCall_t)(
6434     ctl_device_adapter_handle_t,
6435     ctl_reserved_args_t*
6436     );
6437
6438
6439 ///////////////////////////////////////////////////////////////////////////////
6440 /// @brief Function-pointer for ctlGetSupported3DCapabilities
6441 typedef ctl_result_t (CTL_APICALL *ctl_pfnGetSupported3DCapabilities_t)(
6442     ctl_device_adapter_handle_t,
6443     ctl_3d_feature_caps_t*
6444     );
6445
6446
6447 ///////////////////////////////////////////////////////////////////////////////
6448 /// @brief Function-pointer for ctlGetSet3DFeature
6449 typedef ctl_result_t (CTL_APICALL *ctl_pfnGetSet3DFeature_t)(
6450     ctl_device_adapter_handle_t,
6451     ctl_3d_feature_getset_t*
6452     );
6453
6454
6455 ///////////////////////////////////////////////////////////////////////////////
6456 /// @brief Function-pointer for ctlCheckDriverVersion
6457 typedef ctl_result_t (CTL_APICALL *ctl_pfnCheckDriverVersion_t)(
6458     ctl_device_adapter_handle_t,
6459     ctl_version_info_t
6460     );
6461
6462
6463 ///////////////////////////////////////////////////////////////////////////////
6464 /// @brief Function-pointer for ctlEnumerateDevices
6465 typedef ctl_result_t (CTL_APICALL *ctl_pfnEnumerateDevices_t)(
6466     ctl_api_handle_t,
6467     uint32_t*,
6468     ctl_device_adapter_handle_t*
6469     );
6470
6471
6472 ///////////////////////////////////////////////////////////////////////////////
6473 /// @brief Function-pointer for ctlEnumerateDisplayOutputs
6474 typedef ctl_result_t (CTL_APICALL *ctl_pfnEnumerateDisplayOutputs_t)(
6475     ctl_device_adapter_handle_t,
6476     uint32_t*,
6477     ctl_display_output_handle_t*
6478     );
6479
6480
6481 ///////////////////////////////////////////////////////////////////////////////
6482 /// @brief Function-pointer for ctlGetDeviceProperties
6483 typedef ctl_result_t (CTL_APICALL *ctl_pfnGetDeviceProperties_t)(
6484     ctl_device_adapter_handle_t,
6485     ctl_device_adapter_properties_t*
6486     );
6487
6488
6489 ///////////////////////////////////////////////////////////////////////////////
6490 /// @brief Function-pointer for ctlGetDisplayProperties
6491 typedef ctl_result_t (CTL_APICALL *ctl_pfnGetDisplayProperties_t)(
6492     ctl_display_output_handle_t,
6493     ctl_display_properties_t*
6494     );
6495
6496
6497 ///////////////////////////////////////////////////////////////////////////////
6498 /// @brief Function-pointer for ctlGetAdaperDisplayEncoderProperties
6499 typedef ctl_result_t (CTL_APICALL *ctl_pfnGetAdaperDisplayEncoderProperties_t)(
6500     ctl_display_output_handle_t,
6501     ctl_adapter_display_encoder_properties_t*
6502     );
6503
6504
6505 ///////////////////////////////////////////////////////////////////////////////
6506 /// @brief Function-pointer for ctlGetZeDevice
6507 typedef ctl_result_t (CTL_APICALL *ctl_pfnGetZeDevice_t)(
6508     ctl_device_adapter_handle_t,
6509     void*,
6510     void**
6511     );
6512
6513
6514 ///////////////////////////////////////////////////////////////////////////////
6515 /// @brief Function-pointer for ctlGetSharpnessCaps
6516 typedef ctl_result_t (CTL_APICALL *ctl_pfnGetSharpnessCaps_t)(
6517     ctl_display_output_handle_t,
6518     ctl_sharpness_caps_t*
6519     );
6520
6521
6522 ///////////////////////////////////////////////////////////////////////////////
6523 /// @brief Function-pointer for ctlGetCurrentSharpness
6524 typedef ctl_result_t (CTL_APICALL *ctl_pfnGetCurrentSharpness_t)(
6525     ctl_display_output_handle_t,
6526     ctl_sharpness_settings_t*
6527     );
6528
6529
6530 ///////////////////////////////////////////////////////////////////////////////
6531 /// @brief Function-pointer for ctlSetCurrentSharpness
6532 typedef ctl_result_t (CTL_APICALL *ctl_pfnSetCurrentSharpness_t)(
6533     ctl_display_output_handle_t,
6534     ctl_sharpness_settings_t*
6535     );
6536
6537
6538 ///////////////////////////////////////////////////////////////////////////////
6539 /// @brief Function-pointer for ctlI2CAccess
6540 typedef ctl_result_t (CTL_APICALL *ctl_pfnI2CAccess_t)(
6541     ctl_display_output_handle_t,
6542     ctl_i2c_access_args_t*
6543     );
6544
6545
6546 ///////////////////////////////////////////////////////////////////////////////
6547 /// @brief Function-pointer for ctlAUXAccess
6548 typedef ctl_result_t (CTL_APICALL *ctl_pfnAUXAccess_t)(
6549     ctl_display_output_handle_t,
6550     ctl_aux_access_args_t*
6551     );
6552
6553
6554 ///////////////////////////////////////////////////////////////////////////////
6555 /// @brief Function-pointer for ctlGetPowerOptimizationCaps
6556 typedef ctl_result_t (CTL_APICALL *ctl_pfnGetPowerOptimizationCaps_t)(
6557     ctl_display_output_handle_t,
6558     ctl_power_optimization_caps_t*
6559     );
6560
6561
6562 ///////////////////////////////////////////////////////////////////////////////
6563 /// @brief Function-pointer for ctlGetPowerOptimizationSetting
6564 typedef ctl_result_t (CTL_APICALL *ctl_pfnGetPowerOptimizationSetting_t)(
6565     ctl_display_output_handle_t,
6566     ctl_power_optimization_settings_t*
6567     );
6568
6569
6570 ///////////////////////////////////////////////////////////////////////////////
6571 /// @brief Function-pointer for ctlSetPowerOptimizationSetting
6572 typedef ctl_result_t (CTL_APICALL *ctl_pfnSetPowerOptimizationSetting_t)(
6573     ctl_display_output_handle_t,
6574     ctl_power_optimization_settings_t*
6575     );
6576
6577
6578 ///////////////////////////////////////////////////////////////////////////////
6579 /// @brief Function-pointer for ctlSetBrightnessSetting
6580 typedef ctl_result_t (CTL_APICALL *ctl_pfnSetBrightnessSetting_t)(
6581     ctl_display_output_handle_t,
6582     ctl_set_brightness_t*
6583     );
6584
6585
6586 ///////////////////////////////////////////////////////////////////////////////
6587 /// @brief Function-pointer for ctlGetBrightnessSetting
6588 typedef ctl_result_t (CTL_APICALL *ctl_pfnGetBrightnessSetting_t)(
6589     ctl_display_output_handle_t,
6590     ctl_get_brightness_t*
6591     );
6592
6593
6594 ///////////////////////////////////////////////////////////////////////////////
6595 /// @brief Function-pointer for ctlPixelTransformationGetConfig
6596 typedef ctl_result_t (CTL_APICALL *ctl_pfnPixelTransformationGetConfig_t)(
6597     ctl_display_output_handle_t,
6598     ctl_pixtx_pipe_get_config_t*
6599     );
6600
6601
6602 ///////////////////////////////////////////////////////////////////////////////
6603 /// @brief Function-pointer for ctlPixelTransformationSetConfig
6604 typedef ctl_result_t (CTL_APICALL *ctl_pfnPixelTransformationSetConfig_t)(
6605     ctl_display_output_handle_t,
6606     ctl_pixtx_pipe_set_config_t*
6607     );
6608
6609
6610 ///////////////////////////////////////////////////////////////////////////////
6611 /// @brief Function-pointer for ctlPanelDescriptorAccess
6612 typedef ctl_result_t (CTL_APICALL *ctl_pfnPanelDescriptorAccess_t)(
6613     ctl_display_output_handle_t,
6614     ctl_panel_descriptor_access_args_t*
6615     );
6616
6617
6618 ///////////////////////////////////////////////////////////////////////////////
6619 /// @brief Function-pointer for ctlGetSupportedRetroScalingCapability
6620 typedef ctl_result_t (CTL_APICALL *ctl_pfnGetSupportedRetroScalingCapability_t)(
6621     ctl_device_adapter_handle_t,
6622     ctl_retro_scaling_caps_t*
6623     );
6624
6625
6626 ///////////////////////////////////////////////////////////////////////////////
6627 /// @brief Function-pointer for ctlGetSetRetroScaling
6628 typedef ctl_result_t (CTL_APICALL *ctl_pfnGetSetRetroScaling_t)(
6629     ctl_device_adapter_handle_t,
6630     ctl_retro_scaling_settings_t*
6631     );
6632
6633
6634 ///////////////////////////////////////////////////////////////////////////////
6635 /// @brief Function-pointer for ctlGetSupportedScalingCapability
6636 typedef ctl_result_t (CTL_APICALL *ctl_pfnGetSupportedScalingCapability_t)(
6637     ctl_display_output_handle_t,
6638     ctl_scaling_caps_t*
6639     );
6640
6641
6642 ///////////////////////////////////////////////////////////////////////////////
6643 /// @brief Function-pointer for ctlGetCurrentScaling
6644 typedef ctl_result_t (CTL_APICALL *ctl_pfnGetCurrentScaling_t)(
6645     ctl_display_output_handle_t,
6646     ctl_scaling_settings_t*
6647     );
6648
6649
6650 ///////////////////////////////////////////////////////////////////////////////
6651 /// @brief Function-pointer for ctlSetCurrentScaling
6652 typedef ctl_result_t (CTL_APICALL *ctl_pfnSetCurrentScaling_t)(
6653     ctl_display_output_handle_t,
6654     ctl_scaling_settings_t*
6655     );
6656
6657
6658 ///////////////////////////////////////////////////////////////////////////////
6659 /// @brief Function-pointer for ctlGetLACEConfig
6660 typedef ctl_result_t (CTL_APICALL *ctl_pfnGetLACEConfig_t)(
6661     ctl_display_output_handle_t,
6662     ctl_lace_config_t*
6663     );
6664
6665
6666 ///////////////////////////////////////////////////////////////////////////////
6667 /// @brief Function-pointer for ctlSetLACEConfig
6668 typedef ctl_result_t (CTL_APICALL *ctl_pfnSetLACEConfig_t)(
6669     ctl_display_output_handle_t,
6670     ctl_lace_config_t*
6671     );
6672
6673
6674 ///////////////////////////////////////////////////////////////////////////////
6675 /// @brief Function-pointer for ctlSoftwarePSR
6676 typedef ctl_result_t (CTL_APICALL *ctl_pfnSoftwarePSR_t)(
6677     ctl_display_output_handle_t,
6678     ctl_sw_psr_settings_t*
6679     );
6680
6681
6682 ///////////////////////////////////////////////////////////////////////////////
6683 /// @brief Function-pointer for ctlGetIntelArcSyncInfoForMonitor
6684 typedef ctl_result_t (CTL_APICALL *ctl_pfnGetIntelArcSyncInfoForMonitor_t)(
6685     ctl_display_output_handle_t,
6686     ctl_intel_arc_sync_monitor_params_t*
6687     );
6688
6689
6690 ///////////////////////////////////////////////////////////////////////////////
6691 /// @brief Function-pointer for ctlEnumerateMuxDevices
6692 typedef ctl_result_t (CTL_APICALL *ctl_pfnEnumerateMuxDevices_t)(
6693     ctl_api_handle_t,
6694     uint32_t*,
6695     ctl_mux_output_handle_t*
6696     );
6697
6698
6699 ///////////////////////////////////////////////////////////////////////////////
6700 /// @brief Function-pointer for ctlGetMuxProperties
6701 typedef ctl_result_t (CTL_APICALL *ctl_pfnGetMuxProperties_t)(
6702     ctl_mux_output_handle_t,
6703     ctl_mux_properties_t*
6704     );
6705
6706
6707 ///////////////////////////////////////////////////////////////////////////////
6708 /// @brief Function-pointer for ctlSwitchMux
6709 typedef ctl_result_t (CTL_APICALL *ctl_pfnSwitchMux_t)(
6710     ctl_mux_output_handle_t,
6711     ctl_display_output_handle_t
6712     );
6713
6714
6715 ///////////////////////////////////////////////////////////////////////////////
6716 /// @brief Function-pointer for ctlGetIntelArcSyncProfile
6717 typedef ctl_result_t (CTL_APICALL *ctl_pfnGetIntelArcSyncProfile_t)(
6718     ctl_display_output_handle_t,
6719     ctl_intel_arc_sync_profile_params_t*
6720     );
6721
6722
6723 ///////////////////////////////////////////////////////////////////////////////
6724 /// @brief Function-pointer for ctlSetIntelArcSyncProfile
6725 typedef ctl_result_t (CTL_APICALL *ctl_pfnSetIntelArcSyncProfile_t)(
6726     ctl_display_output_handle_t,
6727     ctl_intel_arc_sync_profile_params_t*
6728     );
6729
6730
6731 ///////////////////////////////////////////////////////////////////////////////
6732 /// @brief Function-pointer for ctlEdidManagement
6733 typedef ctl_result_t (CTL_APICALL *ctl_pfnEdidManagement_t)(
6734     ctl_display_output_handle_t,
6735     ctl_edid_management_args_t*
6736     );
6737
6738
6739 ///////////////////////////////////////////////////////////////////////////////
6740 /// @brief Function-pointer for ctlGetSetCustomMode
6741 typedef ctl_result_t (CTL_APICALL *ctl_pfnGetSetCustomMode_t)(
6742     ctl_display_output_handle_t,
6743     ctl_get_set_custom_mode_args_t*
6744     );
6745
6746
6747 ///////////////////////////////////////////////////////////////////////////////
6748 /// @brief Function-pointer for ctlGetSetCombinedDisplay
6749 typedef ctl_result_t (CTL_APICALL *ctl_pfnGetSetCombinedDisplay_t)(
6750     ctl_device_adapter_handle_t,
6751     ctl_combined_display_args_t*
6752     );
6753
6754
6755 ///////////////////////////////////////////////////////////////////////////////
6756 /// @brief Function-pointer for ctlGetSetDisplayGenlock
6757 typedef ctl_result_t (CTL_APICALL *ctl_pfnGetSetDisplayGenlock_t)(
6758     ctl_device_adapter_handle_t*,
6759     ctl_genlock_args_t**,
6760     uint32_t,
6761     ctl_device_adapter_handle_t*
6762     );
6763
6764
6765 ///////////////////////////////////////////////////////////////////////////////
6766 /// @brief Function-pointer for ctlEnumEngineGroups
6767 typedef ctl_result_t (CTL_APICALL *ctl_pfnEnumEngineGroups_t)(
6768     ctl_device_adapter_handle_t,
6769     uint32_t*,
6770     ctl_engine_handle_t*
6771     );
6772
6773
6774 ///////////////////////////////////////////////////////////////////////////////
6775 /// @brief Function-pointer for ctlEngineGetProperties
6776 typedef ctl_result_t (CTL_APICALL *ctl_pfnEngineGetProperties_t)(
6777     ctl_engine_handle_t,
6778     ctl_engine_properties_t*
6779     );
6780
6781
6782 ///////////////////////////////////////////////////////////////////////////////
6783 /// @brief Function-pointer for ctlEngineGetActivity
6784 typedef ctl_result_t (CTL_APICALL *ctl_pfnEngineGetActivity_t)(
6785     ctl_engine_handle_t,
6786     ctl_engine_stats_t*
6787     );
6788
6789
6790 ///////////////////////////////////////////////////////////////////////////////
6791 /// @brief Function-pointer for ctlEnumFans
6792 typedef ctl_result_t (CTL_APICALL *ctl_pfnEnumFans_t)(
6793     ctl_device_adapter_handle_t,
6794     uint32_t*,
6795     ctl_fan_handle_t*
6796     );
6797
6798
6799 ///////////////////////////////////////////////////////////////////////////////
6800 /// @brief Function-pointer for ctlFanGetProperties
6801 typedef ctl_result_t (CTL_APICALL *ctl_pfnFanGetProperties_t)(
6802     ctl_fan_handle_t,
6803     ctl_fan_properties_t*
6804     );
6805
6806
6807 ///////////////////////////////////////////////////////////////////////////////
6808 /// @brief Function-pointer for ctlFanGetConfig
6809 typedef ctl_result_t (CTL_APICALL *ctl_pfnFanGetConfig_t)(
6810     ctl_fan_handle_t,
6811     ctl_fan_config_t*
6812     );
6813
6814
6815 ///////////////////////////////////////////////////////////////////////////////
6816 /// @brief Function-pointer for ctlFanSetDefaultMode
6817 typedef ctl_result_t (CTL_APICALL *ctl_pfnFanSetDefaultMode_t)(
6818     ctl_fan_handle_t
6819     );
6820
6821
6822 ///////////////////////////////////////////////////////////////////////////////
6823 /// @brief Function-pointer for ctlFanSetFixedSpeedMode
6824 typedef ctl_result_t (CTL_APICALL *ctl_pfnFanSetFixedSpeedMode_t)(
6825     ctl_fan_handle_t,
6826     const ctl_fan_speed_t*
6827     );
6828
6829
6830 ///////////////////////////////////////////////////////////////////////////////
6831 /// @brief Function-pointer for ctlFanSetSpeedTableMode
6832 typedef ctl_result_t (CTL_APICALL *ctl_pfnFanSetSpeedTableMode_t)(
6833     ctl_fan_handle_t,
6834     const ctl_fan_speed_table_t*
6835     );
6836
6837
6838 ///////////////////////////////////////////////////////////////////////////////
6839 /// @brief Function-pointer for ctlFanGetState
6840 typedef ctl_result_t (CTL_APICALL *ctl_pfnFanGetState_t)(
6841     ctl_fan_handle_t,
6842     ctl_fan_speed_units_t,
6843     int32_t*
6844     );
6845
6846
6847 ///////////////////////////////////////////////////////////////////////////////
6848 /// @brief Function-pointer for ctlEnumFrequencyDomains
6849 typedef ctl_result_t (CTL_APICALL *ctl_pfnEnumFrequencyDomains_t)(
6850     ctl_device_adapter_handle_t,
6851     uint32_t*,
6852     ctl_freq_handle_t*
6853     );
6854
6855
6856 ///////////////////////////////////////////////////////////////////////////////
6857 /// @brief Function-pointer for ctlFrequencyGetProperties
6858 typedef ctl_result_t (CTL_APICALL *ctl_pfnFrequencyGetProperties_t)(
6859     ctl_freq_handle_t,
6860     ctl_freq_properties_t*
6861     );
6862
6863
6864 ///////////////////////////////////////////////////////////////////////////////
6865 /// @brief Function-pointer for ctlFrequencyGetAvailableClocks
6866 typedef ctl_result_t (CTL_APICALL *ctl_pfnFrequencyGetAvailableClocks_t)(
6867     ctl_freq_handle_t,
6868     uint32_t*,
6869     double*
6870     );
6871
6872
6873 ///////////////////////////////////////////////////////////////////////////////
6874 /// @brief Function-pointer for ctlFrequencyGetRange
6875 typedef ctl_result_t (CTL_APICALL *ctl_pfnFrequencyGetRange_t)(
6876     ctl_freq_handle_t,
6877     ctl_freq_range_t*
6878     );
6879
6880
6881 ///////////////////////////////////////////////////////////////////////////////
6882 /// @brief Function-pointer for ctlFrequencySetRange
6883 typedef ctl_result_t (CTL_APICALL *ctl_pfnFrequencySetRange_t)(
6884     ctl_freq_handle_t,
6885     const ctl_freq_range_t*
6886     );
6887
6888
6889 ///////////////////////////////////////////////////////////////////////////////
6890 /// @brief Function-pointer for ctlFrequencyGetState
6891 typedef ctl_result_t (CTL_APICALL *ctl_pfnFrequencyGetState_t)(
6892     ctl_freq_handle_t,
6893     ctl_freq_state_t*
6894     );
6895
6896
6897 ///////////////////////////////////////////////////////////////////////////////
6898 /// @brief Function-pointer for ctlFrequencyGetThrottleTime
6899 typedef ctl_result_t (CTL_APICALL *ctl_pfnFrequencyGetThrottleTime_t)(
6900     ctl_freq_handle_t,
6901     ctl_freq_throttle_time_t*
6902     );
6903
6904
6905 ///////////////////////////////////////////////////////////////////////////////
6906 /// @brief Function-pointer for ctlGetSupportedVideoProcessingCapabilities
6907 typedef ctl_result_t (CTL_APICALL *ctl_pfnGetSupportedVideoProcessingCapabilities_t)(
6908     ctl_device_adapter_handle_t,
6909     ctl_video_processing_feature_caps_t*
6910     );
6911
6912
6913 ///////////////////////////////////////////////////////////////////////////////
6914 /// @brief Function-pointer for ctlGetSetVideoProcessingFeature
6915 typedef ctl_result_t (CTL_APICALL *ctl_pfnGetSetVideoProcessingFeature_t)(
6916     ctl_device_adapter_handle_t,
6917     ctl_video_processing_feature_getset_t*
6918     );
6919
6920
6921 ///////////////////////////////////////////////////////////////////////////////
6922 /// @brief Function-pointer for ctlEnumMemoryModules
6923 typedef ctl_result_t (CTL_APICALL *ctl_pfnEnumMemoryModules_t)(
6924     ctl_device_adapter_handle_t,
6925     uint32_t*,
6926     ctl_mem_handle_t*
6927     );
6928
6929
6930 ///////////////////////////////////////////////////////////////////////////////
6931 /// @brief Function-pointer for ctlMemoryGetProperties
6932 typedef ctl_result_t (CTL_APICALL *ctl_pfnMemoryGetProperties_t)(
6933     ctl_mem_handle_t,
6934     ctl_mem_properties_t*
6935     );
6936
6937
6938 ///////////////////////////////////////////////////////////////////////////////
6939 /// @brief Function-pointer for ctlMemoryGetState
6940 typedef ctl_result_t (CTL_APICALL *ctl_pfnMemoryGetState_t)(
6941     ctl_mem_handle_t,
6942     ctl_mem_state_t*
6943     );
6944
6945
6946 ///////////////////////////////////////////////////////////////////////////////
6947 /// @brief Function-pointer for ctlMemoryGetBandwidth
6948 typedef ctl_result_t (CTL_APICALL *ctl_pfnMemoryGetBandwidth_t)(
6949     ctl_mem_handle_t,
6950     ctl_mem_bandwidth_t*
6951     );
6952
6953
6954 ///////////////////////////////////////////////////////////////////////////////
6955 /// @brief Function-pointer for ctlOverclockGetProperties
6956 typedef ctl_result_t (CTL_APICALL *ctl_pfnOverclockGetProperties_t)(
6957     ctl_device_adapter_handle_t,
6958     ctl_oc_properties_t*
6959     );
6960
6961
6962 ///////////////////////////////////////////////////////////////////////////////
6963 /// @brief Function-pointer for ctlOverclockWaiverSet
6964 typedef ctl_result_t (CTL_APICALL *ctl_pfnOverclockWaiverSet_t)(
6965     ctl_device_adapter_handle_t
6966     );
6967
6968
6969 ///////////////////////////////////////////////////////////////////////////////
6970 /// @brief Function-pointer for ctlOverclockGpuFrequencyOffsetGet
6971 typedef ctl_result_t (CTL_APICALL *ctl_pfnOverclockGpuFrequencyOffsetGet_t)(
6972     ctl_device_adapter_handle_t,
6973     double*
6974     );
6975
6976
6977 ///////////////////////////////////////////////////////////////////////////////
6978 /// @brief Function-pointer for ctlOverclockGpuFrequencyOffsetSet
6979 typedef ctl_result_t (CTL_APICALL *ctl_pfnOverclockGpuFrequencyOffsetSet_t)(
6980     ctl_device_adapter_handle_t,
6981     double
6982     );
6983
6984
6985 ///////////////////////////////////////////////////////////////////////////////
6986 /// @brief Function-pointer for ctlOverclockGpuVoltageOffsetGet
6987 typedef ctl_result_t (CTL_APICALL *ctl_pfnOverclockGpuVoltageOffsetGet_t)(
6988     ctl_device_adapter_handle_t,
6989     double*
6990     );
6991
6992
6993 ///////////////////////////////////////////////////////////////////////////////
6994 /// @brief Function-pointer for ctlOverclockGpuVoltageOffsetSet
6995 typedef ctl_result_t (CTL_APICALL *ctl_pfnOverclockGpuVoltageOffsetSet_t)(
6996     ctl_device_adapter_handle_t,
6997     double
6998     );
6999
7000
7001 ///////////////////////////////////////////////////////////////////////////////
7002 /// @brief Function-pointer for ctlOverclockGpuLockGet
7003 typedef ctl_result_t (CTL_APICALL *ctl_pfnOverclockGpuLockGet_t)(
7004     ctl_device_adapter_handle_t,
7005     ctl_oc_vf_pair_t*
7006     );
7007
7008
7009 ///////////////////////////////////////////////////////////////////////////////
7010 /// @brief Function-pointer for ctlOverclockGpuLockSet
7011 typedef ctl_result_t (CTL_APICALL *ctl_pfnOverclockGpuLockSet_t)(
7012     ctl_device_adapter_handle_t,
7013     ctl_oc_vf_pair_t
7014     );
7015
7016
7017 ///////////////////////////////////////////////////////////////////////////////
7018 /// @brief Function-pointer for ctlOverclockVramFrequencyOffsetGet
7019 typedef ctl_result_t (CTL_APICALL *ctl_pfnOverclockVramFrequencyOffsetGet_t)(
7020     ctl_device_adapter_handle_t,
7021     double*
7022     );
7023
7024
7025 ///////////////////////////////////////////////////////////////////////////////
7026 /// @brief Function-pointer for ctlOverclockVramFrequencyOffsetSet
7027 typedef ctl_result_t (CTL_APICALL *ctl_pfnOverclockVramFrequencyOffsetSet_t)(
7028     ctl_device_adapter_handle_t,
7029     double
7030     );
7031
7032
7033 ///////////////////////////////////////////////////////////////////////////////
7034 /// @brief Function-pointer for ctlOverclockVramVoltageOffsetGet
7035 typedef ctl_result_t (CTL_APICALL *ctl_pfnOverclockVramVoltageOffsetGet_t)(
7036     ctl_device_adapter_handle_t,
7037     double*
7038     );
7039
7040
7041 ///////////////////////////////////////////////////////////////////////////////
7042 /// @brief Function-pointer for ctlOverclockVramVoltageOffsetSet
7043 typedef ctl_result_t (CTL_APICALL *ctl_pfnOverclockVramVoltageOffsetSet_t)(
7044     ctl_device_adapter_handle_t,
7045     double
7046     );
7047
7048
7049 ///////////////////////////////////////////////////////////////////////////////
7050 /// @brief Function-pointer for ctlOverclockPowerLimitGet
7051 typedef ctl_result_t (CTL_APICALL *ctl_pfnOverclockPowerLimitGet_t)(
7052     ctl_device_adapter_handle_t,
7053     double*
7054     );
7055
7056
7057 ///////////////////////////////////////////////////////////////////////////////
7058 /// @brief Function-pointer for ctlOverclockPowerLimitSet
7059 typedef ctl_result_t (CTL_APICALL *ctl_pfnOverclockPowerLimitSet_t)(
7060     ctl_device_adapter_handle_t,
7061     double
7062     );
7063
7064
7065 ///////////////////////////////////////////////////////////////////////////////
7066 /// @brief Function-pointer for ctlOverclockTemperatureLimitGet
7067 typedef ctl_result_t (CTL_APICALL *ctl_pfnOverclockTemperatureLimitGet_t)(
7068     ctl_device_adapter_handle_t,
7069     double*
7070     );
7071
7072
7073 ///////////////////////////////////////////////////////////////////////////////
7074 /// @brief Function-pointer for ctlOverclockTemperatureLimitSet
7075 typedef ctl_result_t (CTL_APICALL *ctl_pfnOverclockTemperatureLimitSet_t)(
7076     ctl_device_adapter_handle_t,
7077     double
7078     );
7079
7080
7081 ///////////////////////////////////////////////////////////////////////////////
7082 /// @brief Function-pointer for ctlPowerTelemetryGet
7083 typedef ctl_result_t (CTL_APICALL *ctl_pfnPowerTelemetryGet_t)(
7084     ctl_device_adapter_handle_t,
7085     ctl_power_telemetry_t*
7086     );
7087
7088
7089 ///////////////////////////////////////////////////////////////////////////////
7090 /// @brief Function-pointer for ctlPciGetProperties
7091 typedef ctl_result_t (CTL_APICALL *ctl_pfnPciGetProperties_t)(
7092     ctl_device_adapter_handle_t,
7093     ctl_pci_properties_t*
7094     );
7095
7096
7097 ///////////////////////////////////////////////////////////////////////////////
7098 /// @brief Function-pointer for ctlPciGetState
7099 typedef ctl_result_t (CTL_APICALL *ctl_pfnPciGetState_t)(
7100     ctl_device_adapter_handle_t,
7101     ctl_pci_state_t*
7102     );
7103
7104
7105 ///////////////////////////////////////////////////////////////////////////////
7106 /// @brief Function-pointer for ctlEnumPowerDomains
7107 typedef ctl_result_t (CTL_APICALL *ctl_pfnEnumPowerDomains_t)(
7108     ctl_device_adapter_handle_t,
7109     uint32_t*,
7110     ctl_pwr_handle_t*
7111     );
7112
7113
7114 ///////////////////////////////////////////////////////////////////////////////
7115 /// @brief Function-pointer for ctlPowerGetProperties
7116 typedef ctl_result_t (CTL_APICALL *ctl_pfnPowerGetProperties_t)(
7117     ctl_pwr_handle_t,
7118     ctl_power_properties_t*
7119     );
7120
7121
7122 ///////////////////////////////////////////////////////////////////////////////
7123 /// @brief Function-pointer for ctlPowerGetEnergyCounter
7124 typedef ctl_result_t (CTL_APICALL *ctl_pfnPowerGetEnergyCounter_t)(
7125     ctl_pwr_handle_t,
7126     ctl_power_energy_counter_t*
7127     );
7128
7129
7130 ///////////////////////////////////////////////////////////////////////////////
7131 /// @brief Function-pointer for ctlPowerGetLimits
7132 typedef ctl_result_t (CTL_APICALL *ctl_pfnPowerGetLimits_t)(
7133     ctl_pwr_handle_t,
7134     ctl_power_limits_t*
7135     );
7136
7137
7138 ///////////////////////////////////////////////////////////////////////////////
7139 /// @brief Function-pointer for ctlPowerSetLimits
7140 typedef ctl_result_t (CTL_APICALL *ctl_pfnPowerSetLimits_t)(
7141     ctl_pwr_handle_t,
7142     const ctl_power_limits_t*
7143     );
7144
7145
7146 ///////////////////////////////////////////////////////////////////////////////
7147 /// @brief Function-pointer for ctlEnumTemperatureSensors
7148 typedef ctl_result_t (CTL_APICALL *ctl_pfnEnumTemperatureSensors_t)(
7149     ctl_device_adapter_handle_t,
7150     uint32_t*,
7151     ctl_temp_handle_t*
7152     );
7153
7154
7155 ///////////////////////////////////////////////////////////////////////////////
7156 /// @brief Function-pointer for ctlTemperatureGetProperties
7157 typedef ctl_result_t (CTL_APICALL *ctl_pfnTemperatureGetProperties_t)(
7158     ctl_temp_handle_t,
7159     ctl_temp_properties_t*
7160     );
7161
7162
7163 ///////////////////////////////////////////////////////////////////////////////
7164 /// @brief Function-pointer for ctlTemperatureGetState
7165 typedef ctl_result_t (CTL_APICALL *ctl_pfnTemperatureGetState_t)(
7166     ctl_temp_handle_t,
7167     double*
7168     );
7169
7170
7171 #if defined(__cplusplus)
7172 } // extern "C"
7173 #endif
7174
7175 #endif // _CTL_API_H