static gboolean
process (GeglOperation *operation,
GeglBuffer *input,
GeglBuffer *output,
const GeglRectangle *result,
gint level)
{
GeglProperties *o = GEGL_PROPERTIES (operation);
GeglBuffer *temp_in;
GeglRectangle compute;
if (gegl_operation_use_opencl (operation))
if (cl_process (operation, input, output, result))
return TRUE;
compute = gegl_operation_get_required_for_output (operation, "input", result);
if (o->radius < 1.0)
{
output = g_object_ref (input);
}
else
{
temp_in = gegl_buffer_create_sub_buffer (input, &compute);
snn_mean (temp_in, output, result, o->radius, o->pairs);
g_object_unref (temp_in);
}
return TRUE;
}
static gboolean
process (GeglOperation *operation,
GeglBuffer *input,
GeglBuffer *output,
const GeglRectangle *result,
gint level)
{
GeglChantO *o = GEGL_CHANT_PROPERTIES (operation);
GeglRectangle compute;
if (o->blur_radius >= 1.0 && gegl_operation_use_opencl (operation))
if (cl_process (operation, input, output, result))
return TRUE;
compute = gegl_operation_get_required_for_output (operation, "input",result);
if (o->blur_radius < 1.0)
{
gegl_buffer_copy (input, result, output, result);
}
else
{
bilateral_filter (input, &compute, output, result, o->blur_radius, o->edge_preservation);
}
return TRUE;
}
static gboolean
gegl_operation_point_filter_process (GeglOperation *operation,
GeglBuffer *input,
GeglBuffer *output,
const GeglRectangle *result,
gint level)
{
const Babl *in_format = gegl_operation_get_format (operation, "input");
const Babl *out_format = gegl_operation_get_format (operation, "output");
GeglOperationPointFilterClass *point_filter_class;
GeglOperationClass *operation_class = GEGL_OPERATION_GET_CLASS (operation);
point_filter_class = GEGL_OPERATION_POINT_FILTER_GET_CLASS (operation);
if ((result->width > 0) && (result->height > 0))
{
if (gegl_operation_use_opencl (operation) &&
(operation_class->cl_data || point_filter_class->cl_process))
{
if (gegl_operation_point_filter_cl_process (operation, input, output, result, level))
return TRUE;
}
{
GeglBufferIterator *i = gegl_buffer_iterator_new (output, result, level, out_format, GEGL_BUFFER_WRITE, GEGL_ABYSS_NONE);
gint read = /*output == input ? 0 :*/ gegl_buffer_iterator_add (i, input, result, level, in_format, GEGL_BUFFER_READ, GEGL_ABYSS_NONE);
/* using separate read and write iterators for in-place ideally a single
* readwrite indice would be sufficient
*/
while (gegl_buffer_iterator_next (i))
point_filter_class->process (operation, i->data[read], i->data[0], i->length, &i->roi[0], level);
}
}
return TRUE;
}
static gboolean
gegl_gblur_1d_process (GeglOperation *operation,
GeglBuffer *input,
GeglBuffer *output,
const GeglRectangle *result,
gint level)
{
GeglProperties *o = GEGL_PROPERTIES (operation);
const Babl *format = gegl_operation_get_format (operation, "output");
GeglGblur1dFilter filter;
GeglAbyssPolicy abyss_policy = to_gegl_policy (o->abyss_policy);
filter = filter_disambiguation (o->filter, o->std_dev);
if (filter == GEGL_GBLUR_1D_IIR)
{
gdouble b[4], m[3][3];
iir_young_find_constants (o->std_dev, b, m);
if (o->orientation == GEGL_ORIENTATION_HORIZONTAL)
iir_young_hor_blur (input, result, output, b, m, abyss_policy, format);
else
iir_young_ver_blur (input, result, output, b, m, abyss_policy, format);
}
else
{
gfloat *cmatrix;
gint clen;
clen = fir_gen_convolve_matrix (o->std_dev, &cmatrix);
/* FIXME: implement others format cases */
if (gegl_operation_use_opencl (operation) &&
format == babl_format ("RaGaBaA float"))
if (fir_cl_process(input, output, result, format,
cmatrix, clen, o->orientation, abyss_policy))
return TRUE;
if (o->orientation == GEGL_ORIENTATION_HORIZONTAL)
fir_hor_blur (input, result, output, cmatrix, clen, abyss_policy, format);
else
fir_ver_blur (input, result, output, cmatrix, clen, abyss_policy, format);
gegl_free (cmatrix);
}
return TRUE;
}
static gboolean
operation_source_process (GeglOperation *operation,
GeglBuffer *output,
const GeglRectangle *result,
gint level)
{
const Babl *out_format = gegl_operation_get_format (operation, "output");
if ((result->width > 0) && (result->height > 0))
{
GeglBufferIterator *iter;
if (gegl_operation_use_opencl (operation) &&
babl_format_get_n_components (out_format) == 4 &&
babl_format_get_type (out_format, 0) == babl_type ("float"))
{
GeglBufferClIterator *cl_iter;
gboolean err;
GEGL_NOTE (GEGL_DEBUG_OPENCL, "GEGL_OPERATION_POINT_RENDER: %s", GEGL_OPERATION_GET_CLASS (operation)->name);
cl_iter = gegl_buffer_cl_iterator_new (output, result, out_format, GEGL_CL_BUFFER_WRITE);
while (gegl_buffer_cl_iterator_next (cl_iter, &err) && !err)
{
err = checkerboard_cl_process (operation, cl_iter->tex[0], cl_iter->size[0], &cl_iter->roi[0], level);
if (err)
{
gegl_buffer_cl_iterator_stop (cl_iter);
break;
}
}
if (err)
GEGL_NOTE (GEGL_DEBUG_OPENCL, "Error: %s", GEGL_OPERATION_GET_CLASS (operation)->name);
else
return TRUE;
}
iter = gegl_buffer_iterator_new (output, result, level, out_format,
GEGL_ACCESS_WRITE, GEGL_ABYSS_NONE);
while (gegl_buffer_iterator_next (iter))
checkerboard_process (operation, iter->data[0], iter->length, &iter->roi[0], level);
}
return TRUE;
}
static gboolean
process (GeglOperation *operation,
GeglBuffer *out_buf,
const GeglRectangle *roi,
gint level)
{
GeglBufferIterator *iter;
const Babl *out_format = gegl_operation_get_format (operation,
"output");
if (gegl_operation_use_opencl (operation))
{
GeglBufferClIterator *cl_iter;
gboolean err;
GEGL_NOTE (GEGL_DEBUG_OPENCL, "GEGL_OPERATION_POINT_RENDER: %s",
GEGL_OPERATION_GET_CLASS (operation)->name);
cl_iter = gegl_buffer_cl_iterator_new (out_buf, roi, out_format,
GEGL_CL_BUFFER_WRITE);
while (gegl_buffer_cl_iterator_next (cl_iter, &err) && !err)
{
err = cl_process (operation, cl_iter->tex[0], cl_iter->roi);
if (err)
{
gegl_buffer_cl_iterator_stop (cl_iter);
break;
}
}
if (err)
GEGL_NOTE (GEGL_DEBUG_OPENCL, "Error: %s",
GEGL_OPERATION_GET_CLASS (operation)->name);
else
return TRUE;
}
iter = gegl_buffer_iterator_new (out_buf, roi, level, out_format,
GEGL_ACCESS_WRITE, GEGL_ABYSS_NONE);
while (gegl_buffer_iterator_next (iter))
c_process (operation, iter->data[0], &iter->roi[0]);
return TRUE;
}
static gboolean
process (GeglOperation *operation,
GeglBuffer *input,
GeglBuffer *output,
const GeglRectangle *result,
gint level)
{
gint i, j;
gfloat *buf1, *buf2, *buf3;
if (gegl_operation_use_opencl (operation))
if (cl_process (operation, input, output, result))
return TRUE;
buf1 = g_new (gfloat, SQR (CHUNK_SIZE + LAPLACE_RADIUS * 2) * 4);
buf2 = g_new (gfloat, SQR (CHUNK_SIZE + LAPLACE_RADIUS * 2) * 4);
buf3 = g_new (gfloat, SQR (CHUNK_SIZE) * 4);
for (j = 0; (j-1) * CHUNK_SIZE < result->height; j++)
for (i = 0; (i-1) * CHUNK_SIZE < result->width; i++)
{
GeglRectangle chunked_result;
GeglRectangle compute;
chunked_result = *GEGL_RECTANGLE (result->x + i * CHUNK_SIZE,
result->y + j * CHUNK_SIZE,
CHUNK_SIZE, CHUNK_SIZE);
gegl_rectangle_intersect (&chunked_result, &chunked_result, result);
if (chunked_result.width < 1 || chunked_result.height < 1)
continue;
compute = gegl_operation_get_required_for_output (operation,
"input",
&chunked_result);
edge_laplace (input, &compute, output, &chunked_result,
buf1, buf2, buf3);
}
g_free (buf1);
g_free (buf2);
g_free (buf3);
return TRUE;
}
static gboolean
bilateral_process (GeglOperation *operation,
GeglBuffer *input,
GeglBuffer *output,
const GeglRectangle *result,
gint level)
{
GeglChantO *o = GEGL_CHANT_PROPERTIES (operation);
if (gegl_operation_use_opencl (operation))
if (bilateral_cl_process (operation, input, output, result, o->s_sigma, o->r_sigma/100))
return TRUE;
bilateral_filter (input, result, output, result, o->s_sigma, o->r_sigma/100);
return TRUE;
}
static gboolean
process (GeglOperation *operation,
GeglBuffer *input,
GeglBuffer *output,
const GeglRectangle *result,
gint level)
{
GeglChantO *o = GEGL_CHANT_PROPERTIES (operation);
GeglRectangle compute;
gboolean has_alpha;
compute = gegl_operation_get_required_for_output (operation, "input", result);
has_alpha = babl_format_has_alpha (gegl_operation_get_format (operation, "output"));
if (gegl_operation_use_opencl (operation))
if (cl_process (operation, input, output, result, has_alpha))
return TRUE;
edge_sobel (input, &compute, output, result, o->horizontal, o->vertical, o->keep_signal, has_alpha);
return TRUE;
}
static gboolean
process (GeglOperation *operation,
GeglBuffer *input,
GeglBuffer *output,
const GeglRectangle *result,
gint level)
{
GeglRectangle rect;
GeglRectangle tmprect;
GeglProperties *o = GEGL_PROPERTIES (operation);
GeglBuffer *temp;
GeglOperationAreaFilter *op_area;
op_area = GEGL_OPERATION_AREA_FILTER (operation);
if (gegl_operation_use_opencl (operation))
if (cl_process (operation, input, output, result))
return TRUE;
rect = *result;
tmprect = *result;
rect.x -= op_area->left * 2;
rect.y -= op_area->top * 2;
rect.width += (op_area->left + op_area->right) * 2;
rect.height += (op_area->top + op_area->bottom) * 2;
/* very tricky: enlarge temp buffer to avoid seams in second pass */
tmprect.y -= o->radius;
tmprect.height += o->radius * 2;
temp = gegl_buffer_new (&tmprect,
babl_format ("RaGaBaA float"));
/* doing second pass in separate gegl op may be significantly faster */
hor_blur (input, &rect, temp, &tmprect, o->radius);
ver_blur (temp, &rect, output, result, o->radius);
g_object_unref (temp);
return TRUE;
}
static gboolean
process (GeglOperation *operation,
GeglBuffer *input,
GeglBuffer *output,
const GeglRectangle *roi,
gint level)
{
GeglRectangle src_rect;
GeglRectangle *whole_region;
GeglProperties *o = GEGL_PROPERTIES (operation);
GeglOperationAreaFilter *op_area;
op_area = GEGL_OPERATION_AREA_FILTER (operation);
whole_region = gegl_operation_source_get_bounding_box (operation, "input");
if (gegl_operation_use_opencl (operation))
if (cl_process (operation, input, output, roi))
return TRUE;
if (o->size_x * o->size_y < SQR (ALLOC_THRESHOLD_SIZE))
{
gfloat background_color[4];
gfloat *input_buf = g_new (gfloat,
(CHUNK_SIZE + o->size_x * 2) *
(CHUNK_SIZE + o->size_y * 2) * 4);
gfloat *output_buf = g_new (gfloat, SQR (CHUNK_SIZE) * 4);
gint i, j;
gegl_color_get_pixel (o->background, babl_format("RaGaBaA float"),
background_color);
for (j = 0; (j-1) * CHUNK_SIZE < roi->height; j++)
for (i = 0; (i-1) * CHUNK_SIZE < roi->width; i++)
{
GeglRectangle chunked_result;
GeglRectangle chunked_sizes;
chunked_result = *GEGL_RECTANGLE (roi->x + i * CHUNK_SIZE,
roi->y + j * CHUNK_SIZE,
CHUNK_SIZE, CHUNK_SIZE);
gegl_rectangle_intersect (&chunked_result, &chunked_result, roi);
if (chunked_result.width < 1 || chunked_result.height < 1)
continue;
src_rect = chunked_result;
src_rect.x -= op_area->left;
src_rect.y -= op_area->top;
src_rect.width += op_area->left + op_area->right;
src_rect.height += op_area->top + op_area->bottom;
gegl_buffer_get (input, &src_rect, 1.0, babl_format ("RaGaBaA float"),
input_buf, GEGL_AUTO_ROWSTRIDE, GEGL_ABYSS_CLAMP);
gegl_rectangle_copy (&chunked_sizes, &chunked_result);
chunked_sizes.x = 0;
chunked_sizes.y = 0;
set_rectangle (output_buf, &chunked_sizes, &chunked_sizes,
chunked_result.width, background_color,
GEGL_PIXELIZE_NORM_INFINITY);
pixelize (input_buf, output_buf, &chunked_result, &src_rect,
whole_region, o);
gegl_buffer_set (output, &chunked_result, 0,
babl_format ("RaGaBaA float"),
output_buf, GEGL_AUTO_ROWSTRIDE);
}
g_free (input_buf);
g_free (output_buf);
}
else
{
gegl_buffer_set_color (output, roi, o->background);
pixelize_noalloc (input, output, roi, whole_region, o);
}
return TRUE;
}
static gboolean
process (GeglOperation *operation,
GeglBuffer *input,
const GeglRectangle *result,
gint level)
{
GeglChantO *o = GEGL_CHANT_PROPERTIES (operation);
if (o->buffer)
{
GeglBuffer *output = GEGL_BUFFER (o->buffer);
const Babl *in_format = gegl_buffer_get_format (input);
const Babl *out_format = gegl_buffer_get_format (output);
if (gegl_operation_use_opencl (operation)
&& gegl_cl_color_supported (in_format, out_format) == GEGL_CL_COLOR_CONVERT)
{
size_t size;
gboolean err;
cl_int cl_err = 0;
GeglBufferClIterator *i = gegl_buffer_cl_iterator_new (output,
result,
out_format,
GEGL_CL_BUFFER_WRITE);
gint read = gegl_buffer_cl_iterator_add (i,
input,
result,
out_format,
GEGL_CL_BUFFER_READ,
GEGL_ABYSS_NONE);
gegl_cl_color_babl (out_format, &size);
GEGL_NOTE (GEGL_DEBUG_OPENCL,
"write-buffer: "
"%p %p %s %s {%d %d %d %d}",
input,
output,
babl_get_name (in_format),
babl_get_name (out_format),
result->x,
result->y,
result->width,
result->height);
while (gegl_buffer_cl_iterator_next (i, &err))
{
if (err) break;
cl_err = gegl_clEnqueueCopyBuffer (gegl_cl_get_command_queue (),
i->tex[read],
i->tex[0],
0,
0,
i->size[0] * size,
0,
NULL,
NULL);
if (cl_err != CL_SUCCESS)
{
GEGL_NOTE (GEGL_DEBUG_OPENCL, "Error: %s", gegl_cl_errstring (cl_err));
break;
}
}
if (cl_err || err)
gegl_buffer_copy (input, result, output, result);
}
else
gegl_buffer_copy (input, result, output, result);
gegl_buffer_flush (output);
}
return TRUE;
}