source: trunk/src/opengl/qpixmapdata_x11gl_egl.cpp@ 890

Last change on this file since 890 was 846, checked in by Dmitry A. Kuminov, 15 years ago

trunk: Merged in qt 4.7.2 sources from branches/vendor/nokia/qt.
  • Property svn:eol-style set to native
File size: 12.5 KB
Line 
1/****************************************************************************
2**
3** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
4** All rights reserved.
5** Contact: Nokia Corporation ([email protected])
6**
7** This file is part of the QtOpenGL module of the Qt Toolkit.
8**
9** $QT_BEGIN_LICENSE:LGPL$
10** Commercial Usage
11** Licensees holding valid Qt Commercial licenses may use this file in
12** accordance with the Qt Commercial License Agreement provided with the
13** Software or, alternatively, in accordance with the terms contained in
14** a written agreement between you and Nokia.
15**
16** GNU Lesser General Public License Usage
17** Alternatively, this file may be used under the terms of the GNU Lesser
18** General Public License version 2.1 as published by the Free Software
19** Foundation and appearing in the file LICENSE.LGPL included in the
20** packaging of this file. Please review the following information to
21** ensure the GNU Lesser General Public License version 2.1 requirements
22** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
23**
24** In addition, as a special exception, Nokia gives you certain additional
25** rights. These rights are described in the Nokia Qt LGPL Exception
26** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
27**
28** GNU General Public License Usage
29** Alternatively, this file may be used under the terms of the GNU
30** General Public License version 3.0 as published by the Free Software
31** Foundation and appearing in the file LICENSE.GPL included in the
32** packaging of this file. Please review the following information to
33** ensure the GNU General Public License version 3.0 requirements will be
34** met: http://www.gnu.org/copyleft/gpl.html.
35**
36** If you have questions regarding the use of this file, please contact
37** Nokia at [email protected].
38** $QT_END_LICENSE$
39**
40****************************************************************************/
41
42#include <QDebug>
43
44#include <QtGui/private/qt_x11_p.h>
45#include <QtGui/private/qegl_p.h>
46#include <QtGui/private/qeglproperties_p.h>
47#include <QtGui/private/qeglcontext_p.h>
48
49#if !defined(QT_OPENGL_ES_1)
50#include <QtOpenGL/private/qpaintengineex_opengl2_p.h>
51#endif
52
53#ifndef QT_OPENGL_ES_2
54#include <QtOpenGL/private/qpaintengine_opengl_p.h>
55#endif
56
57#include <QtOpenGL/private/qgl_p.h>
58#include <QtOpenGL/private/qgl_egl_p.h>
59
60#include "qpixmapdata_x11gl_p.h"
61
62QT_BEGIN_NAMESPACE
63
64
65class QX11GLSharedContexts
66{
67public:
68 QX11GLSharedContexts()
69 : rgbContext(0)
70 , argbContext(0)
71 , sharedQGLContext(0)
72 , sharePixmap(0)
73 {
74 EGLint rgbConfigId;
75 EGLint argbConfigId;
76
77 do {
78 EGLConfig rgbConfig = QEgl::defaultConfig(QInternal::Pixmap, QEgl::OpenGL, QEgl::Renderable);
79 EGLConfig argbConfig = QEgl::defaultConfig(QInternal::Pixmap, QEgl::OpenGL,
80 QEgl::Renderable | QEgl::Translucent);
81
82 eglGetConfigAttrib(QEgl::display(), rgbConfig, EGL_CONFIG_ID, &rgbConfigId);
83 eglGetConfigAttrib(QEgl::display(), argbConfig, EGL_CONFIG_ID, &argbConfigId);
84
85 rgbContext = new QEglContext;
86 rgbContext->setConfig(rgbConfig);
87 rgbContext->createContext();
88
89 if (!rgbContext->isValid())
90 break;
91
92 // If the RGB & ARGB configs are the same, use the same egl context for both:
93 if (rgbConfig == argbConfig)
94 argbContext = rgbContext;
95
96 // Otherwise, create a separate context to be used for ARGB pixmaps:
97 if (!argbContext) {
98 argbContext = new QEglContext;
99 argbContext->setConfig(argbConfig);
100 bool success = argbContext->createContext(rgbContext);
101 if (!success) {
102 qWarning("QX11GLPixmapData - RGB & ARGB contexts aren't shared");
103 success = argbContext->createContext();
104 if (!success)
105 argbContext = rgbContext; // Might work, worth a shot at least.
106 }
107 }
108
109 if (!argbContext->isValid())
110 break;
111
112 // Create the pixmap which will be used to create the egl surface for the share QGLContext
113 QX11PixmapData *rgbPixmapData = new QX11PixmapData(QPixmapData::PixmapType);
114 rgbPixmapData->resize(8, 8);
115 rgbPixmapData->fill(Qt::red);
116 sharePixmap = new QPixmap(rgbPixmapData);
117 EGLSurface sharePixmapSurface = QEgl::createSurface(sharePixmap, rgbConfig);
118 rgbPixmapData->gl_surface = (void*)sharePixmapSurface;
119
120 // Create the actual QGLContext which will be used for sharing
121 sharedQGLContext = new QGLContext(QX11GLPixmapData::glFormat());
122 sharedQGLContext->d_func()->eglContext = rgbContext;
123 sharedQGLContext->d_func()->eglSurface = sharePixmapSurface;
124 sharedQGLContext->d_func()->valid = true;
125 qt_glformat_from_eglconfig(sharedQGLContext->d_func()->glFormat, rgbConfig);
126
127
128 valid = rgbContext->makeCurrent(sharePixmapSurface);
129
130 // If the ARGB & RGB configs are different, check ARGB works too:
131 if (argbConfig != rgbConfig) {
132 QX11PixmapData *argbPixmapData = new QX11PixmapData(QPixmapData::PixmapType);
133 argbPixmapData->resize(8, 8);
134 argbPixmapData->fill(Qt::transparent); // Force ARGB
135 QPixmap argbPixmap(argbPixmapData); // destroys pixmap data when goes out of scope
136 EGLSurface argbPixmapSurface = QEgl::createSurface(&argbPixmap, argbConfig);
137 valid = argbContext->makeCurrent(argbPixmapSurface);
138 argbContext->doneCurrent();
139 eglDestroySurface(QEgl::display(), argbPixmapSurface);
140 argbPixmapData->gl_surface = 0;
141 }
142
143 if (!valid) {
144 qWarning() << "Unable to make pixmap surface current:" << QEgl::errorString();
145 break;
146 }
147
148 // The pixmap surface destruction hooks are installed by QGLTextureCache, so we
149 // must make sure this is instanciated:
150 QGLTextureCache::instance();
151 } while(0);
152
153 if (!valid)
154 cleanup();
155 else
156 qDebug("Using QX11GLPixmapData with EGL config %d for ARGB and config %d for RGB", argbConfigId, rgbConfigId);
157
158 }
159
160 ~QX11GLSharedContexts() {
161 cleanup();
162 }
163
164 void cleanup() {
165 if (sharedQGLContext) {
166 delete sharedQGLContext;
167 sharedQGLContext = 0;
168 }
169 if (argbContext && argbContext != rgbContext)
170 delete argbContext;
171 argbContext = 0;
172
173 if (rgbContext) {
174 delete rgbContext;
175 rgbContext = 0;
176 }
177
178 // Deleting the QPixmap will fire the pixmap destruction cleanup hooks which in turn
179 // will destroy the egl surface:
180 if (sharePixmap) {
181 delete sharePixmap;
182 sharePixmap = 0;
183 }
184 }
185
186 bool isValid() { return valid;}
187
188 // On 16bpp systems, RGB & ARGB pixmaps are different bit-depths and therefore need
189 // different contexts:
190 QEglContext *rgbContext;
191 QEglContext *argbContext;
192
193 // The share context wraps the rgbContext and is used as the master of the context share
194 // group. As all other contexts will have the same egl context (or a shared one if rgb != argb)
195 // all QGLContexts will actually be sharing and can be in the same context group.
196 QGLContext *sharedQGLContext;
197private:
198 QPixmap *sharePixmap;
199 bool valid;
200};
201
202static void qt_cleanup_x11gl_share_contexts();
203
204Q_GLOBAL_STATIC_WITH_INITIALIZER(QX11GLSharedContexts, qt_x11gl_share_contexts,
205 {
206 qAddPostRoutine(qt_cleanup_x11gl_share_contexts);
207 })
208
209static void qt_cleanup_x11gl_share_contexts()
210{
211 qt_x11gl_share_contexts()->cleanup();
212}
213
214
215QX11GLSharedContexts* QX11GLPixmapData::sharedContexts()
216{
217 return qt_x11gl_share_contexts();
218}
219
220bool QX11GLPixmapData::hasX11GLPixmaps()
221{
222 static bool checkedForX11GLPixmaps = false;
223 static bool haveX11GLPixmaps = false;
224
225 if (checkedForX11GLPixmaps)
226 return haveX11GLPixmaps;
227
228 haveX11GLPixmaps = qt_x11gl_share_contexts()->isValid();
229 checkedForX11GLPixmaps = true;
230
231 return haveX11GLPixmaps;
232}
233
234QX11GLPixmapData::QX11GLPixmapData()
235 : QX11PixmapData(QPixmapData::PixmapType),
236 ctx(0)
237{
238}
239
240QX11GLPixmapData::~QX11GLPixmapData()
241{
242 if (ctx)
243 delete ctx;
244}
245
246
247void QX11GLPixmapData::fill(const QColor &color)
248{
249 if (ctx) {
250 ctx->makeCurrent();
251 glFinish();
252 eglWaitClient();
253 }
254
255 QX11PixmapData::fill(color);
256 XSync(X11->display, False);
257
258 if (ctx) {
259 ctx->makeCurrent();
260 eglWaitNative(EGL_CORE_NATIVE_ENGINE);
261 }
262}
263
264void QX11GLPixmapData::copy(const QPixmapData *data, const QRect &rect)
265{
266 if (ctx) {
267 ctx->makeCurrent();
268 glFinish();
269 eglWaitClient();
270 }
271
272 QX11PixmapData::copy(data, rect);
273 XSync(X11->display, False);
274
275 if (ctx) {
276 ctx->makeCurrent();
277 eglWaitNative(EGL_CORE_NATIVE_ENGINE);
278 }
279}
280
281bool QX11GLPixmapData::scroll(int dx, int dy, const QRect &rect)
282{
283 if (ctx) {
284 ctx->makeCurrent();
285 glFinish();
286 eglWaitClient();
287 }
288
289 bool success = QX11PixmapData::scroll(dx, dy, rect);
290 XSync(X11->display, False);
291
292 if (ctx) {
293 ctx->makeCurrent();
294 eglWaitNative(EGL_CORE_NATIVE_ENGINE);
295 }
296
297 return success;
298}
299
300#if !defined(QT_OPENGL_ES_1)
301Q_GLOBAL_STATIC(QGL2PaintEngineEx, qt_gl_pixmap_2_engine)
302#endif
303
304#ifndef QT_OPENGL_ES_2
305Q_GLOBAL_STATIC(QOpenGLPaintEngine, qt_gl_pixmap_engine)
306#endif
307
308
309QPaintEngine* QX11GLPixmapData::paintEngine() const
310{
311 // We need to create the context before beginPaint - do it here:
312 if (!ctx) {
313 ctx = new QGLContext(glFormat());
314 Q_ASSERT(ctx->d_func()->eglContext == 0);
315 ctx->d_func()->eglContext = hasAlphaChannel() ? sharedContexts()->argbContext : sharedContexts()->rgbContext;
316
317 // While we use a separate QGLContext for each pixmap, the underlying QEglContext is
318 // the same. So we must use a "fake" QGLContext and fool the texture cache into thinking
319 // each pixmap's QGLContext is sharing with this central one. The only place this is
320 // going to fail is where we the underlying EGL RGB and ARGB contexts aren't sharing.
321 ctx->d_func()->sharing = true;
322 QGLContextGroup::addShare(ctx, sharedContexts()->sharedQGLContext);
323
324 // Update the glFormat for the QGLContext:
325 qt_glformat_from_eglconfig(ctx->d_func()->glFormat, ctx->d_func()->eglContext->config());
326 }
327
328 QPaintEngine* engine;
329
330#if defined(QT_OPENGL_ES_1)
331 engine = qt_gl_pixmap_engine();
332#elif defined(QT_OPENGL_ES_2)
333 engine = qt_gl_pixmap_2_engine();
334#else
335 if (qt_gl_preferGL2Engine())
336 engine = qt_gl_pixmap_2_engine();
337 else
338 engine = qt_gl_pixmap_engine();
339#endif
340
341
342
343 // Support multiple painters on multiple pixmaps simultaniously
344 if (engine->isActive()) {
345 qWarning("Pixmap paint engine already active");
346
347#if defined(QT_OPENGL_ES_1)
348 engine = new QOpenGLPaintEngine;
349#elif defined(QT_OPENGL_ES_2)
350 engine = new QGL2PaintEngineEx;
351#else
352 if (qt_gl_preferGL2Engine())
353 engine = new QGL2PaintEngineEx;
354 else
355 engine = new QOpenGLPaintEngine;
356#endif
357
358 engine->setAutoDestruct(true);
359 return engine;
360 }
361
362 return engine;
363}
364
365void QX11GLPixmapData::beginPaint()
366{
367// qDebug("QX11GLPixmapData::beginPaint()");
368 // TODO: Check to see if the surface is renderable
369 if ((EGLSurface)gl_surface == EGL_NO_SURFACE) {
370 QPixmap tmpPixmap(this);
371 EGLConfig cfg = ctx->d_func()->eglContext->config();
372 Q_ASSERT(cfg != QEGL_NO_CONFIG);
373
374// qDebug("QX11GLPixmapData - using EGL Config ID %d", ctx->d_func()->eglContext->configAttrib(EGL_CONFIG_ID));
375 EGLSurface surface = QEgl::createSurface(&tmpPixmap, cfg);
376 if (surface == EGL_NO_SURFACE) {
377 qWarning() << "Error creating EGL surface for pixmap:" << QEgl::errorString();
378 return;
379 }
380 gl_surface = (void*)surface;
381 ctx->d_func()->eglSurface = surface;
382 ctx->d_func()->valid = true;
383 }
384 QGLPaintDevice::beginPaint();
385}
386
387QGLContext* QX11GLPixmapData::context() const
388{
389 return ctx;
390}
391
392QSize QX11GLPixmapData::size() const
393{
394 return QSize(w, h);
395}
396
397
398QGLFormat QX11GLPixmapData::glFormat()
399{
400 return QGLFormat::defaultFormat(); //###
401}
402
403QT_END_NAMESPACE
Note: See TracBrowser for help on using the repository browser.