Revision control
++ // Copyright (C) 2016 Research In Motion
++ // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
++
++ #include "qqnxwindowgrabber_p.h"
++
++ #include <QAbstractEventDispatcher>
++ #include <QDebug>
++ #include <QGuiApplication>
++ #include <QImage>
++ #include <QThread>
++ #include <qpa/qplatformnativeinterface.h>
++
++ #include <QOpenGLContext>
++ #include <QOpenGLFunctions>
++
++ #include <rhi/qrhi.h>
++
++ #include <QtMultimedia/private/qeglimagefunctions_p.h>
++ #include <QtMultimedia/private/qmultimedia_gl_support_p.h>
++
++ #include <cstring>
++
++ #include <EGL/egl.h>
++ #include <errno.h>
++
++ QT_BEGIN_NAMESPACE
++
++ using QtMultimediaPrivate::EGLImageHandle;
++ using QtMultimediaPrivate::GlTextureDeleter;
++ using QtMultimediaPrivate::GlTextureHandle;
++ using QtMultimediaPrivate::QEglImageFunctions;
++
++ class QQnxWindowGrabberImage
++ {
++ public:
++ QQnxWindowGrabberImage();
++ ~QQnxWindowGrabberImage();
++
++ bool initialize(screen_context_t screenContext);
++
++ QQnxWindowGrabber::BufferView getBuffer(screen_window_t window, const QSize &size);
++ GLuint getTexture(screen_window_t window, const QSize &size);
++
++ private:
++ bool grab(screen_window_t window);
++ bool resize(const QSize &size);
++
++ QSize m_size;
++ screen_pixmap_t m_pixmap;
++ screen_buffer_t m_pixmapBuffer;
++ EGLImageHandle m_eglImage;
++ GlTextureHandle m_glTexture;
++ unsigned char *m_bufferAddress;
++ int m_bufferStride;
++ };
++
++ QQnxWindowGrabber::QQnxWindowGrabber(QObject *parent)
++ : QObject(parent),
++ m_windowParent(nullptr),
++ m_window(nullptr),
++ m_screenContext(nullptr),
++ m_rhi(nullptr),
++ m_active(false),
++ m_eglImageSupported(false),
++ m_startPending(false)
++ {
++ // grab the window frame with 60 frames per second
++ m_timer.setInterval(1000/60);
++
++ connect(&m_timer, &QTimer::timeout, this, &QQnxWindowGrabber::triggerUpdate);
++
++ QCoreApplication::eventDispatcher()->installNativeEventFilter(this);
++
++ QPlatformNativeInterface *const nativeInterface = QGuiApplication::platformNativeInterface();
++ if (nativeInterface) {
++ m_screenContext = static_cast<screen_context_t>(
++ nativeInterface->nativeResourceForIntegration("screenContext"));
++ }
++
++ // Create a parent window for the window whose content will be grabbed. Since the
++ // window is only a buffer conduit, the characteristics of the parent window are
++ // irrelevant. The contents of the window can be grabbed so long as the window
++ // joins the parent window's group and the parent window is in this process.
++ // Using the window that displays this content isn't possible because there's no
++ // way to reliably retrieve it from this code or any calling code.
++ screen_create_window(&m_windowParent, m_screenContext);
++ screen_create_window_group(m_windowParent, nullptr);
++ }
++
++ QQnxWindowGrabber::~QQnxWindowGrabber()
++ {
++ screen_destroy_window(m_windowParent);
++ QCoreApplication::eventDispatcher()->removeNativeEventFilter(this);
++ }
++
++ void QQnxWindowGrabber::setFrameRate(int frameRate)
++ {
++ m_timer.setInterval(1000/frameRate);
++ }
++
++ void QQnxWindowGrabber::setWindowId(const QByteArray &windowId)
++ {
++ m_windowId = windowId;
++ }
++
++ void QQnxWindowGrabber::setRhi(QRhi *rhi)
++ {
++ m_rhi = rhi;
++
++ checkForEglImageExtension();
++ }
++
++ void QQnxWindowGrabber::start()
++ {
++ if (m_active)
++ return;
++
++ if (!m_window) {
++ m_startPending = true;
++ return;
++ }
++
++ m_startPending = false;
++
++ if (!m_screenContext)
++ screen_get_window_property_pv(m_window, SCREEN_PROPERTY_CONTEXT, reinterpret_cast<void**>(&m_screenContext));
++
++ m_timer.start();
++
++ m_active = true;
++ }
++
++ void QQnxWindowGrabber::stop()
++ {
++ if (!m_active)
++ return;
++
++ resetBuffers();
++
++ m_timer.stop();
++
++ m_active = false;
++ }
++
++ void QQnxWindowGrabber::pause()
++ {
++ m_timer.stop();
++ }
++
++ void QQnxWindowGrabber::resume()
++ {
++ if (!m_active)
++ return;
++
++ m_timer.start();
++ }
++
++ void QQnxWindowGrabber::forceUpdate()
++ {
++ if (!m_active)
++ return;
++
++ triggerUpdate();
++ }
++
++ bool QQnxWindowGrabber::handleScreenEvent(screen_event_t screen_event)
++ {
++
++ int eventType;
++ if (screen_get_event_property_iv(screen_event, SCREEN_PROPERTY_TYPE, &eventType) != 0) {
++ qWarning() << "QQnxWindowGrabber: Failed to query screen event type";
++ return false;
++ }
++
++ if (eventType != SCREEN_EVENT_CREATE)
++ return false;
++
++ screen_window_t window = 0;
++ if (screen_get_event_property_pv(screen_event, SCREEN_PROPERTY_WINDOW, (void**)&window) != 0) {
++ qWarning() << "QQnxWindowGrabber: Failed to query window property";
++ return false;
++ }
++
++ const int maxIdStrLength = 128;
++ char idString[maxIdStrLength];
++ if (screen_get_window_property_cv(window, SCREEN_PROPERTY_ID_STRING, maxIdStrLength, idString) != 0) {
++ qWarning() << "QQnxWindowGrabber: Failed to query window ID string";
++ return false;
++ }
++
++ // Grab windows that have a non-empty ID string and a matching window id to grab
++ if (idString[0] != '\0' && m_windowId == idString) {
++ m_window = window;
++
++ if (m_startPending)
++ start();
++ }
++
++ return false;
++ }
++
++ bool QQnxWindowGrabber::nativeEventFilter(const QByteArray &eventType, void *message, qintptr *)
++ {
++ if (eventType == "screen_event_t") {
++ const screen_event_t event = static_cast<screen_event_t>(message);
++ return handleScreenEvent(event);
++ }
++
++ return false;
++ }
++
++ QByteArray QQnxWindowGrabber::windowGroupId() const
++ {
++ char groupName[256];
++ memset(groupName, 0, sizeof(groupName));
++ screen_get_window_property_cv(m_windowParent,
++ SCREEN_PROPERTY_GROUP,
++ sizeof(groupName) - 1,
++ groupName);
++ return QByteArray(groupName);
++ }
++
++ bool QQnxWindowGrabber::isEglImageSupported() const
++ {
++ return m_eglImageSupported;
++ }
++
++ void QQnxWindowGrabber::checkForEglImageExtension()
++ {
++ m_eglImageSupported = false;
++
++ if (!m_rhi || m_rhi->backend() != QRhi::OpenGLES2)
++ return;
++
++ // Use of EGL images can be disabled by setting QQNX_MM_DISABLE_EGLIMAGE_SUPPORT to something
++ // non-zero. This is probably useful only to test that this path still works since it results
++ // in a high CPU load.
++ if (qgetenv("QQNX_MM_DISABLE_EGLIMAGE_SUPPORT").toInt() != 0)
++ return;
++
++ const EGLDisplay defaultDisplay = eglGetDisplay(EGL_DEFAULT_DISPLAY);
++
++ const char *vendor = eglQueryString(defaultDisplay, EGL_VENDOR);
++
++ if (vendor && std::strstr(vendor, "VMWare"))
++ return;
++
++ m_eglImageSupported = QEglImageFunctions::instance().isValid();
++ }
++
++ void QQnxWindowGrabber::triggerUpdate()
++ {
++ int size[2] = { 0, 0 };
++
++ const int result = screen_get_window_property_iv(m_window, SCREEN_PROPERTY_SOURCE_SIZE, size);
++
++ if (result != 0) {
++ resetBuffers();
++ qWarning() << "QQnxWindowGrabber: cannot get window size:" << strerror(errno);
++ return;
++ }
++
++ if (m_size.width() != size[0] || m_size.height() != size[1])
++ m_size = QSize(size[0], size[1]);
++
++ Q_EMIT updateScene(m_size);
++ }
++
++ bool QQnxWindowGrabber::selectBuffer()
++ {
++ // If we're using egl images we need to double buffer since the gpu may still be using the last
++ // video frame. If we're not, it doesn't matter since the data is immediately copied.
++ if (isEglImageSupported())
++ std::swap(m_frontBuffer, m_backBuffer);
++
++ if (m_frontBuffer)
++ return true;
++
++ auto frontBuffer = std::make_unique<QQnxWindowGrabberImage>();
++
++ if (!frontBuffer->initialize(m_screenContext))
++ return false;
++
++ m_frontBuffer = std::move(frontBuffer);
++
++ return true;
++ }
++
++ int QQnxWindowGrabber::getNextTextureId()
++ {
++ if (!selectBuffer())
++ return 0;
++
++ return m_frontBuffer->getTexture(m_window, m_size);
++ }
++
++ QQnxWindowGrabber::BufferView QQnxWindowGrabber::getNextBuffer()
++ {
++ if (!selectBuffer())
++ return {};
++
++ return m_frontBuffer->getBuffer(m_window, m_size);
++ }
++
++ void QQnxWindowGrabber::resetBuffers()
++ {
++ m_frontBuffer.reset();
++ m_backBuffer.reset();
++ }
++
++ QQnxWindowGrabberImage::QQnxWindowGrabberImage()
++ : m_pixmap(0),
++ m_pixmapBuffer(0),
++ m_bufferAddress(nullptr),
++ m_bufferStride(0)
++ {
++ }
++
++ QQnxWindowGrabberImage::~QQnxWindowGrabberImage()
++ {
++ if (m_pixmap)
++ screen_destroy_pixmap(m_pixmap);
++ }
++
++ bool QQnxWindowGrabberImage::initialize(screen_context_t screenContext)
++ {
++ if (screen_create_pixmap(&m_pixmap, screenContext) != 0) {
++ qWarning() << "QQnxWindowGrabber: cannot create pixmap:" << strerror(errno);
++ return false;
++ }
++ const int usage = SCREEN_USAGE_WRITE | SCREEN_USAGE_READ | SCREEN_USAGE_NATIVE;
++ screen_set_pixmap_property_iv(m_pixmap, SCREEN_PROPERTY_USAGE, &usage);
++
++ // XXX as a matter of fact, the underlying buffer is BGRX8888 (according to
++ // QNX, screen formats can be loose on the ARGB ordering) - as there is no
++ // SCREEN_FORMAT_BGRX8888 constant, we use SCREEN_FORMAT_RGBX8888, which
++ // carries the same depth and allows us to use the buffer.
++ const int format = SCREEN_FORMAT_RGBX8888;
++ screen_set_pixmap_property_iv(m_pixmap, SCREEN_PROPERTY_FORMAT, &format);
++
++ return true;
++ }
++
++ bool QQnxWindowGrabberImage::resize(const QSize &newSize)
++ {
++ if (m_pixmapBuffer) {
++ screen_destroy_pixmap_buffer(m_pixmap);
++ m_pixmapBuffer = 0;
++ m_bufferAddress = 0;
++ m_bufferStride = 0;
++ }
++
++ const int size[2] = { newSize.width(), newSize.height() };
++
++ screen_set_pixmap_property_iv(m_pixmap, SCREEN_PROPERTY_BUFFER_SIZE, size);
++
++ if (screen_create_pixmap_buffer(m_pixmap) == 0) {
++ screen_get_pixmap_property_pv(m_pixmap, SCREEN_PROPERTY_RENDER_BUFFERS,
++ reinterpret_cast<void**>(&m_pixmapBuffer));
++ screen_get_buffer_property_pv(m_pixmapBuffer, SCREEN_PROPERTY_POINTER,
++ reinterpret_cast<void**>(&m_bufferAddress));
++ screen_get_buffer_property_iv(m_pixmapBuffer, SCREEN_PROPERTY_STRIDE, &m_bufferStride);
++ m_size = newSize;
++
++ return true;
++ } else {
++ m_size = QSize();
++ return false;
++ }
++ }
++
++ bool QQnxWindowGrabberImage::grab(screen_window_t window)
++ {
++ const int rect[] = { 0, 0, m_size.width(), m_size.height() };
++ return screen_read_window(window, m_pixmapBuffer, 1, rect, 0) == 0;
++ }
++
++ QQnxWindowGrabber::BufferView QQnxWindowGrabberImage::getBuffer(
++ screen_window_t window, const QSize &size)
++ {
++ if (size != m_size && !resize(size))
++ return {};
++
++ if (!m_bufferAddress || !grab(window))
++ return {};
++
++ return {
++ .width = m_size.width(),
++ .height = m_size.height(),
++ .stride = m_bufferStride,
++ .data = m_bufferAddress
++ };
++ }
++
++ GLuint QQnxWindowGrabberImage::getTexture(screen_window_t window, const QSize &size)
++ {
++ if (size != m_size) {
++ // create a brand new texture to be the KHR image sibling, as
++ // previously used textures cannot be reused with new KHR image
++ // sources
++ GLuint glTexture = 0;
++ glGenTextures(1, &glTexture);
++ m_glTexture = GlTextureHandle(glTexture, GlTextureDeleter(QOpenGLContext::currentContext()));
++
++ const auto &eglImageFunctions = QEglImageFunctions::instance();
++
++ glBindTexture(GL_TEXTURE_2D, m_glTexture.get());
++ if (m_eglImage) {
++ eglImageFunctions.glEGLImageTargetTexture2DOES(GL_TEXTURE_2D, 0);
++ m_eglImage.reset();
++ }
++ if (!resize(size))
++ return 0;
++ m_eglImage = eglImageFunctions.eglCreateImage(eglGetDisplay(EGL_DEFAULT_DISPLAY),
++ EGL_NO_CONTEXT, EGL_NATIVE_PIXMAP_KHR,
++ m_pixmap);
++ eglImageFunctions.glEGLImageTargetTexture2DOES(GL_TEXTURE_2D, m_eglImage.get());
++ }
++
++ if (!m_pixmap || !grab(window))
++ return 0;
++
++ return m_glTexture.get();
++ }
++
++ QT_END_NAMESPACE
++
++ #include "moc_qqnxwindowgrabber_p.cpp"