static gboolean
cl_edge_laplace (cl_mem in_tex,
cl_mem aux_tex,
cl_mem out_tex,
const GeglRectangle *src_rect,
const GeglRectangle *roi,
gint radius)
{
cl_int cl_err = 0;
size_t global_ws_in[2];
size_t global_ws_aux[2];
if (!cl_data)
{
const char *kernel_name[] = {"pre_edgelaplace", "knl_edgelaplace", NULL};
cl_data = gegl_cl_compile_and_build (edge_laplace_cl_source, kernel_name);
}
if (!cl_data) return TRUE;
global_ws_in[0] = roi->width + LAPLACE_RADIUS;
global_ws_in[1] = roi->height + LAPLACE_RADIUS;
global_ws_aux[0] = roi->width;
global_ws_aux[1] = roi->height;
cl_err = gegl_cl_set_kernel_args (cl_data->kernel[0],
sizeof (cl_mem), &in_tex,
sizeof (cl_mem), &aux_tex,
NULL);
CL_CHECK;
cl_err = gegl_clEnqueueNDRangeKernel (gegl_cl_get_command_queue (),
cl_data->kernel[0], 2,
NULL, global_ws_in, NULL,
0, NULL, NULL);
CL_CHECK;
cl_err = gegl_cl_set_kernel_args (cl_data->kernel[1],
sizeof (cl_mem), &aux_tex,
sizeof (cl_mem), &out_tex,
NULL);
CL_CHECK;
cl_err = gegl_clEnqueueNDRangeKernel (gegl_cl_get_command_queue (),
cl_data->kernel[1], 2,
NULL, global_ws_aux, NULL,
0, NULL, NULL);
CL_CHECK;
return FALSE;
error:
return TRUE;
}
static gboolean
cl_process (GeglOperation *operation,
cl_mem in_tex,
cl_mem aux_tex,
cl_mem out_tex,
size_t global_worksize,
const GeglRectangle *roi,
gint level)
{
GeglOperationClass *operation_class = GEGL_OPERATION_GET_CLASS (operation);
cl_int cl_err = 0;
/* The kernel will have been compiled by our parent class */
if (!operation_class->cl_data)
return TRUE;
cl_err = gegl_cl_set_kernel_args (operation_class->cl_data->kernel[0],
sizeof(cl_mem), &in_tex,
sizeof(cl_mem), &aux_tex,
sizeof(cl_mem), &out_tex,
NULL);
CL_CHECK;
cl_err = gegl_clEnqueueNDRangeKernel (gegl_cl_get_command_queue (),
operation_class->cl_data->kernel[0], 1,
NULL, &global_worksize, NULL,
0, NULL, NULL);
CL_CHECK;
return FALSE;
error:
return TRUE;
}
static gboolean
cl_process (GeglOperation *operation,
cl_mem in,
cl_mem out,
size_t global_worksize,
const GeglRectangle *roi,
gint level)
{
GeglProperties *o = GEGL_PROPERTIES (operation);
cl_float3 freq;
cl_float3 phaseshift;
cl_int3 keep;
cl_int cl_err = 0;
if (!cl_data)
{
const char *kernel_name[] = {"cl_alien_map",
NULL};
cl_data = gegl_cl_compile_and_build (alien_map_cl_source, kernel_name);
}
if (!cl_data)
return TRUE;
freq.s[0] = o->cpn_1_frequency * G_PI;
freq.s[1] = o->cpn_2_frequency * G_PI;
freq.s[2] = o->cpn_3_frequency * G_PI;
phaseshift.s[0] = G_PI * o->cpn_1_phaseshift / 180.0;
phaseshift.s[1] = G_PI * o->cpn_2_phaseshift / 180.0;
phaseshift.s[2] = G_PI * o->cpn_3_phaseshift / 180.0;
keep.s[0] = (cl_int)o->cpn_1_keep;
keep.s[1] = (cl_int)o->cpn_2_keep;
keep.s[2] = (cl_int)o->cpn_3_keep;
cl_err = gegl_cl_set_kernel_args (cl_data->kernel[0],
sizeof(cl_mem), &in,
sizeof(cl_mem), &out,
sizeof(cl_float3), &freq,
sizeof(cl_float3), &phaseshift,
sizeof(cl_int3), &keep,
NULL);
CL_CHECK;
cl_err = gegl_clEnqueueNDRangeKernel (gegl_cl_get_command_queue (),
cl_data->kernel[0], 1,
NULL, &global_worksize, NULL,
0, NULL, NULL);
CL_CHECK;
return FALSE;
error:
return TRUE;
}
static gboolean
cl_process (GeglOperation *operation,
cl_mem in,
cl_mem out,
size_t global_worksize,
const GeglRectangle *roi,
gint level)
{
GeglProperties *o = GEGL_PROPERTIES (operation);
CeParamsType *params = (CeParamsType*) o->user_data;
cl_float3 color_diff;
cl_float3 min;
cl_float3 max;
cl_int cl_err = 0;
gint i;
if (!cl_data)
{
const char *kernel_name[] = {"cl_color_exchange",
NULL};
cl_data = gegl_cl_compile_and_build (color_exchange_cl_source, kernel_name);
}
if (!cl_data)
return TRUE;
for (i = 0; i < 3; i++)
{
color_diff.s[i] = params->color_diff[i];
min.s[i] = params->min[i];
max.s[i] = params->max[i];
}
cl_err = gegl_cl_set_kernel_args (cl_data->kernel[0],
sizeof(cl_mem), &in,
sizeof(cl_mem), &out,
sizeof(cl_float3), &color_diff,
sizeof(cl_float3), &min,
sizeof(cl_float3), &max,
NULL);
CL_CHECK;
cl_err = gegl_clEnqueueNDRangeKernel (gegl_cl_get_command_queue (),
cl_data->kernel[0], 1,
NULL, &global_worksize, NULL,
0, NULL, NULL);
CL_CHECK;
return FALSE;
error:
return TRUE;
}
static gboolean
cl_gaussian_blur (cl_mem in_tex,
cl_mem out_tex,
const GeglRectangle *roi,
cl_mem cl_cmatrix,
gint clen,
GeglOrientation orientation)
{
cl_int cl_err = 0;
size_t global_ws[2];
gint kernel_num;
if (!cl_data)
{
const char *kernel_name[] = {"fir_ver_blur", "fir_hor_blur", NULL};
cl_data = gegl_cl_compile_and_build (gblur_1d_cl_source, kernel_name);
}
if (!cl_data)
return TRUE;
if (orientation == GEGL_ORIENTATION_VERTICAL)
kernel_num = 0;
else
kernel_num = 1;
global_ws[0] = roi->width;
global_ws[1] = roi->height;
cl_err = gegl_cl_set_kernel_args (cl_data->kernel[kernel_num],
sizeof(cl_mem), (void*)&in_tex,
sizeof(cl_mem), (void*)&out_tex,
sizeof(cl_mem), (void*)&cl_cmatrix,
sizeof(cl_int), (void*)&clen,
NULL);
CL_CHECK;
cl_err = gegl_clEnqueueNDRangeKernel (gegl_cl_get_command_queue (),
cl_data->kernel[kernel_num], 2,
NULL, global_ws, NULL,
0, NULL, NULL);
CL_CHECK;
cl_err = gegl_clFinish (gegl_cl_get_command_queue ());
CL_CHECK;
return FALSE;
error:
return TRUE;
}
static gboolean
cl_process (GeglOperation *operation,
cl_mem in_buf,
cl_mem out_buf,
const size_t n_pixels,
const GeglRectangle *roi,
gint level)
{
GeglOperationClass *operation_class = GEGL_OPERATION_GET_CLASS (operation);
GeglClRunData *cl_data = operation_class->cl_data;
GeglProperties *o = GEGL_PROPERTIES (operation);
const size_t gbl_size[2] = {roi->width, roi->height};
const size_t gbl_off[2] = {roi->x, roi->y};
cl_int cl_err = 0;
cl_mem filter_pat = NULL;
if (!cl_data)
goto error;
filter_pat = gegl_clCreateBuffer (gegl_cl_get_context (),
CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR,
pattern_width[o->pattern] *
pattern_height[o->pattern] * sizeof(cl_int),
(void*)pattern[o->pattern],
&cl_err);
CL_CHECK;
cl_err = gegl_cl_set_kernel_args (cl_data->kernel[0],
sizeof(cl_mem), &in_buf,
sizeof(cl_mem), &out_buf,
sizeof(cl_mem), &filter_pat,
sizeof(cl_int), &pattern_width[o->pattern],
sizeof(cl_int), &pattern_height[o->pattern],
sizeof(cl_int), &o->additive,
sizeof(cl_int), &o->rotated,
NULL);
CL_CHECK;
cl_err = gegl_clEnqueueNDRangeKernel (gegl_cl_get_command_queue (),
cl_data->kernel[0], 2,
gbl_off, gbl_size, NULL,
0, NULL, NULL);
CL_CHECK;
cl_err = gegl_clFinish (gegl_cl_get_command_queue ());
CL_CHECK;
cl_err = gegl_clReleaseMemObject (filter_pat);
CL_CHECK;
return FALSE;
error:
if (filter_pat)
gegl_clReleaseMemObject (filter_pat);
return TRUE;
}
static gboolean
checkerboard_cl_process (GeglOperation *operation,
cl_mem out_tex,
size_t global_worksize,
const GeglRectangle *roi,
gint level)
{
GeglProperties *o = GEGL_PROPERTIES (operation);
const Babl *out_format = gegl_operation_get_format (operation, "output");
const size_t gbl_size[2] = {roi->width, roi->height};
const size_t gbl_offs[2] = {roi->x, roi->y};
cl_int cl_err = 0;
float color1[4];
float color2[4];
if (!cl_data)
{
const char *kernel_name[] = {"kernel_checkerboard", NULL};
cl_data = gegl_cl_compile_and_build (checkerboard_cl_source, kernel_name);
if (!cl_data)
return TRUE;
}
gegl_color_get_pixel (o->color1, out_format, color1);
gegl_color_get_pixel (o->color2, out_format, color2);
cl_err = gegl_cl_set_kernel_args (cl_data->kernel[0],
sizeof(cl_mem), &out_tex,
sizeof(color1), &color1,
sizeof(color2), &color2,
sizeof(cl_int), &o->x,
sizeof(cl_int), &o->y,
sizeof(cl_int), &o->x_offset,
sizeof(cl_int), &o->y_offset,
NULL);
CL_CHECK;
cl_err = gegl_clEnqueueNDRangeKernel (gegl_cl_get_command_queue (),
cl_data->kernel[0], 2,
gbl_offs, gbl_size, NULL,
0, NULL, NULL);
CL_CHECK;
return FALSE;
error:
return TRUE;
}
static gboolean
cl_process (GeglOperation *operation,
cl_mem in,
cl_mem out,
size_t global_worksize,
const GeglRectangle *roi,
gint level)
{
GeglProperties *o = GEGL_PROPERTIES (operation);
cl_float threshold = o->threshold;
if (!cl_data)
{
const char *kernel_name[] = {"cl_red_eye_removal", NULL};
cl_data = gegl_cl_compile_and_build(red_eye_removal_cl_source, kernel_name);
}
if (!cl_data)
return TRUE;
{
cl_int cl_err = 0;
gegl_cl_set_kernel_args (cl_data->kernel[0],
sizeof(cl_mem), &in,
sizeof(cl_mem), &out,
sizeof(cl_float), &threshold,
NULL);
CL_CHECK;
cl_err = gegl_clEnqueueNDRangeKernel (gegl_cl_get_command_queue (),
cl_data->kernel[0], 1,
NULL, &global_worksize, NULL,
0, NULL, NULL);
CL_CHECK;
}
return FALSE;
error:
return TRUE;
}
static gboolean
cl_pixelize (cl_mem in_tex,
cl_mem aux_tex,
cl_mem out_tex,
const GeglRectangle *src_rect,
const GeglRectangle *roi,
gint xsize,
gint ysize,
gfloat xratio,
gfloat yratio,
gfloat bg_color[4],
gint norm,
GeglRectangle *image_extent)
{
cl_int cl_err = 0;
const size_t gbl_size[2]= {roi->width, roi->height};
gint cx0 = block_index (roi->x, xsize);
gint cy0 = block_index (roi->y, ysize);
gint block_count_x = block_index (roi->x + roi->width + xsize - 1, xsize) - cx0;
gint block_count_y = block_index (roi->y + roi->height + ysize - 1, ysize) - cy0;
cl_int4 bbox = {{ image_extent->x, image_extent->y,
image_extent->x + image_extent->width,
image_extent->y + image_extent->height }};
cl_int line_width = roi->width + 2 * xsize;
size_t gbl_size_tmp[2] = {block_count_x, block_count_y};
if (!cl_data)
{
const char *kernel_name[] = {"calc_block_color", "kernel_pixelize", NULL};
cl_data = gegl_cl_compile_and_build (pixelize_cl_source, kernel_name);
}
if (!cl_data) return 1;
cl_err = gegl_cl_set_kernel_args (cl_data->kernel[0],
sizeof(cl_mem), (void*)&in_tex,
sizeof(cl_mem), (void*)&aux_tex,
sizeof(cl_int), (void*)&xsize,
sizeof(cl_int), (void*)&ysize,
sizeof(cl_int), (void*)&roi->x,
sizeof(cl_int), (void*)&roi->y,
sizeof(cl_int4), &bbox,
sizeof(cl_int), (void*)&line_width,
sizeof(cl_int), (void*)&block_count_x,
NULL);
CL_CHECK;
cl_err = gegl_clEnqueueNDRangeKernel (gegl_cl_get_command_queue (),
cl_data->kernel[0], 2,
NULL, gbl_size_tmp, NULL,
0, NULL, NULL);
CL_CHECK;
cl_err = gegl_cl_set_kernel_args (cl_data->kernel[1],
sizeof(cl_mem), (void*)&aux_tex,
sizeof(cl_mem), (void*)&out_tex,
sizeof(cl_int), (void*)&xsize,
sizeof(cl_int), (void*)&ysize,
sizeof(cl_float), (void*)&xratio,
sizeof(cl_float), (void*)&yratio,
sizeof(cl_int), (void*)&roi->x,
sizeof(cl_int), (void*)&roi->y,
sizeof(cl_float4),(void*)bg_color,
sizeof(cl_int), (void*)&norm,
sizeof(cl_int), (void*)&block_count_x,
NULL);
CL_CHECK;
cl_err = gegl_clEnqueueNDRangeKernel (gegl_cl_get_command_queue (),
cl_data->kernel[1], 2,
NULL, gbl_size, NULL,
0, NULL, NULL);
CL_CHECK;
return FALSE;
error:
return TRUE;
}
static gboolean
cl_process (GeglOperation *operation,
cl_mem out_tex,
const GeglRectangle *roi)
{
GeglProperties *o = GEGL_PROPERTIES (operation);
const size_t gbl_size[] = { roi->width, roi->height };
cl_int cl_err = 0;
cl_int offset_x;
cl_int offset_y;
cl_int width;
cl_int height;
cl_float3 sedges;
cl_float3 contours;
cl_float3 frequency;
cl_float brightness;
cl_float polarization;
cl_float scattering;
cl_int iterations;
cl_float weird_factor;
if (!cl_data)
{
const char *kernel_name[] = { "cl_diffraction_patterns", NULL };
cl_data = gegl_cl_compile_and_build (diffraction_patterns_cl_source,
kernel_name);
if (!cl_data)
return TRUE;
}
offset_x = roi->x;
offset_y = roi->y;
width = o->width;
height = o->height;
sedges.s[0] = o->red_sedges;
sedges.s[1] = o->green_sedges;
sedges.s[2] = o->blue_sedges;
contours.s[0] = o->red_contours;
contours.s[1] = o->green_contours;
contours.s[2] = o->blue_contours;
frequency.s[0] = o->red_frequency;
frequency.s[1] = o->green_frequency;
frequency.s[2] = o->blue_frequency;
brightness = o->brightness;
polarization = o->polarization;
scattering = o->scattering;
iterations = ITERATIONS;
weird_factor = WEIRD_FACTOR;
cl_err = gegl_cl_set_kernel_args (cl_data->kernel[0],
sizeof(cl_mem), &out_tex,
sizeof(cl_int), &offset_x,
sizeof(cl_int), &offset_y,
sizeof(cl_int), &width,
sizeof(cl_int), &height,
sizeof(cl_float3), &sedges,
sizeof(cl_float3), &contours,
sizeof(cl_float3), &frequency,
sizeof(cl_float), &brightness,
sizeof(cl_float), &polarization,
sizeof(cl_float), &scattering,
sizeof(cl_int), &iterations,
sizeof(cl_float), &weird_factor,
NULL);
CL_CHECK;
cl_err = gegl_clEnqueueNDRangeKernel (gegl_cl_get_command_queue (),
cl_data->kernel[0], 2,
NULL, gbl_size, NULL,
0, NULL, NULL);
CL_CHECK;
cl_err = gegl_clFinish (gegl_cl_get_command_queue ());
CL_CHECK;
return FALSE;
error:
return TRUE;
}
static gboolean
cl_bilateral (cl_mem in_tex,
cl_mem out_tex,
const GeglRectangle *roi,
const GeglRectangle *src_rect,
gint s_sigma,
gfloat r_sigma)
{
cl_int cl_err = 0;
gint c;
const gint width = src_rect->width;
const gint height = src_rect->height;
const gint sw = (width -1) / s_sigma + 1;
const gint sh = (height-1) / s_sigma + 1;
const gint depth = (int)(1.0f / r_sigma) + 1;
size_t global_ws[2];
size_t local_ws[2];
cl_mem grid = NULL;
cl_mem blur[4] = {NULL, NULL, NULL, NULL};
if (!cl_data)
{
const char *kernel_name[] = {"bilateral_downsample",
"bilateral_blur",
"bilateral_interpolate",
NULL};
cl_data = gegl_cl_compile_and_build (bilateral_filter_fast_cl_source, kernel_name);
}
if (!cl_data)
return 1;
grid = gegl_clCreateBuffer (gegl_cl_get_context (),
CL_MEM_READ_WRITE,
sw * sh * depth * sizeof(cl_float8),
NULL,
&cl_err);
CL_CHECK;
for(c = 0; c < 4; c++)
{
blur[c] = gegl_clCreateBuffer (gegl_cl_get_context (),
CL_MEM_READ_WRITE,
sw * sh * depth * sizeof(cl_float2),
NULL, &cl_err);
CL_CHECK;
}
local_ws[0] = 8;
local_ws[1] = 8;
global_ws[0] = ((sw + local_ws[0] - 1)/local_ws[0])*local_ws[0];
global_ws[1] = ((sh + local_ws[1] - 1)/local_ws[1])*local_ws[1];
gegl_cl_set_kernel_args (cl_data->kernel[0],
sizeof(cl_mem), &in_tex,
sizeof(cl_mem), &grid,
sizeof(cl_int), &width,
sizeof(cl_int), &height,
sizeof(cl_int), &sw,
sizeof(cl_int), &sh,
sizeof(cl_int), &depth,
sizeof(cl_int), &s_sigma,
sizeof(cl_float), &r_sigma,
NULL);
CL_CHECK;
cl_err = gegl_clEnqueueNDRangeKernel (gegl_cl_get_command_queue (),
cl_data->kernel[0], 2,
NULL, global_ws, local_ws,
0, NULL, NULL);
CL_CHECK;
local_ws[0] = 16;
local_ws[1] = 16;
global_ws[0] = ((sw + local_ws[0] - 1)/local_ws[0])*local_ws[0];
global_ws[1] = ((sh + local_ws[1] - 1)/local_ws[1])*local_ws[1];
gegl_cl_set_kernel_args (cl_data->kernel[1],
sizeof(cl_mem), &grid,
sizeof(cl_mem), &blur[0],
sizeof(cl_mem), &blur[1],
sizeof(cl_mem), &blur[2],
sizeof(cl_mem), &blur[3],
sizeof(cl_int), &sw,
sizeof(cl_int), &sh,
sizeof(cl_int), &depth,
NULL);
cl_err = gegl_clEnqueueNDRangeKernel (gegl_cl_get_command_queue (),
cl_data->kernel[1], 2,
NULL, global_ws, local_ws,
0, NULL, NULL);
CL_CHECK;
global_ws[0] = width;
global_ws[1] = height;
gegl_cl_set_kernel_args (cl_data->kernel[2],
sizeof(cl_mem), &in_tex,
sizeof(cl_mem), &blur[0],
sizeof(cl_mem), &blur[1],
sizeof(cl_mem), &blur[2],
sizeof(cl_mem), &blur[3],
sizeof(cl_mem), &out_tex,
sizeof(cl_int), &width,
sizeof(cl_int), &sw,
sizeof(cl_int), &sh,
sizeof(cl_int), &depth,
sizeof(cl_int), &s_sigma,
sizeof(cl_float), &r_sigma,
NULL);
CL_CHECK;
cl_err = gegl_clEnqueueNDRangeKernel(gegl_cl_get_command_queue (),
cl_data->kernel[2], 2,
NULL, global_ws, NULL,
0, NULL, NULL);
CL_CHECK;
cl_err = gegl_clFinish (gegl_cl_get_command_queue ());
CL_CHECK;
cl_err = gegl_clReleaseMemObject (grid);
CL_CHECK_ONLY (cl_err);
for(c = 0; c < 4; c++)
{
cl_err = gegl_clReleaseMemObject (blur[c]);
CL_CHECK_ONLY (cl_err);
}
return FALSE;
error:
if (grid)
gegl_clReleaseMemObject (grid);
for (c = 0; c < 4; c++)
{
if (blur[c])
gegl_clReleaseMemObject (blur[c]);
}
return TRUE;
}
static gboolean
cl_box_blur (cl_mem in_tex,
cl_mem aux_tex,
cl_mem out_tex,
size_t global_worksize,
const GeglRectangle *roi,
gint radius)
{
cl_int cl_err = 0;
size_t global_ws_hor[2], global_ws_ver[2], global_ws[2];
size_t local_ws_hor[2], local_ws_ver[2], local_ws[2];
size_t step_size ;
if (!cl_data)
{
const char *kernel_name[] = { "kernel_blur_hor", "kernel_blur_ver","kernel_box_blur_fast", NULL};
cl_data = gegl_cl_compile_and_build (box_blur_cl_source, kernel_name);
}
if (!cl_data)
return TRUE;
step_size = 64;
local_ws[0]=256;
local_ws[1]=1;
if( radius <=110 )
{
global_ws[0] = (roi->width + local_ws[0] - 2 * radius - 1) / ( local_ws[0] - 2 * radius ) * local_ws[0];
global_ws[1] = (roi->height + step_size - 1) / step_size;
cl_err = gegl_cl_set_kernel_args(cl_data->kernel[2],
sizeof(cl_mem), (void *)&in_tex,
sizeof(cl_mem), (void *)&out_tex,
sizeof(cl_float4)*local_ws[0], (void *)NULL,
sizeof(cl_int), (void *)&roi->width,
sizeof(cl_int), (void *)&roi->height,
sizeof(cl_int), (void *)&radius,
sizeof(cl_int), (void *)&step_size, NULL);
CL_CHECK;
cl_err = gegl_clEnqueueNDRangeKernel(gegl_cl_get_command_queue(),
cl_data->kernel[2], 2,
NULL, global_ws, local_ws, 0, NULL, NULL );
CL_CHECK;
}
else
{
local_ws_hor[0] = 1;
local_ws_hor[1] = 256;
global_ws_hor[0] = roi->height + 2 * radius;
global_ws_hor[1] = ((roi->width + local_ws_hor[1] -1)/local_ws_hor[1]) * local_ws_hor[1];
local_ws_ver[0] = 1;
local_ws_ver[1] = 256;
global_ws_ver[0] = roi->height;
global_ws_ver[1] = ((roi->width + local_ws_ver[1] -1)/local_ws_ver[1]) * local_ws_ver[1];
cl_err = gegl_cl_set_kernel_args (cl_data->kernel[0],
sizeof(cl_mem), (void*)&in_tex,
sizeof(cl_mem), (void*)&aux_tex,
sizeof(cl_int), (void*)&roi->width,
sizeof(cl_int), (void*)&radius,
NULL);
CL_CHECK;
cl_err = gegl_clEnqueueNDRangeKernel (gegl_cl_get_command_queue (),
cl_data->kernel[0], 2,
NULL, global_ws_hor, local_ws_hor,
0, NULL, NULL);
CL_CHECK;
cl_err = gegl_cl_set_kernel_args (cl_data->kernel[1],
sizeof(cl_mem), (void*)&aux_tex,
sizeof(cl_mem), (void*)&out_tex,
sizeof(cl_int), (void*)&roi->width,
sizeof(cl_int), (void*)&radius,
NULL);
CL_CHECK;
cl_err = gegl_clEnqueueNDRangeKernel (gegl_cl_get_command_queue (),
cl_data->kernel[1], 2,
NULL, global_ws_ver, local_ws_ver,
0, NULL, NULL);
CL_CHECK;
}
return FALSE;
error:
return TRUE;
}
static gboolean
cl_process (GeglOperation *operation,
cl_mem in,
cl_mem out,
size_t global_worksize,
const GeglRectangle *roi,
gint level)
{
GeglProperties *o = GEGL_PROPERTIES (operation);
GeglRectangle *wr = gegl_operation_source_get_bounding_box (operation,
"input");
cl_int cl_err = 0;
cl_mem cl_random_data = NULL;
cl_int x_offset = roi->x;
cl_int y_offset = roi->y;
cl_int roi_width = roi->width;
cl_int wr_width = wr->width;
cl_ushort4 rand;
cl_int holdness;
cl_float hue_distance;
cl_float saturation_distance;
cl_float value_distance;
gegl_cl_random_get_ushort4 (o->rand, &rand);
if (!cl_data)
{
const char *kernel_name[] = { "cl_noise_hsv", NULL };
cl_data = gegl_cl_compile_and_build (noise_hsv_cl_source, kernel_name);
}
if (!cl_data)
return TRUE;
cl_random_data = gegl_cl_load_random_data (&cl_err);
CL_CHECK;
holdness = o->holdness;
hue_distance = o->hue_distance / 360.0;
saturation_distance = o->saturation_distance;
value_distance = o->value_distance;
gegl_cl_set_kernel_args (cl_data->kernel[0],
sizeof(cl_mem), &in,
sizeof(cl_mem), &out,
sizeof(cl_mem), &cl_random_data,
sizeof(cl_ushort4), &rand,
sizeof(cl_int), &x_offset,
sizeof(cl_int), &y_offset,
sizeof(cl_int), &roi_width,
sizeof(cl_int), &wr_width,
sizeof(cl_int), &holdness,
sizeof(cl_float), &hue_distance,
sizeof(cl_float), &saturation_distance,
sizeof(cl_float), &value_distance,
NULL);
CL_CHECK;
cl_err = gegl_clEnqueueNDRangeKernel (gegl_cl_get_command_queue (),
cl_data->kernel[0], 1,
NULL, &global_worksize, NULL,
0, NULL, NULL);
CL_CHECK;
cl_err = gegl_clFinish (gegl_cl_get_command_queue ());
CL_CHECK;
return FALSE;
error:
return TRUE;
}