Accelerated Graphics Driver Example

Step 2: Implementing a Custom Raster Paint Engine

Qt for Embedded Linux uses QRasterPaintEngine (a raster-based implementation of QPaintEngine) to implement the painting operations.

Acceleration of the painting operations is done by deriving from QRasterPaintEngine class. This is a powerful mechanism for accelerating graphic primitives while getting software fallbacks for all the primitives you do not accelerate.

 #include <private/qpaintengine_raster_p.h>

 class SvgalibPaintEngine : public QRasterPaintEngine
 {
 public:
     SvgalibPaintEngine(QPaintDevice *device);
     ~SvgalibPaintEngine();

     bool begin(QPaintDevice *device);
     bool end();
     void updateState();
     void drawRects(const QRect *rects, int rectCount);

 private:
     void setClip(const QRegion &region);
     void updateClip();

     QPen pen;
     bool simplePen;
     QBrush brush;
     bool simpleBrush;
     QTransform matrix;
     bool simpleMatrix;
     QRegion clip;
     bool clipEnabled;
     bool simpleClip;
     bool opaque;
     bool aliased;
     bool sourceOver;
     QPaintDevice *device;
 };

In this example, we will only accelerate one of the drawRects() functions, i.e., only non-rotated, aliased and opaque rectangles will be rendered using accelerated painting. All other primitives are rendered using the base class's unaccelerated implementation.

The paint engine's state is stored in the private member variables, and we reimplement the updateState() function to ensure that our custom paint engine's state is updated properly whenever it is required. The private setClip() and updateClip() functions are only helper function used to simplify the updateState() implementation.

We also reimplement QRasterPaintEngine's begin() and end() functions to initialize the paint engine and to do the cleanup when we are done rendering, respectively.

The begin() function initializes the internal state of the paint engine. Note that it also calls the base class implementation to initialize the parts inherited from QRasterPaintEngine:

 bool SvgalibPaintEngine::begin(QPaintDevice *dev)
 {
     device = dev;
     pen = Qt::NoPen;
     simplePen = true;
     brush = Qt::NoBrush;
     simpleBrush = true;
     matrix = QTransform();
     simpleMatrix = true;
     setClip(QRect(0, 0, device->width(), device->height()));
     opaque = true;
     aliased = true;
     sourceOver = true;

     return QRasterPaintEngine::begin(dev);
 }

 bool SvgalibPaintEngine::end()
 {
     gl_setclippingwindow(0, 0, device->width() - 1, device->height() - 1);
     return QRasterPaintEngine::end();
 }

The implementation of the end() function removes the clipping constraints that might have been set in SVGAlib, before calling the corresponding base class implementation.

 void SvgalibPaintEngine::updateState()
 {
     QRasterPaintEngineState *s = state();

     if (s->dirty & DirtyTransform) {
         matrix = s->matrix;
         simpleMatrix = (matrix.m12() == 0 && matrix.m21() == 0);
     }

     if (s->dirty & DirtyPen) {
         pen = s->pen;
         simplePen = (pen.width() == 0 || pen.widthF() <= 1)
                     && (pen.style() == Qt::NoPen || pen.style() == Qt::SolidLine)
                     && (pen.color().alpha() == 255);
     }

     if (s->dirty & DirtyBrush) {
         brush = s->brush;
         simpleBrush = (brush.style() == Qt::SolidPattern
                        || brush.style() == Qt::NoBrush)
                       && (brush.color().alpha() == 255);
     }

     if (s->dirty & DirtyClipRegion)
         setClip(s->clipRegion);

     if (s->dirty & DirtyClipEnabled) {
         clipEnabled = s->isClipEnabled();
         updateClip();
     }

     if (s->dirty & DirtyClipPath) {
         setClip(QRegion());
         simpleClip = false;
     }

     if (s->dirty & DirtyCompositionMode) {
         const QPainter::CompositionMode m = s->composition_mode;
         sourceOver = (m == QPainter::CompositionMode_SourceOver);
     }

     if (s->dirty & DirtyOpacity)
         opaque = (s->opacity == 256);

     if (s->dirty & DirtyHints)
         aliased = !(s->flags.antialiased);
 }

The updateState() function updates our custom paint engine's state. The QPaintEngineState class provides information about the active paint engine's current state.

Note that we only accept and save the current matrix if it doesn't do any shearing. The pen is accepted if it is opaque and only one pixel wide. The rest of the engine's properties are updated following the same pattern. Again it is important that the QPaintEngine::updateState() function is called to update the parts inherited from the base class.

 void SvgalibPaintEngine::setClip(const QRegion &region)
 {
     if (region.isEmpty())
         clip = QRect(0, 0, device->width(), device->height());
     else
         clip = matrix.map(region) & QRect(0, 0, device->width(), device->height());
     clipEnabled = true;
     updateClip();
 }

 void SvgalibPaintEngine::updateClip()
 {
     QRegion clipRegion = QRect(0, 0, device->width(), device->height());

     if (!systemClip().isEmpty())
         clipRegion &= systemClip();
     if (clipEnabled)
         clipRegion &= clip;

     simpleClip = (clipRegion.rects().size() <= 1);

     const QRect r = clipRegion.boundingRect();
     gl_setclippingwindow(r.left(), r.top(),
                          r.x() + r.width(),
                          r.y() + r.height());
 }

The setClip() helper function is called from our custom implementation of updateState(), and enables clipping to the given region. An empty region means that clipping is disabled.

Our custom update function also makes use of the updateClip() helper function that checks if the clip is "simple", i.e., that it can be represented by only one rectangle, and updates the clip region in SVGAlib.

 void SvgalibPaintEngine::drawRects(const QRect *rects, int rectCount)
 {
     const bool canAccelerate = simplePen && simpleBrush && simpleMatrix
                                && simpleClip && opaque && aliased
                                && sourceOver;
     if (!canAccelerate) {
         QRasterPaintEngine::drawRects(rects, rectCount);
         return;
     }

     for (int i = 0; i < rectCount; ++i) {
         const QRect r = matrix.mapRect(rects[i]);
         if (brush != Qt::NoBrush) {
             gl_fillbox(r.left(), r.top(), r.width(), r.height(),
                        brush.color().rgba());
         }
         if (pen != Qt::NoPen) {
             const int c = pen.color().rgba();
             gl_hline(r.left(), r.top(), r.right(), c);
             gl_hline(r.left(), r.bottom(), r.right(), c);
             gl_line(r.left(), r.top(), r.left(), r.bottom(), c);
             gl_line(r.right(), r.top(), r.right(), r.bottom(), c);
         }
     }
 }

Finally, we accelerated that drawing of non-rotated, aliased and opaque rectangles in our reimplementation of the drawRects() function. The QRasterPaintEngine fallback is used whenever the rectangle is not simple enough.

 class SvgalibPaintDevice : public QCustomRasterPaintDevice
 {
 public:
     SvgalibPaintDevice(QWidget *w);
     ~SvgalibPaintDevice();

     void* memory() const { return QScreen::instance()->base(); }

     QPaintEngine *paintEngine() const { return pengine; }
     int metric(PaintDeviceMetric m) const;

 private:
     SvgalibPaintEngine *pengine;
 };

 class SvgalibSurface : public QWSWindowSurface
 {
 public:
     SvgalibSurface();
     SvgalibSurface(QWidget *w);
     ~SvgalibSurface();

     void setGeometry(const QRect &rect);
     bool isValid() const { return true; }
     bool scroll(const QRegion &region, int dx, int dy);
     QString key() const { return QLatin1String("svgalib"); }

     bool attach(const QByteArray &) { return true; }
     void detach() {}

     QImage image() const { return QImage(); }
     QPaintDevice *paintDevice() { return pdevice; }
     QPoint painterOffset() const;

 private:
     SvgalibPaintDevice *pdevice;
 };

 bool SvgalibSurface::scroll(const QRegion &region, int dx, int dy)
 {
     const QVector<QRect> rects = region.rects();
     for (int i = 0; i < rects.size(); ++i) {
         const QRect r = rects.at(i);
         gl_copybox(r.left(), r.top(), r.width(), r.height(),
                    r.left() + dx, r.top() + dy);
     }

     return true;
 }

 QWSWindowSurface* SvgalibScreen::createSurface(QWidget *widget) const
 {
     if (base()) {
         static int onScreenPaint = -1;
         if (onScreenPaint == -1)
             onScreenPaint = qgetenv("QT_ONSCREEN_PAINT").toInt();

         if (onScreenPaint > 0 || widget->testAttribute(Qt::WA_PaintOnScreen))
             return new SvgalibSurface(widget);
     }
     return QScreen::createSurface(widget);
 }

 QWSWindowSurface* SvgalibScreen::createSurface(const QString &key) const
 {
     if (key == QLatin1String("svgalib"))
         return new SvgalibSurface;
     return QScreen::createSurface(key);
 }