gint
gegl_buffer_cl_iterator_add_2 (GeglBufferClIterator *iterator,
GeglBuffer *buffer,
const GeglRectangle *result,
const Babl *format,
guint flags,
gint left,
gint right,
gint top,
gint bottom,
GeglAbyssPolicy abyss_policy)
{
GeglBufferClIterators *i = (gpointer)iterator;
gint self = 0;
if (i->iterators+1 > GEGL_CL_BUFFER_MAX_ITERATORS)
{
g_error ("too many iterators (%i)", i->iterators+1);
}
if (i->iterators == 0) /* for sanity, we zero at init */
{
memset (i, 0, sizeof (GeglBufferClIterators));
}
self = i->iterators++;
if (!result)
result = self==0?&(buffer->extent):&(i->rect[0]);
i->rect[self]=*result;
i->flags[self]=flags;
if (flags == GEGL_CL_BUFFER_WRITE || flags == GEGL_CL_BUFFER_READ)
{
g_assert (buffer);
i->buffer[self]= g_object_ref (buffer);
if (format)
i->format[self]=format;
else
i->format[self]=buffer->soft_format;
if (flags == GEGL_CL_BUFFER_WRITE)
i->conv[self] = gegl_cl_color_supported (format, buffer->soft_format);
else
i->conv[self] = gegl_cl_color_supported (buffer->soft_format, format);
gegl_cl_color_babl (buffer->soft_format, &i->buf_cl_format_size[self]);
gegl_cl_color_babl (format, &i->op_cl_format_size [self]);
}
else /* GEGL_CL_BUFFER_AUX */
{
g_assert (buffer == NULL);
i->buffer[self] = NULL;
i->format[self] = NULL;
i->conv[self] = -1;
i->buf_cl_format_size[self] = SIZE_MAX;
gegl_cl_color_babl (format, &i->op_cl_format_size [self]);
}
i->area[self][0] = left;
i->area[self][1] = right;
i->area[self][2] = top;
i->area[self][3] = bottom;
if (flags == GEGL_CL_BUFFER_WRITE
&& (left > 0 || right > 0 || top > 0 || bottom > 0))
g_assert(FALSE);
if (self!=0)
{
/* we make all subsequently added iterators share the width and height of the first one */
i->rect[self].width = i->rect[0].width;
i->rect[self].height = i->rect[0].height;
}
else
{
gint x, y, j;
i->rois = 0;
for (y=result->y; y < result->y + result->height; y += gegl_cl_get_iter_height ())
for (x=result->x; x < result->x + result->width; x += gegl_cl_get_iter_width ())
i->rois++;
i->roi_no = 0;
i->roi_all = g_new0 (GeglRectangle, i->rois);
j = 0;
for (y=0; y < result->height; y += gegl_cl_get_iter_height ())
for (x=0; x < result->width; x += gegl_cl_get_iter_width ())
{
GeglRectangle r = {x, y,
MIN(gegl_cl_get_iter_width (), result->width - x),
MIN(gegl_cl_get_iter_height (), result->height - y)};
i->roi_all[j] = r;
j++;
}
}
return self;
}
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;
}
