kis_auto_brush.cpp File Reference

#include "kis_auto_brush.h"
#include <kis_debug.h>
#include <math.h>
#include <QPainterPath>
#include <QRect>
#include <QDomElement>
#include <QBuffer>
#include <QFile>
#include <KoColor.h>
#include <KoColorSpace.h>
#include <KoColorSpaceRegistry.h>
#include <kis_datamanager.h>
#include <kis_fixed_paint_device.h>
#include <kis_paint_device.h>
#include <brushengine/kis_paint_information.h>
#include <kis_mask_generator.h>
#include <kis_boundary.h>
#include <brushengine/kis_paintop_lod_limitations.h>
#include <kis_brush_mask_applicator_base.h>
#include "kis_algebra_2d.h"
#include <KisOptimizedBrushOutline.h>

Go to the source code of this file.

Classes
struct	KisAutoBrush::Private

Functions
void	fillPixelOptimized_4bytes (quint8 *color, quint8 *buf, int size)
void	fillPixelOptimized_general (quint8 *color, quint8 *buf, int size, int pixelSize)
static KisDabShape	lieAboutDabShape (KisDabShape const &shape, int spikes)

Function Documentation

fillPixelOptimized_4bytes()

void fillPixelOptimized_4bytes ( quint8 * color, quint8 * buf, int size )

inline

This version of filling uses low granularity of data transfers (32-bit chunks) and internal processor's parallelism. It reaches 25% better performance in KisStrokeBenchmark in comparison to per-pixel memcpy version (tested on Sandy Bridge).

Definition at line 200 of file kis_auto_brush.cpp.

{
    int block1 = size / 8;
    int block2 = size % 8;
 
    quint32 *src = reinterpret_cast<quint32*>(color);
    quint32 *dst = reinterpret_cast<quint32*>(buf);
 
    // check whether all buffers are 4 bytes aligned
    // (uncomment if experience some problems)
    // Q_ASSERT(((qint64)src & 3) == 0);
    // Q_ASSERT(((qint64)dst & 3) == 0);
 
    for (int i = 0; i < block1; i++) {
        *dst = *src;
        *(dst + 1) = *src;
        *(dst + 2) = *src;
        *(dst + 3) = *src;
        *(dst + 4) = *src;
        *(dst + 5) = *src;
        *(dst + 6) = *src;
        *(dst + 7) = *src;
 
        dst += 8;
    }
 
    for (int i = 0; i < block2; i++) {
        *dst = *src;
        dst++;
    }
}

fillPixelOptimized_general()

void fillPixelOptimized_general ( quint8 * color, quint8 * buf, int size, int pixelSize )

inline

This version uses internal processor's parallelism and gives 20% better performance in KisStrokeBenchmark in comparison to per-pixel memcpy version (tested on Sandy Bridge (+20%) and on Merom (+10%)).

Definition at line 239 of file kis_auto_brush.cpp.

{
    int block1 = size / 8;
    int block2 = size % 8;
 
    for (int i = 0; i < block1; i++) {
        quint8 *d1 = buf;
        quint8 *d2 = buf + pixelSize;
        quint8 *d3 = buf + 2 * pixelSize;
        quint8 *d4 = buf + 3 * pixelSize;
        quint8 *d5 = buf + 4 * pixelSize;
        quint8 *d6 = buf + 5 * pixelSize;
        quint8 *d7 = buf + 6 * pixelSize;
        quint8 *d8 = buf + 7 * pixelSize;
 
        for (int j = 0; j < pixelSize; j++) {
            *(d1 + j) = color[j];
            *(d2 + j) = color[j];
            *(d3 + j) = color[j];
            *(d4 + j) = color[j];
            *(d5 + j) = color[j];
            *(d6 + j) = color[j];
            *(d7 + j) = color[j];
            *(d8 + j) = color[j];
        }
 
        buf += 8 * pixelSize;
    }
 
    for (int i = 0; i < block2; i++) {
        memcpy(buf, color, pixelSize);
        buf += pixelSize;
    }
}

lieAboutDabShape()

static KisDabShape lieAboutDabShape ( KisDabShape const & shape, int spikes )

static

Definition at line 171 of file kis_auto_brush.cpp.

{
    return spikes > 2 ? KisDabShape(shape.scale(), 1.0, shape.rotation()) : shape;
}

References KisDabShape::rotation(), and KisDabShape::scale().