/* Do the final setup of the iter struct */
static void
prepare_iteration (GeglBufferIterator *iter)
{
int index;
GeglBufferIteratorPriv *priv = iter->priv;
gint origin_offset_x;
gint origin_offset_y;
/* Set up the origin tile */
/* FIXME: Pick the most compatable buffer, not just the first */
{
GeglBuffer *buf = priv->sub_iter[0].buffer;
priv->origin_tile.x = buf->shift_x;
priv->origin_tile.y = buf->shift_y;
priv->origin_tile.width = buf->tile_width;
priv->origin_tile.height = buf->tile_height;
origin_offset_x = buf->shift_x + priv->sub_iter[0].full_rect.x;
origin_offset_y = buf->shift_y + priv->sub_iter[0].full_rect.y;
}
for (index = 0; index < priv->num_buffers; index++)
{
SubIterState *sub = &priv->sub_iter[index];
GeglBuffer *buf = sub->buffer;
gint current_offset_x = buf->shift_x + priv->sub_iter[index].full_rect.x;
gint current_offset_y = buf->shift_y + priv->sub_iter[index].full_rect.y;
/* Format converison needed */
if (gegl_buffer_get_format (sub->buffer) != sub->format)
sub->access_mode |= GEGL_ITERATOR_INCOMPATIBLE;
/* Incompatable tiles */
else if ((priv->origin_tile.width != buf->tile_width) ||
(priv->origin_tile.height != buf->tile_height) ||
(abs(origin_offset_x - current_offset_x) % priv->origin_tile.width != 0) ||
(abs(origin_offset_y - current_offset_y) % priv->origin_tile.height != 0))
{
/* Check if the buffer is a linear buffer */
if ((buf->extent.x == -buf->shift_x) &&
(buf->extent.y == -buf->shift_y) &&
(buf->extent.width == buf->tile_width) &&
(buf->extent.height == buf->tile_height))
{
sub->linear_tile = gegl_buffer_get_tile (sub->buffer, 0, 0, 0);
if (sub->access_mode & GEGL_ACCESS_WRITE)
gegl_tile_lock (sub->linear_tile);
}
else
sub->access_mode |= GEGL_ITERATOR_INCOMPATIBLE;
}
gegl_buffer_lock (sub->buffer);
}
}
static void linear_shortcut (GeglBufferIterator *iter)
{
GeglBufferIteratorPriv *priv = iter->priv;
SubIterState *sub0 = &priv->sub_iter[0];
int index;
int re_use_first[16] = {0,};
for (index = priv->num_buffers-1; index >=0 ; index--)
{
SubIterState *sub = &priv->sub_iter[index];
sub->real_roi = sub0->full_rect;
iter->roi[index] = sub0->full_rect;
iter->length = iter->roi[0].width * iter->roi[0].height;
if (priv->sub_iter[0].buffer == sub->buffer && index != 0)
{
if (sub->format == priv->sub_iter[0].format)
re_use_first[index] = 1;
}
if (!re_use_first[index])
{
gegl_buffer_lock (sub->buffer);
if (index == 0)
get_tile (iter, index);
else
{
if (sub->buffer->tile_width == sub->buffer->extent.width
&& sub->buffer->tile_height == sub->buffer->extent.height
&& sub->buffer->extent.x == iter->roi[index].x
&& sub->buffer->extent.y == iter->roi[index].y)
{
get_tile (iter, index);
}
else
get_indirect (iter, index);
}
}
}
for (index = 1; index < priv->num_buffers; index++)
{
if (re_use_first[index])
{
g_print ("!\n");
iter->data[index] = iter->data[0];
}
}
priv->state = GeglIteratorState_Invalid; /* quit on next iterator_next */
}
/* Do the final setup of the iter struct */
static void
prepare_iteration (GeglBufferIterator *iter)
{
int index;
GeglBufferIteratorPriv *priv = iter->priv;
/* Set up the origin tile */
/* FIXME: Pick the most compatable buffer, not just the first */
{
GeglBuffer *buf = priv->sub_iter[0].buffer;
priv->origin_tile.x = buf->shift_x;
priv->origin_tile.y = buf->shift_y;
priv->origin_tile.width = buf->tile_width;
priv->origin_tile.height = buf->tile_height;
}
for (index = 0; index < priv->num_buffers; index++)
{
SubIterState *sub = &priv->sub_iter[index];
GeglBuffer *buf = sub->buffer;
/* Format converison needed */
if (gegl_buffer_get_format (sub->buffer) != sub->format)
sub->flags |= GEGL_ITERATOR_INCOMPATIBLE;
/* Incompatable tiles */
else if ((priv->origin_tile.x != buf->shift_x) ||
(priv->origin_tile.y != buf->shift_y) ||
(priv->origin_tile.width != buf->tile_width) ||
(priv->origin_tile.height != buf->tile_height))
{
/* Check if the buffer is a linear buffer */
if ((buf->extent.x == -buf->shift_x) &&
(buf->extent.y == -buf->shift_y) &&
(buf->extent.width == buf->tile_width) &&
(buf->extent.height == buf->tile_height))
{
sub->linear_tile = gegl_tile_source_get_tile ((GeglTileSource *)(sub->buffer), 0, 0, 0);
if (sub->flags & GEGL_BUFFER_WRITE)
gegl_tile_lock (sub->linear_tile);
}
else
sub->flags |= GEGL_ITERATOR_INCOMPATIBLE;
}
gegl_buffer_lock (sub->buffer);
}
}
gboolean
gegl_buffer_cl_iterator_next (GeglBufferClIterator *iterator, gboolean *err)
{
GeglBufferClIterators *i = (gpointer)iterator;
gboolean result = FALSE;
gint no, j;
cl_int cl_err = 0;
if (i->is_finished)
g_error ("%s called on finished buffer iterator", G_STRFUNC);
if (i->iteration_no == 0)
{
for (no=0; no<i->iterators;no++)
{
if (i->buffer[no])
{
gint j;
gboolean found = FALSE;
for (j=0; j<no; j++)
if (i->buffer[no]==i->buffer[j])
{
found = TRUE;
break;
}
if (!found)
gegl_buffer_lock (i->buffer[no]);
if (i->flags[no] == GEGL_CL_BUFFER_WRITE
|| (i->flags[no] == GEGL_CL_BUFFER_READ
&& (i->area[no][0] > 0 || i->area[no][1] > 0 || i->area[no][2] > 0 || i->area[no][3] > 0)))
{
gegl_buffer_cl_cache_flush (i->buffer[no], &i->rect[no]);
}
}
}
}
else
{
/* complete pending write work */
for (no=0; no<i->iterators;no++)
{
if (i->flags[no] == GEGL_CL_BUFFER_WRITE)
{
/* Wait Processing */
cl_err = gegl_clEnqueueBarrier(gegl_cl_get_command_queue());
if (cl_err != CL_SUCCESS) CL_ERROR;
/* color conversion in the GPU (output) */
if (i->conv[no] == GEGL_CL_COLOR_CONVERT)
for (j=0; j < i->n; j++)
{
cl_err = gegl_cl_color_conv (i->tex_op[no][j], i->tex_buf[no][j], i->size[no][j],
i->format[no], i->buffer[no]->soft_format);
if (cl_err == FALSE) CL_ERROR;
}
/* Wait Processing */
cl_err = gegl_clEnqueueBarrier(gegl_cl_get_command_queue());
if (cl_err != CL_SUCCESS) CL_ERROR;
/* GPU -> CPU */
for (j=0; j < i->n; j++)
{
gpointer data;
/* tile-ize */
if (i->conv[no] == GEGL_CL_COLOR_NOT_SUPPORTED)
{
data = gegl_clEnqueueMapBuffer(gegl_cl_get_command_queue(), i->tex_op[no][j], CL_TRUE,
CL_MAP_READ,
0, i->size[no][j] * i->op_cl_format_size [no],
0, NULL, NULL, &cl_err);
if (cl_err != CL_SUCCESS) CL_ERROR;
/* color conversion using BABL */
gegl_buffer_set (i->buffer[no], &i->roi[no][j], 0, i->format[no], data, GEGL_AUTO_ROWSTRIDE);
cl_err = gegl_clEnqueueUnmapMemObject (gegl_cl_get_command_queue(), i->tex_op[no][j], data,
0, NULL, NULL);
if (cl_err != CL_SUCCESS) CL_ERROR;
}
else
#ifdef OPENCL_USE_CACHE
{
gegl_buffer_cl_cache_new (i->buffer[no], &i->roi[no][j], i->tex_buf[no][j]);
/* don't release this texture */
i->tex_buf[no][j] = NULL;
}
#else
{
data = gegl_clEnqueueMapBuffer(gegl_cl_get_command_queue(), i->tex_buf[no][j], CL_TRUE,
CL_MAP_READ,
0, i->size[no][j] * i->buf_cl_format_size [no],
0, NULL, NULL, &cl_err);
if (cl_err != CL_SUCCESS) CL_ERROR;
/* color conversion using BABL */
gegl_buffer_set (i->buffer[no], &i->roi[no][j], i->format[no], data, GEGL_AUTO_ROWSTRIDE);
cl_err = gegl_clEnqueueUnmapMemObject (gegl_cl_get_command_queue(), i->tex_buf[no][j], data,
0, NULL, NULL);
if (cl_err != CL_SUCCESS) CL_ERROR;
}
#endif
}
}
}
/* Run! */
cl_err = gegl_clFinish(gegl_cl_get_command_queue());
if (cl_err != CL_SUCCESS) CL_ERROR;
for (no=0; no < i->iterators; no++)
for (j=0; j < i->n; j++)
{
if (i->tex_buf_from_cache [no][j])
{
gboolean ok = gegl_buffer_cl_cache_release (i->tex_buf[no][j]);
g_assert (ok);
}
if (i->tex_buf[no][j] && !i->tex_buf_from_cache [no][j])
gegl_clReleaseMemObject (i->tex_buf[no][j]);
if (i->tex_op [no][j])
gegl_clReleaseMemObject (i->tex_op [no][j]);
i->tex [no][j] = NULL;
i->tex_buf[no][j] = NULL;
i->tex_op [no][j] = NULL;
}
}
g_assert (i->iterators > 0);
result = (i->roi_no >= i->rois)? FALSE : TRUE;
i->n = MIN(GEGL_CL_NTEX, i->rois - i->roi_no);
/* then we iterate all */
for (no=0; no<i->iterators;no++)
{
for (j = 0; j < i->n; j++)
{
GeglRectangle r = {i->rect[no].x + i->roi_all[i->roi_no+j].x - i->area[no][0],
i->rect[no].y + i->roi_all[i->roi_no+j].y - i->area[no][2],
i->roi_all[i->roi_no+j].width + i->area[no][0] + i->area[no][1],
i->roi_all[i->roi_no+j].height + i->area[no][2] + i->area[no][3]};
i->roi [no][j] = r;
i->size[no][j] = r.width * r.height;
}
if (i->flags[no] == GEGL_CL_BUFFER_READ)
{
for (j=0; j < i->n; j++)
{
gpointer data;
/* un-tile */
switch (i->conv[no])
{
case GEGL_CL_COLOR_NOT_SUPPORTED:
{
gegl_buffer_cl_cache_flush (i->buffer[no], &i->roi[no][j]);
g_assert (i->tex_op[no][j] == NULL);
i->tex_op[no][j] = gegl_clCreateBuffer (gegl_cl_get_context (),
CL_MEM_ALLOC_HOST_PTR | CL_MEM_READ_ONLY,
i->size[no][j] * i->op_cl_format_size [no],
NULL, &cl_err);
if (cl_err != CL_SUCCESS) CL_ERROR;
/* pre-pinned memory */
data = gegl_clEnqueueMapBuffer(gegl_cl_get_command_queue(), i->tex_op[no][j], CL_TRUE,
CL_MAP_WRITE,
0, i->size[no][j] * i->op_cl_format_size [no],
0, NULL, NULL, &cl_err);
if (cl_err != CL_SUCCESS) CL_ERROR;
/* color conversion using BABL */
gegl_buffer_get (i->buffer[no], &i->roi[no][j], 1.0, i->format[no], data, GEGL_AUTO_ROWSTRIDE, GEGL_ABYSS_NONE);
cl_err = gegl_clEnqueueUnmapMemObject (gegl_cl_get_command_queue(), i->tex_op[no][j], data,
0, NULL, NULL);
if (cl_err != CL_SUCCESS) CL_ERROR;
i->tex[no][j] = i->tex_op[no][j];
break;
}
case GEGL_CL_COLOR_EQUAL:
{
i->tex_buf[no][j] = gegl_buffer_cl_cache_get (i->buffer[no], &i->roi[no][j]);
if (i->tex_buf[no][j])
i->tex_buf_from_cache [no][j] = TRUE; /* don't free texture from cache */
else
{
gegl_buffer_cl_cache_flush (i->buffer[no], &i->roi[no][j]);
g_assert (i->tex_buf[no][j] == NULL);
i->tex_buf[no][j] = gegl_clCreateBuffer (gegl_cl_get_context (),
CL_MEM_ALLOC_HOST_PTR | CL_MEM_READ_ONLY,
i->size[no][j] * i->buf_cl_format_size [no],
NULL, &cl_err);
if (cl_err != CL_SUCCESS) CL_ERROR;
/* pre-pinned memory */
data = gegl_clEnqueueMapBuffer(gegl_cl_get_command_queue(), i->tex_buf[no][j], CL_TRUE,
CL_MAP_WRITE,
0, i->size[no][j] * i->buf_cl_format_size [no],
0, NULL, NULL, &cl_err);
if (cl_err != CL_SUCCESS) CL_ERROR;
/* color conversion will be performed in the GPU later */
gegl_buffer_cl_worker_transf (i->buffer[no], data, i->buf_cl_format_size [no], i->roi[no][j], FALSE);
cl_err = gegl_clEnqueueUnmapMemObject (gegl_cl_get_command_queue(), i->tex_buf[no][j], data,
0, NULL, NULL);
if (cl_err != CL_SUCCESS) CL_ERROR;
}
i->tex[no][j] = i->tex_buf[no][j];
break;
}
case GEGL_CL_COLOR_CONVERT:
{
i->tex_buf[no][j] = gegl_buffer_cl_cache_get (i->buffer[no], &i->roi[no][j]);
if (i->tex_buf[no][j])
i->tex_buf_from_cache [no][j] = TRUE; /* don't free texture from cache */
else
{
gegl_buffer_cl_cache_flush (i->buffer[no], &i->roi[no][j]);
g_assert (i->tex_buf[no][j] == NULL);
i->tex_buf[no][j] = gegl_clCreateBuffer (gegl_cl_get_context (),
CL_MEM_ALLOC_HOST_PTR | CL_MEM_READ_ONLY,
i->size[no][j] * i->buf_cl_format_size [no],
NULL, &cl_err);
if (cl_err != CL_SUCCESS) CL_ERROR;
/* pre-pinned memory */
data = gegl_clEnqueueMapBuffer(gegl_cl_get_command_queue(), i->tex_buf[no][j], CL_TRUE,
CL_MAP_WRITE,
0, i->size[no][j] * i->buf_cl_format_size [no],
0, NULL, NULL, &cl_err);
if (cl_err != CL_SUCCESS) CL_ERROR;
/* color conversion will be performed in the GPU later */
/* get buffer data using multiple worker threads
to increase bandwidth */
gegl_buffer_cl_worker_transf (i->buffer[no], data, i->buf_cl_format_size [no], i->roi[no][j], FALSE);
cl_err = gegl_clEnqueueUnmapMemObject (gegl_cl_get_command_queue(), i->tex_buf[no][j], data,
0, NULL, NULL);
if (cl_err != CL_SUCCESS) CL_ERROR;
}
g_assert (i->tex_op[no][j] == NULL);
i->tex_op[no][j] = gegl_clCreateBuffer (gegl_cl_get_context (),
CL_MEM_READ_WRITE,
i->size[no][j] * i->op_cl_format_size [no],
NULL, &cl_err);
if (cl_err != CL_SUCCESS) CL_ERROR;
/* color conversion in the GPU (input) */
g_assert (i->tex_buf[no][j] && i->tex_op[no][j]);
cl_err = gegl_cl_color_conv (i->tex_buf[no][j], i->tex_op[no][j], i->size[no][j],
i->buffer[no]->soft_format, i->format[no]);
if (cl_err == FALSE) CL_ERROR;
i->tex[no][j] = i->tex_op[no][j];
break;
}
}
}
/* Wait Processing */
cl_err = gegl_clEnqueueBarrier(gegl_cl_get_command_queue());
if (cl_err != CL_SUCCESS) CL_ERROR;
}
else if (i->flags[no] == GEGL_CL_BUFFER_WRITE)
{
for (j=0; j < i->n; j++)
{
switch (i->conv[no])
{
case GEGL_CL_COLOR_NOT_SUPPORTED:
{
g_assert (i->tex_op[no][j] == NULL);
i->tex_op[no][j] = gegl_clCreateBuffer (gegl_cl_get_context (),
CL_MEM_ALLOC_HOST_PTR | CL_MEM_WRITE_ONLY,
i->size[no][j] * i->op_cl_format_size [no],
NULL, &cl_err);
if (cl_err != CL_SUCCESS) CL_ERROR;
i->tex[no][j] = i->tex_op[no][j];
break;
}
case GEGL_CL_COLOR_EQUAL:
{
g_assert (i->tex_buf[no][j] == NULL);
i->tex_buf[no][j] = gegl_clCreateBuffer (gegl_cl_get_context (),
CL_MEM_ALLOC_HOST_PTR | CL_MEM_READ_WRITE, /* cache */
i->size[no][j] * i->buf_cl_format_size [no],
NULL, &cl_err);
if (cl_err != CL_SUCCESS) CL_ERROR;
i->tex[no][j] = i->tex_buf[no][j];
break;
}
case GEGL_CL_COLOR_CONVERT:
{
g_assert (i->tex_buf[no][j] == NULL);
i->tex_buf[no][j] = gegl_clCreateBuffer (gegl_cl_get_context (),
CL_MEM_ALLOC_HOST_PTR | CL_MEM_READ_WRITE, /* cache */
i->size[no][j] * i->buf_cl_format_size [no],
NULL, &cl_err);
if (cl_err != CL_SUCCESS) CL_ERROR;
g_assert (i->tex_op[no][j] == NULL);
i->tex_op[no][j] = gegl_clCreateBuffer (gegl_cl_get_context (),
CL_MEM_READ_WRITE,
i->size[no][j] * i->op_cl_format_size [no],
NULL, &cl_err);
if (cl_err != CL_SUCCESS) CL_ERROR;
i->tex[no][j] = i->tex_op[no][j];
break;
}
}
}
}
else if (i->flags[no] == GEGL_CL_BUFFER_AUX)
{
for (j=0; j < i->n; j++)
{
g_assert (i->tex_op[no][j] == NULL);
i->tex_op[no][j] = gegl_clCreateBuffer (gegl_cl_get_context (),
CL_MEM_READ_WRITE,
i->size[no][j] * i->op_cl_format_size [no],
NULL, &cl_err);
if (cl_err != CL_SUCCESS) CL_ERROR;
i->tex[no][j] = i->tex_op[no][j];
}
}
}
i->roi_no += i->n;
i->iteration_no++;
if (result == FALSE)
{
for (no=0; no<i->iterators;no++)
{
if (i->buffer[no])
{
gint j;
gboolean found = FALSE;
for (j=0; j<no; j++)
if (i->buffer[no]==i->buffer[j])
{
found = TRUE;
break;
}
if (!found)
gegl_buffer_unlock (i->buffer[no]);
g_object_unref (i->buffer[no]);
}
}
i->is_finished = TRUE;
g_free (i->roi_all);
g_slice_free (GeglBufferClIterators, i);
}
*err = FALSE;
return result;
error:
for (no=0; no<i->iterators;no++)
for (j=0; j < i->n; j++)
{
if (i->tex_buf[no][j]) gegl_clReleaseMemObject (i->tex_buf[no][j]);
if (i->tex_op [no][j]) gegl_clReleaseMemObject (i->tex_op [no][j]);
i->tex [no][j] = NULL;
i->tex_buf[no][j] = NULL;
i->tex_op [no][j] = NULL;
}
*err = TRUE;
return FALSE;
}
gboolean
gegl_buffer_iterator_next (GeglBufferIterator *iterator)
{
GeglBufferIterators *i = (gpointer)iterator;
gboolean result = FALSE;
gint no;
if (i->is_finished)
g_error ("%s called on finished buffer iterator", G_STRFUNC);
if (i->iteration_no == 0)
{
for (no=0; no<i->iterators;no++)
{
gint j;
gboolean found = FALSE;
for (j=0; j<no; j++)
if (i->buffer[no]==i->buffer[j])
{
found = TRUE;
break;
}
if (!found)
gegl_buffer_lock (i->buffer[no]);
if (gegl_cl_is_accelerated ())
gegl_buffer_cl_cache_flush (i->buffer[no], &i->rect[no]);
}
}
else
{
/* complete pending write work */
for (no=0; no<i->iterators;no++)
{
if (i->flags[no] & GEGL_BUFFER_WRITE)
{
if (i->flags[no] & GEGL_BUFFER_SCAN_COMPATIBLE &&
i->flags[no] & GEGL_BUFFER_FORMAT_COMPATIBLE &&
i->roi[no].width == i->i[no].buffer->tile_storage->tile_width && (i->flags[no] & GEGL_BUFFER_FORMAT_COMPATIBLE))
{ /* direct access, don't need to do anything */
#if DEBUG_DIRECT
direct_write += i->roi[no].width * i->roi[no].height;
#endif
}
else
{
#if DEBUG_DIRECT
in_direct_write += i->roi[no].width * i->roi[no].height;
#endif
ensure_buf (i, no);
/* XXX: should perhaps use _set_unlocked, and keep the lock in the
* iterator.
*/
gegl_buffer_set (i->buffer[no], &(i->roi[no]), 0, i->format[no], i->buf[no], GEGL_AUTO_ROWSTRIDE); /* XXX: use correct level */
}
}
}
}
g_assert (i->iterators > 0);
/* then we iterate all */
for (no=0; no<i->iterators;no++)
{
if (i->flags[no] & GEGL_BUFFER_SCAN_COMPATIBLE)
{
gboolean res;
res = gegl_buffer_tile_iterator_next (&i->i[no]);
if (no == 0)
{
result = res;
}
i->roi[no] = i->i[no].roi2;
/* since they were scan compatible this should be true */
if (res != result)
{
g_print ("%i==%i != 0==%i\n", no, res, result);
}
g_assert (res == result);
if ((i->flags[no] & GEGL_BUFFER_FORMAT_COMPATIBLE) &&
i->roi[no].width == i->i[no].buffer->tile_storage->tile_width
)
{
/* direct access */
i->data[no]=i->i[no].sub_data;
#if DEBUG_DIRECT
direct_read += i->roi[no].width * i->roi[no].height;
#endif
}
else
{
ensure_buf (i, no);
if (i->flags[no] & GEGL_BUFFER_READ)
{
gegl_buffer_get_unlocked (i->buffer[no], 1.0, &(i->roi[no]), i->format[no], i->buf[no], GEGL_AUTO_ROWSTRIDE);
}
i->data[no]=i->buf[no];
#if DEBUG_DIRECT
in_direct_read += i->roi[no].width * i->roi[no].height;
#endif
}
}
else
{
/* we copy the roi from iterator 0 */
i->roi[no] = i->roi[0];
i->roi[no].x += (i->rect[no].x-i->rect[0].x);
i->roi[no].y += (i->rect[no].y-i->rect[0].y);
ensure_buf (i, no);
if (i->flags[no] & GEGL_BUFFER_READ)
{
gegl_buffer_get_unlocked (i->buffer[no], 1.0, &(i->roi[no]), i->format[no], i->buf[no], GEGL_AUTO_ROWSTRIDE);
}
i->data[no]=i->buf[no];
#if DEBUG_DIRECT
in_direct_read += i->roi[no].width * i->roi[no].height;
#endif
}
i->length = i->roi[no].width * i->roi[no].height;
}
i->iteration_no++;
if (result == FALSE)
gegl_buffer_iterator_stop (iterator);
return result;
}
static void inline
gegl_sampler_get_pixel (GeglSampler *sampler,
gint x,
gint y,
gpointer data,
GeglAbyssPolicy repeat_mode)
{
GeglSamplerNearest *nearest_sampler = (GeglSamplerNearest*)(sampler);
GeglBuffer *buffer = sampler->buffer;
const GeglRectangle *abyss = &buffer->abyss;
guchar *buf = data;
if (y < abyss->y ||
x < abyss->x ||
y >= abyss->y + abyss->height ||
x >= abyss->x + abyss->width)
{
switch (repeat_mode)
{
case GEGL_ABYSS_CLAMP:
x = CLAMP (x, abyss->x, abyss->x+abyss->width-1);
y = CLAMP (y, abyss->y, abyss->y+abyss->height-1);
break;
case GEGL_ABYSS_LOOP:
x = abyss->x + GEGL_REMAINDER (x - abyss->x, abyss->width);
y = abyss->y + GEGL_REMAINDER (y - abyss->y, abyss->height);
break;
case GEGL_ABYSS_BLACK:
{
gfloat color[4] = {0.0, 0.0, 0.0, 1.0};
babl_process (babl_fish (gegl_babl_rgba_linear_float (), sampler->format),
color,
buf,
1);
return;
}
case GEGL_ABYSS_WHITE:
{
gfloat color[4] = {1.0, 1.0, 1.0, 1.0};
babl_process (babl_fish (gegl_babl_rgba_linear_float (),
sampler->format),
color,
buf,
1);
return;
}
default:
case GEGL_ABYSS_NONE:
memset (buf, 0x00, babl_format_get_bytes_per_pixel (sampler->format));
return;
}
}
gegl_buffer_lock (sampler->buffer);
{
gint tile_width = buffer->tile_width;
gint tile_height = buffer->tile_height;
gint tiledy = y + buffer->shift_y;
gint tiledx = x + buffer->shift_x;
gint indice_x = gegl_tile_indice (tiledx, tile_width);
gint indice_y = gegl_tile_indice (tiledy, tile_height);
GeglTile *tile = nearest_sampler->hot_tile;
if (!(tile &&
tile->x == indice_x &&
tile->y == indice_y))
{
if (gegl_config_threads()>1)
g_rec_mutex_lock (&buffer->tile_storage->mutex);
if (tile)
gegl_tile_unref (tile);
tile = gegl_tile_source_get_tile ((GeglTileSource *) (buffer),
indice_x, indice_y,
0);
nearest_sampler->hot_tile = tile;
if (gegl_config_threads()>1)
g_rec_mutex_unlock (&buffer->tile_storage->mutex);
}
if (tile)
{
gint tile_origin_x = indice_x * tile_width;
gint tile_origin_y = indice_y * tile_height;
gint offsetx = tiledx - tile_origin_x;
gint offsety = tiledy - tile_origin_y;
guchar *tp = gegl_tile_get_data (tile) + (offsety * tile_width + offsetx) * nearest_sampler->buffer_bpp;
babl_process (sampler->fish, tp, buf, 1);
}
}
gegl_buffer_unlock (sampler->buffer);
}