1 /****************************************************************************

     2 **

     3 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).

     4 ** All rights reserved.

     5 ** Contact: Nokia Corporation (qt-info@nokia.com)

     6 **

     7 ** This file is part of the QtOpenGL module of the Qt Toolkit.

     8 **

     9 ** $QT_BEGIN_LICENSE:LGPL$

    10 ** No Commercial Usage

    11 ** This file contains pre-release code and may not be distributed.

    12 ** You may use this file in accordance with the terms and conditions

    13 ** contained in the Technology Preview License Agreement accompanying

    14 ** this package.

    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 ** If you have questions regarding the use of this file, please contact

    29 ** Nokia at qt-info@nokia.com.

    30 **

    31 **

    32 **

    33 **

    34 **

    35 **

    36 **

    37 **

    38 ** $QT_END_LICENSE$

    39 **

    40 ****************************************************************************/

    41 

    42 #include "qpixmap.h"

    43 #include "qglframebufferobject.h"

    44 

    45 #include <private/qpaintengine_raster_p.h>

    46 

    47 #include "qpixmapdata_gl_p.h"

    48 

    49 #include <private/qgl_p.h>

    50 #include <private/qdrawhelper_p.h>

    51 #include <private/qimage_p.h>

    52 

    53 #include <private/qpaintengineex_opengl2_p.h>

    54 

    55 #include <qdesktopwidget.h>

    56 #include <qfile.h>

    57 #include <qimagereader.h>

    58 

    59 QT_BEGIN_NAMESPACE

    60 

    61 extern QGLWidget* qt_gl_share_widget();

    62 

    63 /*!

    64     \class QGLFramebufferObjectPool

    65     \since 4.6

    66 

    67     \brief The QGLFramebufferObject class provides a pool of framebuffer

    68     objects for offscreen rendering purposes.

    69 

    70     When requesting an FBO of a given size and format, an FBO of the same

    71     format and a size at least as big as the requested size will be returned.

    72 

    73     \internal

    74 */

    75 

    76 static inline int areaDiff(const QSize &size, const QGLFramebufferObject *fbo)

    77 {

    78     return qAbs(size.width() * size.height() - fbo->width() * fbo->height());

    79 }

    80 

    81 extern int qt_next_power_of_two(int v);

    82 

    83 static inline QSize maybeRoundToNextPowerOfTwo(const QSize &sz)

    84 {

    85 #ifdef QT_OPENGL_ES_2

    86     QSize rounded(qt_next_power_of_two(sz.width()), qt_next_power_of_two(sz.height()));

    87     if (rounded.width() * rounded.height() < 1.20 * sz.width() * sz.height())

    88         return rounded;

    89 #endif

    90     return sz;

    91 }

    92 

    93 

    94 QGLFramebufferObject *QGLFramebufferObjectPool::acquire(const QSize &requestSize, const QGLFramebufferObjectFormat &requestFormat, bool strictSize)

    95 {

    96     QGLFramebufferObject *chosen = 0;

    97     QGLFramebufferObject *candidate = 0;

    98     for (int i = 0; !chosen && i < m_fbos.size(); ++i) {

    99         QGLFramebufferObject *fbo = m_fbos.at(i);

   100 

   101         if (strictSize) {

   102             if (fbo->size() == requestSize && fbo->format() == requestFormat) {

   103                 chosen = fbo;

   104                 break;

   105             } else {

   106                 continue;

   107             }

   108         }

   109 

   110         if (fbo->format() == requestFormat) {

   111             // choose the fbo with a matching format and the closest size

   112             if (!candidate || areaDiff(requestSize, candidate) > areaDiff(requestSize, fbo))

   113                 candidate = fbo;

   114         }

   115 

   116         if (candidate) {

   117             m_fbos.removeOne(candidate);

   118 

   119             const QSize fboSize = candidate->size();

   120             QSize sz = fboSize;

   121 

   122             if (sz.width() < requestSize.width())

   123                 sz.setWidth(qMax(requestSize.width(), qRound(sz.width() * 1.5)));

   124             if (sz.height() < requestSize.height())

   125                 sz.setHeight(qMax(requestSize.height(), qRound(sz.height() * 1.5)));

   126 

   127             // wasting too much space?

   128             if (sz.width() * sz.height() > requestSize.width() * requestSize.height() * 4)

   129                 sz = requestSize;

   130 

   131             if (sz != fboSize) {

   132                 delete candidate;

   133                 candidate = new QGLFramebufferObject(maybeRoundToNextPowerOfTwo(sz), requestFormat);

   134             }

   135 

   136             chosen = candidate;

   137         }

   138     }

   139 

   140     if (!chosen) {

   141         if (strictSize)

   142             chosen = new QGLFramebufferObject(requestSize, requestFormat);

   143         else

   144             chosen = new QGLFramebufferObject(maybeRoundToNextPowerOfTwo(requestSize), requestFormat);

   145     }

   146 

   147     if (!chosen->isValid()) {

   148         delete chosen;

   149         chosen = 0;

   150     }

   151 

   152     return chosen;

   153 }

   154 

   155 void QGLFramebufferObjectPool::release(QGLFramebufferObject *fbo)

   156 {

   157     if (fbo)

   158         m_fbos << fbo;

   159 }

   160 

   161 

   162 QPaintEngine* QGLPixmapGLPaintDevice::paintEngine() const

   163 {

   164     return data->paintEngine();

   165 }

   166 

   167 void QGLPixmapGLPaintDevice::beginPaint()

   168 {

   169     if (!data->isValid())

   170         return;

   171 

   172     // QGLPaintDevice::beginPaint will store the current binding and replace

   173     // it with m_thisFBO:

   174     m_thisFBO = data->m_renderFbo->handle();

   175     QGLPaintDevice::beginPaint();

   176 

   177     Q_ASSERT(data->paintEngine()->type() == QPaintEngine::OpenGL2);

   178 

   179     // QPixmap::fill() is deferred until now, where we actually need to do the fill:

   180     if (data->needsFill()) {

   181         const QColor &c = data->fillColor();

   182         float alpha = c.alphaF();

   183         glDisable(GL_SCISSOR_TEST);

   184         glClearColor(c.redF() * alpha, c.greenF() * alpha, c.blueF() * alpha, alpha);

   185         glClear(GL_COLOR_BUFFER_BIT);

   186     }

   187     else if (!data->isUninitialized()) {

   188         // If the pixmap (GL Texture) has valid content (it has been

   189         // uploaded from an image or rendered into before), we need to

   190         // copy it from the texture to the render FBO.

   191 

   192         glDisable(GL_DEPTH_TEST);

   193         glDisable(GL_SCISSOR_TEST);

   194         glDisable(GL_BLEND);

   195 

   196 #if !defined(QT_OPENGL_ES_2)

   197         glMatrixMode(GL_MODELVIEW);

   198         glLoadIdentity();

   199 

   200         glMatrixMode(GL_PROJECTION);

   201         glLoadIdentity();

   202         glOrtho(0, data->width(), data->height(), 0, -999999, 999999);

   203 #endif

   204 

   205         glViewport(0, 0, data->width(), data->height());

   206 

   207         // Pass false to bind so it doesn't copy the FBO into the texture!

   208         context()->drawTexture(QRect(0, 0, data->width(), data->height()), data->bind(false));

   209     }

   210 }

   211 

   212 void QGLPixmapGLPaintDevice::endPaint()

   213 {

   214     if (!data->isValid())

   215         return;

   216 

   217     data->copyBackFromRenderFbo(false);

   218 

   219     // Base's endPaint will restore the previous FBO binding

   220     QGLPaintDevice::endPaint();

   221 

   222     qgl_fbo_pool()->release(data->m_renderFbo);

   223     data->m_renderFbo = 0;

   224 }

   225 

   226 QGLContext* QGLPixmapGLPaintDevice::context() const

   227 {

   228     data->ensureCreated();

   229     return data->m_ctx;

   230 }

   231 

   232 QSize QGLPixmapGLPaintDevice::size() const

   233 {

   234     return data->size();

   235 }

   236 

   237 bool QGLPixmapGLPaintDevice::alphaRequested() const

   238 {

   239     return data->m_hasAlpha;

   240 }

   241 

   242 void QGLPixmapGLPaintDevice::setPixmapData(QGLPixmapData* d)

   243 {

   244     data = d;

   245 }

   246 

   247 static int qt_gl_pixmap_serial = 0;

   248 

   249 QGLPixmapData::QGLPixmapData(PixelType type)

   250     : QPixmapData(type, OpenGLClass)

   251     , m_renderFbo(0)

   252     , m_engine(0)

   253     , m_ctx(0)

   254     , m_dirty(false)

   255     , m_hasFillColor(false)

   256     , m_hasAlpha(false)

   257 {

   258     setSerialNumber(++qt_gl_pixmap_serial);

   259     m_glDevice.setPixmapData(this);

   260 }

   261 

   262 QGLPixmapData::~QGLPixmapData()

   263 {

   264     QGLWidget *shareWidget = qt_gl_share_widget();

   265     if (!shareWidget)

   266         return;

   267 

   268     delete m_engine;

   269 

   270     if (m_texture.id) {

   271         QGLShareContextScope ctx(shareWidget->context());

   272         glDeleteTextures(1, &m_texture.id);

   273     }

   274 }

   275 

   276 QPixmapData *QGLPixmapData::createCompatiblePixmapData() const

   277 {

   278     return new QGLPixmapData(pixelType());

   279 }

   280 

   281 bool QGLPixmapData::isValid() const

   282 {

   283     return w > 0 && h > 0;

   284 }

   285 

   286 bool QGLPixmapData::isValidContext(const QGLContext *ctx) const

   287 {

   288     if (ctx == m_ctx)

   289         return true;

   290 

   291     const QGLContext *share_ctx = qt_gl_share_widget()->context();

   292     return ctx == share_ctx || QGLContext::areSharing(ctx, share_ctx);

   293 }

   294 

   295 void QGLPixmapData::resize(int width, int height)

   296 {

   297     if (width == w && height == h)

   298         return;

   299 

   300     if (width <= 0 || height <= 0) {

   301         width = 0;

   302         height = 0;

   303     }

   304 

   305     w = width;

   306     h = height;

   307     is_null = (w <= 0 || h <= 0);

   308     d = pixelType() == QPixmapData::PixmapType ? 32 : 1;

   309 

   310     if (m_texture.id) {

   311         QGLShareContextScope ctx(qt_gl_share_widget()->context());

   312         glDeleteTextures(1, &m_texture.id);

   313         m_texture.id = 0;

   314     }

   315 

   316     m_source = QImage();

   317     m_dirty = isValid();

   318     setSerialNumber(++qt_gl_pixmap_serial);

   319 }

   320 

   321 void QGLPixmapData::ensureCreated() const

   322 {

   323     if (!m_dirty)

   324         return;

   325 

   326     m_dirty = false;

   327 

   328     QGLShareContextScope ctx(qt_gl_share_widget()->context());

   329     m_ctx = ctx;

   330 

   331     const GLenum internal_format = m_hasAlpha ? GL_RGBA : GL_RGB;

   332 #ifdef QT_OPENGL_ES_2

   333     const GLenum external_format = internal_format;

   334 #else

   335     const GLenum external_format = qt_gl_preferredTextureFormat();

   336 #endif

   337     const GLenum target = GL_TEXTURE_2D;

   338 

   339     if (!m_texture.id) {

   340         glGenTextures(1, &m_texture.id);

   341         glBindTexture(target, m_texture.id);

   342         glTexImage2D(target, 0, internal_format, w, h, 0, external_format, GL_UNSIGNED_BYTE, 0);

   343         glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);

   344         glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);

   345     }

   346 

   347     if (!m_source.isNull()) {

   348         if (external_format == GL_RGB) {

   349             const QImage tx = m_source.convertToFormat(QImage::Format_RGB888).mirrored(false, true);

   350 

   351             glBindTexture(target, m_texture.id);

   352             glTexSubImage2D(target, 0, 0, 0, w, h, external_format,

   353                             GL_UNSIGNED_BYTE, tx.bits());

   354         } else {

   355             const QImage tx = ctx->d_func()->convertToGLFormat(m_source, true, external_format);

   356 

   357             glBindTexture(target, m_texture.id);

   358             glTexSubImage2D(target, 0, 0, 0, w, h, external_format,

   359                             GL_UNSIGNED_BYTE, tx.bits());

   360         }

   361 

   362         if (useFramebufferObjects())

   363             m_source = QImage();

   364     }

   365 

   366     m_texture.options &= ~QGLContext::MemoryManagedBindOption;

   367 }

   368 

   369 void QGLPixmapData::fromImage(const QImage &image,

   370                               Qt::ImageConversionFlags /*flags*/)

   371 {

   372     if (image.size() == QSize(w, h))

   373         setSerialNumber(++qt_gl_pixmap_serial);

   374     resize(image.width(), image.height());

   375 

   376     if (pixelType() == BitmapType) {

   377         m_source = image.convertToFormat(QImage::Format_MonoLSB);

   378 

   379     } else {

   380         QImage::Format format = QImage::Format_RGB32;

   381         if (qApp->desktop()->depth() == 16)

   382             format = QImage::Format_RGB16;

   383 

   384         if (image.hasAlphaChannel() && const_cast<QImage &>(image).data_ptr()->checkForAlphaPixels())

   385             format = QImage::Format_ARGB32_Premultiplied;;

   386 

   387         m_source = image.convertToFormat(format);

   388     }

   389 

   390     m_dirty = true;

   391     m_hasFillColor = false;

   392 

   393     m_hasAlpha = m_source.hasAlphaChannel();

   394     w = image.width();

   395     h = image.height();

   396     is_null = (w <= 0 || h <= 0);

   397     d = m_source.depth();

   398 

   399     if (m_texture.id) {

   400         QGLShareContextScope ctx(qt_gl_share_widget()->context());

   401         glDeleteTextures(1, &m_texture.id);

   402         m_texture.id = 0;

   403     }

   404 }

   405 

   406 bool QGLPixmapData::fromFile(const QString &filename, const char *format,

   407                              Qt::ImageConversionFlags flags)

   408 {

   409     if (pixelType() == QPixmapData::BitmapType)

   410         return QPixmapData::fromFile(filename, format, flags);

   411     QFile file(filename);

   412     if (!file.open(QIODevice::ReadOnly))

   413         return false;

   414     QByteArray data = file.peek(64);

   415     bool alpha;

   416     if (m_texture.canBindCompressedTexture

   417             (data.constData(), data.size(), format, &alpha)) {

   418         resize(0, 0);

   419         data = file.readAll();

   420         file.close();

   421         QGLShareContextScope ctx(qt_gl_share_widget()->context());

   422         QSize size = m_texture.bindCompressedTexture

   423             (data.constData(), data.size(), format);

   424         if (!size.isEmpty()) {

   425             w = size.width();

   426             h = size.height();

   427             is_null = false;

   428             d = 32;

   429             m_hasAlpha = alpha;

   430             m_source = QImage();

   431             m_dirty = isValid();

   432             return true;

   433         }

   434         return false;

   435     }

   436     fromImage(QImageReader(&file, format).read(), flags);

   437     return !isNull();

   438 }

   439 

   440 bool QGLPixmapData::fromData(const uchar *buffer, uint len, const char *format,

   441                              Qt::ImageConversionFlags flags)

   442 {

   443     bool alpha;

   444     const char *buf = reinterpret_cast<const char *>(buffer);

   445     if (m_texture.canBindCompressedTexture(buf, int(len), format, &alpha)) {

   446         resize(0, 0);

   447         QGLShareContextScope ctx(qt_gl_share_widget()->context());

   448         QSize size = m_texture.bindCompressedTexture(buf, int(len), format);

   449         if (!size.isEmpty()) {

   450             w = size.width();

   451             h = size.height();

   452             is_null = false;

   453             d = 32;

   454             m_hasAlpha = alpha;

   455             m_source = QImage();

   456             m_dirty = isValid();

   457             return true;

   458         }

   459     }

   460     return QPixmapData::fromData(buffer, len, format, flags);

   461 }

   462 

   463 bool QGLPixmapData::scroll(int dx, int dy, const QRect &rect)

   464 {

   465     Q_UNUSED(dx);

   466     Q_UNUSED(dy);

   467     Q_UNUSED(rect);

   468     return false;

   469 }

   470 

   471 void QGLPixmapData::copy(const QPixmapData *data, const QRect &rect)

   472 {

   473     if (data->classId() != QPixmapData::OpenGLClass) {

   474         QPixmapData::copy(data, rect);

   475         return;

   476     }

   477 

   478     // can be optimized to do a framebuffer blit or similar ...

   479     QPixmapData::copy(data, rect);

   480 }

   481 

   482 void QGLPixmapData::fill(const QColor &color)

   483 {

   484     if (!isValid())

   485         return;

   486 

   487     bool hasAlpha = color.alpha() != 255;

   488     if (hasAlpha && !m_hasAlpha) {

   489         if (m_texture.id) {

   490             glDeleteTextures(1, &m_texture.id);

   491             m_texture.id = 0;

   492             m_dirty = true;

   493         }

   494         m_hasAlpha = color.alpha() != 255;

   495     }

   496 

   497     if (useFramebufferObjects()) {

   498         m_source = QImage();

   499         m_hasFillColor = true;

   500         m_fillColor = color;

   501     } else {

   502 

   503         if (m_source.isNull()) {

   504             m_fillColor = color;

   505             m_hasFillColor = true;

   506 

   507         } else if (m_source.depth() == 32) {

   508             m_source.fill(PREMUL(color.rgba()));

   509 

   510         } else if (m_source.depth() == 1) {

   511             if (color == Qt::color1)

   512                 m_source.fill(1);

   513             else

   514                 m_source.fill(0);

   515         }

   516     }

   517 }

   518 

   519 bool QGLPixmapData::hasAlphaChannel() const

   520 {

   521     return m_hasAlpha;

   522 }

   523 

   524 QImage QGLPixmapData::fillImage(const QColor &color) const

   525 {

   526     QImage img;

   527     if (pixelType() == BitmapType) {

   528         img = QImage(w, h, QImage::Format_MonoLSB);

   529 

   530         img.setColorCount(2);

   531         img.setColor(0, QColor(Qt::color0).rgba());

   532         img.setColor(1, QColor(Qt::color1).rgba());

   533 

   534         if (color == Qt::color1)

   535             img.fill(1);

   536         else

   537             img.fill(0);

   538     } else {

   539         img = QImage(w, h,

   540                 m_hasAlpha

   541                 ? QImage::Format_ARGB32_Premultiplied

   542                 : QImage::Format_RGB32);

   543         img.fill(PREMUL(color.rgba()));

   544     }

   545     return img;

   546 }

   547 

   548 extern QImage qt_gl_read_texture(const QSize &size, bool alpha_format, bool include_alpha);

   549 

   550 QImage QGLPixmapData::toImage() const

   551 {

   552     if (!isValid())

   553         return QImage();

   554 

   555     if (m_renderFbo) {

   556         copyBackFromRenderFbo(true);

   557     } else if (!m_source.isNull()) {

   558         return m_source;

   559     } else if (m_dirty || m_hasFillColor) {

   560         return fillImage(m_fillColor);

   561     } else {

   562         ensureCreated();

   563     }

   564 

   565     QGLShareContextScope ctx(qt_gl_share_widget()->context());

   566     glBindTexture(GL_TEXTURE_2D, m_texture.id);

   567     return qt_gl_read_texture(QSize(w, h), true, true);

   568 }

   569 

   570 struct TextureBuffer

   571 {

   572     QGLFramebufferObject *fbo;

   573     QGL2PaintEngineEx *engine;

   574 };

   575 

   576 Q_GLOBAL_STATIC(QGLFramebufferObjectPool, _qgl_fbo_pool)

   577 QGLFramebufferObjectPool* qgl_fbo_pool()

   578 {

   579     return _qgl_fbo_pool();

   580 }

   581 

   582 void QGLPixmapData::copyBackFromRenderFbo(bool keepCurrentFboBound) const

   583 {

   584     if (!isValid())

   585         return;

   586 

   587     m_hasFillColor = false;

   588 

   589     const QGLContext *share_ctx = qt_gl_share_widget()->context();

   590     QGLShareContextScope ctx(share_ctx);

   591 

   592     ensureCreated();

   593 

   594     if (!ctx->d_ptr->fbo)

   595         glGenFramebuffers(1, &ctx->d_ptr->fbo);

   596 

   597     glBindFramebuffer(GL_DRAW_FRAMEBUFFER_EXT, ctx->d_ptr->fbo);

   598     glFramebufferTexture2D(GL_DRAW_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT,

   599         GL_TEXTURE_2D, m_texture.id, 0);

   600 

   601     const int x0 = 0;

   602     const int x1 = w;

   603     const int y0 = 0;

   604     const int y1 = h;

   605 

   606     if (!m_renderFbo->isBound())

   607         glBindFramebuffer(GL_READ_FRAMEBUFFER_EXT, m_renderFbo->handle());

   608 

   609     glDisable(GL_SCISSOR_TEST);

   610 

   611     glBlitFramebufferEXT(x0, y0, x1, y1,

   612             x0, y0, x1, y1,

   613             GL_COLOR_BUFFER_BIT,

   614             GL_NEAREST);

   615 

   616     if (keepCurrentFboBound) {

   617         glBindFramebuffer(GL_FRAMEBUFFER_EXT, ctx->d_ptr->current_fbo);

   618     } else {

   619         glBindFramebuffer(GL_DRAW_FRAMEBUFFER_EXT, m_renderFbo->handle());

   620         ctx->d_ptr->current_fbo = m_renderFbo->handle();

   621     }

   622 }

   623 

   624 bool QGLPixmapData::useFramebufferObjects()

   625 {

   626     return QGLFramebufferObject::hasOpenGLFramebufferObjects()

   627            && QGLFramebufferObject::hasOpenGLFramebufferBlit()

   628            && qt_gl_preferGL2Engine();

   629 }

   630 

   631 QPaintEngine* QGLPixmapData::paintEngine() const

   632 {

   633     if (!isValid())

   634         return 0;

   635 

   636     if (m_renderFbo)

   637         return m_engine;

   638 

   639     if (useFramebufferObjects()) {

   640         extern QGLWidget* qt_gl_share_widget();

   641 

   642         if (!QGLContext::currentContext())

   643             qt_gl_share_widget()->makeCurrent();

   644         QGLShareContextScope ctx(qt_gl_share_widget()->context());

   645 

   646         QGLFramebufferObjectFormat format;

   647         format.setAttachment(QGLFramebufferObject::CombinedDepthStencil);

   648         format.setSamples(4);

   649         format.setInternalTextureFormat(GLenum(m_hasAlpha ? GL_RGBA : GL_RGB));

   650 

   651         m_renderFbo = qgl_fbo_pool()->acquire(size(), format);

   652 

   653         if (m_renderFbo) {

   654             if (!m_engine)

   655                 m_engine = new QGL2PaintEngineEx;

   656             return m_engine;

   657         }

   658 

   659         qWarning() << "Failed to create pixmap texture buffer of size " << size() << ", falling back to raster paint engine";

   660     }

   661 

   662     m_dirty = true;

   663     if (m_source.size() != size())

   664         m_source = QImage(size(), QImage::Format_ARGB32_Premultiplied);

   665     if (m_hasFillColor) {

   666         m_source.fill(PREMUL(m_fillColor.rgba()));

   667         m_hasFillColor = false;

   668     }

   669     return m_source.paintEngine();

   670 }

   671 

   672 extern QRgb qt_gl_convertToGLFormat(QRgb src_pixel, GLenum texture_format);

   673 

   674 // If copyBack is true, bind will copy the contents of the render

   675 // FBO to the texture (which is not bound to the texture, as it's

   676 // a multisample FBO).

   677 GLuint QGLPixmapData::bind(bool copyBack) const

   678 {

   679     if (m_renderFbo && copyBack) {

   680         copyBackFromRenderFbo(true);

   681     } else {

   682         ensureCreated();

   683     }

   684 

   685     GLuint id = m_texture.id;

   686     glBindTexture(GL_TEXTURE_2D, id);

   687 

   688     if (m_hasFillColor) {

   689         if (!useFramebufferObjects()) {

   690             m_source = QImage(w, h, QImage::Format_ARGB32_Premultiplied);

   691             m_source.fill(PREMUL(m_fillColor.rgba()));

   692         }

   693 

   694         m_hasFillColor = false;

   695 

   696         GLenum format = qt_gl_preferredTextureFormat();

   697         QImage tx(w, h, QImage::Format_ARGB32_Premultiplied);

   698         tx.fill(qt_gl_convertToGLFormat(m_fillColor.rgba(), format));

   699         glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, w, h, format, GL_UNSIGNED_BYTE, tx.bits());

   700     }

   701 

   702     return id;

   703 }

   704 

   705 QGLTexture* QGLPixmapData::texture() const

   706 {

   707     return &m_texture;

   708 }

   709 

   710 extern int qt_defaultDpiX();

   711 extern int qt_defaultDpiY();

   712 

   713 int QGLPixmapData::metric(QPaintDevice::PaintDeviceMetric metric) const

   714 {

   715     if (w == 0)

   716         return 0;

   717 

   718     switch (metric) {

   719     case QPaintDevice::PdmWidth:

   720         return w;

   721     case QPaintDevice::PdmHeight:

   722         return h;

   723     case QPaintDevice::PdmNumColors:

   724         return 0;

   725     case QPaintDevice::PdmDepth:

   726         return d;

   727     case QPaintDevice::PdmWidthMM:

   728         return qRound(w * 25.4 / qt_defaultDpiX());

   729     case QPaintDevice::PdmHeightMM:

   730         return qRound(h * 25.4 / qt_defaultDpiY());

   731     case QPaintDevice::PdmDpiX:

   732     case QPaintDevice::PdmPhysicalDpiX:

   733         return qt_defaultDpiX();

   734     case QPaintDevice::PdmDpiY:

   735     case QPaintDevice::PdmPhysicalDpiY:

   736         return qt_defaultDpiY();

   737     default:

   738         qWarning("QGLPixmapData::metric(): Invalid metric");

   739         return 0;

   740     }

   741 }

   742 

   743 QGLPaintDevice *QGLPixmapData::glDevice() const

   744 {

   745     return &m_glDevice;

   746 }

   747 

   748 QT_END_NAMESPACE