Native image handle provider support in QGLPixmapData

QGLPixmapData's fromNativeType() accepts QNativeImageHandleProvider
pointers with type NativeImageHandleProvider from now on, similarly
to OpenVG pixmaps.

Task-number: QTBUG-18209
Reviewed-by: Jani Hautakangas

3 files changed, 72 insertions, 3 deletions

diff --git a/src/opengl/qgl_symbian.cpp b/src/opengl/qgl_symbian.cpp
index 7caaabd..1b41db4 100644
--- a/src/opengl/qgl_symbian.cpp
+++ b/src/opengl/qgl_symbian.cpp
@@ -48,6 +48,7 @@
 #include <private/qgl_p.h>
 #include <private/qpaintengine_opengl_p.h>
 #include <private/qwidget_p.h> // to access QWExtra
+#include <private/qnativeimagehandleprovider_p.h>
 #include "qgl_egl_p.h"
 #include "qpixmapdata_gl_p.h"
 #include "qgltexturepool_p.h"
@@ -411,6 +412,11 @@ void QGLPixmapData::fromNativeType(void* pixmap, NativeType type)
         m_hasAlpha = m_source.hasAlphaChannel();
         m_hasFillColor = false;
         m_dirty = true;
+    } else if (type == QPixmapData::NativeImageHandleProvider && pixmap) {
+        destroyTexture();
+        nativeImageHandleProvider = static_cast<QNativeImageHandleProvider *>(pixmap);
+        // Cannot defer the retrieval, we need at least the size right away.
+        createFromNativeImageHandleProvider();
     }
 }
 
@@ -425,4 +431,42 @@ void* QGLPixmapData::toNativeType(NativeType type)
     return 0;
 }
 
+bool QGLPixmapData::initFromNativeImageHandle(void *handle, const QString &type)
+{
+    if (type == QLatin1String("RSgImage")) {
+        fromNativeType(handle, QPixmapData::SgImage);
+        return true;
+    } else if (type == QLatin1String("CFbsBitmap")) {
+        fromNativeType(handle, QPixmapData::FbsBitmap);
+        return true;
+    }
+    return false;
+}
+
+void QGLPixmapData::createFromNativeImageHandleProvider()
+{
+    void *handle = 0;
+    QString type;
+    nativeImageHandleProvider->get(&handle, &type);
+    if (handle) {
+        if (initFromNativeImageHandle(handle, type)) {
+            nativeImageHandle = handle;
+            nativeImageType = type;
+        } else {
+            qWarning("QGLPixmapData: Unknown native image type '%s'", qPrintable(type));
+        }
+    } else {
+        qWarning("QGLPixmapData: Native handle is null");
+    }
+}
+
+void QGLPixmapData::releaseNativeImageHandle()
+{
+    if (nativeImageHandleProvider && nativeImageHandle) {
+        nativeImageHandleProvider->release(nativeImageHandle, nativeImageType);
+        nativeImageHandle = 0;
+        nativeImageType = QString();
+    }
+}
+
 QT_END_NAMESPACE
diff --git a/src/opengl/qpixmapdata_gl_p.h b/src/opengl/qpixmapdata_gl_p.h
index 41740dd..8855c20 100644
--- a/src/opengl/qpixmapdata_gl_p.h
+++ b/src/opengl/qpixmapdata_gl_p.h
@@ -76,6 +76,10 @@ void qt_gl_unregister_pixmap(QGLPixmapData *pd);
 void qt_gl_hibernate_pixmaps();
 #endif
 
+#ifdef Q_OS_SYMBIAN
+class QNativeImageHandleProvider;
+#endif
+
 class QGLFramebufferObjectPool
 {
 public:
@@ -160,6 +164,9 @@ public:
     QImage::Format idealFormat(QImage &image, Qt::ImageConversionFlags flags);
     void* toNativeType(NativeType type);
     void fromNativeType(void* pixmap, NativeType type);
+    bool initFromNativeImageHandle(void *handle, const QString &type);
+    void createFromNativeImageHandleProvider();
+    void releaseNativeImageHandle();
 #endif
 
 private:
@@ -191,6 +198,9 @@ private:
     mutable QGLContext *m_ctx;
 #ifdef Q_OS_SYMBIAN
     mutable QVolatileImage m_source;
+    mutable QNativeImageHandleProvider *nativeImageHandleProvider;
+    void *nativeImageHandle;
+    QString nativeImageType;
 #else
     mutable QImage m_source;
 #endif
diff --git a/src/opengl/qpixmapdata_poolgl.cpp b/src/opengl/qpixmapdata_poolgl.cpp
index 64de29e..44d9c84 100644
--- a/src/opengl/qpixmapdata_poolgl.cpp
+++ b/src/opengl/qpixmapdata_poolgl.cpp
@@ -49,6 +49,7 @@
 #include <private/qgl_p.h>
 #include <private/qdrawhelper_p.h>
 #include <private/qimage_p.h>
+#include <private/qnativeimagehandleprovider_p.h>
 
 #include <private/qpaintengineex_opengl2_p.h>
 
@@ -254,6 +255,8 @@ QGLPixmapData::QGLPixmapData(PixelType type)
     , m_renderFbo(0)
     , m_engine(0)
     , m_ctx(0)
+    , nativeImageHandleProvider(0)
+    , nativeImageHandle(0)
     , m_dirty(false)
     , m_hasFillColor(false)
     , m_hasAlpha(false)
@@ -292,6 +295,8 @@ void QGLPixmapData::destroyTexture()
     }
     m_texture.id = 0;
     inTexturePool = false;
+
+    releaseNativeImageHandle();
 }
 
 QPixmapData *QGLPixmapData::createCompatiblePixmapData() const
@@ -342,6 +347,9 @@ void QGLPixmapData::ensureCreated() const
 
     m_dirty = false;
 
+    if (nativeImageHandleProvider && !nativeImageHandle)
+        const_cast<QGLPixmapData *>(this)->createFromNativeImageHandleProvider();
+
     QGLShareContextScope ctx(qt_gl_share_widget()->context());
     m_ctx = ctx;
 
@@ -860,9 +868,16 @@ void QGLPixmapData::detachTextureFromPool()
 
 void QGLPixmapData::hibernate()
 {
-    // If the texture was imported (e.g, from an SgImage under Symbian),
-    // then we cannot copy it back to main memory for storage.
-    if (m_texture.id && m_source.isNull())
+    // If the image was imported (e.g, from an SgImage under Symbian), then
+    // skip the hibernation, there is no sense in copying it back to main
+    // memory because the data is most likely shared between several processes.
+    bool skipHibernate = (m_texture.id && m_source.isNull());
+#if defined(Q_OS_SYMBIAN)
+    // However we have to proceed normally if the image was retrieved via
+    // a handle provider.
+    skipHibernate &= !nativeImageHandleProvider;
+#endif
+    if (skipHibernate)
         return;
 
     forceToImage();