AuroraMiddleware/qt5base-lts
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Move EGLDevice/Output/Stream resolvers into eglconvenience

Browse Source 
Needed by Qt Wayland as well.

Change-Id: Ic349f0a79831e9121cbe9885246897efea2701d5
Reviewed-by: Andy Nichols <andy.nichols@theqtcompany.com>
This commit is contained in:
Laszlo Agocs 2015-10-15 16:17:03 +02:00
parent f4bfdc8610
commit 5c3cd4a6a1
6 changed files with 319 additions and 123 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
src/platformsupport/eglconvenience/eglconvenience.pri
View File

@ -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 \

112
src/platformsupport/eglconvenience/qeglstreamconvenience.cpp Normal file
View File

@ -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

175
src/platformsupport/eglconvenience/qeglstreamconvenience_p.h Normal file
View File

@ -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

2
src/plugins/platforms/eglfs/deviceintegration/eglfs_kms_egldevice/eglfs_kms_egldevice.pro
View File

@ -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

103
src/plugins/platforms/eglfs/deviceintegration/eglfs_kms_egldevice/qeglfskmsegldeviceintegration.cpp
View File

@ -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

44
src/plugins/platforms/eglfs/deviceintegration/eglfs_kms_egldevice/qeglfskmsegldeviceintegration.h
View File

@ -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