/* This file is part of GEGL
*
* GEGL is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 3 of the License, or (at your option) any later version.
*
* GEGL is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with GEGL; if not, see <http://www.gnu.org/licenses/>.
*
* Copyright 2006 Øyvind Kolås
*/
#include "config.h"
#include <glib-object.h>
#include "gegl.h"
#include "gegl-types-internal.h"
#include "gegl-operation-point-composer3.h"
#include "gegl-utils.h"
#include "graph/gegl-node.h"
#include "graph/gegl-pad.h"
#include <string.h>
static gboolean gegl_operation_point_composer3_process
(GeglOperation *operation,
GeglBuffer *input,
GeglBuffer *aux,
GeglBuffer *aux2,
GeglBuffer *output,
const GeglRectangle *result,
gint level);
static gboolean
gegl_operation_composer3_process2 (GeglOperation *operation,
GeglOperationContext *context,
const gchar *output_prop,
const GeglRectangle *result,
gint level);
G_DEFINE_TYPE (GeglOperationPointComposer3, gegl_operation_point_composer3, GEGL_TYPE_OPERATION_COMPOSER3)
static void prepare (GeglOperation *operation)
{
const Babl *format = babl_format ("RGBA float");
gegl_operation_set_format (operation, "input", format);
gegl_operation_set_format (operation, "aux", format);
gegl_operation_set_format (operation, "aux2", format);
gegl_operation_set_format (operation, "output", format);
}
static void
gegl_operation_point_composer3_class_init (GeglOperationPointComposer3Class *klass)
{
/*GObjectClass *object_class = G_OBJECT_CLASS (klass);*/
GeglOperationClass *operation_class = GEGL_OPERATION_CLASS (klass);
GeglOperationComposer3Class *composer_class = GEGL_OPERATION_COMPOSER3_CLASS (klass);
composer_class->process = gegl_operation_point_composer3_process;
operation_class->prepare = prepare;
operation_class->no_cache =TRUE;
operation_class->process = gegl_operation_composer3_process2;
}
static void
gegl_operation_point_composer3_init (GeglOperationPointComposer3 *self)
{
}
/* we replicate the process function from GeglOperationComposer3 to be
* able to bail out earlier for some common processing time pitfalls
*/
static gboolean
gegl_operation_composer3_process2 (GeglOperation *operation,
GeglOperationContext *context,
const gchar *output_prop,
const GeglRectangle *result,
gint level)
{
GeglOperationComposer3Class *klass = GEGL_OPERATION_COMPOSER3_GET_CLASS (operation);
GeglBuffer *input;
GeglBuffer *aux;
GeglBuffer *aux2;
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");
aux2 = gegl_operation_context_get_source (context, "aux2");
/* we could be even faster by not alway writing to this buffer, that
* would potentially break other assumptions we want to make from the
* GEGL core so we avoid doing that
*/
output = gegl_operation_context_get_target (context, "output");
if (input != NULL ||
aux != NULL ||
aux2 != NULL)
{
gboolean done = FALSE;
if (result->width == 0 ||
result->height == 0)
done = TRUE;
success = done;
if (!done)
{
success = klass->process (operation, input, aux, aux2, output, result, context->level);
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);
if (aux2)
g_object_unref (aux2);
}
else
{
g_warning ("%s received NULL input, aux, and aux2",
gegl_node_get_debug_name (operation->node));
}
return success;
}
static gboolean
gegl_operation_point_composer3_process (GeglOperation *operation,
GeglBuffer *input,
GeglBuffer *aux,
GeglBuffer *aux2,
GeglBuffer *output,
const GeglRectangle *result,
gint level)
{
GeglOperationPointComposer3Class *point_composer3_class = GEGL_OPERATION_POINT_COMPOSER3_GET_CLASS (operation);
const Babl *in_format = gegl_operation_get_format (operation, "input");
const Babl *aux_format = gegl_operation_get_format (operation, "aux");
const Babl *aux2_format = gegl_operation_get_format (operation, "aux2");
const Babl *out_format = gegl_operation_get_format (operation, "output");
if ((result->width > 0) && (result->height > 0))
{
GeglBufferIterator *i = gegl_buffer_iterator_new (output, result, level, out_format, GEGL_BUFFER_WRITE, GEGL_ABYSS_NONE);
gint read = gegl_buffer_iterator_add (i, input, result, level, in_format, GEGL_BUFFER_READ, GEGL_ABYSS_NONE);
if (aux)
{
gint foo = gegl_buffer_iterator_add (i, aux, result, level, aux_format, GEGL_BUFFER_READ, GEGL_ABYSS_NONE);
if (aux2)
{
gint bar = gegl_buffer_iterator_add (i, aux2, result, level, aux2_format, GEGL_BUFFER_READ, GEGL_ABYSS_NONE);
while (gegl_buffer_iterator_next (i))
{
point_composer3_class->process (operation, i->data[read], i->data[foo], i->data[bar], i->data[0], i->length, &(i->roi[0]), level);
}
}
else
{
while (gegl_buffer_iterator_next (i))
{
point_composer3_class->process (operation, i->data[read], i->data[foo], NULL, i->data[0], i->length, &(i->roi[0]), level);
}
}
}
else
{
if (aux2)
{
gint bar = gegl_buffer_iterator_add (i, aux2, result, level, aux2_format, GEGL_BUFFER_READ, GEGL_ABYSS_NONE);
while (gegl_buffer_iterator_next (i))
{
point_composer3_class->process (operation, i->data[read], NULL, i->data[bar], i->data[0], i->length, &(i->roi[0]), level);
}
}
else
{
while (gegl_buffer_iterator_next (i))
{
point_composer3_class->process (operation, i->data[read], NULL, NULL, i->data[0], i->length, &(i->roi[0]), level);
}
}
}
return TRUE;
}
return TRUE;
}