void GVRInterface::enterVRMode() {
#if defined(ANDROID) && defined(HAVE_LIBOVR)
// Default vrModeParms
ovrModeParms vrModeParms;
vrModeParms.AsynchronousTimeWarp = true;
vrModeParms.AllowPowerSave = true;
vrModeParms.DistortionFileName = NULL;
vrModeParms.EnableImageServer = false;
vrModeParms.CpuLevel = 2;
vrModeParms.GpuLevel = 2;
vrModeParms.GameThreadTid = 0;
QAndroidJniEnvironment jniEnv;
QPlatformNativeInterface* interface = QApplication::platformNativeInterface();
jobject activity = (jobject) interface->nativeResourceForIntegration("QtActivity");
vrModeParms.ActivityObject = activity;
ovrHmdInfo hmdInfo;
_ovr = ovr_EnterVrMode(vrModeParms, &hmdInfo);
_inVRMode = true;
#endif
}
void XCompositeGLXClientBufferIntegration::initializeHardware(QtWayland::Display *)
{
qDebug() << "Initializing GLX integration";
QPlatformNativeInterface *nativeInterface = QGuiApplicationPrivate::platformIntegration()->nativeInterface();
if (nativeInterface) {
mDisplay = static_cast<Display *>(nativeInterface->nativeResourceForWindow("Display",m_compositor->window()));
if (!mDisplay)
qFatal("could not retireve Display from platform integration");
} else {
qFatal("Platform integration doesn't have native interface");
}
mScreen = XDefaultScreen(mDisplay);
mHandler = new XCompositeHandler(m_compositor->handle(), mDisplay);
QOpenGLContext *glContext = new QOpenGLContext();
glContext->create();
m_glxBindTexImageEXT = reinterpret_cast<PFNGLXBINDTEXIMAGEEXTPROC>(glContext->getProcAddress("glXBindTexImageEXT"));
if (!m_glxBindTexImageEXT) {
qDebug() << "Did not find glxBindTexImageExt, everything will FAIL!";
}
m_glxReleaseTexImageEXT = reinterpret_cast<PFNGLXRELEASETEXIMAGEEXTPROC>(glContext->getProcAddress("glXReleaseTexImageEXT"));
if (!m_glxReleaseTexImageEXT) {
qDebug() << "Did not find glxReleaseTexImageExt";
}
delete glContext;
}
VibroWorker::VibroWorker ()
: last_is_alarm (false), last_vibration_looped (false),
mCancel (NULL), mVibrate (NULL), mVibratePattern (NULL),
objVibrator (NULL)
{
QPlatformNativeInterface *interface = QApplication::platformNativeInterface ();
jobject objActivity = (jobject) interface->nativeResourceForIntegration ("QtActivity");
jclass classActivity = jni_env->FindClass ("android/app/Activity");
if (objActivity && classActivity) {
jmethodID mSystemService = jni_env->GetMethodID (classActivity, "getSystemService", "(Ljava/lang/String;)Ljava/lang/Object;");
jstring strMethod = jni_env->NewStringUTF ("vibrator");
if (mSystemService && strMethod)
objVibrator = jni_env->CallObjectMethod (objActivity, mSystemService, strMethod);
if (objVibrator) {
jclass classVibrator = jni_env->GetObjectClass (objVibrator);
if (classVibrator) {
mCancel = jni_env->GetMethodID (classVibrator, "cancel", "()V");
mVibrate = jni_env->GetMethodID (classVibrator, "vibrate", "(J)V");
mVibratePattern = jni_env->GetMethodID (classVibrator, "vibrate", "([JI)V");
}
}
}
cancel_vibration_timer.setSingleShot (true);
connect (&cancel_vibration_timer, SIGNAL (timeout ()), this, SLOT (cancelLoopedVibration ()));
}
static JavaVM *getJavaVM()
{
if (!g_javaVM){
QPlatformNativeInterface *nativeInterface = QGuiApplication::platformNativeInterface();
g_javaVM = static_cast<JavaVM*>(nativeInterface->nativeResourceForIntegration("JavaVM"));
}
return g_javaVM;
}
static void enableMacToolBar(QToolBar *toolbar, bool enable)
{
QPlatformNativeInterface *nativeInterface = QApplication::platformNativeInterface();
QPlatformNativeInterface::NativeResourceForIntegrationFunction function =
nativeInterface->nativeResourceFunctionForIntegration("setContentBorderAreaEnabled");
if (!function)
return; // Not Cocoa platform plugin.
typedef void (*SetContentBorderAreaEnabledFunction)(QWindow *window, void *identifier, bool enabled);
(reinterpret_cast<SetContentBorderAreaEnabledFunction>(function))(toolbar->window()->windowHandle(), toolbar, enable);
}
void InputRegionPrivate::update()
{
Q_Q(InputRegion);
q->killTimer(updateTimerId);
updateTimerId = 0;
if (window && window->handle()) {
QPlatformNativeInterface *native = QGuiApplication::platformNativeInterface();
native->setWindowProperty(window->handle(), QLatin1String("MOUSE_REGION"), QVariant(QRegion(x, y, width, height)));
}
}
inline static Display* x11Display() {
// Qt 5 does not support QX11Info.
#if QT_VERSION >= 0x050000
// references: https://github.com/hawaii-desktop/libkdeqt5staging/blob/master/src/qt5only/qx11info.cpp
QPlatformNativeInterface* native = qApp->platformNativeInterface();
void* display = native->nativeResourceForScreen(QByteArray("display"), QGuiApplication::primaryScreen());
return reinterpret_cast<Display*>(display);
#else
return QX11Info::display();
#endif
}
/*------------------------------------------------------------------------------
| get_egl_display
+-----------------------------------------------------------------------------*/
EGLDisplay get_egl_display()
{
QPlatformNativeInterface* nativeInterface =
QGuiApplicationPrivate::platformIntegration()->nativeInterface();
Q_ASSERT(nativeInterface);
EGLDisplay d = nativeInterface->nativeResourceForIntegration("egldisplay");
if (!d)
log_warn("Couldn't get EGL display handle.");
return d;
}
GraphicsSurfacePrivate(const PlatformGraphicsContext3D shareContext = 0)
: m_display(0)
, m_xPixmap(0)
, m_glxPixmap(0)
, m_glContext(0)
, m_detachedContext(0)
, m_detachedSurface(0)
, m_textureIsYInverted(false)
, m_hasAlpha(false)
{
GLXContext shareContextObject = 0;
m_display = XOpenDisplay(0);
#if PLATFORM(QT)
if (shareContext) {
#if 0
// This code path requires QXcbNativeInterface::nativeResourceForContext() which is not availble in Qt5 on the build bots yet.
QPlatformNativeInterface* nativeInterface = QGuiApplication::platformNativeInterface();
shareContextObject = static_cast<GLXContext>(nativeInterface->nativeResourceForContext(QByteArrayLiteral("glxcontext"), shareContext));
if (!shareContextObject)
return;
#else
// This code path should be removed as soon as QXcbNativeInterface::nativeResourceForContext() can provide the GLXContext.
QOpenGLContext* previousContext = QOpenGLContext::currentContext();
QSurface* previousSurface = previousContext->surface();
QSurface* currentSurface = shareContext->surface();
shareContext->makeCurrent(currentSurface);
shareContextObject = glXGetCurrentContext();
previousContext->makeCurrent(previousSurface);
#endif
}
#endif
m_display = m_offScreenWindow.display();
int attributes[] = {
GLX_LEVEL, 0,
GLX_DRAWABLE_TYPE, GLX_WINDOW_BIT,
GLX_RENDER_TYPE, GLX_RGBA_BIT,
GLX_RED_SIZE, 1,
GLX_GREEN_SIZE, 1,
GLX_BLUE_SIZE, 1,
GLX_DOUBLEBUFFER, True,
None
};
int numReturned;
m_fbConfigs = glXChooseFBConfig(m_display, DefaultScreen(m_display), attributes, &numReturned);
// Create a GLX context for OpenGL rendering
m_glContext = glXCreateNewContext(m_display, m_fbConfigs[0], GLX_RGBA_TYPE, shareContextObject, true);
}
void GLWidget::makeObject()
{
static const int coords[6][4][3] = {
{ { +1, -1, -1 }, { -1, -1, -1 }, { -1, +1, -1 }, { +1, +1, -1 } },
{ { +1, +1, -1 }, { -1, +1, -1 }, { -1, +1, +1 }, { +1, +1, +1 } },
{ { +1, -1, +1 }, { +1, -1, -1 }, { +1, +1, -1 }, { +1, +1, +1 } },
{ { -1, -1, -1 }, { -1, -1, +1 }, { -1, +1, +1 }, { -1, +1, -1 } },
{ { +1, -1, +1 }, { -1, -1, +1 }, { -1, -1, -1 }, { +1, -1, -1 } },
{ { -1, -1, +1 }, { +1, -1, +1 }, { +1, +1, +1 }, { -1, +1, +1 } }
};
QElapsedTimer timer;
timer.start();
#ifndef DISABLED_OPENMAX
//loadWithOmx();
QPlatformNativeInterface* nativeInterface = QGuiApplicationPrivate::platformIntegration()->nativeInterface();
Q_ASSERT(nativeInterface);
EGLDisplay eglDisplay = nativeInterface->nativeResourceForIntegration("egldisplay");
EGLContext eglContext = nativeInterface->nativeResourceForContext("eglcontext", QOpenGLContext::currentContext());
#if 0
eglImageVideo = getEGLImage(1920, 1080, eglDisplay, eglContext, textures[0]);
#endif
for (int i = 0; i < 5; i++)
textures[i] = 0;
//QtConcurrent::run(video_decode_test, videoPath, eglImageVideo, eglDisplay);
m_videoProc = new OMX_VideoProcessor(eglDisplay, eglContext, m_provider);
connect(m_videoProc, SIGNAL(textureReady(uint)), this, SLOT(onTextureChanged(uint)));
m_videoProc->setVideoPath("/home/pi/out.h264");
m_videoProc->play();
#else
for (int i = 0; i < 6; i++) {
QPixmap pixmap(QString("%1%2.jpg").arg(prefix).arg(i));
if (pixmap.isNull())
LOG_ERROR(LOG_TAG, "Failed to load image!");
textures[i] = bindTexture(pixmap, GL_TEXTURE_2D, GL_RGBA);
}
#endif
LOG_INFORMATION(LOG_TAG, "Elapsed: %lld.", timer.elapsed());
for (int i = 0; i < 6; ++i) {
for (int j = 0; j < 4; ++j) {
texCoords.append
(QVector2D(j == 0 || j == 3, j == 0 || j == 1));
vertices.append
(QVector3D(0.2 * coords[i][j][0], 0.2 * coords[i][j][1],
0.2 * coords[i][j][2]));
}
}
}
HRESULT STDMETHODCALLTYPE QWindowsAccessible::GetWindow(HWND *phwnd)
{
*phwnd = 0;
if (!accessible->isValid())
return E_UNEXPECTED;
QWindow *window = window_helper(accessible);
if (!window)
return E_FAIL;
QPlatformNativeInterface *platform = QGuiApplication::platformNativeInterface();
Q_ASSERT(platform);
*phwnd = (HWND)platform->nativeResourceForWindow("handle", window);
return S_OK;
}
OMX_TextureData* OMX_TextureProviderQGLWidget::instantiateTexture(QSize size)
{
// TODO: Reimplement.
#if 0
m_parent->makeCurrent();
QPlatformNativeInterface* nativeInterface = QGuiApplicationPrivate::platformIntegration()->nativeInterface();
Q_ASSERT(nativeInterface);
EGLDisplay eglDisplay = nativeInterface->nativeResourceForIntegration("egldisplay");
EGLContext eglContext = nativeInterface->nativeResourceForContext("eglcontext", QOpenGLContext::currentContext());
GLuint texture;
eglImageVideo = getEGLImage(size.width(), size.height(), eglDisplay, eglContext, texture);
return texture;
#endif
return 0;
}
QHimePlatformInputContext::QHimePlatformInputContext()
{
dbg("QHimePlatformInputContext::QHimePlatformInputContext() \n");
QPlatformNativeInterface *native = QGuiApplication::platformNativeInterface();
if(!native)
return;
Display *display = static_cast<Display *>(native->nativeResourceForWindow("display", NULL));
if (!(hime_ch = hime_im_client_open(display))) {
perror("cannot open hime_ch");
dbg("hime_im_client_open error\n");
return;
}
dbg("QHimePlatformInputContext succ\n");
}
void XCompositeEglClientBufferIntegration::initializeHardware(QtWayland::Display *)
{
QPlatformNativeInterface *nativeInterface = QGuiApplication::platformNativeInterface();
if (nativeInterface) {
mDisplay = static_cast<Display *>(nativeInterface->nativeResourceForIntegration("Display"));
if (!mDisplay)
qFatal("could not retrieve Display from platform integration");
mEglDisplay = static_cast<EGLDisplay>(nativeInterface->nativeResourceForIntegration("EGLDisplay"));
if (!mEglDisplay)
qFatal("could not retrieve EGLDisplay from platform integration");
} else {
qFatal("Platform integration doesn't have native interface");
}
mScreen = XDefaultScreen(mDisplay);
new XCompositeHandler(m_compositor->handle(), mDisplay);
}
/*------------------------------------------------------------------------------
| get_egl_context
+-----------------------------------------------------------------------------*/
EGLContext get_global_egl_context()
{
QOpenGLContext* c = QOpenGLContext::globalShareContext();
if (!c)
return (void*)log_warn("Cannot get an OpenGL context.");
QPlatformNativeInterface* nativeInterface =
QGuiApplicationPrivate::platformIntegration()->nativeInterface();
Q_ASSERT(nativeInterface);
EGLContext eglc =
nativeInterface->nativeResourceForContext("eglcontext", c);
if (!eglc)
log_warn("Couldn't get EGL context from currrent OpenGL context.");
return eglc;
}
Compositor *Compositor::fromApplication(QObject *parent)
{
if (!QGuiApplication::platformName().contains(QStringLiteral("wayland"), Qt::CaseInsensitive)) {
return nullptr;
}
QPlatformNativeInterface *native = qApp->platformNativeInterface();
if (!native) {
return nullptr;
}
wl_compositor *compositor = reinterpret_cast<wl_compositor*>(native->nativeResourceForIntegration(QByteArrayLiteral("compositor")));
if (!compositor) {
return nullptr;
}
Compositor *c = new Compositor(parent);
c->d->compositor.setup(compositor, true);
return c;
}
/**************************************************************\
* IOleWindow *
**************************************************************/
HRESULT STDMETHODCALLTYPE QWindowsMsaaAccessible::GetWindow(HWND *phwnd)
{
*phwnd = 0;
QAccessibleInterface *accessible = accessibleInterface();
accessibleDebugClientCalls(accessible);
if (!accessible)
return E_FAIL;
QWindow *window = QWindowsAccessibility::windowHelper(accessible);
if (!window)
return E_FAIL;
QPlatformNativeInterface *platform = QGuiApplication::platformNativeInterface();
Q_ASSERT(platform);
*phwnd = (HWND)platform->nativeResourceForWindow("handle", window);
accessibleDebug("QWindowsAccessible::GetWindow(): %p", *phwnd);
return S_OK;
}
Surface *Surface::fromQt(QWindow *window, QObject *parent)
{
if (!QGuiApplication::platformName().startsWith(QLatin1String("wayland")))
return Q_NULLPTR;
QPlatformNativeInterface *native = QGuiApplication::platformNativeInterface();
if (!native)
return Q_NULLPTR;
wl_surface *surface = reinterpret_cast<wl_surface *>(
native->nativeResourceForWindow(QByteArrayLiteral("surface"), window));
if (!surface)
return Q_NULLPTR;
Surface *s = new Surface(parent);
SurfacePrivate::get(s)->init(surface);
return s;
}
void GLWidget::loadWithOmx()
{
LOG_VERBOSE(LOG_TAG, "Loading with OMX.");
QPlatformNativeInterface* nativeInterface = QGuiApplicationPrivate::platformIntegration()->nativeInterface();
Q_ASSERT(nativeInterface);
EGLDisplay eglDisplay = nativeInterface->nativeResourceForIntegration("egldisplay");
EGLContext eglContext = nativeInterface->nativeResourceForContext("eglcontext", QOpenGLContext::currentContext());
for (int i = 5; i < 6; i++) {
QString fileAbsPath = QString("%1%2.jpg").arg(prefix).arg(i);
OpenMAXILTextureLoader* omTextureLoader = OpenMAXILTextureLoader::intance();
if (!omTextureLoader->loadTextureFromImage(fileAbsPath, eglDisplay, eglContext, textures[i])) {
LOG_ERROR(LOG_TAG, "Failed to load image.");
}
else {
LOG_INFORMATION(LOG_TAG, "Image %s successfully decoded and loaded.", qPrintable(fileAbsPath));
}
}
}
void MouseTouchAdaptor::fetchXInput2Info()
{
QPlatformNativeInterface *nativeInterface = qGuiApp->platformNativeInterface();
Display *xDisplay = static_cast<Display*>(nativeInterface->nativeResourceForIntegration("Display"));
if (xDisplay && XQueryExtension(xDisplay, "XInputExtension", &m_xiOpCode, &m_xiEventBase, &m_xiErrorBase)) {
int xiMajor = 2;
m_xi2Minor = 2; // try 2.2 first, needed for TouchBegin/Update/End
if (XIQueryVersion(xDisplay, &xiMajor, &m_xi2Minor) == BadRequest) {
m_xi2Minor = 1; // for smooth scrolling 2.1 is enough
if (XIQueryVersion(xDisplay, &xiMajor, &m_xi2Minor) == BadRequest) {
m_xi2Minor = 0; // for tablet support 2.0 is enough
m_xi2Enabled = XIQueryVersion(xDisplay, &xiMajor, &m_xi2Minor) != BadRequest;
} else
m_xi2Enabled = true;
} else {
m_xi2Enabled = true;
}
}
}
GVRInterface::GVRInterface(int argc, char* argv[]) :
QApplication(argc, argv),
_mainWindow(NULL),
_inVRMode(false)
{
setApplicationName("gvr-interface");
setOrganizationName("highfidelity");
setOrganizationDomain("io");
if (!launchURLString.isEmpty()) {
// did we get launched with a lookup URL? If so it is time to give that to the AddressManager
qDebug() << "We were opened via a hifi URL -" << launchURLString;
}
_client = new RenderingClient(this, launchURLString);
launchURLString = QString();
connect(this, &QGuiApplication::applicationStateChanged, this, &GVRInterface::handleApplicationStateChange);
#if defined(ANDROID) && defined(HAVE_LIBOVR)
QAndroidJniEnvironment jniEnv;
QPlatformNativeInterface* interface = QApplication::platformNativeInterface();
jobject activity = (jobject) interface->nativeResourceForIntegration("QtActivity");
ovr_RegisterHmtReceivers(&*jniEnv, activity);
// PLATFORMACTIVITY_REMOVAL: Temp workaround for PlatformActivity being
// stripped from UnityPlugin. Alternate is to use LOCAL_WHOLE_STATIC_LIBRARIES
// but that increases the size of the plugin by ~1MiB
OVR::linkerPlatformActivity++;
#endif
// call our idle function whenever we can
QTimer* idleTimer = new QTimer(this);
connect(idleTimer, &QTimer::timeout, this, &GVRInterface::idle);
idleTimer->start(0);
// call our quit handler before we go down
connect(this, &QCoreApplication::aboutToQuit, this, &GVRInterface::handleApplicationQuit);
}
int main(int argc, char *argv[])
{
QScopedPointer<QGuiApplication> app (SailfishApp::application(argc, argv));
QScopedPointer<QQuickView> view (SailfishApp::createView());
MGConfItem partnerSpaceQml (PARTNERSPACEMANAGER_QML_DCONF);
QString qmlFile = partnerSpaceQml.value(QString()).toString();
if (qmlFile.isEmpty()) {
return 1;
}
qDebug() << "Running partner-space launcher with" << qmlFile;
view->setSource(QUrl(qmlFile));
// The view is a partner window
view->create();
QPlatformNativeInterface *native = QGuiApplication::platformNativeInterface();
native->setWindowProperty(view->handle(), QLatin1String("CATEGORY"), QString(QLatin1String("partner")));
view->show();
return app->exec();
}
GraphicsSurfacePrivate(const PlatformGraphicsContext3D shareContext = 0)
: m_display(m_offScreenWindow.display())
, m_xPixmap(0)
, m_glxPixmap(0)
, m_surface(0)
, m_glxSurface(0)
, m_glContext(0)
, m_detachedContext(0)
, m_detachedSurface(0)
, m_fbConfig(0)
, m_textureIsYInverted(false)
, m_hasAlpha(false)
, m_isReceiver(false)
{
GLXContext shareContextObject = 0;
#if PLATFORM(QT)
if (shareContext) {
QPlatformNativeInterface* nativeInterface = QGuiApplication::platformNativeInterface();
shareContextObject = static_cast<GLXContext>(nativeInterface->nativeResourceForContext(QByteArrayLiteral("glxcontext"), shareContext));
if (!shareContextObject)
return;
}
#else
UNUSED_PARAM(shareContext);
#endif
int numReturned;
GLXFBConfig* fbConfigs = glXChooseFBConfig(m_display, DefaultScreen(m_display), attributes, &numReturned);
// Make sure that we choose a configuration that supports an alpha mask.
m_fbConfig = findFBConfigWithAlpha(fbConfigs, numReturned);
XFree(fbConfigs);
// Create a GLX context for OpenGL rendering
m_glContext = glXCreateNewContext(m_display, m_fbConfig, GLX_RGBA_TYPE, shareContextObject, true);
}
QSGNode* OMX_MediaProcessorElement::updatePaintNode(QSGNode*, UpdatePaintNodeData*)
{
if (!m_texProvider) {
m_texProvider = new OMX_TextureProviderQQuickItem(this);
m_mediaProc = new OMX_MediaProcessor(m_texProvider);
connect(m_mediaProc, SIGNAL(playbackCompleted()), this, SIGNAL(playbackCompleted()));
connect(m_mediaProc, SIGNAL(playbackStarted()), this, SIGNAL(playbackStarted()));
// Open if filepath is set.
// TODO: Handle errors.
if (!m_source.isNull()) {
//if (QFile(m_source).exists()) {
if (openMedia(m_source))
m_mediaProc->play();
//}
//else {
LOG_WARNING(LOG_TAG, "File does not exist.");
//}
}
}
return NULL;
#if 0
QSGGeometryNode* node = 0;
QSGGeometry* geometry = 0;
if (!oldNode) {
// Create the node.
node = new QSGGeometryNode;
geometry = new QSGGeometry(QSGGeometry::defaultAttributes_TexturedPoint2D(), 4);
geometry->setDrawingMode(GL_TRIANGLE_STRIP);
node->setGeometry(geometry);
node->setFlag(QSGNode::OwnsGeometry);
// TODO: Who is freeing this?
// TODO: I cannot know the texture size here.
QSGOpaqueTextureMaterial* material = new QSGOpaqueTextureMaterial;
m_sgtexture = new OMX_SGTexture(m_texture, QSize(1920, 1080));
material->setTexture(m_sgtexture);
node->setMaterial(material);
node->setFlag(QSGNode::OwnsMaterial);
#ifdef ENABLE_VIDEO_PROCESSOR
QPlatformNativeInterface* nativeInterface =
QGuiApplicationPrivate::platformIntegration()->nativeInterface();
Q_ASSERT(nativeInterface);
EGLDisplay eglDisplay = nativeInterface->nativeResourceForIntegration("egldisplay");
EGLContext eglContext = nativeInterface->nativeResourceForContext(
"eglcontext",
QOpenGLContext::currentContext()
);
#endif
// Provider MUST be built in this thread.
m_provider = new OMX_TextureProviderQQuickItem(this);
#ifdef ENABLE_VIDEO_PROCESSOR
m_videoProc = new OMX_VideoProcessor(eglDisplay, eglContext, m_provider);
connect(m_videoProc, SIGNAL(textureReady(uint)), this, SLOT(onTextureChanged(uint)));
if (!m_source.isNull())
m_videoProc->setVideoPath(m_source);
if (m_playScheduled) {
m_timer->start(30);
m_videoProc->play();
}
#elif ENABLE_MEDIA_PROCESSOR
LOG_VERBOSE(LOG_TAG, "Starting video using media processor...");
m_mediaProc = new OMX_MediaProcessor(m_provider);
m_mediaProc->setFilename("/home/pi/usb/Cars2.mkv", m_texture);
//if (m_playScheduled) {
m_timer->start(40);
m_mediaProc->play();
//}
#else
LOG_VERBOSE(LOG_TAG, "Starting video...");
QtConcurrent::run(&startVideo, m_provider, this);
m_timer->start(30);
#endif
}
else {
node = static_cast<QSGGeometryNode*>(oldNode);
geometry = node->geometry();
geometry->allocate(4);
// Update texture in the node if needed.
QSGOpaqueTextureMaterial* material = (QSGOpaqueTextureMaterial*)node->material();
if (m_texture != (GLuint)material->texture()->textureId()) {
// TODO: Does setTextureId frees the prev texture?
// TODO: I should the given the texture size.
LOG_ERROR(LOG_TAG, "Updating texture to %u!", m_texture);
material = new QSGOpaqueTextureMaterial;
m_sgtexture->setTexture(m_texture, QSize(1920, 1080));
}
}
// Create the vertices and map to texture.
QRectF bounds = boundingRect();
QSGGeometry::TexturedPoint2D* vertices = geometry->vertexDataAsTexturedPoint2D();
vertices[0].set(bounds.x(), bounds.y() + bounds.height(), 0.0f, 0.0f);
vertices[1].set(bounds.x() + bounds.width(), bounds.y() + bounds.height(), 1.0f, 0.0f);
vertices[2].set(bounds.x(), bounds.y(), 0.0f, 1.0f);
vertices[3].set(bounds.x() + bounds.width(), bounds.y(), 1.0f, 1.0f);
return node;
#endif
}
void WaylandEglClientBufferIntegration::initializeHardware(QtWayland::Display *waylandDisplay)
{
Q_D(WaylandEglClientBufferIntegration);
const bool ignoreBindDisplay = !qgetenv("QT_WAYLAND_IGNORE_BIND_DISPLAY").isEmpty();
QPlatformNativeInterface *nativeInterface = QGuiApplication::platformNativeInterface();
if (!nativeInterface) {
qWarning("QtCompositor: Failed to initialize EGL display. No native platform interface available.");
return;
}
d->egl_display = nativeInterface->nativeResourceForWindow("EglDisplay", m_compositor->window());
if (!d->egl_display) {
qWarning("QtCompositor: Failed to initialize EGL display. Could not get EglDisplay for window.");
return;
}
const char *extensionString = eglQueryString(d->egl_display, EGL_EXTENSIONS);
if ((!extensionString || !strstr(extensionString, "EGL_WL_bind_wayland_display")) && !ignoreBindDisplay) {
qWarning("QtCompositor: Failed to initialize EGL display. There is no EGL_WL_bind_wayland_display extension.");
return;
}
d->egl_bind_wayland_display = reinterpret_cast<PFNEGLBINDWAYLANDDISPLAYWL>(eglGetProcAddress("eglBindWaylandDisplayWL"));
d->egl_unbind_wayland_display = reinterpret_cast<PFNEGLUNBINDWAYLANDDISPLAYWL>(eglGetProcAddress("eglUnbindWaylandDisplayWL"));
if ((!d->egl_bind_wayland_display || !d->egl_unbind_wayland_display) && !ignoreBindDisplay) {
qWarning("QtCompositor: Failed to initialize EGL display. Could not find eglBindWaylandDisplayWL and eglUnbindWaylandDisplayWL.");
return;
}
d->egl_query_wayland_buffer = reinterpret_cast<PFNEGLQUERYWAYLANDBUFFERWL_compat>(eglGetProcAddress("eglQueryWaylandBufferWL"));
if (!d->egl_query_wayland_buffer) {
qWarning("QtCompositor: Failed to initialize EGL display. Could not find eglQueryWaylandBufferWL.");
return;
}
d->egl_create_image = reinterpret_cast<PFNEGLCREATEIMAGEKHRPROC>(eglGetProcAddress("eglCreateImageKHR"));
d->egl_destroy_image = reinterpret_cast<PFNEGLDESTROYIMAGEKHRPROC>(eglGetProcAddress("eglDestroyImageKHR"));
if (!d->egl_create_image || !d->egl_destroy_image) {
qWarning("QtCompositor: Failed to initialize EGL display. Could not find eglCreateImageKHR and eglDestroyImageKHR.");
return;
}
d->gl_egl_image_target_texture_2d = reinterpret_cast<PFNGLEGLIMAGETARGETTEXTURE2DOESPROC>(eglGetProcAddress("glEGLImageTargetTexture2DOES"));
if (!d->gl_egl_image_target_texture_2d) {
qWarning("QtCompositor: Failed to initialize EGL display. Could not find glEGLImageTargetTexture2DOES.");
return;
}
if (d->egl_bind_wayland_display && d->egl_unbind_wayland_display) {
d->display_bound = d->egl_bind_wayland_display(d->egl_display, waylandDisplay->handle());
if (!d->display_bound) {
if (!ignoreBindDisplay) {
qWarning("QtCompositor: Failed to initialize EGL display. Could not bind Wayland display.");
return;
} else {
qWarning("QtCompositor: Could not bind Wayland display. Ignoring.");
}
}
}
d->valid = true;
}
void QWindowsAccessibility::notifyAccessibilityUpdate(QObject *o, int who, QAccessible::Event reason)
{
QString soundName;
switch (reason) {
case QAccessible::PopupMenuStart:
soundName = QLatin1String("MenuPopup");
break;
case QAccessible::MenuCommand:
soundName = QLatin1String("MenuCommand");
break;
case QAccessible::Alert:
{
/* ### FIXME
#ifndef QT_NO_MESSAGEBOX
QMessageBox *mb = qobject_cast<QMessageBox*>(o);
if (mb) {
switch (mb->icon()) {
case QMessageBox::Warning:
soundName = QLatin1String("SystemExclamation");
break;
case QMessageBox::Critical:
soundName = QLatin1String("SystemHand");
break;
case QMessageBox::Information:
soundName = QLatin1String("SystemAsterisk");
break;
default:
break;
}
} else
#endif // QT_NO_MESSAGEBOX
*/
{
soundName = QLatin1String("SystemAsterisk");
}
}
break;
default:
break;
}
if (!soundName.isEmpty()) {
#ifndef QT_NO_SETTINGS
QSettings settings(QLatin1String("HKEY_CURRENT_USER\\AppEvents\\Schemes\\Apps\\.Default\\") + soundName,
QSettings::NativeFormat);
QString file = settings.value(QLatin1String(".Current/.")).toString();
#else
QString file;
#endif
if (!file.isEmpty()) {
PlaySound(reinterpret_cast<const wchar_t *>(soundName.utf16()), 0, SND_ALIAS | SND_ASYNC | SND_NODEFAULT | SND_NOWAIT);
}
}
typedef void (WINAPI *PtrNotifyWinEvent)(DWORD, HWND, LONG, LONG);
#if defined(Q_WS_WINCE) // ### TODO: check for NotifyWinEvent in CE 6.0
// There is no user32.lib nor NotifyWinEvent for CE
return;
#else
static PtrNotifyWinEvent ptrNotifyWinEvent = 0;
static bool resolvedNWE = false;
if (!resolvedNWE) {
resolvedNWE = true;
ptrNotifyWinEvent = (PtrNotifyWinEvent)QSystemLibrary::resolve(QLatin1String("user32"), "NotifyWinEvent");
}
if (!ptrNotifyWinEvent)
return;
// An event has to be associated with a window,
// so find the first parent that is a widget and that has a WId
QAccessibleInterface *iface = QAccessible::queryAccessibleInterface(o);
QWindow *window = iface ? window_helper(iface) : 0;
if (!window) {
window = QGuiApplication::activeWindow();
if (!window)
return;
}
QPlatformNativeInterface *platform = QGuiApplication::platformNativeInterface();
HWND hWnd = (HWND)platform->nativeResourceForWindow("handle", window);
if (reason != QAccessible::MenuCommand) { // MenuCommand is faked
// See comment "SENDING EVENTS TO OBJECTS WITH NO WINDOW HANDLE"
eventNum %= 50; //[0..49]
int eventId = - eventNum - 1;
qAccessibleRecentSentEvents()->insert(eventId, qMakePair(o, who));
ptrNotifyWinEvent(reason, hWnd, OBJID_CLIENT, eventId );
++eventNum;
}
#endif // Q_WS_WINCE
}
/**
* Request the video to avoid the conflicts
**/
bool VideoWidget::request( struct vout_window_t *p_wnd )
{
if( stable )
{
msg_Dbg( p_intf, "embedded video already in use" );
return false;
}
assert( !p_window );
/* The owner of the video window needs a stable handle (WinId). Reparenting
* in Qt4-X11 changes the WinId of the widget, so we need to create another
* dummy widget that stays within the reparentable widget. */
stable = new QWidget();
QPalette plt = palette();
plt.setColor( QPalette::Window, Qt::black );
stable->setPalette( plt );
stable->setAutoFillBackground(true);
/* Force the widget to be native so that it gets a winId() */
stable->setAttribute( Qt::WA_NativeWindow, true );
/* Indicates that the widget wants to draw directly onto the screen.
Widgets with this attribute set do not participate in composition
management */
/* This is currently disabled on X11 as it does not seem to improve
* performance, but causes the video widget to be transparent... */
#if !defined (QT5_HAS_X11)
stable->setAttribute( Qt::WA_PaintOnScreen, true );
#else
stable->setMouseTracking( true );
setMouseTracking( true );
#endif
layout->addWidget( stable );
sync();
p_window = p_wnd;
p_wnd->type = p_intf->p_sys->voutWindowType;
switch( p_wnd->type )
{
case VOUT_WINDOW_TYPE_XID:
p_wnd->handle.xid = stable->winId();
p_wnd->display.x11 = NULL;
break;
case VOUT_WINDOW_TYPE_HWND:
p_wnd->handle.hwnd = (void *)stable->winId();
break;
case VOUT_WINDOW_TYPE_NSOBJECT:
p_wnd->handle.nsobject = (void *)stable->winId();
break;
#ifdef QT5_HAS_WAYLAND
case VOUT_WINDOW_TYPE_WAYLAND:
{
QWindow *window = stable->windowHandle();
assert(window != NULL);
window->create();
QPlatformNativeInterface *qni = qApp->platformNativeInterface();
assert(qni != NULL);
p_wnd->handle.wl = static_cast<wl_surface*>(
qni->nativeResourceForWindow(QByteArrayLiteral("surface"),
window));
p_wnd->display.wl = static_cast<wl_display*>(
qni->nativeResourceForIntegration(QByteArrayLiteral("wl_display")));
break;
}
#endif
default:
vlc_assert_unreachable();
}
return true;
}
void QWindowsAccessibility::notifyAccessibilityUpdate(QAccessibleEvent *event)
{
QString soundName;
switch (event->type()) {
case QAccessible::PopupMenuStart:
soundName = QLatin1String("MenuPopup");
break;
case QAccessible::MenuCommand:
soundName = QLatin1String("MenuCommand");
break;
case QAccessible::Alert:
soundName = event->object()->inherits("QMessageBox") ?
messageBoxAlertSound(event->object()) : QStringLiteral("SystemAsterisk");
break;
default:
break;
}
if (!soundName.isEmpty()) {
#ifndef QT_NO_SETTINGS
QSettings settings(QLatin1String("HKEY_CURRENT_USER\\AppEvents\\Schemes\\Apps\\.Default\\") + soundName,
QSettings::NativeFormat);
QString file = settings.value(QLatin1String(".Current/.")).toString();
#else
QString file;
#endif
if (!file.isEmpty()) {
PlaySound(reinterpret_cast<const wchar_t *>(soundName.utf16()), 0, SND_ALIAS | SND_ASYNC | SND_NODEFAULT | SND_NOWAIT);
}
}
#if defined(Q_OS_WINCE) // ### TODO: check for NotifyWinEvent in CE 6.0
// There is no user32.lib nor NotifyWinEvent for CE
return;
#else
// An event has to be associated with a window,
// so find the first parent that is a widget and that has a WId
QAccessibleInterface *iface = event->accessibleInterface();
if (!isActive() || !iface || !iface->isValid())
return;
QWindow *window = QWindowsAccessibility::windowHelper(iface);
if (!window) {
window = QGuiApplication::focusWindow();
if (!window)
return;
}
QPlatformNativeInterface *platform = QGuiApplication::platformNativeInterface();
if (!window->handle()) // Called before show(), no native window yet.
return;
HWND hWnd = (HWND)platform->nativeResourceForWindow("handle", window);
if (event->type() != QAccessible::MenuCommand && // MenuCommand is faked
event->type() != QAccessible::ObjectDestroyed) {
::NotifyWinEvent(event->type(), hWnd, OBJID_CLIENT, QAccessible::uniqueId(iface));
}
#endif // Q_OS_WINCE
}
void D3DPresentEngine::createOffscreenTexture()
{
// First, check if we have a context on this thread
QOpenGLContext *currentContext = QOpenGLContext::currentContext();
if (!currentContext) {
//Create OpenGL context and set share context from surface
QOpenGLContext *shareContext = qobject_cast<QOpenGLContext*>(m_surface->property("GLContext").value<QObject*>());
if (!shareContext)
return;
m_offscreenSurface = new QWindow;
m_offscreenSurface->setSurfaceType(QWindow::OpenGLSurface);
//Needs geometry to be a valid surface, but size is not important
m_offscreenSurface->setGeometry(-1, -1, 1, 1);
m_offscreenSurface->create();
m_glContext = new QOpenGLContext;
m_glContext->setFormat(m_offscreenSurface->requestedFormat());
m_glContext->setShareContext(shareContext);
if (!m_glContext->create()) {
delete m_glContext;
delete m_offscreenSurface;
m_glContext = 0;
m_offscreenSurface = 0;
return;
}
currentContext = m_glContext;
}
if (m_glContext)
m_glContext->makeCurrent(m_offscreenSurface);
if (!m_egl)
m_egl = new EGLWrapper;
QPlatformNativeInterface *nativeInterface = QGuiApplication::platformNativeInterface();
m_eglDisplay = static_cast<EGLDisplay*>(
nativeInterface->nativeResourceForContext("eglDisplay", currentContext));
m_eglConfig = static_cast<EGLConfig*>(
nativeInterface->nativeResourceForContext("eglConfig", currentContext));
currentContext->functions()->glGenTextures(1, &m_glTexture);
int w = m_surfaceFormat.frameWidth();
int h = m_surfaceFormat.frameHeight();
bool hasAlpha = currentContext->format().hasAlpha();
EGLint attribs[] = {
EGL_WIDTH, w,
EGL_HEIGHT, h,
EGL_TEXTURE_FORMAT, hasAlpha ? EGL_TEXTURE_RGBA : EGL_TEXTURE_RGB,
EGL_TEXTURE_TARGET, EGL_TEXTURE_2D,
EGL_NONE
};
EGLSurface pbuffer = m_egl->createPbufferSurface(m_eglDisplay, m_eglConfig, attribs);
HANDLE share_handle = 0;
PFNEGLQUERYSURFACEPOINTERANGLEPROC eglQuerySurfacePointerANGLE =
reinterpret_cast<PFNEGLQUERYSURFACEPOINTERANGLEPROC>(m_egl->getProcAddress("eglQuerySurfacePointerANGLE"));
Q_ASSERT(eglQuerySurfacePointerANGLE);
eglQuerySurfacePointerANGLE(
m_eglDisplay,
pbuffer,
EGL_D3D_TEXTURE_2D_SHARE_HANDLE_ANGLE, &share_handle);
m_device->CreateTexture(w, h, 1,
D3DUSAGE_RENDERTARGET,
hasAlpha ? D3DFMT_A8R8G8B8 : D3DFMT_X8R8G8B8,
D3DPOOL_DEFAULT,
&m_texture,
&share_handle);
m_eglSurface = pbuffer;
if (m_glContext)
m_glContext->doneCurrent();
}
GraphicsSurfacePrivate(const PlatformGraphicsContext3D shareContext, const IntSize& size, GraphicsSurface::Flags flags)
: m_context(0)
, m_size(size)
, m_frontBufferTexture(0)
, m_frontBufferReadTexture(0)
, m_backBufferTexture(0)
, m_backBufferReadTexture(0)
, m_readFbo(0)
, m_drawFbo(0)
{
#if PLATFORM(QT)
QPlatformNativeInterface* nativeInterface = QGuiApplication::platformNativeInterface();
CGLContextObj shareContextObject = static_cast<CGLContextObj>(nativeInterface->nativeResourceForContext(QByteArrayLiteral("cglContextObj"), shareContext));
if (!shareContextObject)
return;
CGLPixelFormatObj pixelFormatObject = CGLGetPixelFormat(shareContextObject);
if (kCGLNoError != CGLCreateContext(pixelFormatObject, shareContextObject, &m_context))
return;
CGLRetainContext(m_context);
#endif
unsigned pixelFormat = 'BGRA';
unsigned bytesPerElement = 4;
int width = m_size.width();
int height = m_size.height();
unsigned long bytesPerRow = IOSurfaceAlignProperty(kIOSurfaceBytesPerRow, width * bytesPerElement);
if (!bytesPerRow)
return;
unsigned long allocSize = IOSurfaceAlignProperty(kIOSurfaceAllocSize, height * bytesPerRow);
if (!allocSize)
return;
const void *keys[6];
const void *values[6];
keys[0] = kIOSurfaceWidth;
values[0] = CFNumberCreate(0, kCFNumberIntType, &width);
keys[1] = kIOSurfaceHeight;
values[1] = CFNumberCreate(0, kCFNumberIntType, &height);
keys[2] = kIOSurfacePixelFormat;
values[2] = CFNumberCreate(0, kCFNumberIntType, &pixelFormat);
keys[3] = kIOSurfaceBytesPerElement;
values[3] = CFNumberCreate(0, kCFNumberIntType, &bytesPerElement);
keys[4] = kIOSurfaceBytesPerRow;
values[4] = CFNumberCreate(0, kCFNumberLongType, &bytesPerRow);
keys[5] = kIOSurfaceAllocSize;
values[5] = CFNumberCreate(0, kCFNumberLongType, &allocSize);
CFDictionaryRef dict = CFDictionaryCreate(0, keys, values, 6, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);
for (unsigned i = 0; i < 6; i++)
CFRelease(values[i]);
m_frontBuffer = IOSurfaceCreate(dict);
m_backBuffer = IOSurfaceCreate(dict);
if (!(flags & GraphicsSurface::SupportsSharing))
return;
m_token = GraphicsSurfaceToken(IOSurfaceCreateMachPort(m_frontBuffer), IOSurfaceCreateMachPort(m_backBuffer));
}