void vegaSeparableConvolve(VGImage dst, VGImage src,
VGint kernelWidth,
VGint kernelHeight,
VGint shiftX, VGint shiftY,
const VGshort * kernelX,
const VGshort * kernelY,
VGfloat scale,
VGfloat bias,
VGTilingMode tilingMode)
{
struct vg_context *ctx = vg_current_context();
VGshort *kernel;
VGint i, j, idx = 0;
const VGint max_kernel_size = vgGeti(VG_MAX_SEPARABLE_KERNEL_SIZE);
if (dst == VG_INVALID_HANDLE || src == VG_INVALID_HANDLE) {
vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
return;
}
if (kernelWidth <= 0 || kernelHeight <= 0 ||
kernelWidth > max_kernel_size || kernelHeight > max_kernel_size) {
vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
return;
}
if (!kernelX || !kernelY ||
!is_aligned_to(kernelX, 2) || !is_aligned_to(kernelY, 2)) {
vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
return;
}
if (tilingMode < VG_TILE_FILL ||
tilingMode > VG_TILE_REFLECT) {
vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
return;
}
kernel = malloc(sizeof(VGshort)*kernelWidth*kernelHeight);
for (i = 0; i < kernelWidth; ++i) {
for (j = 0; j < kernelHeight; ++j) {
kernel[idx] = kernelX[i] * kernelY[j];
++idx;
}
}
vgConvolve(dst, src, kernelWidth, kernelHeight, shiftX, shiftY,
kernel, scale, bias, tilingMode);
free(kernel);
}
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);
}
