/******************************************************************************** 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 <QtGui/qpaintdevice.h>#include <QtGui/qpixmap.h>#include <QtGui/qwidget.h>#include <QtCore/qdebug.h>#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(QEGL_NO_CONFIG) , 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 QT_OPENGL_ES#ifdef EGL_OPENGL_ES_API if (apiType == QEgl::OpenGL) eglBindAPI(EGL_OPENGL_ES_API);#endif#else#ifdef EGL_OPENGL_API if (apiType == QEgl::OpenGL) eglBindAPI(EGL_OPENGL_API);#endif#endif //defined(QT_OPENGL_ES)#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;#ifdef 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 (surface == EGL_NO_SURFACE) { qWarning() << "QEglContext::makeCurrent(): Cannot make invalid surface 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(" << surface << "):" << 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;}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;}typedef EGLImageKHR (EGLAPIENTRY *_eglCreateImageKHR)(EGLDisplay, EGLContext, EGLenum, EGLClientBuffer, const EGLint*);typedef EGLBoolean (EGLAPIENTRY *_eglDestroyImageKHR)(EGLDisplay, EGLImageKHR);// Defined in qegl.cpp:static _eglCreateImageKHR qt_eglCreateImageKHR = 0;static _eglDestroyImageKHR qt_eglDestroyImageKHR = 0;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; } // Resolve the egl extension function pointers:#if (defined(EGL_KHR_image) || defined(EGL_KHR_image_base)) && !defined(EGL_EGLEXT_PROTOTYPES) if (QEgl::hasExtension("EGL_KHR_image") || QEgl::hasExtension("EGL_KHR_image_base")) { qt_eglCreateImageKHR = (_eglCreateImageKHR) eglGetProcAddress("eglCreateImageKHR"); qt_eglDestroyImageKHR = (_eglDestroyImageKHR) eglGetProcAddress("eglDestroyImageKHR"); }#endif } return dpy;}EGLImageKHR QEgl::eglCreateImageKHR(EGLDisplay dpy, EGLContext ctx, EGLenum target, EGLClientBuffer buffer, const EGLint *attrib_list){ if (qt_eglCreateImageKHR) return qt_eglCreateImageKHR(dpy, ctx, target, buffer, attrib_list); QEgl::display(); // Initialises function pointers if (qt_eglCreateImageKHR) return qt_eglCreateImageKHR(dpy, ctx, target, buffer, attrib_list); qWarning("QEgl::eglCreateImageKHR() called but EGL_KHR_image(_base) extension not present"); return 0;}EGLBoolean QEgl::eglDestroyImageKHR(EGLDisplay dpy, EGLImageKHR img){ if (qt_eglDestroyImageKHR) return qt_eglDestroyImageKHR(dpy, img); QEgl::display(); // Initialises function pointers if (qt_eglDestroyImageKHR) return qt_eglDestroyImageKHR(dpy, img); qWarning("QEgl::eglDestroyImageKHR() called but EGL_KHR_image(_base) extension not present"); return 0;}#ifndef Q_WS_X11EGLSurface 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<QPixmap *>(device)); ok = (pixmapDrawable != 0); } else if (devType == QInternal::Widget) { windowDrawable = nativeWindow(static_cast<QWidget *>(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); }}// 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<QByteArray> extensions = QByteArray(reinterpret_cast<const char *> (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