FCL/sf/mw/qt: comparison src/plugins/gfxdrivers/directfb/qdirectfbpaintengine.cpp

equal deleted inserted replaced

-:2f34d5167611
+:fcece45ef507
 Matrix_RectsUnsupported = (QTransform::TxRotate|QTransform::TxShear|QTransform::TxProject),
 Matrix_BlitsUnsupported = (Matrix_NegativeScale|Matrix_RectsUnsupported)
 };
 enum CompositionModeStatus {
-PorterDuff_None = 0x00,
+PorterDuff_None = 0x0,
-PorterDuff_SupportedBlits = 0x01,
+PorterDuff_Supported = 0x1,
-PorterDuff_SupportedPrimitives = 0x02,
+PorterDuff_PremultiplyColors = 0x2,
-PorterDuff_SupportedOpaquePrimitives = 0x04,
+PorterDuff_AlwaysBlend = 0x4
-PorterDuff_Dirty = 0x10
 };
 enum ClipType {
 ClipUnset,
 NoClip,
 inline void lock();
 inline void unlock();
 static inline void unlock(QDirectFBPaintDevice *device);
-inline bool testCompositionMode(const QPen *pen, const QBrush *brush, const QColor *color = 0) const;
 inline bool isSimpleBrush(const QBrush &brush) const;
 void drawTiledPixmap(const QRectF &dest, const QPixmap &pixmap, const QPointF &pos);
 void blit(const QRectF &dest, IDirectFBSurface *surface, const QRectF &src);
 quint8 opacity;
 ClipType clipType;
 QDirectFBPaintDevice *dfbDevice;
 uint compositionModeStatus;
+bool isPremultiplied;
 bool inClip;
 QRect currentClip;
 QDirectFBPaintEngine *q;
 }
 };
 static QCache<qint64, CachedImage> imageCache(4*1024*1024); // 4 MB
 #endif
-#if defined QT_DIRECTFB_WARN_ON_RASTERFALLBACKS || defined QT_DIRECTFB_DISABLE_RASTERFALLBACKS
+#if defined QT_DIRECTFB_WARN_ON_RASTERFALLBACKS || defined QT_DIRECTFB_DISABLE_RASTERFALLBACKS || defined QT_DEBUG
 #define VOID_ARG() static_cast<bool>(false)
 enum PaintOperation {
 DRAW_RECTS = 0x0001, DRAW_LINES = 0x0002, DRAW_IMAGE = 0x0004,
 DRAW_PIXMAP = 0x0008, DRAW_TILED_PIXMAP = 0x0010, STROKE_PATH = 0x0020,
 DRAW_PATH = 0x0040, DRAW_POINTS = 0x0080, DRAW_ELLIPSE = 0x0100,
 DRAW_POLYGON = 0x0200, DRAW_TEXT = 0x0400, FILL_PATH = 0x0800,
 FILL_RECT = 0x1000, DRAW_COLORSPANS = 0x2000, DRAW_ROUNDED_RECT = 0x4000,
 ALL = 0xffff
 };
-#endif
+#ifdef QT_DEBUG
+static void initRasterFallbacksMasks(int *warningMask, int *disableMask)
+{
+struct {
+const char *name;
+PaintOperation operation;
+} const operations[] = {
+{ "DRAW_RECTS", DRAW_RECTS },
+{ "DRAW_LINES", DRAW_LINES },
+{ "DRAW_IMAGE", DRAW_IMAGE },
+{ "DRAW_PIXMAP", DRAW_PIXMAP },
+{ "DRAW_TILED_PIXMAP", DRAW_TILED_PIXMAP },
+{ "STROKE_PATH", STROKE_PATH },
+{ "DRAW_PATH", DRAW_PATH },
+{ "DRAW_POINTS", DRAW_POINTS },
+{ "DRAW_ELLIPSE", DRAW_ELLIPSE },
+{ "DRAW_POLYGON", DRAW_POLYGON },
+{ "DRAW_TEXT", DRAW_TEXT },
+{ "FILL_PATH", FILL_PATH },
+{ "FILL_RECT", FILL_RECT },
+{ "DRAW_COLORSPANS", DRAW_COLORSPANS },
+{ "DRAW_ROUNDED_RECT", DRAW_ROUNDED_RECT },
+{ "ALL", ALL },
+{ 0, ALL }
+};
+QStringList warning = QString::fromLatin1(qgetenv("QT_DIRECTFB_WARN_ON_RASTERFALLBACKS")).toUpper().split(QLatin1Char('|'),
+QString::SkipEmptyParts);
+QStringList disable = QString::fromLatin1(qgetenv("QT_DIRECTFB_DISABLE_RASTERFALLBACKS")).toUpper().split(QLatin1Char('|'),
+QString::SkipEmptyParts);
+*warningMask = 0;
+*disableMask = 0;
+if (!warning.isEmpty() || !disable.isEmpty()) {
+for (int i=0; operations[i].name; ++i) {
+const QString name = QString::fromLatin1(operations[i].name);
+int idx = warning.indexOf(name);
+if (idx != -1) {
+*warningMask |= operations[i].operation;
+warning.erase(warning.begin() + idx);
+}
+idx = disable.indexOf(name);
+if (idx != -1) {
+*disableMask |= operations[i].operation;
+disable.erase(disable.begin() + idx);
+}
+}
+}
+if (!warning.isEmpty()) {
+qWarning("QDirectFBPaintEngine QT_DIRECTFB_WARN_ON_RASTERFALLBACKS Unknown operation(s): %s",
+qPrintable(warning.join(QLatin1String("|"))));
+}
+if (!disable.isEmpty()) {
+qWarning("QDirectFBPaintEngine QT_DIRECTFB_DISABLE_RASTERFALLBACKS Unknown operation(s): %s",
+qPrintable(disable.join(QLatin1String("|"))));
+}
+}
+#endif
+static inline int rasterFallbacksMask(bool warn)
+{
 #ifdef QT_DIRECTFB_WARN_ON_RASTERFALLBACKS
+if (warn)
+return QT_DIRECTFB_WARN_ON_RASTERFALLBACKS;
+#endif
+#ifdef QT_DIRECTFB_DISABLE_RASTERFALLBACKS
+if (!warn)
+return QT_DIRECTFB_DISABLE_RASTERFALLBACKS;
+#endif
+#ifndef QT_DEBUG
+return 0;
+#else
+static int warnMask = -1;
+static int disableMask = -1;
+if (warnMask == -1)
+initRasterFallbacksMasks(&warnMask, &disableMask);
+return warn ? warnMask : disableMask;
+#endif
+}
+#endif
+#if defined QT_DIRECTFB_WARN_ON_RASTERFALLBACKS || defined QT_DEBUG
 template <typename device, typename T1, typename T2, typename T3>
 static void rasterFallbackWarn(const char *msg, const char *func, const device *dev,
 uint transformationType, bool simplePen,
 uint clipType, uint compositionModeStatus,
 const char *nameOne, const T1 &one,
 const char *nameTwo, const T2 &two,
 const char *nameThree, const T3 &three);
 #endif
-#if defined QT_DIRECTFB_WARN_ON_RASTERFALLBACKS && defined QT_DIRECTFB_DISABLE_RASTERFALLBACKS
+#if defined QT_DEBUG || (defined QT_DIRECTFB_WARN_ON_RASTERFALLBACKS && defined QT_DIRECTFB_DISABLE_RASTERFALLBACKS)
 #define RASTERFALLBACK(op, one, two, three)                             \
-if (op & (QT_DIRECTFB_WARN_ON_RASTERFALLBACKS))                     \
+{                                                                   \
-rasterFallbackWarn("Disabled raster engine operation",          \
+const bool disable = op & rasterFallbacksMask(false);           \
-__FUNCTION__, state()->painter->device(),    \
+if (op & rasterFallbacksMask(true))                             \
-d_func()->transformationType,                \
+rasterFallbackWarn(disable                                  \
-d_func()->simplePen,                         \
+? "Disabled raster engine operation"     \
-d_func()->clipType,                          \
+: "Falling back to raster engine for",   \
-d_func()->compositionModeStatus,             \
+__FUNCTION__,                            \
-#one, one, #two, two, #three, three);        \
+state()->painter->device(),              \
-if (op & (QT_DIRECTFB_DISABLE_RASTERFALLBACKS))                     \
+d_func()->transformationType,            \
-return;
+d_func()->simplePen,                     \
+d_func()->clipType,                      \
+d_func()->compositionModeStatus,         \
+#one, one, #two, two, #three, three);    \
+if (disable)                                                    \
+return;                                                     \
+}
 #elif defined QT_DIRECTFB_DISABLE_RASTERFALLBACKS
-#define RASTERFALLBACK(op, one, two, three)             \
+#define RASTERFALLBACK(op, one, two, three)                             \
-if (op & (QT_DIRECTFB_DISABLE_RASTERFALLBACKS))     \
+if (op & rasterFallbacksMask(false))                                \
 return;
 #elif defined QT_DIRECTFB_WARN_ON_RASTERFALLBACKS
 #define RASTERFALLBACK(op, one, two, three)                             \
-if (op & (QT_DIRECTFB_WARN_ON_RASTERFALLBACKS))                     \
+if (op & rasterFallbacksMask(true))                                 \
 rasterFallbackWarn("Falling back to raster engine for",         \
 __FUNCTION__, state()->painter->device(),    \
 d_func()->transformationType,                \
 d_func()->simplePen,                         \
 d_func()->clipType,                          \
 if (!d->surface) {
 qFatal("QDirectFBPaintEngine used on an invalid device: 0x%x",
 device->devType());
 }
+d->isPremultiplied = QDirectFBScreen::isPremultiplied(d->dfbDevice->format());
 d->prepare(d->dfbDevice);
 gccaps = AllFeatures;
 d->setCompositionMode(state()->composition_mode);
 if ((d->transformationType & QDirectFBPaintEnginePrivate::Matrix_RectsUnsupported)
 || !d->simplePen
 || d->clipType == QDirectFBPaintEnginePrivate::ComplexClip
 || !d->isSimpleBrush(brush)
-|| !d->testCompositionMode(&pen, &brush)) {
+|| !(d->compositionModeStatus & QDirectFBPaintEnginePrivate::PorterDuff_Supported)) {
 RASTERFALLBACK(DRAW_RECTS, rectCount, VOID_ARG(), VOID_ARG());
 d->lock();
 QRasterPaintEngine::drawRects(rects, rectCount);
 return;
 }
 if ((d->transformationType & QDirectFBPaintEnginePrivate::Matrix_RectsUnsupported)
 || !d->simplePen
 || d->clipType == QDirectFBPaintEnginePrivate::ComplexClip
 || !d->isSimpleBrush(brush)
-|| !d->testCompositionMode(&pen, &brush)) {
+|| !(d->compositionModeStatus & QDirectFBPaintEnginePrivate::PorterDuff_Supported)) {
 RASTERFALLBACK(DRAW_RECTS, rectCount, VOID_ARG(), VOID_ARG());
 d->lock();
 QRasterPaintEngine::drawRects(rects, rectCount);
 return;
 }
 Q_D(QDirectFBPaintEngine);
 const QPen &pen = state()->pen;
 if (!d->simplePen
 || d->clipType == QDirectFBPaintEnginePrivate::ComplexClip
-|| !d->testCompositionMode(&pen, 0)) {
+|| !(d->compositionModeStatus & QDirectFBPaintEnginePrivate::PorterDuff_Supported)) {
 RASTERFALLBACK(DRAW_LINES, lineCount, VOID_ARG(), VOID_ARG());
 d->lock();
 QRasterPaintEngine::drawLines(lines, lineCount);
 return;
 }
 Q_D(QDirectFBPaintEngine);
 const QPen &pen = state()->pen;
 if (!d->simplePen
 || d->clipType == QDirectFBPaintEnginePrivate::ComplexClip
-|| !d->testCompositionMode(&pen, 0)) {
+|| !(d->compositionModeStatus & QDirectFBPaintEnginePrivate::PorterDuff_Supported)) {
 RASTERFALLBACK(DRAW_LINES, lineCount, VOID_ARG(), VOID_ARG());
 d->lock();
 QRasterPaintEngine::drawLines(lines, lineCount);
 return;
 }
 images and the cost of caching the image (bytes used) is higher
 than the max image cache size we fall back to raster engine.
 */
 #if !defined QT_NO_DIRECTFB_PREALLOCATED || defined QT_DIRECTFB_IMAGECACHE
-if (!(d->compositionModeStatus & QDirectFBPaintEnginePrivate::PorterDuff_SupportedBlits)
+if (!(d->compositionModeStatus & QDirectFBPaintEnginePrivate::PorterDuff_Supported)
 || (d->transformationType & QDirectFBPaintEnginePrivate::Matrix_BlitsUnsupported)
 || (d->clipType == QDirectFBPaintEnginePrivate::ComplexClip)
 || (!d->supportsStretchBlit() && state()->matrix.mapRect(r).size() != sr.size())
 #ifndef QT_DIRECTFB_IMAGECACHE
 || (QDirectFBScreen::getSurfacePixelFormat(image.format()) == DSPF_UNKNOWN)
 QRasterPaintEngine::drawPixmap(r, pixmap, sr);
 } else {
 QPixmapData *data = pixmap.pixmapData();
 Q_ASSERT(data->classId() == QPixmapData::DirectFBClass);
 QDirectFBPixmapData *dfbData = static_cast<QDirectFBPixmapData*>(data);
-if (!(d->compositionModeStatus & QDirectFBPaintEnginePrivate::PorterDuff_SupportedBlits)
+if (!(d->compositionModeStatus & QDirectFBPaintEnginePrivate::PorterDuff_Supported)
 || (d->transformationType & QDirectFBPaintEnginePrivate::Matrix_BlitsUnsupported)
 || (d->clipType == QDirectFBPaintEnginePrivate::ComplexClip)
 || (!d->supportsStretchBlit() && state()->matrix.mapRect(r).size() != sr.size())) {
 RASTERFALLBACK(DRAW_PIXMAP, r, pixmap.size(), sr);
 const QImage *img = dfbData->buffer();
 Q_D(QDirectFBPaintEngine);
 if (pixmap.pixmapData()->classId() != QPixmapData::DirectFBClass) {
 RASTERFALLBACK(DRAW_TILED_PIXMAP, r, pixmap.size(), offset);
 d->lock();
 QRasterPaintEngine::drawTiledPixmap(r, pixmap, offset);
-} else if (!(d->compositionModeStatus & QDirectFBPaintEnginePrivate::PorterDuff_SupportedBlits)
+} else if (!(d->compositionModeStatus & QDirectFBPaintEnginePrivate::PorterDuff_Supported)
 || (d->transformationType & QDirectFBPaintEnginePrivate::Matrix_BlitsUnsupported)
 || (d->clipType == QDirectFBPaintEnginePrivate::ComplexClip)
 || (!d->supportsStretchBlit() && state()->matrix.isScaling())) {
 RASTERFALLBACK(DRAW_TILED_PIXMAP, r, pixmap.size(), offset);
 QPixmapData *pixmapData = pixmap.pixmapData();
 if (brush.style() == Qt::NoBrush)
 return;
 if (d->clipType != QDirectFBPaintEnginePrivate::ComplexClip) {
 switch (brush.style()) {
 case Qt::SolidPattern: {
-if (d->transformationType & QDirectFBPaintEnginePrivate::Matrix_RectsUnsupported
-|| !d->testCompositionMode(0, &brush)) {
-break;
-}
 const QColor color = brush.color();
 if (!color.isValid())
 return;
+if (d->transformationType & QDirectFBPaintEnginePrivate::Matrix_RectsUnsupported
+|| !(d->compositionModeStatus & QDirectFBPaintEnginePrivate::PorterDuff_Supported)) {
+break;
+}
 d->setDFBColor(color);
 const QRect r = state()->matrix.mapRect(rect).toRect();
 CLIPPED_PAINT(d->surface->FillRectangle(d->surface, r.x(), r.y(), r.width(), r.height()));
 return; }
 case Qt::TexturePattern: {
-if (!(d->compositionModeStatus & QDirectFBPaintEnginePrivate::PorterDuff_SupportedBlits)
+if (!(d->compositionModeStatus & QDirectFBPaintEnginePrivate::PorterDuff_Supported)
 || (d->transformationType & QDirectFBPaintEnginePrivate::Matrix_BlitsUnsupported)
 || (!d->supportsStretchBlit() && state()->matrix.isScaling())) {
 break;
 }
 if (!color.isValid())
 return;
 Q_D(QDirectFBPaintEngine);
 if ((d->transformationType & QDirectFBPaintEnginePrivate::Matrix_RectsUnsupported)
 || (d->clipType == QDirectFBPaintEnginePrivate::ComplexClip)
-|| !d->testCompositionMode(0, 0, &color)) {
+|| !(d->compositionModeStatus & QDirectFBPaintEnginePrivate::PorterDuff_Supported)) {
 RASTERFALLBACK(FILL_RECT, rect, color, VOID_ARG());
 d->lock();
 QRasterPaintEngine::fillRect(rect, color);
 } else {
 d->setDFBColor(color);
 QDirectFBPaintEnginePrivate::QDirectFBPaintEnginePrivate(QDirectFBPaintEngine *p)
 : surface(0), antialiased(false), simplePen(false),
 transformationType(0), opacity(255),
 clipType(ClipUnset), dfbDevice(0),
-compositionModeStatus(0), inClip(false), q(p)
+compositionModeStatus(0), isPremultiplied(false), inClip(false), q(p)
 {
 fb = QDirectFBScreen::instance()->dfb();
 surfaceCache = new SurfaceCache;
 }
 bool QDirectFBPaintEnginePrivate::isSimpleBrush(const QBrush &brush) const
 {
 return (brush.style() == Qt::NoBrush) || (brush.style() == Qt::SolidPattern && !antialiased);
 }
-bool QDirectFBPaintEnginePrivate::testCompositionMode(const QPen *pen, const QBrush *brush, const QColor *color) const
-{
-Q_ASSERT(!pen || pen->style() == Qt::NoPen || pen->style() == Qt::SolidLine);
-Q_ASSERT(!brush || brush->style() == Qt::NoBrush || brush->style() == Qt::SolidPattern);
-switch (compositionModeStatus & (QDirectFBPaintEnginePrivate::PorterDuff_SupportedOpaquePrimitives
-|QDirectFBPaintEnginePrivate::PorterDuff_SupportedPrimitives)) {
-case QDirectFBPaintEnginePrivate::PorterDuff_SupportedPrimitives:
-return true;
-case QDirectFBPaintEnginePrivate::PorterDuff_SupportedOpaquePrimitives:
-if (pen && pen->style() == Qt::SolidLine && pen->color().alpha() != 255)
-return false;
-if (brush) {
-if (brush->style() == Qt::SolidPattern && brush->color().alpha() != 255) {
-return false;
-}
-} else if (color && color->alpha() != 255) {
-return false;
-}
-return true;
-case QDirectFBPaintEnginePrivate::PorterDuff_None:
-return false;
-default:
-// ### PorterDuff_SupportedOpaquePrimitives|PorterDuff_SupportedPrimitives can't be combined
-break;
-}
-Q_ASSERT(0);
-return false;
-}
 void QDirectFBPaintEnginePrivate::lock()
 {
 // We will potentially get a new pointer to the buffer after a
 // lock so we need to call the base implementation of prepare so
 if (!surface)
 return;
 static const bool forceRasterFallBack = qgetenv("QT_DIRECTFB_FORCE_RASTER").toInt() > 0;
 if (forceRasterFallBack) {
-compositionModeStatus = 0;
+compositionModeStatus = PorterDuff_None;
 return;
 }
-compositionModeStatus = PorterDuff_SupportedBlits;
+compositionModeStatus = PorterDuff_Supported|PorterDuff_PremultiplyColors|PorterDuff_AlwaysBlend;
 switch (mode) {
 case QPainter::CompositionMode_Clear:
 surface->SetPorterDuff(surface, DSPD_CLEAR);
 break;
 case QPainter::CompositionMode_Source:
 surface->SetPorterDuff(surface, DSPD_SRC);
-compositionModeStatus |= PorterDuff_SupportedOpaquePrimitives;
+compositionModeStatus &= ~PorterDuff_AlwaysBlend;
+if (!isPremultiplied)
+compositionModeStatus &= ~PorterDuff_PremultiplyColors;
 break;
 case QPainter::CompositionMode_SourceOver:
-compositionModeStatus |= PorterDuff_SupportedPrimitives;
+compositionModeStatus &= ~PorterDuff_AlwaysBlend;
 surface->SetPorterDuff(surface, DSPD_SRC_OVER);
 break;
 case QPainter::CompositionMode_DestinationOver:
 surface->SetPorterDuff(surface, DSPD_DST_OVER);
 break;
 case QPainter::CompositionMode_SourceIn:
 surface->SetPorterDuff(surface, DSPD_SRC_IN);
+if (!isPremultiplied)
+compositionModeStatus &= ~PorterDuff_PremultiplyColors;
 break;
 case QPainter::CompositionMode_DestinationIn:
 surface->SetPorterDuff(surface, DSPD_DST_IN);
 break;
 case QPainter::CompositionMode_SourceOut:
 surface->SetPorterDuff(surface, DSPD_SRC_OUT);
 break;
 case QPainter::CompositionMode_DestinationOut:
 surface->SetPorterDuff(surface, DSPD_DST_OUT);
 break;
+#if (Q_DIRECTFB_VERSION >= 0x010209)
+case QPainter::CompositionMode_Destination:
+surface->SetPorterDuff(surface, DSPD_DST);
+break;
+#endif
 #if (Q_DIRECTFB_VERSION >= 0x010000)
 case QPainter::CompositionMode_SourceAtop:
 surface->SetPorterDuff(surface, DSPD_SRC_ATOP);
 break;
 case QPainter::CompositionMode_DestinationAtop:
 case QPainter::CompositionMode_Xor:
 surface->SetPorterDuff(surface, DSPD_XOR);
 break;
 #endif
 default:
-compositionModeStatus = 0;
+compositionModeStatus = PorterDuff_None;
 break;
 }
 }
 void QDirectFBPaintEnginePrivate::setRenderHints(QPainter::RenderHints hints)
 if (opacity != 255) {
 blittingFlags |= DSBLIT_BLEND_COLORALPHA;
 }
 surface->SetColor(surface, 0xff, 0xff, 0xff, opacity);
 surface->SetBlittingFlags(surface, blittingFlags);
-if (compositionModeStatus & PorterDuff_Dirty) {
-setCompositionMode(q->state()->composition_mode);
-}
 }
 static inline uint ALPHA_MUL(uint x, uint a)
 {
 uint t = x * a;
 }
 void QDirectFBPaintEnginePrivate::setDFBColor(const QColor &color)
 {
 Q_ASSERT(surface);
+Q_ASSERT(compositionModeStatus & PorterDuff_Supported);
 const quint8 alpha = (opacity == 255 ?
 color.alpha() : ALPHA_MUL(color.alpha(), opacity));
-surface->SetColor(surface, color.red(), color.green(), color.blue(), alpha);
+QColor col;
-surface->SetPorterDuff(surface, DSPD_NONE);
+if (compositionModeStatus & PorterDuff_PremultiplyColors) {
-surface->SetDrawingFlags(surface, alpha == 255 ? DSDRAW_NOFX : DSDRAW_BLEND);
+col = QColor(ALPHA_MUL(color.red(), alpha),
-compositionModeStatus |= PorterDuff_Dirty;
+ALPHA_MUL(color.green(), alpha),
+ALPHA_MUL(color.blue(), alpha),
+alpha);
+} else {
+col = QColor(color.red(), color.green(), color.blue(), alpha);
+}
+surface->SetColor(surface, col.red(), col.green(), col.blue(), col.alpha());
+surface->SetDrawingFlags(surface, alpha == 255 && !(compositionModeStatus & PorterDuff_AlwaysBlend) ? DSDRAW_NOFX : DSDRAW_BLEND);
 }
 IDirectFBSurface *QDirectFBPaintEnginePrivate::getSurface(const QImage &img, bool *release)
 {
 #ifdef QT_NO_DIRECTFB_IMAGECACHE
 const QRect r = mapRect(transform, rects[i]);
 surface->DrawRectangle(surface, r.x(), r.y(), r.width(), r.height());
 }
 }
-#ifdef QT_DIRECTFB_WARN_ON_RASTERFALLBACKS
+#if defined QT_DIRECTFB_WARN_ON_RASTERFALLBACKS || defined QT_DEBUG
 template <typename T> inline const T *ptr(const T &t) { return &t; }
 template <> inline const bool* ptr<bool>(const bool &) { return 0; }
 template <typename device, typename T1, typename T2, typename T3>
 static void rasterFallbackWarn(const char *msg, const char *func, const device *dev,
 uint transformationType, bool simplePen,

changeset 19	fcece45ef507
parent 18	2f34d5167611
child 30	5dc02b23752f