Updating prebuilts and/or headers

dbd4f936a8aa1443e2fc31fb619267b33d2f1127 - WF/wfdplatform.h
d3925649a315b1d45ecaf1a06a5e41a8bdc5b583 - WF/wfd.h
62a080557194f175550e5abe18cf344aa18ee084 - WF/wfdext.h

Change-Id: Iaed817ce916b93e82f36addadb7b8949098aa9df

WF/wfd.h

@@ -0,0 +1,645 @@
+/* Copyright (c) 2009 The Khronos Group Inc.
+ * Copyright (c) 2020-2022, NVIDIA CORPORATION.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and/or associated documentation files (the
+ * "Materials"), to deal in the Materials without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Materials, and to
+ * permit persons to whom the Materials are furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Materials.
+ *
+ * THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
+ */
+
+/*! \defgroup wfd OpenWF Display SI
+ * @{
+ */
+
+/*! \file wfd.h
+ *
+ *  \brief OpenWF Display public API, type definitions and function prototypes
+ *
+ *  This is one of the three header files defined by the specification.
+ *  This file contains the portable definitions of data types
+ *  and function prototypes.
+
+ *  Refer to OpenWF Display specification for the
+ *  additional documentation.
+ *
+ */
+
+/*! @} */
+
+#ifndef WFD_H
+#define WFD_H
+
+#include <WF/wfdplatform.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define OPENWFD_VERSION_1_0         (1)
+
+#define WFD_NONE                    (0)
+
+#define WFD_INVALID_PORT_ID         (0)
+#define WFD_INVALID_PIPELINE_ID     (0)
+#define WFD_INVALID_PIPELINE_LAYER  (0)
+
+#define WFD_DEFAULT_DEVICE_ID       (0)
+
+typedef enum
+{ WFD_FALSE = KHRONOS_FALSE,
+  WFD_TRUE  = KHRONOS_TRUE
+} WFDboolean;
+
+typedef char char_t;
+
+#define WFD_MAX_INT   ((WFDint)16777216)
+#define WFD_MAX_FLOAT ((WFDfloat)16777216)
+
+#define WFD_INVALID_HANDLE ((WFDHandle)0)
+
+typedef WFDHandle WFDDevice;
+typedef WFDHandle WFDPort;
+typedef WFDHandle WFDPortMode;
+typedef WFDHandle WFDPipeline;
+typedef WFDHandle WFDSource;
+
+#ifndef NV_SAFETY_BUILD
+typedef WFDHandle WFDEvent;
+typedef WFDHandle WFDMask;
+#endif
+
+typedef enum
+{ WFD_VENDOR                                = 0x7500,
+  WFD_RENDERER                              = 0x7501,
+  WFD_VERSION                               = 0x7502,
+  WFD_EXTENSIONS                            = 0x7503,
+  WFD_STRING_ID_FORCE_32BIT                 = 0x7FFFFFFF
+} WFDStringID;
+
+typedef enum
+{ WFD_ERROR_NONE                            = 0,
+  WFD_ERROR_OUT_OF_MEMORY                   = 0x7510,
+  WFD_ERROR_ILLEGAL_ARGUMENT                = 0x7511,
+  WFD_ERROR_NOT_SUPPORTED                   = 0x7512,
+  WFD_ERROR_BAD_ATTRIBUTE                   = 0x7513,
+  WFD_ERROR_IN_USE                          = 0x7514,
+  WFD_ERROR_BUSY                            = 0x7515,
+  WFD_ERROR_BAD_DEVICE                      = 0x7516,
+  WFD_ERROR_BAD_HANDLE                      = 0x7517,
+  WFD_ERROR_INCONSISTENCY                   = 0x7518,
+  WFD_ERROR_FORCE_32BIT                     = 0x7FFFFFFF
+} WFDErrorCode;
+
+typedef enum
+{ WFD_DEVICE_FILTER_PORT_ID                 = 0x7530,
+  WFD_DEVICE_FILTER_FORCE_32BIT             = 0x7FFFFFFF
+} WFDDeviceFilter;
+
+typedef enum
+{ WFD_COMMIT_ENTIRE_DEVICE                  = 0x7550,
+  WFD_COMMIT_ENTIRE_PORT                    = 0x7551,
+  WFD_COMMIT_PIPELINE                       = 0x7552,
+  WFD_COMMIT_FORCE_32BIT                    = 0x7FFFFFFF
+} WFDCommitType;
+
+#ifndef NV_SAFETY_BUILD
+
+typedef enum
+{ WFD_DEVICE_ID                             = 0x7560,
+  WFD_DEVICE_ATTRIB_FORCE_32BIT             = 0x7FFFFFFF
+} WFDDeviceAttrib;
+
+typedef enum
+{ WFD_EVENT_INVALID                         = 0x7580,
+  WFD_EVENT_NONE                            = 0x7581,
+  WFD_EVENT_DESTROYED                       = 0x7582,
+  WFD_EVENT_PORT_ATTACH_DETACH              = 0x7583,
+  WFD_EVENT_PORT_PROTECTION_FAILURE         = 0x7584,
+  WFD_EVENT_PIPELINE_BIND_SOURCE_COMPLETE   = 0x7585,
+  WFD_EVENT_PIPELINE_BIND_MASK_COMPLETE     = 0x7586,
+  WFD_EVENT_FORCE_32BIT                     = 0x7FFFFFFF
+} WFDEventType;
+
+typedef enum
+{ /* Configuration Attributes */
+  WFD_EVENT_PIPELINE_BIND_QUEUE_SIZE        = 0x75C0,
+
+  /* Generic Event Attributes */
+  WFD_EVENT_TYPE                            = 0x75C1,
+
+  /* Port Attach Event Attributes */
+  WFD_EVENT_PORT_ATTACH_PORT_ID             = 0x75C2,
+  WFD_EVENT_PORT_ATTACH_STATE               = 0x75C3,
+
+  /* Port Protection Event Attributes */
+  WFD_EVENT_PORT_PROTECTION_PORT_ID         = 0x75C4,
+
+  /* Pipeline Bind Complete Event Attributes */
+  WFD_EVENT_PIPELINE_BIND_PIPELINE_ID       = 0x75C5,
+  WFD_EVENT_PIPELINE_BIND_SOURCE            = 0x75C6,
+  WFD_EVENT_PIPELINE_BIND_MASK              = 0x75C7,
+  WFD_EVENT_PIPELINE_BIND_QUEUE_OVERFLOW    = 0x75C8,
+
+  WFD_EVENT_ATTRIB_FORCE_32BIT              = 0x7FFFFFFF
+} WFDEventAttrib;
+
+typedef enum
+{ WFD_POWER_MODE_OFF                        = 0x7680,
+  WFD_POWER_MODE_SUSPEND                    = 0x7681,
+  WFD_POWER_MODE_LIMITED_USE                = 0x7682,
+  WFD_POWER_MODE_ON                         = 0x7683,
+  WFD_POWER_MODE_FORCE_32BIT                = 0x7FFFFFFF
+} WFDPowerMode;
+
+typedef enum
+{ WFD_DISPLAY_DATA_FORMAT_NONE              = 0x76A0,
+  WFD_DISPLAY_DATA_FORMAT_EDID_V1           = 0x76A1,
+  WFD_DISPLAY_DATA_FORMAT_EDID_V2           = 0x76A2,
+  WFD_DISPLAY_DATA_FORMAT_DISPLAYID         = 0x76A3,
+  WFD_DISPLAY_DATA_FORMAT_FORCE_32BIT       = 0x7FFFFFFF
+} WFDDisplayDataFormat;
+
+#endif // !NV_SAFETY_BUILD
+
+typedef enum
+{ WFD_PORT_MODE_WIDTH                       = 0x7600,
+  WFD_PORT_MODE_HEIGHT                      = 0x7601,
+  WFD_PORT_MODE_REFRESH_RATE                = 0x7602,
+  WFD_PORT_MODE_FLIP_MIRROR_SUPPORT         = 0x7603,
+  WFD_PORT_MODE_ROTATION_SUPPORT            = 0x7604,
+  WFD_PORT_MODE_INTERLACED                  = 0x7605,
+  WFD_PORT_MODE_ATTRIB_FORCE_32BIT          = 0x7FFFFFFF
+} WFDPortModeAttrib;
+
+typedef enum
+{ WFD_PORT_ID                               = 0x7620,
+  WFD_PORT_TYPE                             = 0x7621,
+  WFD_PORT_DETACHABLE                       = 0x7622,
+  WFD_PORT_ATTACHED                         = 0x7623,
+  WFD_PORT_NATIVE_RESOLUTION                = 0x7624,
+  WFD_PORT_PHYSICAL_SIZE                    = 0x7625,
+  WFD_PORT_FILL_PORT_AREA                   = 0x7626,
+  WFD_PORT_BACKGROUND_COLOR                 = 0x7627,
+  WFD_PORT_FLIP                             = 0x7628,
+  WFD_PORT_MIRROR                           = 0x7629,
+  WFD_PORT_ROTATION                         = 0x762A,
+  WFD_PORT_POWER_MODE                       = 0x762B,
+  WFD_PORT_GAMMA_RANGE                      = 0x762C,
+  WFD_PORT_GAMMA                            = 0x762D,
+  WFD_PORT_PARTIAL_REFRESH_SUPPORT          = 0x762E,
+  WFD_PORT_PARTIAL_REFRESH_MAXIMUM          = 0x762F,
+  WFD_PORT_PARTIAL_REFRESH_ENABLE           = 0x7630,
+  WFD_PORT_PARTIAL_REFRESH_RECTANGLE        = 0x7631,
+  WFD_PORT_PIPELINE_ID_COUNT                = 0x7632,
+  WFD_PORT_BINDABLE_PIPELINE_IDS            = 0x7633,
+  WFD_PORT_PROTECTION_ENABLE                = 0x7634,
+  WFD_PORT_ATTRIB_FORCE_32BIT               = 0x7FFFFFFF
+} WFDPortConfigAttrib;
+
+typedef enum
+{ WFD_PORT_TYPE_INTERNAL                    = 0x7660,
+  WFD_PORT_TYPE_COMPOSITE                   = 0x7661,
+  WFD_PORT_TYPE_SVIDEO                      = 0x7662,
+  WFD_PORT_TYPE_COMPONENT_YPbPr             = 0x7663,
+  WFD_PORT_TYPE_COMPONENT_RGB               = 0x7664,
+  WFD_PORT_TYPE_COMPONENT_RGBHV             = 0x7665,
+  WFD_PORT_TYPE_DVI                         = 0x7666,
+  WFD_PORT_TYPE_HDMI                        = 0x7667,
+  WFD_PORT_TYPE_DISPLAYPORT                 = 0x7668,
+  WFD_PORT_TYPE_OTHER                       = 0x7669,
+  WFD_PORT_TYPE_FORCE_32BIT                 = 0x7FFFFFFF
+} WFDPortType;
+
+typedef enum
+{ WFD_PARTIAL_REFRESH_NONE                  = 0x7690,
+  WFD_PARTIAL_REFRESH_VERTICAL              = 0x7691,
+  WFD_PARTIAL_REFRESH_HORIZONTAL            = 0x7692,
+  WFD_PARTIAL_REFRESH_BOTH                  = 0x7693,
+  WFD_PARTIAL_REFRESH_FORCE_32BIT           = 0x7FFFFFFF
+} WFDPartialRefresh;
+
+typedef enum
+{ WFD_ROTATION_SUPPORT_NONE                 = 0x76D0,
+  WFD_ROTATION_SUPPORT_LIMITED              = 0x76D1,
+  WFD_ROTATION_SUPPORT_FORMAT_FORCE_32BIT   = 0x7FFFFFFF
+} WFDRotationSupport;
+
+typedef enum
+{ WFD_PIPELINE_ID                           = 0x7720,
+  WFD_PIPELINE_PORTID                       = 0x7721,
+  WFD_PIPELINE_LAYER                        = 0x7722,
+  WFD_PIPELINE_SHAREABLE                    = 0x7723,
+  WFD_PIPELINE_DIRECT_REFRESH               = 0x7724,
+  WFD_PIPELINE_MAX_SOURCE_SIZE              = 0x7725,
+  WFD_PIPELINE_SOURCE_RECTANGLE             = 0x7726,
+  WFD_PIPELINE_FLIP                         = 0x7727,
+  WFD_PIPELINE_MIRROR                       = 0x7728,
+  WFD_PIPELINE_ROTATION_SUPPORT             = 0x7729,
+  WFD_PIPELINE_ROTATION                     = 0x772A,
+  WFD_PIPELINE_SCALE_RANGE                  = 0x772B,
+  WFD_PIPELINE_SCALE_FILTER                 = 0x772C,
+  WFD_PIPELINE_DESTINATION_RECTANGLE        = 0x772D,
+  WFD_PIPELINE_TRANSPARENCY_ENABLE          = 0x772E,
+  WFD_PIPELINE_GLOBAL_ALPHA                 = 0x772F,
+  WFD_PIPELINE_ATTRIB_FORCE_32BIT           = 0x7FFFFFFF
+} WFDPipelineConfigAttrib;
+
+typedef enum
+{ WFD_SCALE_FILTER_NONE                     = 0x7760,
+  WFD_SCALE_FILTER_FASTER                   = 0x7761,
+  WFD_SCALE_FILTER_BETTER                   = 0x7762,
+  WFD_SCALE_FILTER_FORCE_32BIT              = 0x7FFFFFFF
+} WFDScaleFilter;
+
+typedef enum
+{ WFD_TRANSPARENCY_NONE                     = 0,
+  WFD_TRANSPARENCY_SOURCE_COLOR             = (1 << 0),
+  WFD_TRANSPARENCY_GLOBAL_ALPHA             = (1 << 1),
+  WFD_TRANSPARENCY_SOURCE_ALPHA             = (1 << 2),
+  WFD_TRANSPARENCY_MASK                     = (1 << 3),
+  WFD_TRANSPARENCY_FORCE_32BIT              = 0x7FFFFFFF
+} WFDTransparency;
+
+#ifndef NV_SAFETY_BUILD
+typedef enum
+{ WFD_TSC_FORMAT_UINT8_RGB_8_8_8_LINEAR     = 0x7790,
+  WFD_TSC_FORMAT_UINT8_RGB_5_6_5_LINEAR     = 0x7791,
+  WFD_TSC_FORMAT_FORCE_32BIT                = 0x7FFFFFFF
+} WFDTSColorFormat;
+#endif // NV_SAFETY_BUILD
+
+typedef enum
+{ WFD_TRANSITION_INVALID                    = 0x77E0,
+  WFD_TRANSITION_IMMEDIATE                  = 0x77E1,
+  WFD_TRANSITION_AT_VSYNC                   = 0x77E2,
+  WFD_TRANSITION_FORCE_32BIT                = 0x7FFFFFFF
+} WFDTransition;
+
+typedef struct
+{ WFDint offsetX;
+  WFDint offsetY;
+  WFDint width;
+  WFDint height;
+} WFDRect;
+
+/* Function Prototypes */
+
+/* Implementation Information */
+
+#ifndef NV_SAFETY_BUILD
+
+WFD_API_CALL WFDint WFD_APIENTRY
+    wfdGetStrings(const WFDDevice device,
+                  const WFDStringID name,
+                  const char_t **const strings,
+                  const WFDint stringsCount) WFD_APIEXIT;
+
+WFD_API_CALL WFDboolean WFD_APIENTRY
+    wfdIsExtensionSupported(const WFDDevice device,
+                            const char_t *const extensionString) WFD_APIEXIT;
+
+#endif // NV_SAFETY_BUILD
+
+/* Error */
+
+WFD_API_CALL WFDErrorCode WFD_APIENTRY
+    wfdGetError(const WFDDevice device) WFD_APIEXIT;
+
+/* Device */
+
+#ifndef NV_SAFETY_BUILD
+
+WFD_API_CALL WFDint WFD_APIENTRY
+    wfdEnumerateDevices(WFDint *const deviceIds,
+                        const WFDint deviceIdsCount,
+                        const WFDint *const filterList) WFD_APIEXIT;
+#endif // NV_SAFETY_BUILD
+
+WFD_API_CALL WFDDevice WFD_APIENTRY
+    wfdCreateDevice(const WFDint deviceId,
+                    const WFDint *const attribList) WFD_APIEXIT;
+
+WFD_API_CALL WFDErrorCode WFD_APIENTRY
+    wfdDestroyDevice(const WFDDevice device) WFD_APIEXIT;
+
+WFD_API_CALL void WFD_APIENTRY
+    wfdDeviceCommit(const WFDDevice device,
+                    const WFDCommitType type,
+                    const WFDHandle handle) WFD_APIEXIT;
+
+#ifndef NV_SAFETY_BUILD
+WFD_API_CALL WFDint WFD_APIENTRY
+    wfdGetDeviceAttribi(const WFDDevice device,
+                        const WFDDeviceAttrib attrib) WFD_APIEXIT;
+
+WFD_API_CALL void WFD_APIENTRY
+    wfdSetDeviceAttribi(const WFDDevice device,
+                        const WFDDeviceAttrib attrib,
+                        const WFDint value) WFD_APIEXIT;
+
+WFD_API_CALL WFDEvent WFD_APIENTRY
+    wfdCreateEvent(const WFDDevice device,
+                   const WFDint *const attribList) WFD_APIEXIT;
+
+WFD_API_CALL void WFD_APIENTRY
+    wfdDestroyEvent(const WFDDevice device,
+                    const WFDEvent event) WFD_APIEXIT;
+
+WFD_API_CALL WFDint WFD_APIENTRY
+    wfdGetEventAttribi(const WFDDevice device,
+                       const WFDEvent event,
+                       const WFDEventAttrib attrib) WFD_APIEXIT;
+
+WFD_API_CALL void WFD_APIENTRY
+    wfdDeviceEventAsync(const WFDDevice device,
+                        const WFDEvent event,
+                        const WFDEGLDisplay display,
+                        const WFDEGLSync sync) WFD_APIEXIT;
+
+WFD_API_CALL WFDEventType WFD_APIENTRY
+    wfdDeviceEventWait(const WFDDevice device,
+                       const WFDEvent event,
+                       const WFDtime timeout) WFD_APIEXIT;
+
+WFD_API_CALL void WFD_APIENTRY
+    wfdDeviceEventFilter(const WFDDevice device,
+                         const WFDEvent event,
+                         const WFDEventType *const filter) WFD_APIEXIT;
+#endif // NV_SAFETY_BUILD
+
+/* Port */
+
+WFD_API_CALL WFDint WFD_APIENTRY
+    wfdEnumeratePorts(const WFDDevice device,
+                      WFDint *const portIds,
+                      const WFDint portIdsCount,
+                      const WFDint *const filterList) WFD_APIEXIT;
+
+WFD_API_CALL WFDPort WFD_APIENTRY
+    wfdCreatePort(const WFDDevice device,
+                  const WFDint portId,
+                  const WFDint *const attribList) WFD_APIEXIT;
+
+WFD_API_CALL void WFD_APIENTRY
+    wfdDestroyPort(const WFDDevice device, const WFDPort port) WFD_APIEXIT;
+
+WFD_API_CALL WFDint WFD_APIENTRY
+    wfdGetPortModes(const WFDDevice device,
+                    const WFDPort port,
+                    WFDPortMode *const modes,
+                    const WFDint modesCount) WFD_APIEXIT;
+
+WFD_API_CALL WFDint WFD_APIENTRY
+    wfdGetPortModeAttribi(const WFDDevice device,
+                          const WFDPort port,
+                          const WFDPortMode mode,
+                          const WFDPortModeAttrib attrib) WFD_APIEXIT;
+
+WFD_API_CALL WFDfloat WFD_APIENTRY
+    wfdGetPortModeAttribf(const WFDDevice device,
+                          const WFDPort port,
+                          const WFDPortMode mode,
+                          const WFDPortModeAttrib attrib) WFD_APIEXIT;
+
+WFD_API_CALL void WFD_APIENTRY
+    wfdSetPortMode(const WFDDevice device,
+                   const WFDPort port,
+                   const WFDPortMode mode) WFD_APIEXIT;
+
+WFD_API_CALL WFDPortMode WFD_APIENTRY
+    wfdGetCurrentPortMode(const WFDDevice device, const WFDPort port) WFD_APIEXIT;
+
+WFD_API_CALL WFDint WFD_APIENTRY
+    wfdGetPortAttribi(const WFDDevice device,
+                      const WFDPort port,
+                      const WFDPortConfigAttrib attrib) WFD_APIEXIT;
+
+WFD_API_CALL void WFD_APIENTRY
+    wfdSetPortAttribi(const WFDDevice device,
+                      const WFDPort port,
+                      const WFDPortConfigAttrib attrib,
+                      const WFDint value) WFD_APIEXIT;
+
+#ifndef NV_SAFETY_BUILD
+WFD_API_CALL WFDfloat WFD_APIENTRY
+    wfdGetPortAttribf(const WFDDevice device,
+                      const WFDPort port,
+                      const WFDPortConfigAttrib attrib) WFD_APIEXIT;
+#endif // NV_SAFETY_BUILD
+
+WFD_API_CALL void WFD_APIENTRY
+    wfdGetPortAttribiv(const WFDDevice device,
+                       const WFDPort port,
+                       const WFDPortConfigAttrib attrib,
+                       const WFDint count,
+                       WFDint *const value) WFD_APIEXIT;
+
+#ifndef NV_SAFETY_BUILD
+WFD_API_CALL void WFD_APIENTRY
+    wfdGetPortAttribfv(const WFDDevice device,
+                       const WFDPort port,
+                       const WFDPortConfigAttrib attrib,
+                       const WFDint count,
+                       WFDfloat *const value) WFD_APIEXIT;
+
+WFD_API_CALL void WFD_APIENTRY
+    wfdSetPortAttribf(const WFDDevice device,
+                      const WFDPort port,
+                      const WFDPortConfigAttrib attrib,
+                      const WFDfloat value) WFD_APIEXIT;
+
+WFD_API_CALL void WFD_APIENTRY
+    wfdSetPortAttribiv(const WFDDevice device,
+                       const WFDPort port,
+                       const WFDPortConfigAttrib attrib,
+                       const WFDint count,
+                       const WFDint *const value) WFD_APIEXIT;
+
+WFD_API_CALL void WFD_APIENTRY
+    wfdSetPortAttribfv(const WFDDevice device,
+                       const WFDPort port,
+                       const WFDPortConfigAttrib attrib,
+                       const WFDint count,
+                       const WFDfloat *const value) WFD_APIEXIT;
+
+#endif // NV_SAFETY_BUILD
+
+WFD_API_CALL void WFD_APIENTRY
+    wfdBindPipelineToPort(const WFDDevice device,
+                          const WFDPort port,
+                          const WFDPipeline pipeline) WFD_APIEXIT;
+
+#ifndef NV_SAFETY_BUILD
+WFD_API_CALL WFDint WFD_APIENTRY
+    wfdGetDisplayDataFormats(const WFDDevice device,
+                             const WFDPort port,
+                             const WFDDisplayDataFormat *const format,
+                             const WFDint formatCount) WFD_APIEXIT;
+
+WFD_API_CALL WFDint WFD_APIENTRY
+    wfdGetDisplayData(const WFDDevice device,
+                      const WFDPort port,
+                      const WFDDisplayDataFormat format,
+                      const WFDuint8 *const data,
+                      const WFDint dataCount) WFD_APIEXIT;
+#endif
+
+/* Pipeline */
+
+WFD_API_CALL WFDint WFD_APIENTRY
+    wfdEnumeratePipelines(const WFDDevice device,
+                          WFDint *const pipelineIds,
+                          const WFDint pipelineIdsCount,
+                          const WFDint *const filterList) WFD_APIEXIT;
+
+WFD_API_CALL WFDPipeline WFD_APIENTRY
+    wfdCreatePipeline(const WFDDevice device,
+                      const WFDint pipelineId,
+                      const WFDint *const attribList) WFD_APIEXIT;
+
+WFD_API_CALL void WFD_APIENTRY
+    wfdDestroyPipeline(const WFDDevice device,
+                       const WFDPipeline pipeline) WFD_APIEXIT;
+
+#ifndef NV_SAFETY_BUILD
+WFD_API_CALL WFDSource WFD_APIENTRY
+    wfdCreateSourceFromImage(const WFDDevice device,
+                             const WFDPipeline pipeline,
+                             const WFDEGLImage image,
+                             const WFDint *const attribList) WFD_APIEXIT;
+
+WFD_API_CALL WFDSource WFD_APIENTRY
+    wfdCreateSourceFromStream(const WFDDevice device,
+                              const WFDPipeline pipeline,
+                              const WFDNativeStreamType stream,
+                              const WFDint *const attribList) WFD_APIEXIT;
+#endif
+
+WFD_API_CALL void WFD_APIENTRY
+    wfdDestroySource(const WFDDevice device,
+                     const WFDSource source) WFD_APIEXIT;
+
+#ifndef NV_SAFETY_BUILD
+WFD_API_CALL WFDMask WFD_APIENTRY
+    wfdCreateMaskFromImage(const WFDDevice device,
+                           const WFDPipeline pipeline,
+                           const WFDEGLImage image,
+                           const WFDint *const attribList) WFD_APIEXIT;
+
+WFD_API_CALL WFDMask WFD_APIENTRY
+    wfdCreateMaskFromStream(const WFDDevice device,
+                            const WFDPipeline pipeline,
+                            const WFDNativeStreamType stream,
+                            const WFDint *const attribList) WFD_APIEXIT;
+
+WFD_API_CALL void WFD_APIENTRY
+    wfdDestroyMask(const WFDDevice device,
+                   const WFDMask mask) WFD_APIEXIT;
+#endif
+
+WFD_API_CALL void WFD_APIENTRY
+    wfdBindSourceToPipeline(const WFDDevice device,
+                            const WFDPipeline pipeline,
+                            const WFDSource source,
+                            const WFDTransition transition,
+                            const WFDRect *const region) WFD_APIEXIT;
+#ifndef NV_SAFETY_BUILD
+WFD_API_CALL void WFD_APIENTRY
+    wfdBindMaskToPipeline(const WFDDevice device,
+                          const WFDPipeline pipeline,
+                          const WFDMask mask,
+                          const WFDTransition transition) WFD_APIEXIT;
+#endif
+
+WFD_API_CALL WFDint WFD_APIENTRY
+    wfdGetPipelineAttribi(const WFDDevice device,
+                          const WFDPipeline pipeline,
+                          const WFDPipelineConfigAttrib attrib) WFD_APIEXIT;
+
+WFD_API_CALL WFDfloat WFD_APIENTRY
+    wfdGetPipelineAttribf(const WFDDevice device,
+                          const WFDPipeline pipeline,
+                          const WFDPipelineConfigAttrib attrib) WFD_APIEXIT;
+
+WFD_API_CALL void WFD_APIENTRY
+    wfdGetPipelineAttribiv(const WFDDevice device,
+                           const WFDPipeline pipeline,
+                           const WFDPipelineConfigAttrib attrib,
+                           const WFDint count,
+                           WFDint *const value) WFD_APIEXIT;
+
+#ifndef NV_SAFETY_BUILD
+WFD_API_CALL void WFD_APIENTRY
+    wfdGetPipelineAttribfv(const WFDDevice device,
+                           const WFDPipeline pipeline,
+                           const WFDPipelineConfigAttrib attrib,
+                           const WFDint count,
+                           WFDfloat *const value) WFD_APIEXIT;
+#endif // NV_SAFETY_BUILD
+
+WFD_API_CALL void WFD_APIENTRY
+    wfdSetPipelineAttribi(const WFDDevice device,
+                          const WFDPipeline pipeline,
+                          const WFDPipelineConfigAttrib attrib,
+                          const WFDint value) WFD_APIEXIT;
+
+WFD_API_CALL void WFD_APIENTRY
+    wfdSetPipelineAttribf(const WFDDevice device,
+                          const WFDPipeline pipeline,
+                          const WFDPipelineConfigAttrib attrib,
+                          const WFDfloat value) WFD_APIEXIT;
+
+WFD_API_CALL void WFD_APIENTRY
+    wfdSetPipelineAttribiv(const WFDDevice device,
+                           const WFDPipeline pipeline,
+                           const WFDPipelineConfigAttrib attrib,
+                           const WFDint count,
+                           const WFDint *const value) WFD_APIEXIT;
+
+#ifndef NV_SAFETY_BUILD
+WFD_API_CALL void WFD_APIENTRY
+    wfdSetPipelineAttribfv(const WFDDevice device,
+                           const WFDPipeline pipeline,
+                           const WFDPipelineConfigAttrib attrib,
+                           const WFDint count,
+                           const WFDfloat *const value) WFD_APIEXIT;
+#endif // NV_SAFETY_BUILD
+
+WFD_API_CALL WFDint WFD_APIENTRY
+    wfdGetPipelineTransparency(const WFDDevice device,
+                               const WFDPipeline pipeline,
+                               WFDbitfield *const trans,
+                               const WFDint transCount) WFD_APIEXIT;
+#ifndef NV_SAFETY_BUILD
+WFD_API_CALL void WFD_APIENTRY
+    wfdSetPipelineTSColor(const WFDDevice device,
+                          const WFDPipeline pipeline,
+                          const WFDTSColorFormat colorFormat,
+                          const WFDint count,
+                          const void *const color) WFD_APIEXIT;
+#endif // NV_SAFETY_BUILD
+
+WFD_API_CALL WFDint WFD_APIENTRY
+    wfdGetPipelineLayerOrder(const WFDDevice device,
+                             const WFDPort port,
+                             const WFDPipeline pipeline) WFD_APIEXIT;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* WFD_H */

WF/wfdext.h

@@ -0,0 +1,304 @@
+/* Copyright (c) 2009 The Khronos Group Inc.
+ * Copyright (c) 2020-2023, NVIDIA CORPORATION.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and/or associated documentation files (the
+ * "Materials"), to deal in the Materials without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Materials, and to
+ * permit persons to whom the Materials are furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Materials.
+ *
+ * THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
+ */
+
+/*! \ingroup wfd
+ *  \file wfdext.h
+ *
+ *  \brief Header file for defining available extension on a platform
+ *
+ *  See OpenWF specification for usage of this header file.
+ */
+
+#ifndef WFDEXT_H_
+#define WFDEXT_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+#define WFD_VENDOR_INDEX        (0)
+#define WFD_RENDERER_INDEX      (1)
+#define WFD_VERSION_INDEX       (2)
+
+/* Extensions */
+
+#ifdef WFD_NVX_create_source_from_nvrmsurface
+
+struct NvRmSurfaceRec;
+typedef struct NvRmSurfaceRec NvRmSurface;
+
+#ifdef WFD_WFDEXT_PROTOTYPES
+WFD_API_CALL WFDSource WFD_APIENTRY
+    wfdCreateSourceFromNvRmSurfaceNVX(const WFDDevice device, const WFDPipeline pipeline,
+                                      const WFDint numSurfaces, const NvRmSurface *const surfaces);
+#endif /* WFD_WFDEXT_PROTOTYPES */
+
+typedef WFDSource (WFD_APIENTRY PFNWFDCREATESOURCEFROMNVRMSURFACENVX) (const WFDDevice device,
+                   const WFDPipeline pipeline, const WFDint numSurfaces, const NvRmSurface *const surfaces);
+
+#endif /* WFD_NVX_create_source_from_nvrmsurface */
+
+#ifdef WFD_NVX_nvrmfence
+
+struct NvRmFenceRec;
+typedef struct NvRmFenceRec NvRmFence;
+
+#ifdef WFD_WFDEXT_PROTOTYPES
+WFD_API_CALL WFDErrorCode WFD_APIENTRY
+    wfdBindNvRmFenceToSourceNVX(const WFDDevice device, const WFDSource source,
+                                const NvRmFence *const fence);
+
+WFD_API_CALL void WFD_APIENTRY
+    wfdDeviceCommitWithNvRmFenceNVX(const WFDDevice device,
+                                    const WFDCommitType type,
+                                    const WFDHandle handle,
+                                    NvRmFence *const fence);
+#endif /* WFD_WFDEXT_PROTOTYPES */
+
+typedef WFDErrorCode (WFD_APIENTRY PFNWFDBINDNVRMFENCETOSOURCENVX) (const WFDDevice device,
+                      const WFDSource source, const NvRmFence *const fence);
+typedef void (WFD_APIENTRY PFNWFDDEVICECOMMITWITHNVRMFENCENVX) (const WFDDevice device,
+              const WFDCommitType type, const WFDHandle handle, NvRmFence *const fence);
+
+#endif /* WFD_NVX_nvrmfence */
+
+#ifndef WFD_NV_permissible_latency
+#define WFD_NV_permissible_latency 1
+
+#define WFD_PORT_PERMISSIBLE_LATENCY_MS_NV 0x7635
+
+#ifdef WFD_WFDEXT_PROTOTYPES
+WFD_API_CALL void WFD_APIENTRY
+    wfdBindSourceToPipelineWithTimestampNV(const WFDDevice device,
+                                           const WFDPipeline pipeline,
+                                           const WFDSource source,
+                                           const WFDTransition transition,
+                                           const WFDRect *const region,
+                                           const WFDuint64 timestamp);
+#endif /* WFD_WFDEXT_PROTOTYPES */
+
+typedef void (WFD_APIENTRY PFNWFDBINDSOURCETOPIPELINEWITHTIMESTAMPNV) (const WFDDevice device,
+                                                                       const WFDPipeline pipeline,
+                                                                       const WFDSource source,
+                                                                       const WFDTransition transition,
+                                                                       const WFDRect *const region,
+                                                                       const WFDuint64 timestamp);
+#endif /* WFD_NV_permissible_latency */
+
+#ifndef WFD_NV_safe_state
+#define WFD_NV_safe_state 1
+
+#ifdef WFD_WFDEXT_PROTOTYPES
+WFD_API_CALL WFDErrorCode WFD_APIENTRY
+    wfdDeviceSetSafeStateNV(const WFDDevice device);
+#endif /* WFD_WFDEXT_PROTOTYPES */
+
+typedef void (WFD_APIENTRY PFNWFDDEVICESETSAFESTATENV) (const WFDDevice device);
+
+#endif /* WFD_NV_safe_state */
+
+#ifdef WFD_NVX_create_source_from_nvscibuf
+struct NvSciBufObjRefRec;
+typedef struct NvSciBufObjRefRec* NvSciBufObj;
+struct NvSciBufAttrListRec;
+typedef struct NvSciBufAttrListRec* NvSciBufAttrList;
+#ifdef WFD_WFDEXT_PROTOTYPES
+WFD_API_CALL WFDSource WFD_APIENTRY
+    wfdCreateSourceFromNvSciBufNVX(const WFDDevice device, const WFDPipeline pipeline,
+                                   NvSciBufObj *const bufObj);
+WFD_API_CALL WFDErrorCode WFD_APIENTRY
+    wfdNvSciBufSetDisplayAttributesNVX(NvSciBufAttrList *const attrList);
+#endif /* WFD_WFDEXT_PROTOTYPES */
+typedef WFDSource (WFD_APIENTRY PFNWFDCREATESOURCEFROMNVSCIBUFNVX) (const WFDDevice device,
+                   const WFDPipeline pipeline, NvSciBufObj *const bufObj);
+typedef WFDErrorCode (WFD_APIENTRY PFNWFDNVSCIBUFSETDISPLAYATTRIBUTESNVX) (NvSciBufAttrList *const attrList);
+#endif /* WFD_NVX_create_source_from_nvscibuf */
+
+#ifndef WFD_NVX_nvscisync
+#define WFD_NVX_nvscisync 1
+struct NvSciSyncObjRec;
+typedef struct NvSciSyncObjRec* NvSciSyncObj;
+struct NvSciSyncAttrListRec;
+typedef struct NvSciSyncAttrListRec* NvSciSyncAttrList;
+typedef struct NvSciSyncFence NvSciSyncFence;
+#ifdef WFD_WFDEXT_PROTOTYPES
+WFD_API_CALL WFDErrorCode WFD_APIENTRY
+    wfdNvSciSyncSetWaiterAttributesNVX(NvSciSyncAttrList *const attrList);
+
+WFD_API_CALL WFDErrorCode WFD_APIENTRY
+    wfdNvSciSyncSetSignalerAttributesNVX(NvSciSyncAttrList *const attrList);
+
+WFD_API_CALL WFDErrorCode WFD_APIENTRY
+    wfdBindNvSciSyncFenceToSourceNVX(const WFDDevice device, const WFDSource source,
+                                     const NvSciSyncFence *const fence);
+
+WFD_API_CALL WFDErrorCode WFD_APIENTRY
+    wfdRegisterPostFlipNvSciSyncObjNVX(const WFDDevice device, const NvSciSyncObj *const obj);
+
+WFD_API_CALL void WFD_APIENTRY
+    wfdDeviceCommitWithNvSciSyncFenceNVX(const WFDDevice device,
+                                         const WFDCommitType type,
+                                         const WFDHandle handle,
+                                         NvSciSyncFence *const fence);
+#endif /* WFD_WFDEXT_PROTOTYPES */
+typedef WFDErrorCode (WFD_APIENTRY PFNWFDNVSCISYNCSETSIGNALERATTRIBUTESNVX)
+                     (NvSciSyncAttrList *const attrList);
+
+typedef WFDErrorCode (WFD_APIENTRY PFNWFDNVSCISYNCSETWAITERATTRIBUTESNVX)
+                     (NvSciSyncAttrList *const attrList);
+
+typedef WFDErrorCode (WFD_APIENTRY PFNWFDBINDNVSCISYNCFENCETOSOURCENVX)
+                     (const WFDDevice device, const WFDSource source, const NvSciSyncFence *const fence);
+
+typedef WFDErrorCode (WFD_APIENTRY PFNWFDREGISTERPOSTFLIPNVSCISYNCOBJNVX)
+                     (const WFDDevice device, const NvSciSyncObj *const obj);
+
+typedef void (WFD_APIENTRY PFNWFDDEVICECOMMITWITHNVSCISYNCFENCENVX)
+             (const WFDDevice device, const WFDCommitType type,
+              const WFDHandle handle, NvSciSyncFence *const fence);
+
+#define WFD_PIPELINE_POSTFENCE_SCANOUT_BEGIN_NVX 0x7731
+
+#endif /* WFD_NVX_nvscisync */
+
+#ifndef WFD_NVX_commit_non_blocking
+#define WFD_NVX_commit_non_blocking 1
+#define WFD_PIPELINE_COMMIT_NON_BLOCKING_NVX 0x7730
+#endif
+
+#ifndef WFD_NVX_port_mode_timings
+#define WFD_NVX_port_mode_timings 1
+#define WFD_PORT_MODE_H_TOTAL_NVX   0x7608
+#define WFD_PORT_MODE_V_TOTAL_NVX   0x7609
+#endif
+
+#ifndef WFD_NV_frozen_frame_detection
+#define WFD_NV_frozen_frame_detection 1
+#define WFD_PORT_DETECT_FROZEN_FRAME_NV 0x7636
+#endif
+
+#if defined(__QNX__)
+
+
+
+#ifndef NV_SAFETY_BUILD
+#ifndef WFD_QNX_cbabc
+#define WFD_QNX_cbabc 1
+#define WFD_PORT_CBABC_MODE_QNX 0x7670
+typedef enum
+{   WFD_PORT_CBABC_MODE_NONE_QNX   = 0x7671,
+    WFD_PORT_CBABC_MODE_VIDEO_QNX  = 0x7672,
+    WFD_PORT_CBABC_MODE_UI_QNX     = 0x7673,
+    WFD_PORT_CBABC_MODE_PHOTO_QNX  = 0x7674,
+    WFD_PORT_CBABC_MODE_32BIT_QNX  = 0x7FFFFFFF
+} WFDPortCBABCModeQNX;
+#endif
+
+#ifndef WFD_QNX_bchs_filter
+#define WFD_QNX_bchs_filter 1
+#define WFD_PIPELINE_BRIGHTNESS_QNX     0x7750
+#define WFD_PIPELINE_CONTRAST_QNX       0x7751
+#define WFD_PIPELINE_HUE_QNX            0x7752
+#define WFD_PIPELINE_SATURATION_QNX     0x7753
+#endif
+
+#ifndef WFD_QNX_port_mode_info
+#define WFD_QNX_port_mode_info 1
+#define WFD_PORT_MODE_ASPECT_RATIO_QNX  0x7606
+#define WFD_PORT_MODE_PREFERRED_QNX     0x7607
+#endif
+#ifndef WFD_QNX_vsync
+#define WFD_QNX_vsync 1
+#ifdef WFD_WFDEXT_PROTOTYPES
+WFD_API_CALL WFDErrorCode WFD_APIENTRY
+    wfdWaitForVSyncQNX(WFDDevice device, WFDPort port) WFD_APIEXIT;
+#endif /* WFD_WFDEXT_PROTOTYPES */
+typedef WFDErrorCode (WFD_APIENTRY PFNWFDWAITFORVSYNCQNX) (WFDDevice device, WFDPort port);
+#endif
+
+#ifndef WFD_QNX_read_pixels_from_source
+#define WFD_QNX_read_pixels_from_source 1
+#ifdef WFD_WFDEXT_PROTOTYPES
+WFD_API_CALL WFDErrorCode WFD_APIENTRY
+    wfdReadPixelsFromSourceQNX(WFDDevice device, WFDSource source, WFDint x, WFDint y,
+                               WFDint width, WFDint height, WFDint format, void *data);
+#endif /* WFD_WFDEXT_PROTOTYPES */
+typedef WFDErrorCode (WFD_APIENTRY PFNWFDREADPIXELSFROMSOURCEQNX) (WFDDevice device, WFDSource source,
+                      WFDint x, WFDint y, WFDint width,
+                      WFDint height, WFDint format, void *data);
+#endif
+
+#ifndef WFD_QNX_egl_images
+#define WFD_QNX_egl_images 1
+#define WFD_USAGE_DISPLAY_QNX      (1 << 0)
+#define WFD_USAGE_READ_QNX         (1 << 1)
+#define WFD_USAGE_WRITE_QNX        (1 << 2)
+#define WFD_USAGE_NATIVE_QNX       (1 << 3)
+#define WFD_USAGE_OPENGL_ES1_QNX   (1 << 4)
+#define WFD_USAGE_OPENGL_ES2_QNX   (1 << 5)
+#define WFD_USAGE_OPENGL_ES3_QNX   (1 << 11)
+#define WFD_USAGE_OPENVG_QNX       (1 << 6)
+#define WFD_USAGE_VIDEO_QNX        (1 << 7)
+#define WFD_USAGE_CAPTURE_QNX      (1 << 8)
+#define WFD_USAGE_ROTATION_QNX     (1 << 9)
+#define WFD_USAGE_OVERLAY_QNX      (1 << 10)
+#define WFD_USAGE_WRITEBACK_QNX    (1 << 31)
+#define WFD_FORMAT_BYTE_QNX              1
+#define WFD_FORMAT_RGBA4444_QNX          2
+#define WFD_FORMAT_RGBX4444_QNX          3
+#define WFD_FORMAT_RGBA5551_QNX          4
+#define WFD_FORMAT_RGBX5551_QNX          5
+#define WFD_FORMAT_RGB565_QNX            6
+#define WFD_FORMAT_RGB888_QNX            7
+#define WFD_FORMAT_RGBA8888_QNX          8
+#define WFD_FORMAT_RGBX8888_QNX          9
+#define WFD_FORMAT_YVU9_QNX             10
+#define WFD_FORMAT_YUV420_QNX           11
+#define WFD_FORMAT_NV12_QNX             12
+#define WFD_FORMAT_YV12_QNX             13
+#define WFD_FORMAT_UYVY_QNX             14
+#define WFD_FORMAT_YUY2_QNX             15
+#define WFD_FORMAT_YVYU_QNX             16
+#define WFD_FORMAT_V422_QNX             17
+#define WFD_FORMAT_AYUV_QNX             18
+#define WFD_FORMAT_NV12_QC_SUPERTILE    ((1 << 16) | WFD_FORMAT_NV12_QNX)
+#define WFD_FORMAT_NV12_QC_32M4KA       ((2 << 16) | WFD_FORMAT_NV12_QNX)
+#ifdef WFD_WFDEXT_PROTOTYPES
+WFD_API_CALL WFDErrorCode WFD_APIENTRY
+    wfdCreateWFDEGLImagesQNX(WFDDevice device, WFDint width, WFDint height, WFDint format, WFDint usage, WFDint count, WFDEGLImage *images);
+WFD_API_CALL WFDErrorCode WFD_APIENTRY
+    wfdDestroyWFDEGLImagesQNX(WFDDevice device, WFDint count, WFDEGLImage *images);
+#endif /* WFD_WFDEXT_PROTOTYPES */
+typedef WFDErrorCode (WFD_APIENTRY PFNWFDCREATEWFDEGLIMAGESQNX) (WFDDevice device, WFDint width, WFDint height, WFDint usage, WFDint count, WFDEGLImage *images);
+typedef WFDErrorCode (WFD_APIENTRY PFNWFDDESTROYWFDEGLIMAGESQNX) (WFDDevice device, WFDint count, WFDEGLImage *images);
+#endif
+#endif /* !NV_SAFETY_BUILD */
+#endif // defined(__QNX__)
+
+#ifdef __cplusplus
+}
+#endif
+
+
+#endif /* WFDEXT_H_ */

WF/wfdplatform.h

@@ -0,0 +1,79 @@
+/* Copyright (c) 2009 The Khronos Group Inc.
+ * Copyright (c) 2020-2021, NVIDIA CORPORATION.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and/or associated documentation files (the
+ * "Materials"), to deal in the Materials without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Materials, and to
+ * permit persons to whom the Materials are furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Materials.
+ *
+ * THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
+ */
+
+/*! \ingroup wfd
+ *  \file wfdplatform.h
+ *
+ *  \brief Platform specific type definitions
+ */
+
+
+#ifndef WFDPLATFORM_H
+#define WFDPLATFORM_H
+#include <KHR/khrplatform.h>
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+#ifndef WFD_API_CALL
+#define WFD_API_CALL KHRONOS_APICALL
+#endif
+
+#ifndef WFD_APIENTRY
+#define WFD_APIENTRY KHRONOS_APIENTRY
+#endif
+
+#ifndef WFD_APIEXIT
+#define WFD_APIEXIT KHRONOS_APIATTRIBUTES
+#endif
+
+typedef khronos_int32_t             WFDint;
+typedef khronos_float_t             WFDfloat;
+typedef khronos_uint32_t            WFDbitfield;
+typedef khronos_uint32_t            WFDHandle;
+typedef khronos_uint32_t            WFDuint32;
+typedef khronos_uint64_t            WFDuint64;
+
+#define WFD_FOREVER (0xFFFFFFFFFFFFFFFF)
+
+#ifndef NV_SAFETY_BUILD
+
+typedef khronos_uint8_t             WFDuint8;
+typedef khronos_utime_nanoseconds_t WFDtime;
+
+typedef void*                       WFDEGLDisplay; /* An opaque handle to an EGLDisplay */
+typedef void*                       WFDEGLSync; /* An opaque handle to an EGLSyncKHR */
+typedef void*                       WFDEGLImage; /* An opaque handle to an EGLImage */
+typedef WFDHandle                   WFDNativeStreamType;
+
+#define WFD_INVALID_SYNC ((WFDEGLSync)0)
+
+#endif // !NV_SAFETY_BUILD
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* WFDPLATFORM_H */
+

commitFile.txt

@@ -0,0 +1,5 @@
+Updating prebuilts and/or headers 
+
+dbd4f936a8aa1443e2fc31fb619267b33d2f1127 - WF/wfdplatform.h
+d3925649a315b1d45ecaf1a06a5e41a8bdc5b583 - WF/wfd.h
+62a080557194f175550e5abe18cf344aa18ee084 - WF/wfdext.h

openwfd_headers_README.txt

@@ -0,0 +1,13 @@
+#
+# SPDX-FileCopyrightText: Copyright (c) 2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: LicenseRef-NvidiaProprietary
+#
+# NVIDIA CORPORATION, its affiliates and licensors retain all intellectual
+# property and proprietary rights in and to this material, related
+# documentation and any modifications thereto. Any use, reproduction,
+# disclosure or distribution of this material and related documentation
+# without an express license agreement from NVIDIA CORPORATION or
+# its affiliates is strictly prohibited.
+
+* openwfd_headers.tbz2 contains OpenWFD headers required for inclusion by
+  OpenWFD applications.

push_info.txt

@@ -0,0 +1 @@
+jetson_36.3