qwindowsurface_vgegl.cpp File Reference

#include "qwindowsurface_vgegl_p.h"
#include "qpaintengine_vg_p.h"
#include "qpixmapdata_vg_p.h"
#include "qvgimagepool_p.h"
#include "qvg_p.h"

Go to the source code of this file.

Classes
class	QVGSharedContext

Macros
#define	QVG_NO_PRESERVED_SWAP   1

Functions
static QEglContext *	createContext (QPaintDevice *device)
	Q_GLOBAL_STATIC (QVGSharedContext, sharedContext)
QImage::Format	qt_vg_config_to_image_format (QEglContext *context)
VGImageFormat	qt_vg_config_to_vg_format (QEglContext *context)
QEglContext *	qt_vg_create_context (QPaintDevice *device, int devType)
QVGPaintEngine *	qt_vg_create_paint_engine (void)
void	qt_vg_destroy_context (QEglContext *context, int devType)
void	qt_vg_destroy_paint_engine (QVGPaintEngine *engine)
static void	qt_vg_destroy_shared_context (QVGSharedContext *shared)
void	qt_vg_hibernate_pixmaps (QVGSharedContext *shared)
void	qt_vg_register_pixmap (QVGPixmapData *pd)
EGLSurface	qt_vg_shared_surface (void)
void	qt_vg_unregister_pixmap (QVGPixmapData *pd)

Macro Definition Documentation

QVG_NO_PRESERVED_SWAP

#define QVG_NO_PRESERVED_SWAP   1

Definition at line 62 of file qwindowsurface_vgegl.cpp.

Function Documentation

createContext()

static QEglContext* createContext ( QPaintDevice *  device )

static

Definition at line 213 of file qwindowsurface_vgegl.cpp.

Referenced by qt_vg_create_context(), qt_vg_shared_surface(), and QEglContext::setApi().

{
    QEglContext *context;

    // Create the context object and open the display.
    context = new QEglContext();
    context->setApi(QEgl::OpenVG);

    // Set the swap interval for the display.
    QByteArray interval = qgetenv("QT_VG_SWAP_INTERVAL");
    if (!interval.isEmpty())
        eglSwapInterval(QEgl::display(), interval.toInt());
    else
        eglSwapInterval(QEgl::display(), 1);

#ifdef EGL_RENDERABLE_TYPE
    // Has the user specified an explicit EGL configuration to use?
    QByteArray configId = qgetenv("QT_VG_EGL_CONFIG");
    if (!configId.isEmpty()) {
        EGLint cfgId = configId.toInt();
        EGLint properties[] = {
            EGL_CONFIG_ID, cfgId,
            EGL_NONE
        };
        EGLint matching = 0;
        EGLConfig cfg;
        if (eglChooseConfig
                    (QEgl::display(), properties, &cfg, 1, &matching) &&
                matching > 0) {
            // Check that the selected configuration actually supports OpenVG
            // and then create the context with it.
            EGLint id = 0;
            EGLint type = 0;
            eglGetConfigAttrib
                (QEgl::display(), cfg, EGL_CONFIG_ID, &id);
            eglGetConfigAttrib
                (QEgl::display(), cfg, EGL_RENDERABLE_TYPE, &type);
            if (cfgId == id && (type & EGL_OPENVG_BIT) != 0) {
                context->setConfig(cfg);
                if (!context->createContext()) {
                    delete context;
                    return 0;
                }
                return context;
            } else {
                qWarning("QT_VG_EGL_CONFIG: %d is not a valid OpenVG configuration", int(cfgId));
            }
        }
    }
#endif

    // Choose an appropriate configuration for rendering into the device.
    QEglProperties configProps;
    configProps.setPaintDeviceFormat(device);
    int redSize = configProps.value(EGL_RED_SIZE);
    if (redSize == EGL_DONT_CARE || redSize == 0)
        configProps.setPixelFormat(QImage::Format_ARGB32);  // XXX
    configProps.setValue(EGL_ALPHA_MASK_SIZE, 1);
#ifdef EGL_VG_ALPHA_FORMAT_PRE_BIT
    configProps.setValue(EGL_SURFACE_TYPE, EGL_WINDOW_BIT
                         | EGL_SWAP_BEHAVIOR_PRESERVED_BIT
                         | EGL_VG_ALPHA_FORMAT_PRE_BIT);
    configProps.setRenderableType(QEgl::OpenVG);
    if (!context->chooseConfig(configProps)) {
        // Try again without the "pre" bit.
        configProps.setValue(EGL_SURFACE_TYPE, EGL_WINDOW_BIT | EGL_SWAP_BEHAVIOR_PRESERVED_BIT);
        if (!context->chooseConfig(configProps)) {
            delete context;
            return 0;
        }
    }
#else
    configProps.setValue(EGL_SURFACE_TYPE, EGL_WINDOW_BIT | EGL_SWAP_BEHAVIOR_PRESERVED_BIT);
    configProps.setRenderableType(QEgl::OpenVG);
    if (!context->chooseConfig(configProps)) {
        delete context;
        return 0;
    }
#endif

    // Construct a new EGL context for the selected configuration.
    if (!context->createContext()) {
        delete context;
        return 0;
    }

    return context;
}

Q_GLOBAL_STATIC()

Q_GLOBAL_STATIC	(	QVGSharedContext	,
		sharedContext
	)

Referenced by QVGSharedContext::~QVGSharedContext().

qt_vg_config_to_image_format()

QImage::Format qt_vg_config_to_image_format

(

QEglContext *

context

)

Definition at line 72 of file qwindowsurface_vgegl.cpp.

Referenced by qt_vg_config_to_vg_format().

{
    EGLint red = context->configAttrib(EGL_RED_SIZE);
    EGLint green = context->configAttrib(EGL_GREEN_SIZE);
    EGLint blue = context->configAttrib(EGL_BLUE_SIZE);
    EGLint alpha = context->configAttrib(EGL_ALPHA_SIZE);
    QImage::Format argbFormat;
#ifdef EGL_VG_ALPHA_FORMAT_PRE_BIT
    EGLint type = context->configAttrib(EGL_SURFACE_TYPE);
    if ((type & EGL_VG_ALPHA_FORMAT_PRE_BIT) != 0)
        argbFormat = QImage::Format_ARGB32_Premultiplied;
    else
        argbFormat = QImage::Format_ARGB32;
#else
    argbFormat = QImage::Format_ARGB32;
#endif
    if (red == 8 && green == 8 && blue == 8 && alpha == 8)
        return argbFormat;
    else if (red == 8 && green == 8 && blue == 8 && alpha == 0)
        return QImage::Format_RGB32;
    else if (red == 5 && green == 6 && blue == 5 && alpha == 0)
        return QImage::Format_RGB16;
    else if (red == 4 && green == 4 && blue == 4 && alpha == 4)
        return QImage::Format_ARGB4444_Premultiplied;
    else
        return argbFormat;       // XXX
}

qt_vg_config_to_vg_format()

VGImageFormat qt_vg_config_to_vg_format

(

QEglContext *

context

)

Definition at line 66 of file qwindowsurface_vgegl.cpp.

Referenced by QVGEGLWindowSurfacePrivate::windowSurfaceSize().

{
    return qt_vg_image_to_vg_format
        (qt_vg_config_to_image_format(context));
}

qt_vg_create_context()

QEglContext* qt_vg_create_context	(	QPaintDevice *	device,
		int	devType
	)

Definition at line 304 of file qwindowsurface_vgegl.cpp.

Referenced by QVGPixmapData::destroyImageAndContext(), QVGEGLWindowSurfaceDirect::ensureContext(), qt_vg_shared_surface(), QVGPixmapData::toVGImage(), and QVGEGLWindowSurfacePrivate::windowSurfaceSize().

{
    QVGSharedContext *shared = sharedContext();
    if (devType == QInternal::Widget)
        ++(shared->widgetRefCount);
    if (shared->context) {
        ++(shared->refCount);
        return shared->context;
    } else {
        shared->context = createContext(device);
        shared->refCount = 1;
        return shared->context;
    }
}

qt_vg_create_paint_engine()

QVGPaintEngine* qt_vg_create_paint_engine

(

void

)

Definition at line 144 of file qwindowsurface_vgegl.cpp.

Referenced by QVGEGLWindowSurfacePrivate::paintEngine(), qt_vg_unregister_pixmap(), and QVGCompositionHelper::QVGCompositionHelper().

{
    QVGSharedContext *shared = sharedContext();
    if (!shared->engine)
        shared->engine = new QVGPaintEngine();
    return shared->engine;
}

qt_vg_destroy_context()

void qt_vg_destroy_context	(	QEglContext *	context,
		int	devType
	)

Definition at line 361 of file qwindowsurface_vgegl.cpp.

Referenced by QVGPixmapData::destroyImageAndContext(), QVGEGLWindowSurfaceDirect::ensureContext(), qt_vg_shared_surface(), QVGEGLWindowSurfacePrivate::windowSurfaceSize(), and QVGEGLWindowSurfaceDirect::~QVGEGLWindowSurfaceDirect().

{
    QVGSharedContext *shared = sharedContext();
    if (shared->context != context) {
        // This is not the shared context.  Shouldn't happen!
        delete context;
        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);
    }
}

qt_vg_destroy_paint_engine()

void qt_vg_destroy_paint_engine

(

QVGPaintEngine *

engine

)

Definition at line 152 of file qwindowsurface_vgegl.cpp.

Referenced by QVGEGLWindowSurfacePrivate::destroyPaintEngine(), QVGEGLWindowSurfaceDirect::ensureContext(), and qt_vg_unregister_pixmap().

{
    Q_UNUSED(engine);
}

qt_vg_destroy_shared_context()

static void qt_vg_destroy_shared_context ( QVGSharedContext *  shared )

static

Definition at line 319 of file qwindowsurface_vgegl.cpp.

Referenced by qt_vg_destroy_context(), and qt_vg_hibernate_pixmaps().

{
    shared->context->makeCurrent(qt_vg_shared_surface());
    delete shared->engine;
    shared->engine = 0;
    shared->context->doneCurrent();
    if (shared->surface != EGL_NO_SURFACE) {
        eglDestroySurface(QEgl::display(), shared->surface);
        shared->surface = EGL_NO_SURFACE;
    }
    delete shared->context;
    shared->context = 0;
}

qt_vg_hibernate_pixmaps()

void qt_vg_hibernate_pixmaps

(

QVGSharedContext *

shared

)

Definition at line 333 of file qwindowsurface_vgegl.cpp.

Referenced by qt_vg_destroy_context().

{
    // 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;
    }

    // Hibernate any remaining VGImage's in the image pool.
    QVGImagePool::instance()->hibernate();

    // 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);
}

qt_vg_register_pixmap()

void qt_vg_register_pixmap

(

QVGPixmapData *

pd

)

Definition at line 157 of file qwindowsurface_vgegl.cpp.

Referenced by qt_vg_unregister_pixmap().

{
    QVGSharedContext *shared = sharedContext();
    pd->next = shared->firstPixmap;
    pd->prev = 0;
    if (shared->firstPixmap)
        shared->firstPixmap->prev = pd;
    shared->firstPixmap = pd;
}

qt_vg_shared_surface()

EGLSurface qt_vg_shared_surface

(

void

)

Definition at line 384 of file qwindowsurface_vgegl.cpp.

Referenced by QVGPixmapData::destroyImageAndContext(), qt_vg_destroy_shared_context(), qt_vg_hibernate_pixmaps(), QVGEGLWindowSurfacePrivate::windowSurfaceSize(), and QVGSharedContext::~QVGSharedContext().

{
    QVGSharedContext *shared = sharedContext();
    if (shared->surface == EGL_NO_SURFACE) {
        EGLint attribs[7];
        attribs[0] = EGL_WIDTH;
        attribs[1] = 16;
        attribs[2] = EGL_HEIGHT;
        attribs[3] = 16;
#ifdef EGL_VG_ALPHA_FORMAT_PRE_BIT
        if (isPremultipliedContext(shared->context)) {
            attribs[4] = EGL_VG_ALPHA_FORMAT;
            attribs[5] = EGL_VG_ALPHA_FORMAT_PRE;
            attribs[6] = EGL_NONE;
        } else
#endif
        {
            attribs[4] = EGL_NONE;
        }
        shared->surface = eglCreatePbufferSurface
            (QEgl::display(), shared->context->config(), attribs);
    }
    return shared->surface;
}

qt_vg_unregister_pixmap()

void qt_vg_unregister_pixmap

(

QVGPixmapData *

pd

)

Definition at line 167 of file qwindowsurface_vgegl.cpp.

{
    if (pd->next)
        pd->next->prev = pd->prev;
    if (pd->prev) {
        pd->prev->next = pd->next;
    } else {
        QVGSharedContext *shared = sharedContext();
        if (shared)
           shared->firstPixmap = pd->next;
    }
}