static gboolean
cl_process (GeglOperation *operation,
GeglBuffer *input,
GeglBuffer *output,
const GeglRectangle *result)
{
const Babl *in_format = gegl_operation_get_format (operation, "input");
const Babl *out_format = gegl_operation_get_format (operation, "output");
gint err;
gint j;
cl_int cl_err;
GeglOperationAreaFilter *op_area = GEGL_OPERATION_AREA_FILTER (operation);
GeglBufferClIterator *i = gegl_buffer_cl_iterator_new (output, result, out_format, GEGL_CL_BUFFER_WRITE, GEGL_ABYSS_NONE);
gint read = gegl_buffer_cl_iterator_add_2 (i, input, result, in_format, GEGL_CL_BUFFER_READ, op_area->left, op_area->right, op_area->top, op_area->bottom, GEGL_ABYSS_NONE);
gint aux = gegl_buffer_cl_iterator_add_2 (i, NULL, result, in_format, GEGL_CL_BUFFER_AUX, op_area->left, op_area->right, op_area->top, op_area->bottom, GEGL_ABYSS_NONE);
while (gegl_buffer_cl_iterator_next (i, &err))
{
if (err) return FALSE;
for (j=0; j < i->n; j++)
{
cl_err = cl_edge_laplace(i->tex[read][j], i->tex[aux][j], i->tex[0][j], &i->roi[read][j], &i->roi[0][j], LAPLACE_RADIUS);
if (cl_err != CL_SUCCESS)
{
g_warning("[OpenCL] Error in gegl:edge-laplace: %s", gegl_cl_errstring(cl_err));
return FALSE;
}
}
}
return TRUE;
}
static gboolean
cl_process (GeglOperation *operation,
GeglBuffer *input,
GeglBuffer *output,
const GeglRectangle *result)
{
const Babl *in_format = gegl_operation_get_format (operation, "input");
const Babl *out_format = gegl_operation_get_format (operation, "output");
gint err;
GeglOperationAreaFilter *op_area = GEGL_OPERATION_AREA_FILTER (operation);
GeglChantO *o = GEGL_CHANT_PROPERTIES (operation);
GeglBufferClIterator *i = gegl_buffer_cl_iterator_new (output,
result,
out_format,
GEGL_CL_BUFFER_WRITE);
gint read = gegl_buffer_cl_iterator_add_2 (i,
input,
result,
in_format,
GEGL_CL_BUFFER_READ,
op_area->left,
op_area->right,
op_area->top,
op_area->bottom,
GEGL_ABYSS_NONE);
gint aux = gegl_buffer_cl_iterator_add_2 (i,
NULL,
result,
in_format,
GEGL_CL_BUFFER_AUX,
0,
0,
op_area->top,
op_area->bottom,
GEGL_ABYSS_NONE);
while (gegl_buffer_cl_iterator_next (i, &err))
{
if (err) return FALSE;
err = cl_box_max(i->tex[read],
i->tex[aux],
i->tex[0],
i->size[0],
&i->roi[0],
ceil (o->radius));
if (err) return FALSE;
}
return TRUE;
}
static gboolean
cl_process (GeglOperation *operation,
GeglBuffer *input,
GeglBuffer *output,
const GeglRectangle *result)
{
const Babl *in_format = gegl_operation_get_format (operation, "input");
const Babl *out_format = gegl_operation_get_format (operation, "output");
gint err;
gint j;
cl_int cl_err;
GeglOperationAreaFilter *op_area = GEGL_OPERATION_AREA_FILTER (operation);
GeglChantO *o = GEGL_CHANT_PROPERTIES (operation);
GeglBufferClIterator *i = gegl_buffer_cl_iterator_new (output, result, out_format, GEGL_CL_BUFFER_WRITE, GEGL_ABYSS_NONE);
gint read = gegl_buffer_cl_iterator_add_2 (i, input, result, in_format, GEGL_CL_BUFFER_READ, op_area->left, op_area->right, op_area->top, op_area->bottom, GEGL_ABYSS_NONE);
while (gegl_buffer_cl_iterator_next (i, &err))
{
if (err) return FALSE;
for (j=0; j < i->n; j++)
{
cl_err = cl_bilateral_filter(i->tex[read][j], i->tex[0][j], i->size[0][j], &i->roi[0][j], ceil(o->blur_radius), o->edge_preservation);
if (cl_err != CL_SUCCESS)
{
g_warning("[OpenCL] Error in gegl:bilateral-filter: %s", gegl_cl_errstring(cl_err));
return FALSE;
}
}
}
return TRUE;
}
static gboolean
cl_process (GeglOperation *operation,
GeglBuffer *input,
GeglBuffer *output,
const GeglRectangle *result)
{
const Babl *in_format = gegl_operation_get_format (operation, "input");
const Babl *out_format = gegl_operation_get_format (operation, "output");
gint err = 0;
GeglOperationAreaFilter *op_area = GEGL_OPERATION_AREA_FILTER (operation);
GeglProperties *o = GEGL_PROPERTIES (operation);
GeglBufferClIterator *i = gegl_buffer_cl_iterator_new (output,
result,
out_format,
GEGL_CL_BUFFER_WRITE);
gint read = gegl_buffer_cl_iterator_add_2 (i,
input,
result,
in_format,
GEGL_CL_BUFFER_READ,
op_area->left,
op_area->right,
op_area->top,
op_area->bottom,
GEGL_ABYSS_CLAMP);
gint aux = gegl_buffer_cl_iterator_add_aux (i,
result,
in_format,
0,
0,
op_area->top,
op_area->bottom);
while (gegl_buffer_cl_iterator_next (i, &err) && !err)
{
err = cl_box_blur (i->tex[read],
i->tex[aux],
i->tex[0],
i->size[0],
&i->roi[0],
o->radius);
if (err)
{
gegl_buffer_cl_iterator_stop (i);
break;
}
}
return !err;
}
gint
gegl_buffer_cl_iterator_add (GeglBufferClIterator *iterator,
GeglBuffer *buffer,
const GeglRectangle *result,
const Babl *format,
guint flags,
GeglAbyssPolicy abyss_policy)
{
return gegl_buffer_cl_iterator_add_2 (iterator, buffer, result, format, flags, 0,0,0,0, abyss_policy);
}
static gboolean
cl_process (GeglOperation *operation,
GeglBuffer *input,
GeglBuffer *output,
const GeglRectangle *result,
gboolean has_alpha)
{
const Babl *in_format = babl_format ("RGBA float");
const Babl *out_format = babl_format ("RGBA float");
gint err;
GeglOperationAreaFilter *op_area = GEGL_OPERATION_AREA_FILTER (operation);
GeglChantO *o = GEGL_CHANT_PROPERTIES (operation);
GeglBufferClIterator *i = gegl_buffer_cl_iterator_new (output,
result,
out_format,
GEGL_CL_BUFFER_WRITE);
gint read = gegl_buffer_cl_iterator_add_2 (i,
input,
result,
in_format,
GEGL_CL_BUFFER_READ,
op_area->left,
op_area->right,
op_area->top,
op_area->bottom,
GEGL_ABYSS_NONE);
while (gegl_buffer_cl_iterator_next (i, &err))
{
if (err) return FALSE;
err = cl_edge_sobel(i->tex[read],
i->tex[0],
i->size[0],
&i->roi[0],
o->horizontal,
o->vertical,
o->keep_signal,
has_alpha);
if (err) return FALSE;
}
return TRUE;
}
static gboolean
cl_process (GeglOperation *operation,
GeglBuffer *input,
GeglBuffer *output,
const GeglRectangle *result,
const GeglRectangle *src_rect)
{
const Babl *in_format = gegl_operation_get_format (operation, "input");
const Babl *out_format = gegl_operation_get_format (operation, "output");
gint err;
gint j;
cl_int cl_err;
GeglOperationAreaFilter *op_area = GEGL_OPERATION_AREA_FILTER (operation);
GeglChantO *o = GEGL_CHANT_PROPERTIES (operation);
gdouble theta = o->angle * G_PI / 180.0;
gfloat offset_x = (gfloat)(o->length * cos(theta));
gfloat offset_y = (gfloat)(o->length * sin(theta));
gint num_steps = (gint)ceil(o->length) + 1;
GeglBufferClIterator *i = gegl_buffer_cl_iterator_new (output, result, out_format, GEGL_CL_BUFFER_WRITE, GEGL_ABYSS_NONE);
gint read = gegl_buffer_cl_iterator_add_2 (i, input, result, in_format, GEGL_CL_BUFFER_READ,
op_area->left, op_area->right, op_area->top, op_area->bottom, GEGL_ABYSS_NONE);
while (gegl_buffer_cl_iterator_next (i, &err))
{
if (err) return FALSE;
for (j=0; j < i->n; j++)
{
cl_err = cl_motion_blur(i->tex[read][j], i->tex[0][j], i->size[0][j], &i->roi[0][j], &i->roi[read][j], num_steps, offset_x, offset_y);
if (cl_err != CL_SUCCESS)
{
g_warning("[OpenCL] Error in gegl:motion-blur: %s", gegl_cl_errstring(cl_err));
return FALSE;
}
}
}
return TRUE;
}
static gboolean
cl_process (GeglOperation *operation,
GeglBuffer *input,
GeglBuffer *output,
const GeglRectangle *roi)
{
const Babl *in_format = babl_format ("RaGaBaA float");
const Babl *out_format = babl_format ("RaGaBaA float");
gint err;
gfloat bg_color[4];
gint norm;
GeglOperationAreaFilter *op_area = GEGL_OPERATION_AREA_FILTER (operation);
GeglProperties *o = GEGL_PROPERTIES (operation);
GeglRectangle *image_extent;
GeglBufferClIterator *i = gegl_buffer_cl_iterator_new (output,
roi,
out_format,
GEGL_CL_BUFFER_WRITE);
gint read = gegl_buffer_cl_iterator_add_2 (i,
input,
roi,
in_format,
GEGL_CL_BUFFER_READ,
op_area->left,
op_area->right,
op_area->top,
op_area->bottom,
GEGL_ABYSS_CLAMP);
gint aux = gegl_buffer_cl_iterator_add_aux (i,
roi,
in_format,
op_area->left,
op_area->right,
op_area->top,
op_area->bottom);
gegl_color_get_pixel (o->background, babl_format ("RaGaBaA float"), bg_color);
norm = 0;
norm = o->norm == GEGL_PIXELIZE_NORM_EUCLIDEAN ? 1 : norm;
norm = o->norm == GEGL_PIXELIZE_NORM_INFINITY ? 2 : norm;
image_extent = gegl_operation_source_get_bounding_box (operation, "input");
while (gegl_buffer_cl_iterator_next (i, &err) && !err)
{
err = cl_pixelize(i->tex[read],
i->tex[aux],
i->tex[0],
&i->roi[read],
&i->roi[0],
o->size_x,
o->size_y,
o->ratio_x,
o->ratio_y,
bg_color,
norm,
image_extent);
if (err)
{
gegl_buffer_cl_iterator_stop (i);
break;
}
}
return !err;
}
static gboolean
cl_process (GeglOperation *operation,
GeglBuffer *input,
GeglBuffer *output,
const GeglRectangle *result)
{
const Babl *in_format = gegl_operation_get_format (operation, "input");
const Babl *out_format = gegl_operation_get_format (operation, "output");
gfloat min[] = {1.0f, 1.0f, 1.0f, 1.0f};
gfloat max[] = {0.0f, 0.0f, 0.0f, 0.0f};
gfloat i_min[4], i_max[4], diff[4];
cl_int err = 0;
gint read, c;
GeglBufferClIterator *i;
GeglProperties *o;
cl_float4 cl_min, cl_diff;
o = GEGL_PROPERTIES (operation);
if (cl_build_kernels ())
return FALSE;
i = gegl_buffer_cl_iterator_new (input,
result,
in_format,
GEGL_CL_BUFFER_READ);
while (gegl_buffer_cl_iterator_next (i, &err) && !err)
{
err = cl_buffer_get_min_max (i->tex[0],
i->size[0],
&i->roi[0],
i_min,
i_max);
if (err)
{
gegl_buffer_cl_iterator_stop (i);
break;
}
for (c = 0; c < 3; c++)
{
if (i_min[c] < min[c])
min[c] = i_min[c];
if (i_max[c] > max[c])
max[c] = i_max[c];
}
}
if (err)
return FALSE;
if (o->keep_colors)
reduce_min_max_global (min, max);
for (c = 0; c < 3; c ++)
{
diff[c] = max[c] - min[c];
/* Avoid a divide by zero error if the image is a solid color */
if (diff[c] < 1e-3)
{
min[c] = 0.0;
diff[c] = 1.0;
}
}
cl_diff.x = diff[0];
cl_diff.y = diff[1];
cl_diff.z = diff[2];
cl_diff.w = 1.0;
cl_min.x = min[0];
cl_min.y = min[1];
cl_min.z = min[2];
cl_min.w = 0.0;
i = gegl_buffer_cl_iterator_new (output,
result,
out_format,
GEGL_CL_BUFFER_WRITE);
read = gegl_buffer_cl_iterator_add_2 (i,
input,
result,
in_format,
GEGL_CL_BUFFER_READ,
0,
0,
0,
0,
GEGL_ABYSS_NONE);
while (gegl_buffer_cl_iterator_next (i, &err) && !err)
{
err = cl_stretch_contrast (i->tex[read],
i->tex[0],
i->size[0],
&i->roi[0],
cl_min,
cl_diff);
if (err)
{
gegl_buffer_cl_iterator_stop (i);
break;
}
}
return !err;
}
static gboolean
fir_cl_process (GeglBuffer *input,
GeglBuffer *output,
const GeglRectangle *result,
const Babl *format,
gfloat *cmatrix,
gint clen,
GeglOrientation orientation,
GeglAbyssPolicy abyss)
{
gboolean err = FALSE;
cl_int cl_err;
cl_mem cl_cmatrix = NULL;
GeglBufferClIterator *i;
gint read;
gint left, right, top, bottom;
if (orientation == GEGL_ORIENTATION_HORIZONTAL)
{
right = left = clen / 2;
top = bottom = 0;
}
else
{
right = left = 0;
top = bottom = clen / 2;
}
i = gegl_buffer_cl_iterator_new (output,
result,
format,
GEGL_CL_BUFFER_WRITE);
read = gegl_buffer_cl_iterator_add_2 (i,
input,
result,
format,
GEGL_CL_BUFFER_READ,
left, right,
top, bottom,
abyss);
cl_cmatrix = gegl_clCreateBuffer (gegl_cl_get_context(),
CL_MEM_COPY_HOST_PTR | CL_MEM_READ_ONLY,
clen * sizeof(cl_float), cmatrix, &cl_err);
CL_CHECK;
while (gegl_buffer_cl_iterator_next (i, &err) && !err)
{
err = cl_gaussian_blur(i->tex[read],
i->tex[0],
&i->roi[0],
cl_cmatrix,
clen,
orientation);
if (err)
{
gegl_buffer_cl_iterator_stop (i);
break;
}
}
cl_err = gegl_clReleaseMemObject (cl_cmatrix);
CL_CHECK;
cl_cmatrix = NULL;
return !err;
error:
if (cl_cmatrix)
gegl_clReleaseMemObject (cl_cmatrix);
return FALSE;
}
