static gboolean
process (GeglOperation *operation,
GeglOperationContext *context,
const gchar *output_pad,
const GeglRectangle *result,
gint level)
{
GeglProperties *o = GEGL_PROPERTIES (operation);
#if 1
g_assert (o->user_data);
gegl_operation_context_take_object (context, "output", G_OBJECT (o->user_data));
o->user_data = NULL;
#else
if (o->user_data)
{
g_object_ref (o->user_data); /* Add an extra reference, since gegl_operation_set_data
is stealing one.
*/
/* override core behaviour, by resetting the buffer in the operation_context */
gegl_operation_context_take_object (context, "output", G_OBJECT (o->user_data));
}
#endif
return TRUE;
}
static gboolean
process (GeglOperation *operation,
GeglOperationContext *context,
const gchar *output_pad,
const GeglRectangle *result,
gint level)
{
GeglProperties *o = GEGL_PROPERTIES (operation);
if (o->buffer)
{
g_object_ref (o->buffer); /* Add an extra reference, since
* gegl_operation_set_data is
* stealing one.
*/
/* override core behaviour, by resetting the buffer in the operation_context */
gegl_operation_context_take_object (context, "output",
G_OBJECT (o->buffer));
/* mark that this buffer should not be used for in-place
* processing.
*/
gegl_object_set_has_forked (G_OBJECT (o->buffer));
}
return TRUE;
}
static gboolean gegl_operation_point_filter_op_process
(GeglOperation *operation,
GeglOperationContext *context,
const gchar *output_pad,
const GeglRectangle *roi)
{
GeglBuffer *input;
GeglBuffer *output;
gboolean success = FALSE;
input = gegl_operation_context_get_source (context, "input");
if (gegl_can_do_inplace_processing (operation, input, roi))
{
output = g_object_ref (input);
gegl_operation_context_take_object (context, "output", G_OBJECT (output));
}
else
{
output = gegl_operation_context_get_target (context, "output");
}
success = gegl_operation_point_filter_process (operation, input, output, roi);
if (output == GEGL_BUFFER (operation->node->cache))
gegl_cache_computed (operation->node->cache, roi);
if (input != NULL)
g_object_unref (input);
return success;
}
static gboolean
gegl_nop_process (GeglOperation *operation,
GeglOperationContext *context,
const gchar *output_prop,
const GeglRectangle *result,
gint level)
{
GeglBuffer *input;
if (strcmp (output_prop, "output"))
{
g_warning ("requested processing of %s pad on a nop", output_prop);
return FALSE;
}
input = GEGL_BUFFER (gegl_operation_context_get_object (context, "input"));
if (!input)
{
g_warning ("nop received NULL input");
return FALSE;
}
gegl_operation_context_take_object (context, "output", g_object_ref (G_OBJECT (input)));
return TRUE;
}
static gboolean
operation_process (GeglOperation *operation,
GeglOperationContext *context,
const gchar *output_prop,
const GeglRectangle *result,
gint level)
{
GeglOperationClass *operation_class;
GeglProperties *o = GEGL_PROPERTIES (operation);
operation_class = GEGL_OPERATION_CLASS (gegl_op_parent_class);
if (!o->clip_high && !o->clip_low)
{
gpointer in = gegl_operation_context_get_object (context, "input");
gegl_operation_context_take_object (context, "output",
g_object_ref (G_OBJECT (in)));
return TRUE;
}
/* chain up, which will create the needed buffers for our actual
* process function
*/
return operation_class->process (operation, context, output_prop, result,
gegl_operation_context_get_level (context));
}
static gboolean
process (GeglOperation *operation,
GeglOperationContext *context,
const gchar *output_prop,
const GeglRectangle *result,
gint level)
{
GeglBuffer *input;
if (strcmp (output_prop, "output"))
{
g_warning ("requested processing of %s pad on a clone", output_prop);
return FALSE;
}
input = gegl_operation_context_get_source (context, "input");
if (!input)
{
g_warning ("clone received NULL input");
return FALSE;
}
gegl_operation_context_take_object (context, "output", G_OBJECT (input));
return TRUE;
}
/* Pass-through when trying to perform IIR on an infinite plane
*/
static gboolean
operation_process (GeglOperation *operation,
GeglOperationContext *context,
const gchar *output_prop,
const GeglRectangle *result,
gint level)
{
GeglOperationClass *operation_class;
GeglProperties *o = GEGL_PROPERTIES (operation);
GeglGblur1dFilter filter = filter_disambiguation (o->filter, o->std_dev);
operation_class = GEGL_OPERATION_CLASS (gegl_op_parent_class);
if (filter == GEGL_GBLUR_1D_IIR)
{
const GeglRectangle *in_rect =
gegl_operation_source_get_bounding_box (operation, "input");
if (in_rect && gegl_rectangle_is_infinite_plane (in_rect))
{
gpointer in = gegl_operation_context_get_object (context, "input");
gegl_operation_context_take_object (context, "output",
g_object_ref (G_OBJECT (in)));
return TRUE;
}
}
/* chain up, which will create the needed buffers for our actual
* process function
*/
return operation_class->process (operation, context, output_prop, result,
gegl_operation_context_get_level (context));
}
gboolean
gegl_operation_process (GeglOperation *operation,
GeglOperationContext *context,
const gchar *output_pad,
const GeglRectangle *result,
gint level)
{
GeglOperationClass *klass;
g_return_val_if_fail (GEGL_IS_OPERATION (operation), FALSE);
klass = GEGL_OPERATION_GET_CLASS (operation);
if (!strcmp (output_pad, "output") &&
(result->width == 0 || result->height == 0))
{
GeglBuffer *output = gegl_buffer_new (NULL, NULL);
g_warning ("%s Eeek: processing 0px rectangle", G_STRLOC);
/* when this case is hit.. we've done something bad.. */
gegl_operation_context_take_object (context, "output", G_OBJECT (output));
return TRUE;
}
return klass->process (operation, context, output_pad, result, level);
}
static gboolean
operation_process (GeglOperation *operation,
GeglOperationContext *context,
const gchar *output_prop,
const GeglRectangle *result,
gint level)
{
GeglOperationClass *operation_class;
const GeglRectangle *in_rect =
gegl_operation_source_get_bounding_box (operation, "input");
operation_class = GEGL_OPERATION_CLASS (gegl_op_parent_class);
if (in_rect && gegl_rectangle_is_infinite_plane (in_rect))
{
gpointer in = gegl_operation_context_get_object (context, "input");
gegl_operation_context_take_object (context, "output",
g_object_ref (G_OBJECT (in)));
return TRUE;
}
return operation_class->process (operation, context, output_prop, result,
gegl_operation_context_get_level (context));
}
/* Fast path when opacity is a no-op
*/
static gboolean operation_process (GeglOperation *operation,
GeglOperationContext *context,
const gchar *output_prop,
const GeglRectangle *result,
gint level)
{
GeglOperationClass *operation_class;
gpointer in, aux;
operation_class = GEGL_OPERATION_CLASS (gegl_chant_parent_class);
/* get the raw values this does not increase the reference count */
in = gegl_operation_context_get_object (context, "input");
aux = gegl_operation_context_get_object (context, "aux");
if (in && !aux && GEGL_CHANT_PROPERTIES (operation)->value == 1.0)
{
gegl_operation_context_take_object (context, "output",
g_object_ref (G_OBJECT (in)));
return TRUE;
}
/* chain up, which will create the needed buffers for our actual
* process function
*/
return operation_class->process (operation, context, output_prop, result,
gegl_operation_context_get_level (context));
}
/* Fast paths */
static gboolean operation_process (GeglOperation *operation,
GeglOperationContext *context,
const gchar *output_prop,
const GeglRectangle *result,
gint level)
{
GeglOperationClass *operation_class;
gpointer input, aux;
operation_class = GEGL_OPERATION_CLASS (gegl_chant_parent_class);
/* get the raw values this does not increase the reference count */
input = gegl_operation_context_get_object (context, "input");
aux = gegl_operation_context_get_object (context, "aux");
/* pass the input/aux buffers directly through if they are alone*/
{
const GeglRectangle *in_extent = NULL;
const GeglRectangle *aux_extent = NULL;
if (input)
in_extent = gegl_buffer_get_abyss (input);
if ((!input ||
(aux && !gegl_rectangle_intersect (NULL, in_extent, result))))
{
gegl_operation_context_take_object (context, "output",
g_object_ref (aux));
return TRUE;
}
if (aux)
aux_extent = gegl_buffer_get_abyss (aux);
if (!aux ||
(input && !gegl_rectangle_intersect (NULL, aux_extent, result)))
{
gegl_operation_context_take_object (context, "output",
g_object_ref (input));
return TRUE;
}
}
/* chain up, which will create the needed buffers for our actual
* process function
*/
return operation_class->process (operation, context, output_prop, result, level);
}
void
gegl_operation_context_set_object (GeglOperationContext *context,
const gchar *padname,
GObject *data)
{
/* Make it simple, just add an extra ref and then take the object */
if (data)
g_object_ref (data);
gegl_operation_context_take_object (context, padname, data);
}
void
gegl_operation_context_set_object (GeglOperationContext *context,
const gchar *padname,
GObject *data)
{
g_return_if_fail (!data || GEGL_IS_BUFFER (data));
/* Make it simple, just add an extra ref and then take the object */
if (data)
g_object_ref (data);
gegl_operation_context_take_object (context, padname, data);
}
/* we replicate the process function from GeglOperationComposer to be
* able to bail out earlier for some common processing time pitfalls
*/
static gboolean
gegl_operation_composer_process2 (GeglOperation *operation,
GeglOperationContext *context,
const gchar *output_prop,
const GeglRectangle *result)
{
GeglOperationComposerClass *klass = GEGL_OPERATION_COMPOSER_GET_CLASS (operation);
GeglBuffer *input;
GeglBuffer *aux;
GeglBuffer *output;
gboolean success = FALSE;
if (strcmp (output_prop, "output"))
{
g_warning ("requested processing of %s pad on a composer", output_prop);
return FALSE;
}
input = gegl_operation_context_get_source (context, "input");
aux = gegl_operation_context_get_source (context, "aux");
if (gegl_can_do_inplace_processing (operation, input, result))
{
output = g_object_ref (input);
gegl_operation_context_take_object (context, "output", G_OBJECT (output));
}
else
output = gegl_operation_context_get_target (context, "output");
{
gboolean done = FALSE;
if (result->width == 0 ||
result->height == 0)
done = TRUE;
success = done;
if (!done)
{
success = klass->process (operation, input, aux, output, result);
if (output == GEGL_BUFFER (operation->node->cache))
gegl_cache_computed (operation->node->cache, result);
}
if (input)
g_object_unref (input);
if (aux)
g_object_unref (aux);
}
return success;
}
static gboolean
process (GeglOperation *operation,
GeglOperationContext *context,
const gchar *output_prop,
const GeglRectangle *roi,
gint level)
{
GeglProperties *o = GEGL_PROPERTIES (operation);
GeglBuffer *input;
GeglBuffer *output;
if (! o->input_format || ! o->output_format)
{
g_warning ("cast-format: input-format or output-format are not set");
return FALSE;
}
if (babl_format_get_bytes_per_pixel (o->input_format) !=
babl_format_get_bytes_per_pixel (o->output_format))
{
g_warning ("cast-format: input-format and output-format have different bpp");
return FALSE;
}
if (strcmp (output_prop, "output"))
{
g_warning ("cast-format: requested processing of %s pad", output_prop);
return FALSE;
}
input = gegl_operation_context_get_source (context, "input");
if (! input)
{
g_warning ("cast: received NULL input");
return FALSE;
}
output = gegl_buffer_new (roi, o->input_format);
gegl_buffer_copy (input, roi, GEGL_ABYSS_NONE,
output, roi);
gegl_buffer_set_format (output, o->output_format);
g_object_unref (input);
gegl_operation_context_take_object (context, "output", G_OBJECT (output));
return TRUE;
}
static gboolean
process (GeglOperation *operation,
GeglOperationContext *context,
const gchar *output_pad,
const GeglRectangle *result,
gint level)
{
GeglProperties *o = GEGL_PROPERTIES (operation);
if (!o->user_data)
return FALSE;
/* overriding the predefined behavior */
g_object_ref (o->user_data);
gegl_operation_context_take_object (context, "output", G_OBJECT (o->user_data));
return TRUE;
}
static gboolean
gegl_buffer_load_op_process (GeglOperation *operation,
GeglOperationContext *context,
const gchar *output_pad,
const GeglRectangle *result,
gint level)
{
GeglProperties *o = GEGL_PROPERTIES (operation);
gegl_buffer_load_op_ensure_buffer (o);
gegl_operation_context_take_object (context, output_pad, o->user_data);
o->user_data = NULL;
return TRUE;
}
static gboolean
process (GeglOperation *operation,
GeglOperationContext *context,
const gchar *output_pad,
const GeglRectangle *result,
gint level)
{
GeglProperties *o = GEGL_PROPERTIES (operation);
GeglBuffer *output;
load_buffer (o);
g_assert (o->user_data);
g_assert (g_str_equal (output_pad, "output"));
output = GEGL_BUFFER (o->user_data);
g_object_ref (output);
gegl_operation_context_take_object (context, "output", G_OBJECT (output));
return TRUE;
}
GeglBuffer *
gegl_operation_context_get_output_maybe_in_place (GeglOperation *operation,
GeglOperationContext *context,
GeglBuffer *input,
const GeglRectangle *roi)
{
GeglOperationClass *klass = GEGL_OPERATION_GET_CLASS (operation);
GeglBuffer *output;
if (klass->want_in_place &&
gegl_can_do_inplace_processing (operation, input, roi))
{
output = g_object_ref (input);
gegl_operation_context_take_object (context, "output", G_OBJECT (output));
}
else
{
output = gegl_operation_context_get_target (context, "output");
}
return output;
}
static gboolean
process (GeglOperation *operation,
GeglOperationContext *context,
const gchar *output_pad,
const GeglRectangle *result,
gint level)
{
GeglBuffer *buffer = ensure_buffer (operation);
if (buffer)
{
g_object_ref (buffer); /* Add an extra reference, since
* gegl_operation_set_data is
* stealing one.
*/
/* override core behaviour, by resetting the buffer in the operation_context */
gegl_operation_context_take_object (context, "output", G_OBJECT (buffer));
return TRUE;
}
return FALSE;
}
static gboolean
gegl_crop_process (GeglOperation *operation,
GeglOperationContext *context,
const gchar *output_prop,
const GeglRectangle *result,
gint level)
{
GeglProperties *o = GEGL_PROPERTIES (operation);
GeglBuffer *input;
gboolean success = FALSE;
GeglRectangle extent;
extent.x = o->x;
extent.y = o->y;
extent.width = o->width;
extent.height = o->height;
input = gegl_operation_context_get_source (context, "input");
if (input)
{
GeglBuffer *output = gegl_buffer_create_sub_buffer (input, &extent);
if (gegl_object_get_has_forked (G_OBJECT (input)))
gegl_object_set_has_forked (G_OBJECT (output));
gegl_operation_context_take_object (context, "output", G_OBJECT (output));
g_object_unref (input);
success = TRUE;
}
else
{
g_warning ("%s got NULL input pad", gegl_node_get_operation (operation->node));
}
return success;
}
static gboolean
operation_process (GeglOperation *operation,
GeglOperationContext *context,
const gchar *output_prop,
const GeglRectangle *result,
gint level)
{
GeglOperationClass *operation_class;
GeglProperties *o = GEGL_PROPERTIES (operation);
operation_class = GEGL_OPERATION_CLASS (gegl_op_parent_class);
if (! o->radius)
{
gpointer in = gegl_operation_context_get_object (context, "input");
gegl_operation_context_take_object (context, "output",
g_object_ref (G_OBJECT (in)));
return TRUE;
}
return operation_class->process (operation, context, output_prop, result,
gegl_operation_context_get_level (context));
}
static gboolean
gegl_introspect_process (GeglOperation *operation,
GeglOperationContext *context,
const gchar *output_pad,
const GeglRectangle *result,
gint level)
{
GeglProperties *o = GEGL_PROPERTIES (operation);
gegl_introspect_load_cache (o);
if (!o->user_data)
return FALSE;
/* gegl_operation_context_take_object() takes the reference we have,
* so we must increase it since we want to keep the object
*/
g_object_ref (o->user_data);
gegl_operation_context_take_object (context, output_pad, G_OBJECT (o->user_data));
return TRUE;
}
static gboolean
operation_process (GeglOperation *operation,
GeglOperationContext *context,
const gchar *output_prop,
const GeglRectangle *result,
gint level)
{
GeglChantO *o = GEGL_CHANT_PROPERTIES (operation);
GeglOperationClass *operation_class;
operation_class = GEGL_OPERATION_CLASS (gegl_chant_parent_class);
/* If the profile is NULL, simply become a nop */
if (!o->src_profile)
{
gpointer input = gegl_operation_context_get_object (context, "input");
gegl_operation_context_take_object (context, "output",
g_object_ref (input));
return TRUE;
}
return operation_class->process (operation, context,
output_prop, result, level);
}
GeglBuffer *
gegl_operation_context_get_target (GeglOperationContext *context,
const gchar *padname)
{
GeglBuffer *output;
const GeglRectangle *result;
const Babl *format;
GeglNode *node;
GeglOperation *operation;
#if 0
g_return_val_if_fail (GEGL_IS_OPERATION_CONTEXT (context), NULL);
#endif
operation = context->operation;
node = operation->node; /* <ick */
format = gegl_operation_get_format (operation, padname);
if (format == NULL)
{
g_warning ("no format for %s presuming RGBA float\n",
gegl_node_get_debug_name (node));
format = babl_format ("RGBA float");
}
g_assert (format != NULL);
g_assert (!strcmp (padname, "output"));
result = &context->result_rect;
if (result->width == 0 ||
result->height == 0)
{
output = g_object_ref (emptybuf());
}
else if (node->dont_cache == FALSE &&
! GEGL_OPERATION_CLASS (G_OBJECT_GET_CLASS (operation))->no_cache)
{
GeglBuffer *cache;
cache = GEGL_BUFFER (gegl_node_get_cache (node));
/* Only use the cache if the result is within the cache
* extent. This is certainly not optimal. My gut feeling is that
* the current caching mechanism needs to be redesigned
*/
if (gegl_rectangle_contains (gegl_buffer_get_extent (cache), result))
{
output = g_object_ref (cache);
}
else
{
output = gegl_buffer_new_ram (result, format);
}
}
else
{
output = gegl_buffer_new_ram (result, format);
}
gegl_operation_context_take_object (context, padname, G_OBJECT (output));
return output;
}
static gboolean
gegl_affine_process (GeglOperation *operation,
GeglOperationContext *context,
const gchar *output_prop,
const GeglRectangle *result)
{
GeglBuffer *input;
GeglBuffer *output;
GeglMatrix3 matrix;
OpAffine *affine = (OpAffine *) operation;
gegl_affine_create_composite_matrix (affine, &matrix);
if (gegl_affine_is_intermediate_node (affine) ||
gegl_matrix3_is_identity (&matrix))
{
/* passing straight through (like gegl:nop) */
input = gegl_operation_context_get_source (context, "input");
if (!input)
{
g_warning ("transform received NULL input");
return FALSE;
}
gegl_operation_context_take_object (context, "output", G_OBJECT (input));
}
else if (gegl_affine_matrix3_allow_fast_translate (&matrix) ||
(gegl_matrix3_is_translate (&matrix) &&
! strcmp (affine->filter, "nearest")))
{
/* doing a buffer shifting trick, (enhanced nop) */
input = gegl_operation_context_get_source (context, "input");
output = g_object_new (GEGL_TYPE_BUFFER,
"source", input,
"shift-x", (int)-matrix.coeff[0][2],
"shift-y", (int)-matrix.coeff[1][2],
"abyss-width", -1, /* turn of abyss
(relying on abyss
of source) */
NULL);
if (gegl_object_get_has_forked (input))
gegl_object_set_has_forked (output);
gegl_operation_context_take_object (context, "output", G_OBJECT (output));
if (input != NULL)
g_object_unref (input);
}
else if (gegl_affine_matrix3_allow_fast_reflect_x (&matrix))
{
GeglRectangle src_rect;
GeglSampler *sampler;
GeglRectangle context_rect;
input = gegl_operation_context_get_source (context, "input");
if (!input)
{
g_warning ("transform received NULL input");
return FALSE;
}
output = gegl_operation_context_get_target (context, "output");
src_rect = gegl_operation_get_required_for_output (operation, "output", result);
src_rect.y += 1;
sampler = gegl_buffer_sampler_new (input, babl_format("RaGaBaA float"),
gegl_sampler_type_from_string (affine->filter));
context_rect = *gegl_sampler_get_context_rect (sampler);
src_rect.width -= context_rect.width;
src_rect.height -= context_rect.height;
gegl_affine_fast_reflect_x (output, input, result, &src_rect);
g_object_unref (sampler);
if (input != NULL)
g_object_unref (input);
}
else if (gegl_affine_matrix3_allow_fast_reflect_y (&matrix))
{
GeglRectangle src_rect;
GeglSampler *sampler;
GeglRectangle context_rect;
input = gegl_operation_context_get_source (context, "input");
if (!input)
{
g_warning ("transform received NULL input");
return FALSE;
}
output = gegl_operation_context_get_target (context, "output");
src_rect = gegl_operation_get_required_for_output (operation, "output", result);
src_rect.x += 1;
sampler = gegl_buffer_sampler_new (input, babl_format("RaGaBaA float"),
gegl_sampler_type_from_string (affine->filter));
context_rect = *gegl_sampler_get_context_rect (sampler);
src_rect.width -= context_rect.width;
src_rect.height -= context_rect.height;
gegl_affine_fast_reflect_y (output, input, result, &src_rect);
g_object_unref (sampler);
if (input != NULL)
g_object_unref (input);
}
else
{
/* for all other cases, do a proper resampling */
GeglSampler *sampler;
input = gegl_operation_context_get_source (context, "input");
output = gegl_operation_context_get_target (context, "output");
sampler = gegl_buffer_sampler_new (input, babl_format("RaGaBaA float"),
gegl_sampler_type_from_string (affine->filter));
affine_generic (output, input, &matrix, sampler);
g_object_unref (sampler);
if (input != NULL)
g_object_unref (input);
}
return TRUE;
}
