void tst_NativeImageHandleProvider::hibernate() { #if defined(Q_OS_SYMBIAN) && !defined(QT_NO_OPENVG) QPixmap tmp(10, 20); if (tmp.pixmapData()->classId() == QPixmapData::OpenVGClass) { BitmapProvider prov; prov.bmp = new CFbsBitmap; QCOMPARE(prov.bmp->Create(TSize(prov.w, prov.h), EColor16MAP), KErrNone); QPixmap pm = pixmapFromNativeImageHandleProvider(&prov); QCOMPARE(prov.refCount, 1); QVGPixmapData *vgpd = static_cast<QVGPixmapData *>(pm.pixmapData()); vgpd->hibernate(); QCOMPARE(prov.refCount, 0); // Calling toVGImage() may cause some warnings as we don't have a gui initialized, // but the only thing we care about here is get() being called. vgpd->toVGImage(); QCOMPARE(prov.refCount, 1); pm = QPixmap(); QCOMPARE(prov.refCount, 0); delete prov.bmp; } else { QSKIP("Not openvg", SkipSingle); } #else QSKIP("Not applicable", SkipSingle); #endif }
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; } // 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); }
bool QVGImagePool::reclaimSpace(VGImageFormat format, VGint width, VGint height, QVGPixmapData *data) { Q_UNUSED(format); // For future use in picking the best image to eject. Q_UNUSED(width); Q_UNUSED(height); bool succeeded = false; bool wasInLRU = false; if (data) { wasInLRU = data->inLRU; moveToHeadOfLRU(data); } QVGPixmapData *lrudata = pixmapLRU(); if (lrudata && lrudata != data) { lrudata->reclaimImages(); succeeded = true; } if (data && !wasInLRU) removeFromLRU(data); return succeeded; }
void QVGPixmapDropShadowFilter::draw(QPainter *painter, const QPointF &dest, const QPixmap &src, const QRectF &srcRect) const { if (src.isNull()) return; if (src.pixmapData()->classId() != QPixmapData::OpenVGClass) { // The pixmap data is not an instance of QVGPixmapData, so fall // back to the default drop shadow filter implementation. QPixmapDropShadowFilter::draw(painter, dest, src, srcRect); return; } QVGPixmapData *pd = static_cast<QVGPixmapData *>(src.pixmapData()); VGImage srcImage = pd->toVGImage(); if (srcImage == VG_INVALID_HANDLE) return; QSize size = pd->size(); VGImage dstImage = QVGImagePool::instance()->createTemporaryImage (VG_A_8, size.width(), size.height(), VG_IMAGE_QUALITY_FASTER, pd); if (dstImage == VG_INVALID_HANDLE) return; // Clamp the radius range. We divide by 2 because the OpenVG blur // is "too blurry" compared to the default raster implementation. VGfloat maxRadius = VGfloat(vgGeti(VG_MAX_GAUSSIAN_STD_DEVIATION)); VGfloat radiusF = VGfloat(blurRadius()) / 2.0f; if (radiusF < 0.001f) radiusF = 0.001f; else if (radiusF > maxRadius) radiusF = maxRadius; // Blur the blackened source image. vgGaussianBlur(dstImage, srcImage, radiusF, radiusF, VG_TILE_PAD); VGImage child = VG_INVALID_HANDLE; QRect srect; if (srcRect.isNull() || (srcRect.topLeft().isNull() && srcRect.size() == size)) { child = dstImage; srect = QRect(0, 0, size.width(), size.height()); } else { srect = srcRect.toRect(); child = vgChildImage(dstImage, srect.x(), srect.y(), srect.width(), srect.height()); } qt_vg_drawVGImageStencil(painter, dest + offset(), child, color()); if(child != dstImage) vgDestroyImage(child); QVGImagePool::instance()->releaseImage(0, dstImage); // Now draw the actual pixmap over the top. painter->drawPixmap(dest, src, srect); }
/* \internal Returns the VGImage that is storing the contents of \a pixmap. Returns VG_INVALID_HANDLE if \a pixmap is not owned by the OpenVG graphics system or \a pixmap is invalid. This function is typically used to access the backing store for a pixmap when executing raw OpenVG calls. It must only be used when a QPainter is active and the OpenVG paint engine is in use by the QPainter. \sa {QtOpenVG Module} */ Q_OPENVG_EXPORT VGImage qPixmapToVGImage(const QPixmap& pixmap) { QPixmapData *pd = pixmap.pixmapData(); if (!pd) return VG_INVALID_HANDLE; // null QPixmap if (pd->classId() == QPixmapData::OpenVGClass) { QVGPixmapData *vgpd = static_cast<QVGPixmapData *>(pd); if (vgpd->isValid()) return vgpd->toVGImage(); } return VG_INVALID_HANDLE; }
void QVGPixmapBlurFilter::draw(QPainter *painter, const QPointF &dest, const QPixmap &src, const QRectF &srcRect) const { if (src.isNull()) return; if (src.pixmapData()->classId() != QPixmapData::OpenVGClass) { // The pixmap data is not an instance of QVGPixmapData, so fall // back to the default blur filter implementation. QPixmapBlurFilter::draw(painter, dest, src, srcRect); return; } QVGPixmapData *pd = static_cast<QVGPixmapData *>(src.pixmapData()); VGImage srcImage = pd->toVGImage(); if (srcImage == VG_INVALID_HANDLE) return; QSize size = pd->size(); VGImage dstImage = QVGImagePool::instance()->createTemporaryImage (VG_sARGB_8888_PRE, size.width(), size.height(), VG_IMAGE_QUALITY_FASTER, pd); if (dstImage == VG_INVALID_HANDLE) return; // Clamp the radius range. We divide by 2 because the OpenVG blur // is "too blurry" compared to the default raster implementation. VGfloat maxRadius = VGfloat(vgGeti(VG_MAX_GAUSSIAN_STD_DEVIATION)); VGfloat radiusF = VGfloat(radius()) / 2.0f; if (radiusF < 0.001f) radiusF = 0.001f; else if (radiusF > maxRadius) radiusF = maxRadius; vgGaussianBlur(dstImage, srcImage, radiusF, radiusF, VG_TILE_PAD); VGImage child = VG_INVALID_HANDLE; if (srcRect.isNull() || (srcRect.topLeft().isNull() && srcRect.size() == size)) { child = dstImage; } else { QRect src = srcRect.toRect(); child = vgChildImage(dstImage, src.x(), src.y(), src.width(), src.height()); } qt_vg_drawVGImage(painter, dest, child); if(child != dstImage) vgDestroyImage(child); QVGImagePool::instance()->releaseImage(0, dstImage); }
void QVGImagePool::hibernate() { Q_D(QVGImagePool); QVGPixmapData *pd = d->lruLast; while (pd) { QVGPixmapData *prevLRU = pd->prevLRU; pd->inImagePool = false; pd->inLRU = false; pd->nextLRU = 0; pd->prevLRU = 0; pd->hibernate(); pd = prevLRU; } d->lruFirst = 0; d->lruLast = 0; }
bool QVGImagePool::reclaimSpace(VGImageFormat format, VGint width, VGint height, QVGPixmapData *data) { Q_UNUSED(format); // For future use in picking the best image to eject. Q_UNUSED(width); Q_UNUSED(height); if (data) moveToHeadOfLRU(data); QVGPixmapData *lrudata = pixmapLRU(); if (lrudata && lrudata != data) { lrudata->reclaimImages(); return true; } return false; }
void QVGPixmapConvolutionFilter::draw (QPainter *painter, const QPointF &dest, const QPixmap &src, const QRectF &srcRect) const { if (src.isNull()) return; if (src.pixmapData()->classId() != QPixmapData::OpenVGClass) { // The pixmap data is not an instance of QVGPixmapData, so fall // back to the default convolution filter implementation. QPixmapConvolutionFilter::draw(painter, dest, src, srcRect); return; } QVGPixmapData *pd = static_cast<QVGPixmapData *>(src.pixmapData()); VGImage srcImage = pd->toVGImage(); if (srcImage == VG_INVALID_HANDLE) return; QSize size = pd->size(); VGImage dstImage = QVGImagePool::instance()->createTemporaryImage (VG_sARGB_8888_PRE, size.width(), size.height(), VG_IMAGE_QUALITY_FASTER, pd); if (dstImage == VG_INVALID_HANDLE) return; int kernelWidth = rows(); int kernelHeight = columns(); const qreal *kern = convolutionKernel(); QVarLengthArray<VGshort> kernel; for (int i = 0; i < kernelWidth; ++i) { for (int j = 0; j < kernelHeight; ++j) { kernel.append((VGshort)(kern[j * kernelWidth + i] * 1024.0f)); } } VGfloat values[4]; values[0] = 0.0f; values[1] = 0.0f; values[2] = 0.0f; values[3] = 0.0f; vgSetfv(VG_TILE_FILL_COLOR, 4, values); vgConvolve(dstImage, srcImage, kernelWidth, kernelHeight, 0, 0, kernel.constData(), 1.0f / 1024.0f, 0.0f, VG_TILE_FILL); VGImage child = VG_INVALID_HANDLE; if (srcRect.isNull() || (srcRect.topLeft().isNull() && srcRect.size() == size)) { child = dstImage; } else { QRect src = srcRect.toRect(); child = vgChildImage(dstImage, src.x(), src.y(), src.width(), src.height()); } qt_vg_drawVGImage(painter, dest, child); if(child != dstImage) vgDestroyImage(child); QVGImagePool::instance()->releaseImage(0, dstImage); }
void QVGPixmapColorizeFilter::draw(QPainter *painter, const QPointF &dest, const QPixmap &src, const QRectF &srcRect) const { if (src.isNull()) return; if (src.pixmapData()->classId() != QPixmapData::OpenVGClass) { // The pixmap data is not an instance of QVGPixmapData, so fall // back to the default colorize filter implementation. QPixmapColorizeFilter::draw(painter, dest, src, srcRect); return; } QVGPixmapData *pd = static_cast<QVGPixmapData *>(src.pixmapData()); VGImage srcImage = pd->toVGImage(); if (srcImage == VG_INVALID_HANDLE) return; QSize size = pd->size(); VGImage dstImage = QVGImagePool::instance()->createTemporaryImage (VG_sARGB_8888_PRE, size.width(), size.height(), VG_IMAGE_QUALITY_FASTER, pd); if (dstImage == VG_INVALID_HANDLE) return; // Determine the weights for the matrix from the color and strength. QColor c = color(); VGfloat strength = this->strength(); VGfloat weights[3]; VGfloat invweights[3]; VGfloat alpha = c.alphaF(); weights[0] = c.redF() * alpha; weights[1] = c.greenF() * alpha; weights[2] = c.blueF() * alpha; invweights[0] = (1.0f - weights[0]) * strength; invweights[1] = (1.0f - weights[1]) * strength; invweights[2] = (1.0f - weights[2]) * strength; // Grayscale weights. static const VGfloat redGray = 11.0f / 32.0f; static const VGfloat greenGray = 16.0f / 32.0f; static const VGfloat blueGray = 1.0f - (redGray + greenGray); VGfloat matrix[5][4]; matrix[0][0] = redGray * invweights[0] + (1.0f - strength); matrix[0][1] = redGray * invweights[1]; matrix[0][2] = redGray * invweights[2]; matrix[0][3] = 0.0f; matrix[1][0] = greenGray * invweights[0]; matrix[1][1] = greenGray * invweights[1] + (1.0f - strength); matrix[1][2] = greenGray * invweights[2]; matrix[1][3] = 0.0f; matrix[2][0] = blueGray * invweights[0]; matrix[2][1] = blueGray * invweights[1]; matrix[2][2] = blueGray * invweights[2] + (1.0f - strength); matrix[2][3] = 0.0f; matrix[3][0] = 0.0f; matrix[3][1] = 0.0f; matrix[3][2] = 0.0f; matrix[3][3] = 1.0f; matrix[4][0] = weights[0] * strength; matrix[4][1] = weights[1] * strength; matrix[4][2] = weights[2] * strength; matrix[4][3] = 0.0f; vgColorMatrix(dstImage, srcImage, matrix[0]); VGImage child = VG_INVALID_HANDLE; if (srcRect.isNull() || (srcRect.topLeft().isNull() && srcRect.size() == size)) { child = dstImage; } else { QRect src = srcRect.toRect(); child = vgChildImage(dstImage, src.x(), src.y(), src.width(), src.height()); } qt_vg_drawVGImage(painter, dest, child); if(child != dstImage) vgDestroyImage(child); QVGImagePool::instance()->releaseImage(0, dstImage); }