static VGImage sgImageToVGImage(QEglContext *context, const RSgImage &sgImage)
{
// when "0" used as argument then
// default display, context are used
if (!context)
context = qt_vg_create_context(0, QInternal::Pixmap);
VGImage vgImage = VG_INVALID_HANDLE;
if (sgImage.IsNull())
return vgImage;
const EGLint KEglImageAttribs[] = {EGL_IMAGE_PRESERVED_SYMBIAN, EGL_TRUE, EGL_NONE};
EGLImageKHR eglImage = QEgl::eglCreateImageKHR(QEgl::display(),
EGL_NO_CONTEXT,
EGL_NATIVE_PIXMAP_KHR,
(EGLClientBuffer)&sgImage,
(EGLint*)KEglImageAttribs);
if (!eglImage)
return vgImage;
vgImage = QVG::vgCreateEGLImageTargetKHR(eglImage);
QEgl::eglDestroyImageKHR(QEgl::display(), eglImage);
return vgImage;
}
void QVGPixmapData::destroyImageAndContext()
{
if (vgImage != VG_INVALID_HANDLE) {
// We need to have a context current to destroy the image.
#if !defined(QT_NO_EGL)
if (!context)
context = qt_vg_create_context(0, QInternal::Pixmap);
if (context->isCurrent()) {
destroyImages();
} else {
// We don't currently have a widget surface active, but we
// need a surface to make the context current. So use the
// shared pbuffer surface instead.
context->makeCurrent(qt_vg_shared_surface());
destroyImages();
context->lazyDoneCurrent();
}
#else
destroyImages();
#endif
} else {
#if defined(Q_OS_SYMBIAN)
releaseNativeImageHandle();
#endif
}
#if !defined(QT_NO_EGL)
if (context) {
qt_vg_destroy_context(context, QInternal::Pixmap);
context = 0;
}
#endif
recreate = true;
}
VGImage QVGPixmapData::toVGImage()
{
if (!isValid() || failedToAlloc)
return VG_INVALID_HANDLE;
#if !defined(QT_NO_EGL)
// Increase the reference count on the shared context.
if (!context)
context = qt_vg_create_context(0, QInternal::Pixmap);
#endif
if (recreate && prevSize != QSize(w, h))
destroyImages();
else if (recreate)
cachedOpacity = -1.0f; // Force opacity image to be refreshed later.
#if defined(Q_OS_SYMBIAN)
if (recreate && nativeImageHandleProvider && !nativeImageHandle) {
createFromNativeImageHandleProvider();
}
#endif
if (vgImage == VG_INVALID_HANDLE) {
vgImage = QVGImagePool::instance()->createImageForPixmap
(qt_vg_image_to_vg_format(source.format()), w, h, VG_IMAGE_QUALITY_FASTER, this);
// Bail out if we run out of GPU memory - try again next time.
if (vgImage == VG_INVALID_HANDLE) {
failedToAlloc = true;
return VG_INVALID_HANDLE;
}
inImagePool = true;
} else if (inImagePool) {
QVGImagePool::instance()->useImage(this);
}
if (!source.isNull() && recreate) {
source.beginDataAccess();
vgImageSubData
(vgImage,
source.constBits(), source.bytesPerLine(),
qt_vg_image_to_vg_format(source.format()), 0, 0, w, h);
source.endDataAccess(true);
}
recreate = false;
prevSize = QSize(w, h);
return vgImage;
}
VGImage QVGPixmapData::toVGImage()
{
if (!isValid())
return VG_INVALID_HANDLE;
#if !defined(QT_NO_EGL)
// Increase the reference count on the shared context.
if (!context)
context = qt_vg_create_context(0, QInternal::Pixmap);
#endif
if (recreate && prevSize != QSize(w, h))
destroyImages();
else if (recreate)
cachedOpacity = -1.0f; // Force opacity image to be refreshed later.
if (vgImage == VG_INVALID_HANDLE) {
vgImage = QVGImagePool::instance()->createImageForPixmap
(VG_sARGB_8888_PRE, w, h, VG_IMAGE_QUALITY_FASTER, this);
// Bail out if we run out of GPU memory - try again next time.
if (vgImage == VG_INVALID_HANDLE)
return VG_INVALID_HANDLE;
inImagePool = true;
} else if (inImagePool) {
QVGImagePool::instance()->useImage(this);
}
if (!source.isNull() && recreate) {
vgImageSubData
(vgImage,
source.constBits(), source.bytesPerLine(),
VG_sARGB_8888_PRE, 0, 0, w, h);
}
recreate = false;
prevSize = QSize(w, h);
return vgImage;
}
QEglContext *QVGEGLWindowSurfaceVGImage::ensureContext(QWidget *widget)
{
QSize newSize = windowSurfaceSize(widget);
if (context && size != newSize) {
// The surface size has changed, so we need to recreate
// the back buffer. Keep the same context and paint engine.
size = newSize;
if (isPaintingActive)
context->doneCurrent();
isPaintingActive = false;
recreateBackBuffer = true;
}
if (!context) {
// Create a new EGL context. We create the surface in beginPaint().
size = newSize;
context = qt_vg_create_context(widget, QInternal::Widget);
if (!context)
return 0;
isPaintingActive = false;
}
return context;
}
QEglContext *QVGEGLWindowSurfaceDirect::ensureContext(QWidget *widget)
{
QSize newSize = windowSurfaceSize(widget);
QEglProperties surfaceProps;
#if defined(QVG_RECREATE_ON_SIZE_CHANGE)
#if !defined(QVG_NO_SINGLE_CONTEXT)
if (context && size != newSize) {
// The surface size has changed, so we need to recreate it.
// We can keep the same context and paint engine.
size = newSize;
if (isPaintingActive)
context->doneCurrent();
context->destroySurface(windowSurface);
#if defined(EGL_VG_ALPHA_FORMAT_PRE_BIT)
if (isPremultipliedContext(context)) {
surfaceProps.setValue
(EGL_VG_ALPHA_FORMAT, EGL_VG_ALPHA_FORMAT_PRE);
} else {
surfaceProps.removeValue(EGL_VG_ALPHA_FORMAT);
}
#endif
windowSurface = context->createSurface(widget, &surfaceProps);
isPaintingActive = false;
needToSwap = true;
}
#else
if (context && size != newSize) {
// The surface size has changed, so we need to recreate
// the EGL context for the widget. We also need to recreate
// the surface's paint engine if context sharing is not
// enabled because we cannot reuse the existing paint objects
// in the new context.
qt_vg_destroy_paint_engine(engine);
engine = 0;
context->destroySurface(windowSurface);
qt_vg_destroy_context(context, QInternal::Widget);
context = 0;
windowSurface = EGL_NO_SURFACE;
}
#endif
#endif
if (!context) {
// Create a new EGL context and bind it to the widget surface.
size = newSize;
context = qt_vg_create_context(widget, QInternal::Widget);
if (!context)
return 0;
// We want a direct to window rendering surface if possible.
#if defined(QVG_DIRECT_TO_WINDOW)
surfaceProps.setValue(EGL_RENDER_BUFFER, EGL_SINGLE_BUFFER);
#endif
#if defined(EGL_VG_ALPHA_FORMAT_PRE_BIT)
if (isPremultipliedContext(context)) {
surfaceProps.setValue
(EGL_VG_ALPHA_FORMAT, EGL_VG_ALPHA_FORMAT_PRE);
} else {
surfaceProps.removeValue(EGL_VG_ALPHA_FORMAT);
}
#endif
EGLSurface surface = context->createSurface(widget, &surfaceProps);
if (surface == EGL_NO_SURFACE) {
qt_vg_destroy_context(context, QInternal::Widget);
context = 0;
return 0;
}
needToSwap = true;
#if defined(QVG_DIRECT_TO_WINDOW)
// Did we get a direct to window rendering surface?
EGLint buffer = 0;
if (eglQueryContext(QEgl::display(), context->context(),
EGL_RENDER_BUFFER, &buffer) &&
buffer == EGL_SINGLE_BUFFER) {
needToSwap = false;
}
#endif
windowSurface = surface;
isPaintingActive = false;
}
#if !defined(QVG_NO_PRESERVED_SWAP)
// Try to force the surface back buffer to preserve its contents.
if (needToSwap) {
eglGetError(); // Clear error state first.
eglSurfaceAttrib(QEgl::display(), windowSurface,
EGL_SWAP_BEHAVIOR, EGL_BUFFER_PRESERVED);
if (eglGetError() != EGL_SUCCESS) {
qWarning("QVG: could not enable preserved swap");
}
}
#endif
return context;
}