Merge oslo-staging-2/4.6 into upstream/4.6

4 files changed, 169 insertions, 29 deletions

diff --git a/src/openvg/qpixmapdata_vg.cpp b/src/openvg/qpixmapdata_vg.cpp
index 19c90ed..5d5fcbf 100644
--- a/src/openvg/qpixmapdata_vg.cpp
+++ b/src/openvg/qpixmapdata_vg.cpp
@@ -65,12 +65,21 @@ QVGPixmapData::QVGPixmapData(PixelType type)
     recreate = true;
 #if !defined(QT_NO_EGL)
     context = 0;
+    qt_vg_register_pixmap(this);
 #endif
     setSerialNumber(++qt_vg_pixmap_serial);
 }
 
 QVGPixmapData::~QVGPixmapData()
 {
+    destroyImageAndContext();
+#if !defined(QT_NO_EGL)
+    qt_vg_unregister_pixmap(this);
+#endif
+}
+
+void QVGPixmapData::destroyImageAndContext()
+{
     if (vgImage != VG_INVALID_HANDLE) {
         // We need to have a context current to destroy the image.
 #if !defined(QT_NO_EGL)
@@ -93,11 +102,16 @@ QVGPixmapData::~QVGPixmapData()
         if (vgImageOpacity != VG_INVALID_HANDLE)
             vgDestroyImage(vgImageOpacity);
 #endif
+        vgImage = VG_INVALID_HANDLE;
+        vgImageOpacity = VG_INVALID_HANDLE;
     }
 #if !defined(QT_NO_EGL)
-    if (context)
-        qt_vg_destroy_context(context);
+    if (context) {
+        qt_vg_destroy_context(context, QInternal::Pixmap);
+        context = 0;
+    }
 #endif
+    recreate = true;
 }
 
 QPixmapData *QVGPixmapData::createCompatiblePixmapData() const
@@ -217,7 +231,7 @@ VGImage QVGPixmapData::toVGImage()
 #if !defined(QT_NO_EGL)
     // Increase the reference count on the shared context.
     if (!context)
-        context = qt_vg_create_context(0);
+        context = qt_vg_create_context(0, QInternal::Pixmap);
 #endif
 
     if (recreate && prevSize != QSize(w, h)) {
@@ -286,6 +300,17 @@ VGImage QVGPixmapData::toVGImage(qreal opacity)
 #endif
 }
 
+void QVGPixmapData::hibernate()
+{
+    // If the image was imported (e.g, from an SgImage under Symbian),
+    // then we cannot copy it back to main memory for storage.
+    if (vgImage != VG_INVALID_HANDLE && source.isNull())
+        return;
+
+    forceToImage();
+    destroyImageAndContext();
+}
+
 extern int qt_defaultDpiX();
 extern int qt_defaultDpiY();
 
@@ -376,7 +401,7 @@ void QVGPixmapData::fromNativeType(void* pixmap, NativeType type)
         // when "0" used as argument then
         // default display, context are used
         if (!context)
-            context = qt_vg_create_context(0);
+            context = qt_vg_create_context(0, QInternal::Pixmap);
 
         if (vgImage != VG_INVALID_HANDLE) {
             vgDestroyImage(vgImage);
diff --git a/src/openvg/qpixmapdata_vg_p.h b/src/openvg/qpixmapdata_vg_p.h
index fe19f35..c0bb098 100644
--- a/src/openvg/qpixmapdata_vg_p.h
+++ b/src/openvg/qpixmapdata_vg_p.h
@@ -55,8 +55,6 @@
 
 #include <QtGui/private/qpixmap_raster_p.h>
 #include <private/qvg_p.h>
-#if !defined(QT_NO_EGL)
-#endif
 
 #if defined(Q_OS_SYMBIAN)
 class RSGImage;
@@ -66,6 +64,15 @@ QT_BEGIN_NAMESPACE
 
 class QEglContext;
 
+#if !defined(QT_NO_EGL)
+class QVGPixmapData;
+class QVGSharedContext;
+
+void qt_vg_register_pixmap(QVGPixmapData *pd);
+void qt_vg_unregister_pixmap(QVGPixmapData *pd);
+void qt_vg_hibernate_pixmaps(QVGSharedContext *context);
+#endif
+
 class Q_OPENVG_EXPORT QVGPixmapData : public QPixmapData
 {
 public:
@@ -94,6 +101,14 @@ public:
     // Return the VGImage form for a specific opacity setting.
     virtual VGImage toVGImage(qreal opacity);
 
+    // Release the VG resources associated with this pixmap and copy
+    // the pixmap's contents out of the GPU back into main memory.
+    // The VG resource will be automatically recreated the next time
+    // toVGImage() is called.  Does nothing if the pixmap cannot be
+    // hibernated for some reason (e.g. VGImage is shared with another
+    // process via a SgImage).
+    virtual void hibernate();
+
     QSize size() const { return QSize(w, h); }
 
 #if defined(Q_OS_SYMBIAN)
@@ -108,6 +123,16 @@ protected:
     void cleanup();
 #endif
 
+#if !defined(QT_NO_EGL)
+private:
+    QVGPixmapData *next;
+    QVGPixmapData *prev;
+
+    friend void qt_vg_register_pixmap(QVGPixmapData *pd);
+    friend void qt_vg_unregister_pixmap(QVGPixmapData *pd);
+    friend void qt_vg_hibernate_pixmaps(QVGSharedContext *context);
+#endif
+
 protected:
     QSize prevSize;
     VGImage vgImage;
@@ -121,6 +146,8 @@ protected:
 
     void forceToImage();
     QImage::Format sourceFormat() const;
+
+    void destroyImageAndContext();
 };
 
 QT_END_NAMESPACE
diff --git a/src/openvg/qvg_p.h b/src/openvg/qvg_p.h
index 04e2bab..3577013 100644
--- a/src/openvg/qvg_p.h
+++ b/src/openvg/qvg_p.h
@@ -71,11 +71,17 @@ class QEglContext;
 
 // Create an EGL context, but don't bind it to a surface.  If single-context
 // mode is enabled, this will return the previously-created context.
-Q_OPENVG_EXPORT QEglContext *qt_vg_create_context(QPaintDevice *device);
+// "devType" indicates the type of device using the context, usually
+// QInternal::Widget or QInternal::Pixmap.
+Q_OPENVG_EXPORT QEglContext *qt_vg_create_context
+    (QPaintDevice *device, int devType);
 
 // Destroy an EGL context that was created by qt_vg_create_context().
 // If single-context mode is enabled, this will decrease the reference count.
-Q_OPENVG_EXPORT void qt_vg_destroy_context(QEglContext *context);
+// "devType" indicates the type of device destroying the context, usually
+// QInternal::Widget or QInternal::Pixmap.
+Q_OPENVG_EXPORT void qt_vg_destroy_context
+    (QEglContext *context, int devType);
 
 // Return the shared pbuffer surface that can be made current to
 // destroy VGImage objects when there is no other surface available.
diff --git a/src/openvg/qwindowsurface_vgegl.cpp b/src/openvg/qwindowsurface_vgegl.cpp
index 62871cf..1571083 100644
--- a/src/openvg/qwindowsurface_vgegl.cpp
+++ b/src/openvg/qwindowsurface_vgegl.cpp
@@ -111,15 +111,19 @@ public:
 
     QEglContext *context;
     int refCount;
+    int widgetRefCount;
     QVGPaintEngine *engine;
     EGLSurface surface;
+    QVGPixmapData *firstPixmap;
 };
 
 QVGSharedContext::QVGSharedContext()
     : context(0)
     , refCount(0)
+    , widgetRefCount(0)
     , engine(0)
     , surface(EGL_NO_SURFACE)
+    , firstPixmap(0)
 {
 }
 
@@ -154,6 +158,28 @@ void qt_vg_destroy_paint_engine(QVGPaintEngine *engine)
     Q_UNUSED(engine);
 }
 
+void qt_vg_register_pixmap(QVGPixmapData *pd)
+{
+    QVGSharedContext *shared = sharedContext();
+    pd->next = shared->firstPixmap;
+    pd->prev = 0;
+    if (shared->firstPixmap)
+        shared->firstPixmap->prev = pd;
+    shared->firstPixmap = pd;
+}
+
+void qt_vg_unregister_pixmap(QVGPixmapData *pd)
+{
+    if (pd->next)
+        pd->next->prev = pd->prev;
+    if (pd->prev) {
+        pd->prev->next = pd->next;
+    } else {
+        QVGSharedContext *shared = sharedContext();
+        shared->firstPixmap = pd->next;
+    }
+}
+
 #else
 
 QVGPaintEngine *qt_vg_create_paint_engine(void)
@@ -166,6 +192,16 @@ void qt_vg_destroy_paint_engine(QVGPaintEngine *engine)
     delete engine;
 }
 
+void qt_vg_register_pixmap(QVGPixmapData *pd)
+{
+    Q_UNUSED(pd);
+}
+
+void qt_vg_unregister_pixmap(QVGPixmapData *pd)
+{
+    Q_UNUSED(pd);
+}
+
 #endif
 
 #ifdef EGL_VG_ALPHA_FORMAT_PRE_BIT
@@ -278,9 +314,11 @@ static QEglContext *createContext(QPaintDevice *device)
 
 #if !defined(QVG_NO_SINGLE_CONTEXT)
 
-QEglContext *qt_vg_create_context(QPaintDevice *device)
+QEglContext *qt_vg_create_context(QPaintDevice *device, int devType)
 {
     QVGSharedContext *shared = sharedContext();
+    if (devType == QInternal::Widget)
+        ++(shared->widgetRefCount);
     if (shared->context) {
         ++(shared->refCount);
         return shared->context;
@@ -291,23 +329,65 @@ QEglContext *qt_vg_create_context(QPaintDevice *device)
     }
 }
 
-void qt_vg_destroy_context(QEglContext *context)
+static void qt_vg_destroy_shared_context(QVGSharedContext *shared)
+{
+    shared->context->makeCurrent(qt_vg_shared_surface());
+    delete shared->engine;
+    shared->engine = 0;
+    shared->context->doneCurrent();
+    if (shared->surface != EGL_NO_SURFACE) {
+        eglDestroySurface(shared->context->display(), shared->surface);
+        shared->surface = EGL_NO_SURFACE;
+    }
+    delete shared->context;
+    shared->context = 0;
+}
+
+void qt_vg_hibernate_pixmaps(QVGSharedContext *shared)
+{
+    // Artificially increase the reference count to prevent the
+    // context from being destroyed until after we have finished
+    // the hibernation process.
+    ++(shared->refCount);
+
+    // We need a context current to hibernate the VGImage objects.
+    shared->context->makeCurrent(qt_vg_shared_surface());
+
+    // Scan all QVGPixmapData objects in the system and hibernate them.
+    QVGPixmapData *pd = shared->firstPixmap;
+    while (pd != 0) {
+        pd->hibernate();
+        pd = pd->next;
+    }
+
+    // Don't need the current context any more.
+    shared->context->lazyDoneCurrent();
+
+    // Decrease the reference count and destroy the context if necessary.
+    if (--(shared->refCount) <= 0)
+        qt_vg_destroy_shared_context(shared);
+}
+
+void qt_vg_destroy_context(QEglContext *context, int devType)
 {
     QVGSharedContext *shared = sharedContext();
     if (shared->context != context) {
         // This is not the shared context.  Shouldn't happen!
         delete context;
-    } else if (--(shared->refCount) <= 0) {
-        shared->context->makeCurrent(qt_vg_shared_surface());
-        delete shared->engine;
-        shared->engine = 0;
-        shared->context->doneCurrent();
-        if (shared->surface != EGL_NO_SURFACE) {
-            eglDestroySurface(shared->context->display(), shared->surface);
-            shared->surface = EGL_NO_SURFACE;
-        }
-        delete shared->context;
-        shared->context = 0;
+        return;
+    }
+    if (devType == QInternal::Widget)
+        --(shared->widgetRefCount);
+    if (--(shared->refCount) <= 0) {
+        qt_vg_destroy_shared_context(shared);
+    } else if (shared->widgetRefCount <= 0 && devType == QInternal::Widget) {
+        // All of the widget window surfaces have been destroyed
+        // but we still have VG pixmaps active.  Ask them to hibernate
+        // to free up GPU resources until a widget is shown again.
+        // This may eventually cause the EGLContext to be destroyed
+        // because nothing in the system needs a context, which will
+        // free up even more GPU resources.
+        qt_vg_hibernate_pixmaps(shared);
     }
 }
 
@@ -338,13 +418,15 @@ EGLSurface qt_vg_shared_surface(void)
 
 #else
 
-QEglContext *qt_vg_create_context(QPaintDevice *device)
+QEglContext *qt_vg_create_context(QPaintDevice *device, int devType)
 {
+    Q_UNUSED(devType);
     return createContext(device);
 }
 
-void qt_vg_destroy_context(QEglContext *context)
+void qt_vg_destroy_context(QEglContext *context, int devType)
 {
+    Q_UNUSED(devType);
     delete context;
 }
 
@@ -434,7 +516,7 @@ QVGEGLWindowSurfaceVGImage::~QVGEGLWindowSurfaceVGImage()
         }
         if (windowSurface != EGL_NO_SURFACE)
             context->destroySurface(windowSurface);
-        qt_vg_destroy_context(context);
+        qt_vg_destroy_context(context, QInternal::Widget);
     }
 }
 
@@ -453,7 +535,7 @@ QEglContext *QVGEGLWindowSurfaceVGImage::ensureContext(QWidget *widget)
     if (!context) {
         // Create a new EGL context.  We create the surface in beginPaint().
         size = newSize;
-        context = qt_vg_create_context(widget);
+        context = qt_vg_create_context(widget, QInternal::Widget);
         if (!context)
             return 0;
         isPaintingActive = false;
@@ -548,7 +630,7 @@ QVGEGLWindowSurfaceDirect::~QVGEGLWindowSurfaceDirect()
     if (context) {
         if (windowSurface != EGL_NO_SURFACE)
             context->destroySurface(windowSurface);
-        qt_vg_destroy_context(context);
+        qt_vg_destroy_context(context, QInternal::Widget);
     }
 }
 
@@ -587,7 +669,7 @@ QEglContext *QVGEGLWindowSurfaceDirect::ensureContext(QWidget *widget)
         qt_vg_destroy_paint_engine(engine);
         engine = 0;
         context->destroySurface(windowSurface);
-        qt_vg_destroy_context(context);
+        qt_vg_destroy_context(context, QInternal::Widget);
         context = 0;
         windowSurface = EGL_NO_SURFACE;
     }
@@ -596,7 +678,7 @@ QEglContext *QVGEGLWindowSurfaceDirect::ensureContext(QWidget *widget)
     if (!context) {
         // Create a new EGL context and bind it to the widget surface.
         size = newSize;
-        context = qt_vg_create_context(widget);
+        context = qt_vg_create_context(widget, QInternal::Widget);
         if (!context)
             return 0;
         // We want a direct to window rendering surface if possible.
@@ -613,7 +695,7 @@ QEglContext *QVGEGLWindowSurfaceDirect::ensureContext(QWidget *widget)
 #endif
         EGLSurface surface = context->createSurface(widget, &surfaceProps);
         if (surface == EGL_NO_SURFACE) {
-            qt_vg_destroy_context(context);
+            qt_vg_destroy_context(context, QInternal::Widget);
             context = 0;
             return 0;
         }