594 lines
20 KiB
C++
594 lines
20 KiB
C++
/* PIKA - Photo and Image Kooker Application
|
|
* a rebranding of The GNU Image Manipulation Program (created with heckimp)
|
|
* A derived work which may be trivial. However, any changes may be (C)2023 by Aldercone Studio
|
|
*
|
|
* Original copyright, applying to most contents (license remains unchanged):
|
|
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
|
|
*
|
|
* pikaoperationmaskcomponents.c
|
|
* Copyright (C) 2012 Michael Natterer <mitch@gimp.org>
|
|
*
|
|
* This program is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation; either version 3 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program 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 General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program. If not, see <https://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
#include "config.h"
|
|
|
|
#include <gegl.h>
|
|
|
|
extern "C"
|
|
{
|
|
|
|
#include "operations-types.h"
|
|
|
|
#include "pikaoperationmaskcomponents.h"
|
|
|
|
} /* extern "C" */
|
|
|
|
|
|
enum
|
|
{
|
|
PROP_0,
|
|
PROP_MASK,
|
|
PROP_ALPHA
|
|
};
|
|
|
|
|
|
static void pika_operation_mask_components_get_property (GObject *object,
|
|
guint property_id,
|
|
GValue *value,
|
|
GParamSpec *pspec);
|
|
static void pika_operation_mask_components_set_property (GObject *object,
|
|
guint property_id,
|
|
const GValue *value,
|
|
GParamSpec *pspec);
|
|
|
|
static void pika_operation_mask_components_prepare (GeglOperation *operation);
|
|
static GeglRectangle pika_operation_mask_components_get_bounding_box (GeglOperation *operation);
|
|
static gboolean pika_operation_mask_components_parent_process (GeglOperation *operation,
|
|
GeglOperationContext *context,
|
|
const gchar *output_prop,
|
|
const GeglRectangle *result,
|
|
gint level);
|
|
|
|
static gboolean pika_operation_mask_components_process (GeglOperation *operation,
|
|
void *in_buf,
|
|
void *aux_buf,
|
|
void *out_buf,
|
|
glong samples,
|
|
const GeglRectangle *roi,
|
|
gint level);
|
|
|
|
|
|
G_DEFINE_TYPE (PikaOperationMaskComponents, pika_operation_mask_components,
|
|
GEGL_TYPE_OPERATION_POINT_COMPOSER)
|
|
|
|
#define parent_class pika_operation_mask_components_parent_class
|
|
|
|
|
|
static void
|
|
pika_operation_mask_components_class_init (PikaOperationMaskComponentsClass *klass)
|
|
{
|
|
GObjectClass *object_class = G_OBJECT_CLASS (klass);
|
|
GeglOperationClass *operation_class = GEGL_OPERATION_CLASS (klass);
|
|
GeglOperationPointComposerClass *point_class = GEGL_OPERATION_POINT_COMPOSER_CLASS (klass);
|
|
|
|
object_class->set_property = pika_operation_mask_components_set_property;
|
|
object_class->get_property = pika_operation_mask_components_get_property;
|
|
|
|
gegl_operation_class_set_keys (operation_class,
|
|
"name", "pika:mask-components",
|
|
"categories", "pika",
|
|
"description", "Selectively pick components from src or aux",
|
|
NULL);
|
|
|
|
operation_class->prepare = pika_operation_mask_components_prepare;
|
|
operation_class->get_bounding_box = pika_operation_mask_components_get_bounding_box;
|
|
operation_class->process = pika_operation_mask_components_parent_process;
|
|
|
|
point_class->process = pika_operation_mask_components_process;
|
|
|
|
g_object_class_install_property (object_class, PROP_MASK,
|
|
g_param_spec_flags ("mask",
|
|
"Mask",
|
|
"The component mask",
|
|
PIKA_TYPE_COMPONENT_MASK,
|
|
PIKA_COMPONENT_MASK_ALL,
|
|
(GParamFlags) (
|
|
G_PARAM_READWRITE |
|
|
G_PARAM_CONSTRUCT)));
|
|
|
|
g_object_class_install_property (object_class, PROP_ALPHA,
|
|
g_param_spec_double ("alpha",
|
|
"Alpha",
|
|
"The masked-in alpha value when there's no aux input",
|
|
-G_MAXDOUBLE,
|
|
G_MAXDOUBLE,
|
|
0.0,
|
|
(GParamFlags) (
|
|
G_PARAM_READWRITE |
|
|
G_PARAM_CONSTRUCT)));
|
|
}
|
|
|
|
static void
|
|
pika_operation_mask_components_init (PikaOperationMaskComponents *self)
|
|
{
|
|
}
|
|
|
|
static void
|
|
pika_operation_mask_components_get_property (GObject *object,
|
|
guint property_id,
|
|
GValue *value,
|
|
GParamSpec *pspec)
|
|
{
|
|
PikaOperationMaskComponents *self = PIKA_OPERATION_MASK_COMPONENTS (object);
|
|
|
|
switch (property_id)
|
|
{
|
|
case PROP_MASK:
|
|
g_value_set_flags (value, self->mask);
|
|
break;
|
|
|
|
case PROP_ALPHA:
|
|
g_value_set_double (value, self->alpha);
|
|
break;
|
|
|
|
default:
|
|
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
|
|
break;
|
|
}
|
|
}
|
|
|
|
static void
|
|
pika_operation_mask_components_set_property (GObject *object,
|
|
guint property_id,
|
|
const GValue *value,
|
|
GParamSpec *pspec)
|
|
{
|
|
PikaOperationMaskComponents *self = PIKA_OPERATION_MASK_COMPONENTS (object);
|
|
|
|
switch (property_id)
|
|
{
|
|
case PROP_MASK:
|
|
self->mask = (PikaComponentMask) g_value_get_flags (value);
|
|
break;
|
|
|
|
case PROP_ALPHA:
|
|
self->alpha = g_value_get_double (value);
|
|
break;
|
|
|
|
default:
|
|
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
|
|
break;
|
|
}
|
|
}
|
|
|
|
static guint32
|
|
get_alpha_value (const Babl *format,
|
|
gfloat alpha)
|
|
{
|
|
switch (babl_format_get_bytes_per_pixel (format))
|
|
{
|
|
#define DEF_CASE(bpp, type) \
|
|
case bpp: \
|
|
{ \
|
|
type alpha_value; \
|
|
\
|
|
babl_process ( \
|
|
babl_fish (babl_format_n (babl_type ("float"), 1), \
|
|
babl_format_n (babl_format_get_type (format, 0), 1)), \
|
|
&alpha, &alpha_value, 1); \
|
|
\
|
|
return alpha_value; \
|
|
}
|
|
|
|
DEF_CASE ( 4, guint8)
|
|
DEF_CASE ( 8, guint16)
|
|
DEF_CASE (16, guint32)
|
|
|
|
#undef DEF_CASE
|
|
|
|
default:
|
|
g_return_val_if_reached (0);
|
|
}
|
|
}
|
|
|
|
template <class T>
|
|
struct ProcessGeneric
|
|
{
|
|
static void
|
|
process (gconstpointer in_buf,
|
|
gconstpointer aux_buf,
|
|
gpointer out_buf,
|
|
gint n,
|
|
PikaComponentMask mask,
|
|
T alpha_value)
|
|
{
|
|
T *out = (T *) out_buf;
|
|
gint i;
|
|
gint c;
|
|
|
|
if (aux_buf)
|
|
{
|
|
const T *in[4];
|
|
|
|
for (c = 0; c < 4; c++)
|
|
{
|
|
if (mask & (1 << c))
|
|
in[c] = (const T *) aux_buf + c;
|
|
else
|
|
in[c] = (const T *) in_buf + c;
|
|
}
|
|
|
|
for (i = 0; i < n; i++)
|
|
{
|
|
for (c = 0; c < 4; c++)
|
|
{
|
|
out[c] = *in[c];
|
|
|
|
in[c] += 4;
|
|
}
|
|
|
|
out += 4;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
const T *in = (const T*) in_buf;
|
|
|
|
for (i = 0; i < n; i++)
|
|
{
|
|
for (c = 0; c < 3; c++)
|
|
{
|
|
if (mask & (1 << c))
|
|
out[c] = 0;
|
|
else
|
|
out[c] = in[c];
|
|
}
|
|
|
|
if (mask & (1 << 3))
|
|
out[3] = alpha_value;
|
|
else
|
|
out[3] = in[3];
|
|
|
|
in += 4;
|
|
out += 4;
|
|
}
|
|
}
|
|
}
|
|
};
|
|
|
|
template <class T>
|
|
struct Process : ProcessGeneric<T>
|
|
{
|
|
};
|
|
|
|
#if G_BYTE_ORDER == G_LITTLE_ENDIAN
|
|
|
|
template <>
|
|
struct Process<guint8>
|
|
{
|
|
static void
|
|
process (gconstpointer in_buf,
|
|
gconstpointer aux_buf,
|
|
gpointer out_buf,
|
|
gint n,
|
|
PikaComponentMask mask,
|
|
guint8 alpha_value)
|
|
{
|
|
const guint32 *in;
|
|
guint32 *out;
|
|
guint32 in_mask = 0;
|
|
gint i;
|
|
gint c;
|
|
|
|
if (((guintptr) in_buf | (guintptr) aux_buf | (guintptr) out_buf) % 4)
|
|
{
|
|
ProcessGeneric<guint8>::process (in_buf, aux_buf, out_buf, n,
|
|
mask, alpha_value);
|
|
|
|
return;
|
|
}
|
|
|
|
in = (const guint32 *) in_buf;
|
|
out = (guint32 *) out_buf;
|
|
|
|
for (c = 0; c < 4; c++)
|
|
{
|
|
if (! (mask & (1 << c)))
|
|
in_mask |= 0xff << (8 * c);
|
|
}
|
|
|
|
if (aux_buf)
|
|
{
|
|
const guint32 *aux = (const guint32 *) aux_buf;
|
|
guint32 aux_mask = ~in_mask;
|
|
|
|
for (i = 0; i < n; i++)
|
|
{
|
|
*out = (*in & in_mask) | (*aux & aux_mask);
|
|
|
|
in++;
|
|
aux++;
|
|
out++;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (! (mask & PIKA_COMPONENT_MASK_ALPHA) || ! alpha_value)
|
|
{
|
|
for (i = 0; i < n; i++)
|
|
{
|
|
*out = *in & in_mask;
|
|
|
|
in++;
|
|
out++;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
guint32 alpha_mask = alpha_value << 24;
|
|
|
|
for (i = 0; i < n; i++)
|
|
{
|
|
*out = (*in & in_mask) | alpha_mask;
|
|
|
|
in++;
|
|
out++;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
|
|
#endif /* G_BYTE_ORDER == G_LITTLE_ENDIAN */
|
|
|
|
template <class T>
|
|
static gboolean
|
|
pika_operation_mask_components_process (PikaOperationMaskComponents *self,
|
|
void *in_buf,
|
|
void *aux_buf,
|
|
void *out_buf,
|
|
glong samples,
|
|
const GeglRectangle *roi,
|
|
gint level)
|
|
{
|
|
Process<T>::process (in_buf, aux_buf, out_buf, samples,
|
|
self->mask, self->alpha_value);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
static void
|
|
pika_operation_mask_components_prepare (GeglOperation *operation)
|
|
{
|
|
PikaOperationMaskComponents *self = PIKA_OPERATION_MASK_COMPONENTS (operation);
|
|
const Babl *format;
|
|
|
|
format = pika_operation_mask_components_get_format (
|
|
gegl_operation_get_source_format (operation, "input"));
|
|
|
|
gegl_operation_set_format (operation, "input", format);
|
|
gegl_operation_set_format (operation, "aux", format);
|
|
gegl_operation_set_format (operation, "output", format);
|
|
|
|
if (format != self->format)
|
|
{
|
|
self->format = format;
|
|
|
|
self->alpha_value = get_alpha_value (format, self->alpha);
|
|
|
|
switch (babl_format_get_bytes_per_pixel (format))
|
|
{
|
|
case 4:
|
|
self->process = (gpointer)
|
|
pika_operation_mask_components_process<guint8>;
|
|
break;
|
|
|
|
case 8:
|
|
self->process = (gpointer)
|
|
pika_operation_mask_components_process<guint16>;
|
|
break;
|
|
|
|
case 16:
|
|
self->process = (gpointer)
|
|
pika_operation_mask_components_process<guint32>;
|
|
break;
|
|
|
|
default:
|
|
g_return_if_reached ();
|
|
}
|
|
}
|
|
}
|
|
|
|
static GeglRectangle
|
|
pika_operation_mask_components_get_bounding_box (GeglOperation *operation)
|
|
{
|
|
PikaOperationMaskComponents *self = PIKA_OPERATION_MASK_COMPONENTS (operation);
|
|
GeglRectangle *in_rect;
|
|
GeglRectangle *aux_rect;
|
|
GeglRectangle result = {};
|
|
|
|
in_rect = gegl_operation_source_get_bounding_box (operation, "input");
|
|
aux_rect = gegl_operation_source_get_bounding_box (operation, "aux");
|
|
|
|
if (self->mask == 0)
|
|
{
|
|
if (in_rect)
|
|
return *in_rect;
|
|
}
|
|
else if (self->mask == PIKA_COMPONENT_MASK_ALL)
|
|
{
|
|
if (aux_rect)
|
|
return *aux_rect;
|
|
}
|
|
|
|
if (in_rect)
|
|
gegl_rectangle_bounding_box (&result, &result, in_rect);
|
|
|
|
if (aux_rect)
|
|
gegl_rectangle_bounding_box (&result, &result, aux_rect);
|
|
|
|
return result;
|
|
}
|
|
|
|
static gboolean
|
|
pika_operation_mask_components_parent_process (GeglOperation *operation,
|
|
GeglOperationContext *context,
|
|
const gchar *output_prop,
|
|
const GeglRectangle *result,
|
|
gint level)
|
|
{
|
|
PikaOperationMaskComponents *self = PIKA_OPERATION_MASK_COMPONENTS (operation);
|
|
|
|
if (self->mask == 0)
|
|
{
|
|
GObject *input = gegl_operation_context_get_object (context, "input");
|
|
|
|
gegl_operation_context_set_object (context, "output", input);
|
|
|
|
return TRUE;
|
|
}
|
|
else if (self->mask == PIKA_COMPONENT_MASK_ALL)
|
|
{
|
|
GObject *aux = gegl_operation_context_get_object (context, "aux");
|
|
|
|
/* when there's no aux and the alpha component is masked-in, we set the
|
|
* result's alpha component to the value of the "alpha" property; if it
|
|
* doesn't equal 0, we can't forward an empty aux.
|
|
*/
|
|
if (aux || ! self->alpha_value)
|
|
{
|
|
gegl_operation_context_set_object (context, "output", aux);
|
|
|
|
return TRUE;
|
|
}
|
|
}
|
|
|
|
return GEGL_OPERATION_CLASS (parent_class)->process (operation, context,
|
|
output_prop, result,
|
|
level);
|
|
}
|
|
|
|
static gboolean
|
|
pika_operation_mask_components_process (GeglOperation *operation,
|
|
void *in_buf,
|
|
void *aux_buf,
|
|
void *out_buf,
|
|
glong samples,
|
|
const GeglRectangle *roi,
|
|
gint level)
|
|
{
|
|
typedef gboolean (* ProcessFunc) (PikaOperationMaskComponents *self,
|
|
void *in_buf,
|
|
void *aux_buf,
|
|
void *out_buf,
|
|
glong samples,
|
|
const GeglRectangle *roi,
|
|
gint level);
|
|
|
|
PikaOperationMaskComponents *self = (PikaOperationMaskComponents *) operation;
|
|
|
|
return ((ProcessFunc) self->process) (self,
|
|
in_buf, aux_buf, out_buf, samples,
|
|
roi, level);
|
|
}
|
|
|
|
const Babl *
|
|
pika_operation_mask_components_get_format (const Babl *input_format)
|
|
{
|
|
const Babl *format = NULL;
|
|
|
|
if (input_format)
|
|
{
|
|
const Babl *model = babl_format_get_model (input_format);
|
|
const gchar *model_name = babl_get_name (model);
|
|
const Babl *type = babl_format_get_type (input_format, 0);
|
|
const gchar *type_name = babl_get_name (type);
|
|
|
|
if (! strcmp (model_name, "Y") ||
|
|
! strcmp (model_name, "YA") ||
|
|
! strcmp (model_name, "RGB") ||
|
|
! strcmp (model_name, "RGBA"))
|
|
{
|
|
if (! strcmp (type_name, "u8"))
|
|
format = babl_format ("RGBA u8");
|
|
else if (! strcmp (type_name, "u16"))
|
|
format = babl_format ("RGBA u16");
|
|
else if (! strcmp (type_name, "u32"))
|
|
format = babl_format ("RGBA u32");
|
|
else if (! strcmp (type_name, "half"))
|
|
format = babl_format ("RGBA half");
|
|
else if (! strcmp (type_name, "float"))
|
|
format = babl_format ("RGBA float");
|
|
}
|
|
else if (! strcmp (model_name, "Y'") ||
|
|
! strcmp (model_name, "Y'A") ||
|
|
! strcmp (model_name, "R'G'B'") ||
|
|
! strcmp (model_name, "R'G'B'A") ||
|
|
babl_format_is_palette (input_format))
|
|
{
|
|
if (! strcmp (type_name, "u8"))
|
|
format = babl_format ("R'G'B'A u8");
|
|
else if (! strcmp (type_name, "u16"))
|
|
format = babl_format ("R'G'B'A u16");
|
|
else if (! strcmp (type_name, "u32"))
|
|
format = babl_format ("R'G'B'A u32");
|
|
else if (! strcmp (type_name, "half"))
|
|
format = babl_format ("R'G'B'A half");
|
|
else if (! strcmp (type_name, "float"))
|
|
format = babl_format ("R'G'B'A float");
|
|
}
|
|
}
|
|
|
|
if (! format)
|
|
format = babl_format ("RGBA float");
|
|
|
|
if (input_format)
|
|
return babl_format_with_space ((const gchar *) format, input_format);
|
|
else
|
|
return format;
|
|
}
|
|
|
|
void
|
|
pika_operation_mask_components_process (const Babl *format,
|
|
gconstpointer in,
|
|
gconstpointer aux,
|
|
gpointer out,
|
|
gint n,
|
|
PikaComponentMask mask)
|
|
{
|
|
g_return_if_fail (format != NULL);
|
|
g_return_if_fail (in != NULL);
|
|
g_return_if_fail (out != NULL);
|
|
g_return_if_fail (n >= 0);
|
|
|
|
switch (babl_format_get_bytes_per_pixel (format))
|
|
{
|
|
case 4:
|
|
Process<guint8>::process (in, aux, out, n, mask, 0);
|
|
break;
|
|
|
|
case 8:
|
|
Process<guint16>::process (in, aux, out, n, mask, 0);
|
|
break;
|
|
|
|
case 16:
|
|
Process<guint32>::process (in, aux, out, n, mask, 0);
|
|
break;
|
|
|
|
default:
|
|
g_return_if_reached ();
|
|
}
|
|
}
|
