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; }