Move EGLDevice/Output/Stream resolvers into eglconvenience

Needed by Qt Wayland as well.

Change-Id: Ic349f0a79831e9121cbe9885246897efea2701d5
Reviewed-by: Andy Nichols <andy.nichols@theqtcompany.com>

6 files changed, 319 insertions, 123 deletions

diff --git a/src/platformsupport/eglconvenience/eglconvenience.pri b/src/platformsupport/eglconvenience/eglconvenience.pri
index 457efd68fb..1cab1e556f 100644
--- a/src/platformsupport/eglconvenience/eglconvenience.pri
+++ b/src/platformsupport/eglconvenience/eglconvenience.pri
@@ -1,9 +1,11 @@
 contains(QT_CONFIG,egl) {
     HEADERS += \
-        $$PWD/qeglconvenience_p.h
+        $$PWD/qeglconvenience_p.h \
+        $$PWD/qeglstreamconvenience_p.h
 
     SOURCES += \
-        $$PWD/qeglconvenience.cpp
+        $$PWD/qeglconvenience.cpp \
+        $$PWD/qeglstreamconvenience.cpp
 
     contains(QT_CONFIG,opengl) {
         HEADERS += $$PWD/qeglplatformcontext_p.h \
diff --git a/src/platformsupport/eglconvenience/qeglstreamconvenience.cpp b/src/platformsupport/eglconvenience/qeglstreamconvenience.cpp
new file mode 100644
index 0000000000..2ace144811
--- /dev/null
+++ b/src/platformsupport/eglconvenience/qeglstreamconvenience.cpp
@@ -0,0 +1,112 @@
+/****************************************************************************
+**
+** Copyright (C) 2015 The Qt Company Ltd.
+** Contact: http://www.qt.io/licensing/
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL21$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see http://www.qt.io/terms-conditions. For further
+** information use the contact form at http://www.qt.io/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 or version 3 as published by the Free
+** Software Foundation and appearing in the file LICENSE.LGPLv21 and
+** LICENSE.LGPLv3 included in the packaging of this file. Please review the
+** following information to ensure the GNU Lesser General Public License
+** requirements will be met: https://www.gnu.org/licenses/lgpl.html and
+** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** As a special exception, The Qt Company gives you certain additional
+** rights. These rights are described in The Qt Company LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qeglstreamconvenience_p.h"
+#include <string.h>
+
+QT_BEGIN_NAMESPACE
+
+QEGLStreamConvenience::QEGLStreamConvenience()
+    : initialized(false),
+      has_egl_platform_device(false),
+      has_egl_device_base(false),
+      has_egl_stream(false),
+      has_egl_stream_producer_eglsurface(false),
+      has_egl_stream_consumer_egloutput(false),
+      has_egl_output_drm(false),
+      has_egl_output_base(false),
+      has_egl_stream_cross_process_fd(false),
+      has_egl_stream_consumer_gltexture(false)
+{
+    const char *extensions = eglQueryString(EGL_NO_DISPLAY, EGL_EXTENSIONS);
+    if (!extensions) {
+        qWarning("Failed to query EGL extensions");
+        return;
+    }
+
+    query_devices = reinterpret_cast<PFNEGLQUERYDEVICESEXTPROC>(eglGetProcAddress("eglQueryDevicesEXT"));
+    query_device_string = reinterpret_cast<PFNEGLQUERYDEVICESTRINGEXTPROC>(eglGetProcAddress("eglQueryDeviceStringEXT"));
+    get_platform_display = reinterpret_cast<PFNEGLGETPLATFORMDISPLAYEXTPROC>(eglGetProcAddress("eglGetPlatformDisplayEXT"));
+
+    has_egl_device_base = strstr(extensions, "EGL_EXT_device_base");
+    has_egl_platform_device = strstr(extensions, "EGL_EXT_platform_device");
+}
+
+void QEGLStreamConvenience::initialize(EGLDisplay dpy)
+{
+    if (initialized)
+        return;
+
+    if (!eglBindAPI(EGL_OPENGL_ES_API)) {
+        qWarning("Failed to bind OpenGL ES API");
+        return;
+    }
+
+    const char *extensions = eglQueryString(dpy, EGL_EXTENSIONS);
+    if (!extensions) {
+        qWarning("Failed to query EGL extensions");
+        return;
+    }
+
+    create_stream = reinterpret_cast<PFNEGLCREATESTREAMKHRPROC>(eglGetProcAddress("eglCreateStreamKHR"));
+    destroy_stream = reinterpret_cast<PFNEGLDESTROYSTREAMKHRPROC>(eglGetProcAddress("eglDestroyStreamKHR"));
+    stream_attrib = reinterpret_cast<PFNEGLSTREAMATTRIBKHRPROC>(eglGetProcAddress("eglStreamAttribKHR"));
+    query_stream = reinterpret_cast<PFNEGLQUERYSTREAMKHRPROC>(eglGetProcAddress("eglQueryStreamKHR"));
+    query_stream_u64 = reinterpret_cast<PFNEGLQUERYSTREAMU64KHRPROC>(eglGetProcAddress("eglQueryStreamu64KHR"));
+    create_stream_producer_surface = reinterpret_cast<PFNEGLCREATESTREAMPRODUCERSURFACEKHRPROC>(eglGetProcAddress("eglCreateStreamProducerSurfaceKHR"));
+    stream_consumer_output = reinterpret_cast<PFNEGLSTREAMCONSUMEROUTPUTEXTPROC>(eglGetProcAddress("eglStreamConsumerOutputEXT"));
+    get_output_layers = reinterpret_cast<PFNEGLGETOUTPUTLAYERSEXTPROC>(eglGetProcAddress("eglGetOutputLayersEXT"));
+    get_output_ports = reinterpret_cast<PFNEGLGETOUTPUTPORTSEXTPROC>(eglGetProcAddress("eglGetOutputPortsEXT"));
+    output_layer_attrib = reinterpret_cast<PFNEGLOUTPUTLAYERATTRIBEXTPROC>(eglGetProcAddress("eglOutputLayerAttribEXT"));
+    query_output_layer_attrib = reinterpret_cast<PFNEGLQUERYOUTPUTLAYERATTRIBEXTPROC>(eglGetProcAddress("eglQueryOutputLayerAttribEXT"));
+    query_output_layer_string = reinterpret_cast<PFNEGLQUERYOUTPUTLAYERSTRINGEXTPROC>(eglGetProcAddress("eglQueryOutputLayerStringEXT"));
+    query_output_port_attrib = reinterpret_cast<PFNEGLQUERYOUTPUTPORTATTRIBEXTPROC>(eglGetProcAddress("eglQueryOutputPortAttribEXT"));
+    query_output_port_string = reinterpret_cast<PFNEGLQUERYOUTPUTPORTSTRINGEXTPROC>(eglGetProcAddress("eglQueryOutputPortStringEXT"));
+    get_stream_file_descriptor = reinterpret_cast<PFNEGLGETSTREAMFILEDESCRIPTORKHRPROC>(eglGetProcAddress("eglGetStreamFileDescriptorKHR"));
+    create_stream_from_file_descriptor = reinterpret_cast<PFNEGLCREATESTREAMFROMFILEDESCRIPTORKHRPROC>(eglGetProcAddress("eglCreateStreamFromFileDescriptorKHR"));
+    stream_consumer_gltexture = reinterpret_cast<PFNEGLSTREAMCONSUMERGLTEXTUREEXTERNALKHRPROC>(eglGetProcAddress("eglStreamConsumerGLTextureExternalKHR"));
+    stream_consumer_acquire = reinterpret_cast<PFNEGLSTREAMCONSUMERACQUIREKHRPROC>(eglGetProcAddress("eglStreamConsumerAcquireKHR"));
+    stream_consumer_release = reinterpret_cast<PFNEGLSTREAMCONSUMERRELEASEKHRPROC>(eglGetProcAddress("eglStreamConsumerReleaseKHR"));
+
+    has_egl_stream = strstr(extensions, "EGL_KHR_stream");
+    has_egl_stream_producer_eglsurface = strstr(extensions, "EGL_KHR_stream_producer_eglsurface");
+    has_egl_stream_consumer_egloutput = strstr(extensions, "EGL_EXT_stream_consumer_egloutput");
+    has_egl_output_drm = strstr(extensions, "EGL_EXT_output_drm");
+    has_egl_output_base = strstr(extensions, "EGL_EXT_output_base");
+    has_egl_stream_cross_process_fd = strstr(extensions, "EGL_KHR_stream_cross_process_fd");
+    has_egl_stream_consumer_gltexture = strstr(extensions, "EGL_KHR_stream_consumer_gltexture");
+
+    initialized = true;
+}
+
+QT_END_NAMESPACE
diff --git a/src/platformsupport/eglconvenience/qeglstreamconvenience_p.h b/src/platformsupport/eglconvenience/qeglstreamconvenience_p.h
new file mode 100644
index 0000000000..12787d03ae
--- /dev/null
+++ b/src/platformsupport/eglconvenience/qeglstreamconvenience_p.h
@@ -0,0 +1,175 @@
+/****************************************************************************
+**
+** Copyright (C) 2015 The Qt Company Ltd.
+** Contact: http://www.qt.io/licensing/
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL21$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see http://www.qt.io/terms-conditions. For further
+** information use the contact form at http://www.qt.io/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 or version 3 as published by the Free
+** Software Foundation and appearing in the file LICENSE.LGPLv21 and
+** LICENSE.LGPLv3 included in the packaging of this file. Please review the
+** following information to ensure the GNU Lesser General Public License
+** requirements will be met: https://www.gnu.org/licenses/lgpl.html and
+** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** As a special exception, The Qt Company gives you certain additional
+** rights. These rights are described in The Qt Company LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QEGLSTREAMCONVENIENCE_H
+#define QEGLSTREAMCONVENIENCE_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include <qglobal.h>
+#include <EGL/egl.h>
+#include <EGL/eglext.h>
+
+// This provides runtime EGLDevice/Output/Stream support even when eglext.h in
+// the sysroot is not up-to-date.
+
+#ifndef EGL_VERSION_1_5
+typedef intptr_t EGLAttrib;
+#endif
+
+#ifndef EGL_EXT_platform_base
+typedef EGLDisplay (EGLAPIENTRYP PFNEGLGETPLATFORMDISPLAYEXTPROC) (EGLenum platform, void *native_display, const EGLint *attrib_list);
+#endif
+
+#ifndef EGL_EXT_device_base
+typedef void *EGLDeviceEXT;
+#define EGL_NO_DEVICE_EXT                 ((EGLDeviceEXT)(0))
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLQUERYDEVICESEXTPROC) (EGLint max_devices, EGLDeviceEXT *devices, EGLint *num_devices);
+typedef const char *(EGLAPIENTRYP PFNEGLQUERYDEVICESTRINGEXTPROC) (EGLDeviceEXT device, EGLint name);
+#endif
+
+#ifndef EGL_EXT_output_base
+typedef void *EGLOutputLayerEXT;
+typedef void *EGLOutputPortEXT;
+#define EGL_NO_OUTPUT_LAYER_EXT           ((EGLOutputLayerEXT)0)
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLGETOUTPUTLAYERSEXTPROC) (EGLDisplay dpy, const EGLAttrib *attrib_list, EGLOutputLayerEXT *layers, EGLint max_layers, EGLint *num_layers);
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLGETOUTPUTPORTSEXTPROC) (EGLDisplay dpy, const EGLAttrib *attrib_list, EGLOutputPortEXT *ports, EGLint max_ports, EGLint *num_ports);
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLOUTPUTLAYERATTRIBEXTPROC) (EGLDisplay dpy, EGLOutputLayerEXT layer, EGLint attribute, EGLAttrib value);
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLQUERYOUTPUTLAYERATTRIBEXTPROC) (EGLDisplay dpy, EGLOutputLayerEXT layer, EGLint attribute, EGLAttrib *value);
+typedef const char *(EGLAPIENTRYP PFNEGLQUERYOUTPUTLAYERSTRINGEXTPROC) (EGLDisplay dpy, EGLOutputLayerEXT layer, EGLint name);
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLQUERYOUTPUTPORTATTRIBEXTPROC) (EGLDisplay dpy, EGLOutputPortEXT port, EGLint attribute, EGLAttrib *value);
+typedef const char *(EGLAPIENTRYP PFNEGLQUERYOUTPUTPORTSTRINGEXTPROC) (EGLDisplay dpy, EGLOutputPortEXT port, EGLint name);
+#endif
+
+#ifndef EGL_KHR_stream
+typedef void *EGLStreamKHR;
+typedef quint64 EGLuint64KHR;
+#define EGL_NO_STREAM_KHR                 ((EGLStreamKHR)0)
+typedef EGLStreamKHR (EGLAPIENTRYP PFNEGLCREATESTREAMKHRPROC) (EGLDisplay dpy, const EGLint *attrib_list);
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLDESTROYSTREAMKHRPROC) (EGLDisplay dpy, EGLStreamKHR stream);
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLSTREAMATTRIBKHRPROC) (EGLDisplay dpy, EGLStreamKHR stream, EGLenum attribute, EGLint value);
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLQUERYSTREAMKHRPROC) (EGLDisplay dpy, EGLStreamKHR stream, EGLenum attribute, EGLint *value);
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLQUERYSTREAMU64KHRPROC) (EGLDisplay dpy, EGLStreamKHR stream, EGLenum attribute, EGLuint64KHR *value);
+#endif
+
+#ifndef EGL_KHR_stream_producer_eglsurface
+#define EGL_STREAM_BIT_KHR                0x0800
+typedef EGLSurface (EGLAPIENTRYP PFNEGLCREATESTREAMPRODUCERSURFACEKHRPROC) (EGLDisplay dpy, EGLConfig config, EGLStreamKHR stream, const EGLint *attrib_list);
+#endif
+
+#ifndef EGL_KHR_stream_cross_process_fd
+typedef int EGLNativeFileDescriptorKHR;
+#define EGL_NO_FILE_DESCRIPTOR_KHR        ((EGLNativeFileDescriptorKHR)(-1))
+typedef EGLNativeFileDescriptorKHR (EGLAPIENTRYP PFNEGLGETSTREAMFILEDESCRIPTORKHRPROC) (EGLDisplay dpy, EGLStreamKHR stream);
+typedef EGLStreamKHR (EGLAPIENTRYP PFNEGLCREATESTREAMFROMFILEDESCRIPTORKHRPROC) (EGLDisplay dpy, EGLNativeFileDescriptorKHR file_descriptor);
+#endif
+
+#ifndef EGL_KHR_stream_consumer_gltexture
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLSTREAMCONSUMERGLTEXTUREEXTERNALKHRPROC) (EGLDisplay dpy, EGLStreamKHR stream);
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLSTREAMCONSUMERACQUIREKHRPROC) (EGLDisplay dpy, EGLStreamKHR stream);
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLSTREAMCONSUMERRELEASEKHRPROC) (EGLDisplay dpy, EGLStreamKHR stream);
+#endif
+
+#ifndef EGL_EXT_stream_consumer_egloutput
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLSTREAMCONSUMEROUTPUTEXTPROC) (EGLDisplay dpy, EGLStreamKHR stream, EGLOutputLayerEXT layer);
+#endif
+
+#ifndef EGL_EXT_platform_device
+#define EGL_PLATFORM_DEVICE_EXT           0x313F
+#endif
+
+#ifndef EGL_EXT_device_drm
+#define EGL_DRM_DEVICE_FILE_EXT           0x3233
+#endif
+
+#ifndef EGL_EXT_output_drm
+#define EGL_DRM_CRTC_EXT                  0x3234
+#define EGL_DRM_PLANE_EXT                 0x3235
+#endif
+
+QT_BEGIN_NAMESPACE
+
+class QEGLStreamConvenience
+{
+public:
+    QEGLStreamConvenience();
+    void initialize(EGLDisplay dpy);
+
+    PFNEGLGETPLATFORMDISPLAYEXTPROC get_platform_display;
+    PFNEGLQUERYDEVICESEXTPROC query_devices;
+    PFNEGLQUERYDEVICESTRINGEXTPROC query_device_string;
+    PFNEGLCREATESTREAMKHRPROC create_stream;
+    PFNEGLDESTROYSTREAMKHRPROC destroy_stream;
+    PFNEGLSTREAMATTRIBKHRPROC stream_attrib;
+    PFNEGLQUERYSTREAMKHRPROC query_stream;
+    PFNEGLQUERYSTREAMU64KHRPROC query_stream_u64;
+    PFNEGLCREATESTREAMPRODUCERSURFACEKHRPROC create_stream_producer_surface;
+    PFNEGLSTREAMCONSUMEROUTPUTEXTPROC stream_consumer_output;
+    PFNEGLGETOUTPUTLAYERSEXTPROC get_output_layers;
+    PFNEGLGETOUTPUTPORTSEXTPROC get_output_ports;
+    PFNEGLOUTPUTLAYERATTRIBEXTPROC output_layer_attrib;
+    PFNEGLQUERYOUTPUTLAYERATTRIBEXTPROC query_output_layer_attrib;
+    PFNEGLQUERYOUTPUTLAYERSTRINGEXTPROC query_output_layer_string;
+    PFNEGLQUERYOUTPUTPORTATTRIBEXTPROC query_output_port_attrib;
+    PFNEGLQUERYOUTPUTPORTSTRINGEXTPROC query_output_port_string;
+    PFNEGLGETSTREAMFILEDESCRIPTORKHRPROC get_stream_file_descriptor;
+    PFNEGLCREATESTREAMFROMFILEDESCRIPTORKHRPROC create_stream_from_file_descriptor;
+    PFNEGLSTREAMCONSUMERGLTEXTUREEXTERNALKHRPROC stream_consumer_gltexture;
+    PFNEGLSTREAMCONSUMERACQUIREKHRPROC stream_consumer_acquire;
+    PFNEGLSTREAMCONSUMERRELEASEKHRPROC stream_consumer_release;
+
+    bool initialized;
+
+    bool has_egl_platform_device;
+    bool has_egl_device_base;
+    bool has_egl_stream;
+    bool has_egl_stream_producer_eglsurface;
+    bool has_egl_stream_consumer_egloutput;
+    bool has_egl_output_drm;
+    bool has_egl_output_base;
+    bool has_egl_stream_cross_process_fd;
+    bool has_egl_stream_consumer_gltexture;
+};
+
+QT_END_NAMESPACE
+
+#endif
diff --git a/src/plugins/platforms/eglfs/deviceintegration/eglfs_kms_egldevice/eglfs_kms_egldevice.pro b/src/plugins/platforms/eglfs/deviceintegration/eglfs_kms_egldevice/eglfs_kms_egldevice.pro
index 2274c5b228..393ddd14a5 100644
--- a/src/plugins/platforms/eglfs/deviceintegration/eglfs_kms_egldevice/eglfs_kms_egldevice.pro
+++ b/src/plugins/platforms/eglfs/deviceintegration/eglfs_kms_egldevice/eglfs_kms_egldevice.pro
@@ -8,6 +8,8 @@ QT += core-private gui-private platformsupport-private eglfs_device_lib-private
 
 INCLUDEPATH += $$PWD/../..
 
+DEFINES += MESA_EGL_NO_X11_HEADERS
+
 CONFIG += egl
 QMAKE_LFLAGS += $$QMAKE_LFLAGS_NOUNDEF
 
diff --git a/src/plugins/platforms/eglfs/deviceintegration/eglfs_kms_egldevice/qeglfskmsegldeviceintegration.cpp b/src/plugins/platforms/eglfs/deviceintegration/eglfs_kms_egldevice/qeglfskmsegldeviceintegration.cpp
index 2f32bd73a3..1ddcb3b862 100644
--- a/src/plugins/platforms/eglfs/deviceintegration/eglfs_kms_egldevice/qeglfskmsegldeviceintegration.cpp
+++ b/src/plugins/platforms/eglfs/deviceintegration/eglfs_kms_egldevice/qeglfskmsegldeviceintegration.cpp
@@ -45,6 +45,7 @@ QEglFSKmsEglDeviceIntegration::QEglFSKmsEglDeviceIntegration()
     , m_drm_connector(Q_NULLPTR)
     , m_drm_encoder(Q_NULLPTR)
     , m_drm_crtc(0)
+    , m_funcs(Q_NULLPTR)
 {
     qCDebug(qLcEglfsKmsDebug, "New DRM/KMS on EGLDevice integration created");
 }
@@ -54,7 +55,7 @@ void QEglFSKmsEglDeviceIntegration::platformInit()
     if (!query_egl_device())
         qFatal("Could not set up EGL device!");
 
-    const char *deviceName = m_query_device_string(m_egl_device, EGL_DRM_DEVICE_FILE_EXT);
+    const char *deviceName = m_funcs->query_device_string(m_egl_device, EGL_DRM_DEVICE_FILE_EXT);
     if (!deviceName)
         qFatal("Failed to query device name from EGLDevice");
 
@@ -76,6 +77,9 @@ void QEglFSKmsEglDeviceIntegration::platformDestroy()
         qErrnoWarning("Could not close DRM device");
 
     m_dri_fd = -1;
+
+    delete m_funcs;
+    m_funcs = Q_NULLPTR;
 }
 
 EGLNativeDisplayType QEglFSKmsEglDeviceIntegration::platformDisplay() const
@@ -87,18 +91,13 @@ EGLDisplay QEglFSKmsEglDeviceIntegration::createDisplay(EGLNativeDisplayType nat
 {
     qCDebug(qLcEglfsKmsDebug, "Creating display");
 
-    const char *extensions = eglQueryString(EGL_NO_DISPLAY, EGL_EXTENSIONS);
-
-    m_get_platform_display = reinterpret_cast<PFNEGLGETPLATFORMDISPLAYEXTPROC>(eglGetProcAddress("eglGetPlatformDisplayEXT"));
-    m_has_egl_platform_device = extensions && strstr(extensions, "EGL_EXT_platform_device");
-
     EGLDisplay display;
 
-    if (!m_has_egl_platform_device) {
+    if (m_funcs->has_egl_platform_device) {
+        display = m_funcs->get_platform_display(EGL_PLATFORM_DEVICE_EXT, nativeDisplay, Q_NULLPTR);
+    } else {
         qWarning("EGL_EXT_platform_device not available, falling back to legacy path!");
         display = eglGetDisplay(nativeDisplay);
-    } else {
-        display = m_get_platform_display(EGL_PLATFORM_DEVICE_EXT, nativeDisplay, Q_NULLPTR);
     }
 
     if (display == EGL_NO_DISPLAY)
@@ -165,7 +164,7 @@ public:
 void QEglJetsonTK1Window::invalidateSurface()
 {
     QEglFSWindow::invalidateSurface();
-    m_integration->m_destroy_stream(screen()->display(), m_egl_stream);
+    m_integration->m_funcs->destroy_stream(screen()->display(), m_egl_stream);
 }
 
 void QEglJetsonTK1Window::resetSurface()
@@ -176,7 +175,7 @@ void QEglJetsonTK1Window::resetSurface()
     EGLOutputLayerEXT layer = EGL_NO_OUTPUT_LAYER_EXT;
     EGLint count;
 
-    m_egl_stream = m_integration->m_create_stream(display, Q_NULLPTR);
+    m_egl_stream = m_integration->m_funcs->create_stream(display, Q_NULLPTR);
     if (m_egl_stream == EGL_NO_STREAM_KHR) {
         qWarning("resetSurface: Couldn't create EGLStream for native window");
         return;
@@ -184,7 +183,7 @@ void QEglJetsonTK1Window::resetSurface()
 
     qCDebug(qLcEglfsKmsDebug, "Created stream %p on display %p", m_egl_stream, display);
 
-    if (!m_integration->m_get_output_layers(display, Q_NULLPTR, Q_NULLPTR, 0, &count) || count == 0) {
+    if (!m_integration->m_funcs->get_output_layers(display, Q_NULLPTR, Q_NULLPTR, 0, &count) || count == 0) {
         qWarning("No output layers found");
         return;
     }
@@ -194,20 +193,20 @@ void QEglJetsonTK1Window::resetSurface()
     QVector<EGLOutputLayerEXT> layers;
     layers.resize(count);
     EGLint actualCount;
-    if (!m_integration->m_get_output_layers(display, Q_NULLPTR, layers.data(), count, &actualCount)) {
+    if (!m_integration->m_funcs->get_output_layers(display, Q_NULLPTR, layers.data(), count, &actualCount)) {
         qWarning("Failed to get layers");
         return;
     }
 
     for (int i = 0; i < actualCount; ++i) {
         EGLAttrib id;
-        if (m_integration->m_query_output_layer_attrib(display, layers[i], EGL_DRM_CRTC_EXT, &id)) {
-            qCDebug(qLcEglfsKmsDebug, "  [%d] layer %p - crtc %d", i, layers[i], id);
+        if (m_integration->m_funcs->query_output_layer_attrib(display, layers[i], EGL_DRM_CRTC_EXT, &id)) {
+            qCDebug(qLcEglfsKmsDebug, "  [%d] layer %p - crtc %d", i, layers[i], (int) id);
             if (id == EGLAttrib(m_integration->m_drm_crtc))
                 layer = layers[i];
-        } else if (m_integration->m_query_output_layer_attrib(display, layers[i], EGL_DRM_PLANE_EXT, &id)) {
+        } else if (m_integration->m_funcs->query_output_layer_attrib(display, layers[i], EGL_DRM_PLANE_EXT, &id)) {
             // Not used yet, just for debugging.
-            qCDebug(qLcEglfsKmsDebug, "  [%d] layer %p - plane %d", i, layers[i], id);
+            qCDebug(qLcEglfsKmsDebug, "  [%d] layer %p - plane %d", i, layers[i], (int) id);
         } else {
             qCDebug(qLcEglfsKmsDebug, "  [%d] layer %p - unknown", i, layers[i]);
         }
@@ -227,7 +226,7 @@ void QEglJetsonTK1Window::resetSurface()
 
     qCDebug(qLcEglfsKmsDebug, "Using layer %p", layer);
 
-    if (!m_integration->m_stream_consumer_output(display, m_egl_stream, layer))
+    if (!m_integration->m_funcs->stream_consumer_output(display, m_egl_stream, layer))
         qWarning("resetSurface: Unable to connect stream");
 
     m_config = QEglFSIntegration::chooseConfig(display, m_integration->surfaceFormatFor(window()->requestedFormat()));
@@ -244,7 +243,7 @@ void QEglJetsonTK1Window::resetSurface()
         EGL_NONE
     };
 
-    m_surface = m_integration->m_create_stream_producer_surface(display, m_config, m_egl_stream, stream_producer_attribs);
+    m_surface = m_integration->m_funcs->create_stream_producer_surface(display, m_config, m_egl_stream, stream_producer_attribs);
     if (m_surface == EGL_NO_SURFACE)
         return;
 
@@ -255,7 +254,9 @@ QEglFSWindow *QEglFSKmsEglDeviceIntegration::createWindow(QWindow *window) const
 {
     QEglJetsonTK1Window *eglWindow = new QEglJetsonTK1Window(window, this);
 
-    if (!const_cast<QEglFSKmsEglDeviceIntegration *>(this)->query_egl_extensions(eglWindow->screen()->display()))
+    m_funcs->initialize(eglWindow->screen()->display());
+    if (!(m_funcs->has_egl_output_base && m_funcs->has_egl_output_drm && m_funcs->has_egl_stream
+          && m_funcs->has_egl_stream_producer_eglsurface && m_funcs->has_egl_stream_consumer_egloutput))
         qFatal("Required extensions missing!");
 
     return eglWindow;
@@ -385,21 +386,12 @@ bool QEglFSKmsEglDeviceIntegration::setup_kms()
 
 bool QEglFSKmsEglDeviceIntegration::query_egl_device()
 {
-    const char *extensions = eglQueryString(EGL_NO_DISPLAY, EGL_EXTENSIONS);
-    if (!extensions) {
-        qWarning("eglQueryString failed");
-        return false;
-    }
-
-    m_has_egl_device_base = strstr(extensions, "EGL_EXT_device_base");
-    m_query_devices = reinterpret_cast<PFNEGLQUERYDEVICESEXTPROC>(eglGetProcAddress("eglQueryDevicesEXT"));
-    m_query_device_string = reinterpret_cast<PFNEGLQUERYDEVICESTRINGEXTPROC>(eglGetProcAddress("eglQueryDeviceStringEXT"));
-
-    if (!m_has_egl_device_base || !m_query_devices || !m_query_device_string)
+    m_funcs = new QEGLStreamConvenience;
+    if (!m_funcs->has_egl_device_base)
         qFatal("EGL_EXT_device_base missing");
 
     EGLint num_devices = 0;
-    if (m_query_devices(1, &m_egl_device, &num_devices) != EGL_TRUE) {
+    if (m_funcs->query_devices(1, &m_egl_device, &num_devices) != EGL_TRUE) {
         qWarning("eglQueryDevicesEXT failed: eglError: %x", eglGetError());
         return false;
     }
@@ -414,51 +406,4 @@ bool QEglFSKmsEglDeviceIntegration::query_egl_device()
     return true;
 }
 
-bool QEglFSKmsEglDeviceIntegration::query_egl_extensions(EGLDisplay display)
-{
-    if (!eglBindAPI(EGL_OPENGL_ES_API)) {
-        qWarning() << Q_FUNC_INFO << "failed to bind EGL_OPENGL_ES_API";
-        return false;
-    }
-
-    m_create_stream = reinterpret_cast<PFNEGLCREATESTREAMKHRPROC>(eglGetProcAddress("eglCreateStreamKHR"));
-    m_destroy_stream = reinterpret_cast<PFNEGLDESTROYSTREAMKHRPROC>(eglGetProcAddress("eglDestroyStreamKHR"));
-    m_stream_attrib = reinterpret_cast<PFNEGLSTREAMATTRIBKHRPROC>(eglGetProcAddress("eglStreamAttribKHR"));
-    m_query_stream = reinterpret_cast<PFNEGLQUERYSTREAMKHRPROC>(eglGetProcAddress("eglQueryStreamKHR"));
-    m_query_stream_u64 = reinterpret_cast<PFNEGLQUERYSTREAMU64KHRPROC>(eglGetProcAddress("eglQueryStreamu64KHR"));
-    m_create_stream_producer_surface = reinterpret_cast<PFNEGLCREATESTREAMPRODUCERSURFACEKHRPROC>(eglGetProcAddress("eglCreateStreamProducerSurfaceKHR"));
-    m_stream_consumer_output = reinterpret_cast<PFNEGLSTREAMCONSUMEROUTPUTEXTPROC>(eglGetProcAddress("eglStreamConsumerOutputEXT"));
-    m_get_output_layers = reinterpret_cast<PFNEGLGETOUTPUTLAYERSEXTPROC>(eglGetProcAddress("eglGetOutputLayersEXT"));
-    m_get_output_ports = reinterpret_cast<PFNEGLGETOUTPUTPORTSEXTPROC>(eglGetProcAddress("eglGetOutputPortsEXT"));
-    m_output_layer_attrib = reinterpret_cast<PFNEGLOUTPUTLAYERATTRIBEXTPROC>(eglGetProcAddress("eglOutputLayerAttribEXT"));
-    m_query_output_layer_attrib = reinterpret_cast<PFNEGLQUERYOUTPUTLAYERATTRIBEXTPROC>(eglGetProcAddress("eglQueryOutputLayerAttribEXT"));
-    m_query_output_layer_string = reinterpret_cast<PFNEGLQUERYOUTPUTLAYERSTRINGEXTPROC>(eglGetProcAddress("eglQueryOutputLayerStringEXT"));
-    m_query_output_port_attrib = reinterpret_cast<PFNEGLQUERYOUTPUTPORTATTRIBEXTPROC>(eglGetProcAddress("eglQueryOutputPortAttribEXT"));
-    m_query_output_port_string = reinterpret_cast<PFNEGLQUERYOUTPUTPORTSTRINGEXTPROC>(eglGetProcAddress("eglQueryOutputPortStringEXT"));
-    m_get_stream_file_descriptor = reinterpret_cast<PFNEGLGETSTREAMFILEDESCRIPTORKHRPROC>(eglGetProcAddress("eglGetStreamFileDescriptorKHR"));
-    m_create_stream_from_file_descriptor = reinterpret_cast<PFNEGLCREATESTREAMFROMFILEDESCRIPTORKHRPROC>(eglGetProcAddress("eglCreateStreamFromFileDescriptorKHR"));
-    m_stream_consumer_gltexture = reinterpret_cast<PFNEGLSTREAMCONSUMERGLTEXTUREEXTERNALKHRPROC>(eglGetProcAddress("eglStreamConsumerGLTextureExternalKHR"));
-    m_stream_consumer_acquire = reinterpret_cast<PFNEGLSTREAMCONSUMERACQUIREKHRPROC>(eglGetProcAddress("eglStreamConsumerAcquireKHR"));
-
-    const char *extensions = eglQueryString(display, EGL_EXTENSIONS);
-    if (!extensions) {
-        qWarning() << Q_FUNC_INFO << "eglQueryString failed";
-        return false;
-    }
-
-    m_has_egl_stream = strstr(extensions, "EGL_KHR_stream");
-    m_has_egl_stream_producer_eglsurface = strstr(extensions, "EGL_KHR_stream_producer_eglsurface");
-    m_has_egl_stream_consumer_egloutput = strstr(extensions, "EGL_EXT_stream_consumer_egloutput");
-    m_has_egl_output_drm = strstr(extensions, "EGL_EXT_output_drm");
-    m_has_egl_output_base = strstr(extensions, "EGL_EXT_output_base");
-    m_has_egl_stream_cross_process_fd = strstr(extensions, "EGL_KHR_stream_cross_process_fd");
-    m_has_egl_stream_consumer_gltexture = strstr(extensions, "EGL_KHR_stream_consumer_gltexture");
-
-    return m_has_egl_output_base &&
-        m_has_egl_output_drm &&
-        m_has_egl_stream &&
-        m_has_egl_stream_producer_eglsurface &&
-        m_has_egl_stream_consumer_egloutput;
-}
-
 QT_END_NAMESPACE
diff --git a/src/plugins/platforms/eglfs/deviceintegration/eglfs_kms_egldevice/qeglfskmsegldeviceintegration.h b/src/plugins/platforms/eglfs/deviceintegration/eglfs_kms_egldevice/qeglfskmsegldeviceintegration.h
index c6132354a8..a89a65ca55 100644
--- a/src/plugins/platforms/eglfs/deviceintegration/eglfs_kms_egldevice/qeglfskmsegldeviceintegration.h
+++ b/src/plugins/platforms/eglfs/deviceintegration/eglfs_kms_egldevice/qeglfskmsegldeviceintegration.h
@@ -49,8 +49,7 @@
 #include <xf86drm.h>
 #include <xf86drmMode.h>
 
-#include <EGL/egl.h>
-#include <EGL/eglext.h>
+#include <QtPlatformSupport/private/qeglstreamconvenience_p.h>
 
 QT_BEGIN_NAMESPACE
 
@@ -75,9 +74,7 @@ public:
     bool supportsSurfacelessContexts() const Q_DECL_OVERRIDE;
 
     bool setup_kms();
-
     bool query_egl_device();
-    bool query_egl_extensions(EGLDisplay display);
 
     // device bits
     QByteArray m_device;
@@ -92,44 +89,7 @@ public:
     quint32 m_drm_crtc;
 
     // EGLStream infrastructure
-    PFNEGLGETPLATFORMDISPLAYEXTPROC m_get_platform_display;
-    bool m_has_egl_platform_device;
-
-    PFNEGLQUERYDEVICESEXTPROC m_query_devices;
-    PFNEGLQUERYDEVICESTRINGEXTPROC m_query_device_string;
-    bool m_has_egl_device_base;
-
-    PFNEGLCREATESTREAMKHRPROC m_create_stream;
-    PFNEGLDESTROYSTREAMKHRPROC m_destroy_stream;
-    PFNEGLSTREAMATTRIBKHRPROC m_stream_attrib;
-    PFNEGLQUERYSTREAMKHRPROC m_query_stream;
-    PFNEGLQUERYSTREAMU64KHRPROC m_query_stream_u64;
-    bool m_has_egl_stream;
-
-    PFNEGLCREATESTREAMPRODUCERSURFACEKHRPROC m_create_stream_producer_surface;
-    bool m_has_egl_stream_producer_eglsurface;
-
-    PFNEGLSTREAMCONSUMEROUTPUTEXTPROC m_stream_consumer_output;
-    bool m_has_egl_stream_consumer_egloutput;
-
-    bool m_has_egl_output_drm;
-
-    PFNEGLGETOUTPUTLAYERSEXTPROC m_get_output_layers;
-    PFNEGLGETOUTPUTPORTSEXTPROC m_get_output_ports;
-    PFNEGLOUTPUTLAYERATTRIBEXTPROC m_output_layer_attrib;
-    PFNEGLQUERYOUTPUTLAYERATTRIBEXTPROC m_query_output_layer_attrib;
-    PFNEGLQUERYOUTPUTLAYERSTRINGEXTPROC m_query_output_layer_string;
-    PFNEGLQUERYOUTPUTPORTATTRIBEXTPROC m_query_output_port_attrib;
-    PFNEGLQUERYOUTPUTPORTSTRINGEXTPROC m_query_output_port_string;
-    bool m_has_egl_output_base;
-
-    PFNEGLGETSTREAMFILEDESCRIPTORKHRPROC m_get_stream_file_descriptor;
-    PFNEGLCREATESTREAMFROMFILEDESCRIPTORKHRPROC m_create_stream_from_file_descriptor;
-    bool m_has_egl_stream_cross_process_fd;
-
-    PFNEGLSTREAMCONSUMERGLTEXTUREEXTERNALKHRPROC m_stream_consumer_gltexture;
-    PFNEGLSTREAMCONSUMERACQUIREKHRPROC m_stream_consumer_acquire;
-    bool m_has_egl_stream_consumer_gltexture;
+    QEGLStreamConvenience *m_funcs;
 };
 
 QT_END_NAMESPACE