Revision control
Copy as Markdown
// 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"