callisto-debian/gimp
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

app: improve gimp:mask-components

Browse Source 
Add specialized versions of gimp:mask-components for 8-, 16-, and
32-bpc formats, to improve efficiency, and to preserve the contents
of masked-out components exactly.

Provide public functions for format-selection and processing, which
we'll use in the painting code, instead of reimplementing component
masking.

(cherry picked from commit ee156b8fd6)
This commit is contained in:
Ell
2019-02-16 08:19:06 -05:00
parent 3925ae5fbb
commit 02b8845a2f
2 changed files with 262 additions and 35 deletions
Download Patch File Download Diff File Expand all files Collapse all files

285
app/operations/gimpoperationmaskcomponents.cc
View File

@ -146,28 +146,177 @@ gimp_operation_mask_components_set_property (GObject *object,
} }
} }
template <class T>
struct ProcessGeneric
{
static void
process (gconstpointer in_buf,
gconstpointer aux_buf,
gpointer out_buf,
gint n,
GimpComponentMask mask)
{
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 < 4; c++)
{
if (mask & (1 << c))
out[c] = 0;
else
out[c] = in[c];
}
in += 4;
out += 4;
}
}
}
};
template <class T>
struct Process : ProcessGeneric<T>
{
};
template <>
struct Process<guint8>
{
static void
process (gconstpointer in_buf,
gconstpointer aux_buf,
gpointer out_buf,
gint n,
GimpComponentMask mask)
{
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);
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
{
for (i = 0; i < n; i++)
{
*out = *in & in_mask;
in++;
out++;
}
}
}
};
template <class T>
static gboolean
gimp_operation_mask_components_process (GimpOperationMaskComponents *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);
return TRUE;
}
static void static void
gimp_operation_mask_components_prepare (GeglOperation *operation) gimp_operation_mask_components_prepare (GeglOperation *operation)
{ {
const Babl *format = gegl_operation_get_source_format (operation, "input"); GimpOperationMaskComponents *self = GIMP_OPERATION_MASK_COMPONENTS (operation);
const Babl *format;
if (format) format = gimp_operation_mask_components_get_format (
{ gegl_operation_get_source_format (operation, "input"));
const Babl *model = babl_format_get_model (format);
if (model == babl_model ("R'G'B'A"))
format = babl_format ("R'G'B'A float");
else
format = babl_format ("RGBA float");
}
else
{
format = babl_format ("RGBA float");
}
gegl_operation_set_format (operation, "input", format); gegl_operation_set_format (operation, "input", format);
gegl_operation_set_format (operation, "aux", format); gegl_operation_set_format (operation, "aux", format);
gegl_operation_set_format (operation, "output", format); gegl_operation_set_format (operation, "output", format);
switch (babl_format_get_bytes_per_pixel (format))
{
case 4:
self->process = (gpointer)
gimp_operation_mask_components_process<guint8>;
break;
case 8:
self->process = (gpointer)
gimp_operation_mask_components_process<guint16>;
break;
case 16:
self->process = (gpointer)
gimp_operation_mask_components_process<guint32>;
break;
default:
g_return_if_reached ();
}
} }
static gboolean static gboolean
@ -210,30 +359,98 @@ gimp_operation_mask_components_process (GeglOperation *operation,
const GeglRectangle *roi, const GeglRectangle *roi,
gint level) gint level)
{ {
GimpOperationMaskComponents *self = GIMP_OPERATION_MASK_COMPONENTS (operation); typedef gboolean (* ProcessFunc) (GimpOperationMaskComponents *self,
const gfloat *src = (const gfloat *) in_buf; void *in_buf,
const gfloat *aux = (const gfloat *) aux_buf; void *aux_buf,
gfloat *dest = (gfloat *) out_buf; void *out_buf,
GimpComponentMask mask = self->mask; glong samples,
static const gfloat nothing[] = { 0.0, 0.0, 0.0, 1.0 }; const GeglRectangle *roi,
gint level);
if (! aux) GimpOperationMaskComponents *self = (GimpOperationMaskComponents *) operation;
aux = (gfloat *) nothing;
while (samples--) return ((ProcessFunc) self->process) (self,
in_buf, aux_buf, out_buf, samples,
roi, level);
}
const Babl *
gimp_operation_mask_components_get_format (const Babl *input_format)
{
const Babl *format = NULL;
if (input_format)
{ {
dest[RED] = (mask & GIMP_COMPONENT_MASK_RED) ? aux[RED] : src[RED]; const Babl *model = babl_format_get_model (input_format);
dest[GREEN] = (mask & GIMP_COMPONENT_MASK_GREEN) ? aux[GREEN] : src[GREEN]; const gchar *model_name = babl_get_name (model);
dest[BLUE] = (mask & GIMP_COMPONENT_MASK_BLUE) ? aux[BLUE] : src[BLUE]; const Babl *type = babl_format_get_type (input_format, 0);
dest[ALPHA] = (mask & GIMP_COMPONENT_MASK_ALPHA) ? aux[ALPHA] : src[ALPHA]; const gchar *type_name = babl_get_name (type);
src += 4; if (! strcmp (model_name, "Y") ||
! strcmp (model_name, "YA") ||
if (aux_buf) ! strcmp (model_name, "RGB") ||
aux += 4; ! strcmp (model_name, "RGBA"))
{
dest += 4; 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, "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, "float"))
format = babl_format ("R'G'B'A float");
}
} }
return TRUE; if (! format)
format = babl_format ("RGBA float");
return format;
}
void
gimp_operation_mask_components_process (const Babl *format,
gconstpointer in,
gconstpointer aux,
gpointer out,
gint n,
GimpComponentMask 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);
break;
case 8:
Process<guint16>::process (in, aux, out, n, mask);
break;
case 16:
Process<guint32>::process (in, aux, out, n, mask);
break;
default:
g_return_if_reached ();
}
} }

12
app/operations/gimpoperationmaskcomponents.h
View File

@ -40,6 +40,7 @@ struct _GimpOperationMaskComponents
GeglOperationPointComposer parent_instance; GeglOperationPointComposer parent_instance;
GimpComponentMask mask; GimpComponentMask mask;
gpointer process;
}; };
struct _GimpOperationMaskComponentsClass struct _GimpOperationMaskComponentsClass
@ -48,7 +49,16 @@ struct _GimpOperationMaskComponentsClass
}; };
GType gimp_operation_mask_components_get_type (void) G_GNUC_CONST; GType gimp_operation_mask_components_get_type (void) G_GNUC_CONST;
const Babl * gimp_operation_mask_components_get_format (const Babl *input_format);
void gimp_operation_mask_components_process (const Babl *format,
gconstpointer in,
gconstpointer aux,
gpointer out,
gint n,
GimpComponentMask mask);
#endif /* __GIMP_OPERATION_MASK_COMPONENTS_H__ */ #endif /* __GIMP_OPERATION_MASK_COMPONENTS_H__ */