/**************************************************************************** ** ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies). ** All rights reserved. ** Contact: Nokia Corporation (qt-info@nokia.com) ** ** This file is part of the QtGui module of the Qt Toolkit. ** ** $QT_BEGIN_LICENSE:LGPL$ ** No Commercial Usage ** This file contains pre-release code and may not be distributed. ** You may use this file in accordance with the terms and conditions ** contained in the Technology Preview License Agreement accompanying ** this package. ** ** 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 as published by the Free Software ** Foundation and appearing in the file LICENSE.LGPL included in the ** packaging of this file. Please review the following information to ** ensure the GNU Lesser General Public License version 2.1 requirements ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. ** ** In addition, as a special exception, Nokia gives you certain additional ** rights. These rights are described in the Nokia Qt LGPL Exception ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. ** ** If you have questions regarding the use of this file, please contact ** Nokia at qt-info@nokia.com. ** ** ** ** ** ** ** ** ** $QT_END_LICENSE$ ** ****************************************************************************/ #include #include #include #include #include "qegl_p.h" #include "qeglcontext_p.h" QT_BEGIN_NAMESPACE // Current GL and VG contexts. These are used to determine if // we can avoid an eglMakeCurrent() after a call to lazyDoneCurrent(). // If a background thread modifies the value, the worst that will // happen is a redundant eglMakeCurrent() in the foreground thread. static QEglContext * volatile currentGLContext = 0; static QEglContext * volatile currentVGContext = 0; QEglContext::QEglContext() : apiType(QEgl::OpenGL) , ctx(EGL_NO_CONTEXT) , cfg(0) , currentSurface(EGL_NO_SURFACE) , current(false) , ownsContext(true) , sharing(false) { } QEglContext::~QEglContext() { destroyContext(); if (currentGLContext == this) currentGLContext = 0; if (currentVGContext == this) currentVGContext = 0; } bool QEglContext::isValid() const { return (ctx != EGL_NO_CONTEXT); } bool QEglContext::isCurrent() const { return current; } EGLConfig QEgl::defaultConfig(int devType, API api, ConfigOptions options) { if ( (devType != QInternal::Pixmap) && ((options & Renderable) == 0)) qWarning("QEgl::defaultConfig() - Only configs for pixmaps make sense to be read-only!"); EGLConfig* targetConfig = 0; static EGLConfig defaultVGConfigs[] = { QEGL_NO_CONFIG, // 0 Window Renderable Translucent QEGL_NO_CONFIG, // 1 Window Renderable Opaque QEGL_NO_CONFIG, // 2 Pixmap Renderable Translucent QEGL_NO_CONFIG, // 3 Pixmap Renderable Opaque QEGL_NO_CONFIG, // 4 Pixmap ReadOnly Translucent QEGL_NO_CONFIG // 5 Pixmap ReadOnly Opaque }; if (api == OpenVG) { if (devType == QInternal::Widget) { if (options & Translucent) targetConfig = &(defaultVGConfigs[0]); else targetConfig = &(defaultVGConfigs[1]); } else if (devType == QInternal::Pixmap) { if (options & Renderable) { if (options & Translucent) targetConfig = &(defaultVGConfigs[2]); else // Opaque targetConfig = &(defaultVGConfigs[3]); } else { // Read-only if (options & Translucent) targetConfig = &(defaultVGConfigs[4]); else // Opaque targetConfig = &(defaultVGConfigs[5]); } } } static EGLConfig defaultGLConfigs[] = { QEGL_NO_CONFIG, // 0 Window Renderable Translucent QEGL_NO_CONFIG, // 1 Window Renderable Opaque QEGL_NO_CONFIG, // 2 PBuffer Renderable Translucent QEGL_NO_CONFIG, // 3 PBuffer Renderable Opaque QEGL_NO_CONFIG, // 4 Pixmap Renderable Translucent QEGL_NO_CONFIG, // 5 Pixmap Renderable Opaque QEGL_NO_CONFIG, // 6 Pixmap ReadOnly Translucent QEGL_NO_CONFIG // 7 Pixmap ReadOnly Opaque }; if (api == OpenGL) { if (devType == QInternal::Widget) { if (options & Translucent) targetConfig = &(defaultGLConfigs[0]); else // Opaque targetConfig = &(defaultGLConfigs[1]); } else if (devType == QInternal::Pbuffer) { if (options & Translucent) targetConfig = &(defaultGLConfigs[2]); else // Opaque targetConfig = &(defaultGLConfigs[3]); } else if (devType == QInternal::Pixmap) { if (options & Renderable) { if (options & Translucent) targetConfig = &(defaultGLConfigs[4]); else // Opaque targetConfig = &(defaultGLConfigs[5]); } else { // ReadOnly if (options & Translucent) targetConfig = &(defaultGLConfigs[6]); else // Opaque targetConfig = &(defaultGLConfigs[7]); } } } if (!targetConfig) { qWarning("QEgl::defaultConfig() - No default config for device/api/options combo"); return QEGL_NO_CONFIG; } if (*targetConfig != QEGL_NO_CONFIG) return *targetConfig; // We haven't found an EGL config for the target config yet, so do it now: // Allow overriding from an environment variable: QByteArray configId; if (api == OpenVG) configId = qgetenv("QT_VG_EGL_CONFIG"); else configId = qgetenv("QT_GL_EGL_CONFIG"); if (!configId.isEmpty()) { // Overriden, so get the EGLConfig for the specified config ID: EGLint properties[] = { EGL_CONFIG_ID, (EGLint)configId.toInt(), EGL_NONE }; EGLint configCount = 0; eglChooseConfig(display(), properties, targetConfig, 1, &configCount); if (configCount > 0) return *targetConfig; qWarning() << "QEgl::defaultConfig() -" << configId << "appears to be invalid"; } QEglProperties configAttribs; configAttribs.setRenderableType(api); EGLint surfaceType; switch (devType) { case QInternal::Widget: surfaceType = EGL_WINDOW_BIT; break; case QInternal::Pixmap: surfaceType = EGL_PIXMAP_BIT; break; case QInternal::Pbuffer: surfaceType = EGL_PBUFFER_BIT; break; default: qWarning("QEgl::defaultConfig() - Can't create EGL surface for %d device type", devType); return QEGL_NO_CONFIG; }; #ifdef EGL_VG_ALPHA_FORMAT_PRE_BIT // For OpenVG, we try to create a surface using a pre-multiplied format if // the surface needs to have an alpha channel: if (api == OpenVG && (options & Translucent)) surfaceType |= EGL_VG_ALPHA_FORMAT_PRE_BIT; #endif configAttribs.setValue(EGL_SURFACE_TYPE, surfaceType); #ifdef EGL_BIND_TO_TEXTURE_RGBA if (devType == QInternal::Pixmap || devType == QInternal::Pbuffer) { if (options & Translucent) configAttribs.setValue(EGL_BIND_TO_TEXTURE_RGBA, EGL_TRUE); else configAttribs.setValue(EGL_BIND_TO_TEXTURE_RGB, EGL_TRUE); } #endif // Add paint engine requirements if (api == OpenVG) { #ifndef QVG_SCISSOR_CLIP configAttribs.setValue(EGL_ALPHA_MASK_SIZE, 1); #endif } else { // Both OpenGL paint engines need to have stencil and sample buffers configAttribs.setValue(EGL_STENCIL_SIZE, 1); configAttribs.setValue(EGL_SAMPLE_BUFFERS, 1); #ifndef QT_OPENGL_ES_2 // Aditionally, the GL1 engine likes to have a depth buffer for clipping configAttribs.setValue(EGL_DEPTH_SIZE, 1); #endif } if (options & Translucent) configAttribs.setValue(EGL_ALPHA_SIZE, 1); *targetConfig = chooseConfig(&configAttribs, QEgl::BestPixelFormat); return *targetConfig; } // Choose a configuration that matches "properties". EGLConfig QEgl::chooseConfig(const QEglProperties* properties, QEgl::PixelFormatMatch match) { QEglProperties props(*properties); EGLConfig cfg = QEGL_NO_CONFIG; do { // Get the number of matching configurations for this set of properties. EGLint matching = 0; EGLDisplay dpy = QEgl::display(); if (!eglChooseConfig(dpy, props.properties(), 0, 0, &matching) || !matching) continue; // If we want the best pixel format, then return the first // matching configuration. if (match == QEgl::BestPixelFormat) { eglChooseConfig(display(), props.properties(), &cfg, 1, &matching); if (matching < 1) continue; return cfg; } // Fetch all of the matching configurations and find the // first that matches the pixel format we wanted. EGLint size = matching; EGLConfig *configs = new EGLConfig [size]; eglChooseConfig(display(), props.properties(), configs, size, &matching); for (EGLint index = 0; index < size; ++index) { EGLint red, green, blue, alpha; eglGetConfigAttrib(display(), configs[index], EGL_RED_SIZE, &red); eglGetConfigAttrib(display(), configs[index], EGL_GREEN_SIZE, &green); eglGetConfigAttrib(display(), configs[index], EGL_BLUE_SIZE, &blue); eglGetConfigAttrib(display(), configs[index], EGL_ALPHA_SIZE, &alpha); if (red == props.value(EGL_RED_SIZE) && green == props.value(EGL_GREEN_SIZE) && blue == props.value(EGL_BLUE_SIZE) && (props.value(EGL_ALPHA_SIZE) == 0 || alpha == props.value(EGL_ALPHA_SIZE))) { cfg = configs[index]; delete [] configs; return cfg; } } delete [] configs; } while (props.reduceConfiguration()); #ifdef EGL_BIND_TO_TEXTURE_RGBA // Don't report an error just yet if we failed to get a pbuffer // configuration with texture rendering. Only report failure if // we cannot get any pbuffer configurations at all. if (props.value(EGL_BIND_TO_TEXTURE_RGBA) == EGL_DONT_CARE && props.value(EGL_BIND_TO_TEXTURE_RGB) == EGL_DONT_CARE) #endif { qWarning() << "QEglContext::chooseConfig(): Could not find a suitable EGL configuration"; qWarning() << "Requested:" << props.toString(); qWarning() << "Available:"; QEgl::dumpAllConfigs(); } return QEGL_NO_CONFIG; } bool QEglContext::chooseConfig(const QEglProperties& properties, QEgl::PixelFormatMatch match) { cfg = QEgl::chooseConfig(&properties, match); return cfg != QEGL_NO_CONFIG; } EGLSurface QEglContext::createSurface(QPaintDevice* device, const QEglProperties *properties) { return QEgl::createSurface(device, cfg, properties); } // Create the EGLContext. bool QEglContext::createContext(QEglContext *shareContext, const QEglProperties *properties) { // We need to select the correct API before calling eglCreateContext(). #ifdef EGL_OPENGL_ES_API if (apiType == QEgl::OpenGL) eglBindAPI(EGL_OPENGL_ES_API); #endif #ifdef EGL_OPENVG_API if (apiType == QEgl::OpenVG) eglBindAPI(EGL_OPENVG_API); #endif // Create a new context for the configuration. QEglProperties contextProps; if (properties) contextProps = *properties; #if defined(QT_OPENGL_ES_2) if (apiType == QEgl::OpenGL) contextProps.setValue(EGL_CONTEXT_CLIENT_VERSION, 2); #endif sharing = false; if (shareContext && shareContext->ctx == EGL_NO_CONTEXT) shareContext = 0; if (shareContext) { ctx = eglCreateContext(QEgl::display(), cfg, shareContext->ctx, contextProps.properties()); if (ctx == EGL_NO_CONTEXT) { qWarning() << "QEglContext::createContext(): Could not share context:" << QEgl::errorString(); shareContext = 0; } else { sharing = true; } } if (ctx == EGL_NO_CONTEXT) { ctx = eglCreateContext(display(), cfg, 0, contextProps.properties()); if (ctx == EGL_NO_CONTEXT) { qWarning() << "QEglContext::createContext(): Unable to create EGL context:" << QEgl::errorString(); return false; } } return true; } // Destroy an EGL surface object. If it was current on this context // then call doneCurrent() for it first. void QEglContext::destroySurface(EGLSurface surface) { if (surface != EGL_NO_SURFACE) { if (surface == currentSurface) doneCurrent(); eglDestroySurface(display(), surface); } } // Destroy the context. Note: this does not destroy the surface. void QEglContext::destroyContext() { if (ctx != EGL_NO_CONTEXT && ownsContext) eglDestroyContext(display(), ctx); ctx = EGL_NO_CONTEXT; cfg = 0; } bool QEglContext::makeCurrent(EGLSurface surface) { if (ctx == EGL_NO_CONTEXT) { qWarning() << "QEglContext::makeCurrent(): Cannot make invalid context current"; return false; } // If lazyDoneCurrent() was called on the surface, then we may be able // to assume that it is still current within the thread. if (surface == currentSurface && currentContext(apiType) == this) { current = true; return true; } current = true; currentSurface = surface; setCurrentContext(apiType, this); // Force the right API to be bound before making the context current. // The EGL implementation should be able to figure this out from ctx, // but some systems require the API to be explicitly set anyway. #ifdef EGL_OPENGL_ES_API if (apiType == QEgl::OpenGL) eglBindAPI(EGL_OPENGL_ES_API); #endif #ifdef EGL_OPENVG_API if (apiType == QEgl::OpenVG) eglBindAPI(EGL_OPENVG_API); #endif bool ok = eglMakeCurrent(QEgl::display(), surface, surface, ctx); if (!ok) qWarning() << "QEglContext::makeCurrent():" << QEgl::errorString(); return ok; } bool QEglContext::doneCurrent() { // If the context is invalid, we assume that an error was reported // when makeCurrent() was called. if (ctx == EGL_NO_CONTEXT) return false; current = false; currentSurface = EGL_NO_SURFACE; setCurrentContext(apiType, 0); // We need to select the correct API before calling eglMakeCurrent() // with EGL_NO_CONTEXT because threads can have both OpenGL and OpenVG // contexts active at the same time. #ifdef EGL_OPENGL_ES_API if (apiType == QEgl::OpenGL) eglBindAPI(EGL_OPENGL_ES_API); #endif #ifdef EGL_OPENVG_API if (apiType == QEgl::OpenVG) eglBindAPI(EGL_OPENVG_API); #endif bool ok = eglMakeCurrent(QEgl::display(), EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT); if (!ok) qWarning() << "QEglContext::doneCurrent():" << QEgl::errorString(); return ok; } // Act as though doneCurrent() was called, but keep the context // and the surface active for the moment. This allows makeCurrent() // to skip a call to eglMakeCurrent() if we are using the same // surface as the last set of painting operations. We leave the // currentContext() pointer as-is for now. bool QEglContext::lazyDoneCurrent() { current = false; return true; } bool QEglContext::swapBuffers(EGLSurface surface) { if(ctx == EGL_NO_CONTEXT) return false; bool ok = eglSwapBuffers(QEgl::display(), surface); if (!ok) qWarning() << "QEglContext::swapBuffers():" << QEgl::errorString(); return ok; } // Wait for native rendering operations to complete before starting // to use OpenGL/OpenVG operations. void QEglContext::waitNative() { #ifdef EGL_CORE_NATIVE_ENGINE eglWaitNative(EGL_CORE_NATIVE_ENGINE); #endif } // Wait for client OpenGL/OpenVG operations to complete before // using native rendering operations. void QEglContext::waitClient() { #ifdef EGL_OPENGL_ES_API if (apiType == QEgl::OpenGL) { eglBindAPI(EGL_OPENGL_ES_API); eglWaitClient(); } #else if (apiType == QEgl::OpenGL) eglWaitGL(); #endif #ifdef EGL_OPENVG_API if (apiType == QEgl::OpenVG) { eglBindAPI(EGL_OPENVG_API); eglWaitClient(); } #endif } // Query the value of a configuration attribute. bool QEglContext::configAttrib(int name, EGLint *value) const { return eglGetConfigAttrib(QEgl::display(), cfg, name, value); } int QEglContext::configAttrib(int name) const { EGLint value; EGLBoolean success = eglGetConfigAttrib(QEgl::display(), cfg, name, &value); if (success) return value; else return EGL_DONT_CARE; } QEglProperties QEglContext::configProperties() const { return QEglProperties(config()); } EGLDisplay QEgl::display() { static EGLDisplay dpy = EGL_NO_DISPLAY; static bool openedDisplay = false; if (!openedDisplay) { dpy = eglGetDisplay(nativeDisplay()); openedDisplay = true; if (dpy == EGL_NO_DISPLAY) { qWarning("QEgl::display(): Falling back to EGL_DEFAULT_DISPLAY"); dpy = eglGetDisplay(EGLNativeDisplayType(EGL_DEFAULT_DISPLAY)); } if (dpy == EGL_NO_DISPLAY) { qWarning("QEgl::display(): Can't even open the default display"); return EGL_NO_DISPLAY; } if (!eglInitialize(dpy, NULL, NULL)) { qWarning() << "QEgl::display(): Cannot initialize EGL display:" << QEgl::errorString(); return EGL_NO_DISPLAY; } } return dpy; } #ifndef Q_WS_X11 EGLSurface QEgl::createSurface(QPaintDevice *device, EGLConfig cfg, const QEglProperties *properties) { // Create the native drawable for the paint device. int devType = device->devType(); EGLNativePixmapType pixmapDrawable = 0; EGLNativeWindowType windowDrawable = 0; bool ok; if (devType == QInternal::Pixmap) { pixmapDrawable = nativePixmap(static_cast(device)); ok = (pixmapDrawable != 0); } else if (devType == QInternal::Widget) { windowDrawable = nativeWindow(static_cast(device)); ok = (windowDrawable != 0); } else { ok = false; } if (!ok) { qWarning("QEglContext::createSurface(): Cannot create the native EGL drawable"); return EGL_NO_SURFACE; } // Create the EGL surface to draw into, based on the native drawable. const int *props; if (properties) props = properties->properties(); else props = 0; EGLSurface surf; if (devType == QInternal::Widget) surf = eglCreateWindowSurface(QEgl::display(), cfg, windowDrawable, props); else surf = eglCreatePixmapSurface(QEgl::display(), cfg, pixmapDrawable, props); if (surf == EGL_NO_SURFACE) { qWarning("QEglContext::createSurface(): Unable to create EGL surface, error = 0x%x", eglGetError()); } return surf; } #endif // Return the error string associated with a specific code. QString QEgl::errorString(EGLint code) { static const char * const errors[] = { "Success (0x3000)", // No tr "Not initialized (0x3001)", // No tr "Bad access (0x3002)", // No tr "Bad alloc (0x3003)", // No tr "Bad attribute (0x3004)", // No tr "Bad config (0x3005)", // No tr "Bad context (0x3006)", // No tr "Bad current surface (0x3007)", // No tr "Bad display (0x3008)", // No tr "Bad match (0x3009)", // No tr "Bad native pixmap (0x300A)", // No tr "Bad native window (0x300B)", // No tr "Bad parameter (0x300C)", // No tr "Bad surface (0x300D)", // No tr "Context lost (0x300E)" // No tr }; if (code >= 0x3000 && code <= 0x300E) { return QString::fromLatin1(errors[code - 0x3000]); } else { return QLatin1String("0x") + QString::number(int(code), 16); } } QString QEgl::errorString() { return errorString(error()); } void QEgl::clearError() { eglGetError(); } EGLint QEgl::error() { return eglGetError(); } // Dump all of the EGL configurations supported by the system. void QEgl::dumpAllConfigs() { QEglProperties props; EGLint count = 0; if (!eglGetConfigs(display(), 0, 0, &count) || count < 1) return; EGLConfig *configs = new EGLConfig [count]; eglGetConfigs(display(), configs, count, &count); for (EGLint index = 0; index < count; ++index) { props = QEglProperties(configs[index]); qWarning() << props.toString(); } delete [] configs; } QString QEgl::extensions() { const char* exts = eglQueryString(QEgl::display(), EGL_EXTENSIONS); return QString(QLatin1String(exts)); } bool QEgl::hasExtension(const char* extensionName) { QList extensions = QByteArray(reinterpret_cast (eglQueryString(QEgl::display(), EGL_EXTENSIONS))).split(' '); return extensions.contains(extensionName); } QEglContext *QEglContext::currentContext(QEgl::API api) { if (api == QEgl::OpenGL) return currentGLContext; else return currentVGContext; } void QEglContext::setCurrentContext(QEgl::API api, QEglContext *context) { if (api == QEgl::OpenGL) currentGLContext = context; else currentVGContext = context; } QT_END_NAMESPACE