PIKApp/app/core/pikabuffer.c

556 lines
18 KiB
C
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

/* 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
*
* 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 <cairo.h>
#include <gegl.h>
#include <gdk-pixbuf/gdk-pixbuf.h>
#include "libpikabase/pikabase.h"
#include "libpikacolor/pikacolor.h"
#include "core-types.h"
#include "gegl/pika-babl.h"
#include "gegl/pika-gegl-loops.h"
#include "gegl/pika-gegl-utils.h"
#include "pika-memsize.h"
#include "pikabuffer.h"
#include "pikaimage.h"
#include "pikatempbuf.h"
static void pika_color_managed_iface_init (PikaColorManagedInterface *iface);
static void pika_buffer_finalize (GObject *object);
static gint64 pika_buffer_get_memsize (PikaObject *object,
gint64 *gui_size);
static gboolean pika_buffer_get_size (PikaViewable *viewable,
gint *width,
gint *height);
static void pika_buffer_get_preview_size (PikaViewable *viewable,
gint size,
gboolean is_popup,
gboolean dot_for_dot,
gint *popup_width,
gint *popup_height);
static gboolean pika_buffer_get_popup_size (PikaViewable *viewable,
gint width,
gint height,
gboolean dot_for_dot,
gint *popup_width,
gint *popup_height);
static PikaTempBuf * pika_buffer_get_new_preview (PikaViewable *viewable,
PikaContext *context,
gint width,
gint height);
static GdkPixbuf * pika_buffer_get_new_pixbuf (PikaViewable *viewable,
PikaContext *context,
gint width,
gint height);
static gchar * pika_buffer_get_description (PikaViewable *viewable,
gchar **tooltip);
static const guint8 *
pika_buffer_color_managed_get_icc_profile (PikaColorManaged *managed,
gsize *len);
static PikaColorProfile *
pika_buffer_color_managed_get_color_profile (PikaColorManaged *managed);
static void
pika_buffer_color_managed_profile_changed (PikaColorManaged *managed);
G_DEFINE_TYPE_WITH_CODE (PikaBuffer, pika_buffer, PIKA_TYPE_VIEWABLE,
G_IMPLEMENT_INTERFACE (PIKA_TYPE_COLOR_MANAGED,
pika_color_managed_iface_init))
#define parent_class pika_buffer_parent_class
static void
pika_buffer_class_init (PikaBufferClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS (klass);
PikaObjectClass *pika_object_class = PIKA_OBJECT_CLASS (klass);
PikaViewableClass *viewable_class = PIKA_VIEWABLE_CLASS (klass);
object_class->finalize = pika_buffer_finalize;
pika_object_class->get_memsize = pika_buffer_get_memsize;
viewable_class->default_icon_name = "edit-paste";
viewable_class->name_editable = TRUE;
viewable_class->get_size = pika_buffer_get_size;
viewable_class->get_preview_size = pika_buffer_get_preview_size;
viewable_class->get_popup_size = pika_buffer_get_popup_size;
viewable_class->get_new_preview = pika_buffer_get_new_preview;
viewable_class->get_new_pixbuf = pika_buffer_get_new_pixbuf;
viewable_class->get_description = pika_buffer_get_description;
}
static void
pika_color_managed_iface_init (PikaColorManagedInterface *iface)
{
iface->get_icc_profile = pika_buffer_color_managed_get_icc_profile;
iface->get_color_profile = pika_buffer_color_managed_get_color_profile;
iface->profile_changed = pika_buffer_color_managed_profile_changed;
}
static void
pika_buffer_init (PikaBuffer *buffer)
{
}
static void
pika_buffer_finalize (GObject *object)
{
PikaBuffer *buffer = PIKA_BUFFER (object);
g_clear_object (&buffer->buffer);
pika_buffer_set_color_profile (buffer, NULL);
G_OBJECT_CLASS (parent_class)->finalize (object);
}
static gint64
pika_buffer_get_memsize (PikaObject *object,
gint64 *gui_size)
{
PikaBuffer *buffer = PIKA_BUFFER (object);
gint64 memsize = 0;
memsize += pika_gegl_buffer_get_memsize (buffer->buffer);
memsize += pika_g_object_get_memsize (G_OBJECT (buffer->color_profile));
memsize += pika_g_object_get_memsize (G_OBJECT (buffer->format_profile));
return memsize + PIKA_OBJECT_CLASS (parent_class)->get_memsize (object,
gui_size);
}
static gboolean
pika_buffer_get_size (PikaViewable *viewable,
gint *width,
gint *height)
{
PikaBuffer *buffer = PIKA_BUFFER (viewable);
*width = pika_buffer_get_width (buffer);
*height = pika_buffer_get_height (buffer);
return TRUE;
}
static void
pika_buffer_get_preview_size (PikaViewable *viewable,
gint size,
gboolean is_popup,
gboolean dot_for_dot,
gint *width,
gint *height)
{
PikaBuffer *buffer = PIKA_BUFFER (viewable);
pika_viewable_calc_preview_size (pika_buffer_get_width (buffer),
pika_buffer_get_height (buffer),
size,
size,
dot_for_dot, 1.0, 1.0,
width,
height,
NULL);
}
static gboolean
pika_buffer_get_popup_size (PikaViewable *viewable,
gint width,
gint height,
gboolean dot_for_dot,
gint *popup_width,
gint *popup_height)
{
PikaBuffer *buffer;
gint buffer_width;
gint buffer_height;
buffer = PIKA_BUFFER (viewable);
buffer_width = pika_buffer_get_width (buffer);
buffer_height = pika_buffer_get_height (buffer);
if (buffer_width > width || buffer_height > height)
{
gboolean scaling_up;
pika_viewable_calc_preview_size (buffer_width,
buffer_height,
width * 2,
height * 2,
dot_for_dot, 1.0, 1.0,
popup_width,
popup_height,
&scaling_up);
if (scaling_up)
{
*popup_width = buffer_width;
*popup_height = buffer_height;
}
return TRUE;
}
return FALSE;
}
static PikaTempBuf *
pika_buffer_get_new_preview (PikaViewable *viewable,
PikaContext *context,
gint width,
gint height)
{
PikaBuffer *buffer = PIKA_BUFFER (viewable);
const Babl *format = pika_buffer_get_format (buffer);
PikaTempBuf *preview;
if (babl_format_is_palette (format))
format = pika_babl_format (PIKA_RGB,
PIKA_PRECISION_U8_NON_LINEAR,
babl_format_has_alpha (format),
babl_format_get_space (format));
else
format = pika_babl_format (pika_babl_format_get_base_type (format),
pika_babl_precision (PIKA_COMPONENT_TYPE_U8,
pika_babl_format_get_trc (format)),
babl_format_has_alpha (format),
babl_format_get_space (format));
preview = pika_temp_buf_new (width, height, format);
gegl_buffer_get (buffer->buffer, GEGL_RECTANGLE (0, 0, width, height),
MIN ((gdouble) width / (gdouble) pika_buffer_get_width (buffer),
(gdouble) height / (gdouble) pika_buffer_get_height (buffer)),
format,
pika_temp_buf_get_data (preview),
GEGL_AUTO_ROWSTRIDE, GEGL_ABYSS_NONE);
return preview;
}
static GdkPixbuf *
pika_buffer_get_new_pixbuf (PikaViewable *viewable,
PikaContext *context,
gint width,
gint height)
{
PikaBuffer *buffer = PIKA_BUFFER (viewable);
GdkPixbuf *pixbuf;
gdouble scale;
pixbuf = gdk_pixbuf_new (GDK_COLORSPACE_RGB, TRUE, 8,
width, height);
scale = MIN ((gdouble) width / (gdouble) pika_buffer_get_width (buffer),
(gdouble) height / (gdouble) pika_buffer_get_height (buffer));
if (buffer->color_profile)
{
PikaColorProfile *srgb_profile;
PikaTempBuf *temp_buf;
GeglBuffer *src_buf;
GeglBuffer *dest_buf;
srgb_profile = pika_color_profile_new_rgb_srgb ();
temp_buf = pika_temp_buf_new (width, height,
pika_buffer_get_format (buffer));
gegl_buffer_get (buffer->buffer,
GEGL_RECTANGLE (0, 0, width, height),
scale,
pika_temp_buf_get_format (temp_buf),
pika_temp_buf_get_data (temp_buf),
GEGL_AUTO_ROWSTRIDE, GEGL_ABYSS_CLAMP);
src_buf = pika_temp_buf_create_buffer (temp_buf);
dest_buf = pika_pixbuf_create_buffer (pixbuf);
pika_temp_buf_unref (temp_buf);
pika_gegl_convert_color_profile (src_buf,
GEGL_RECTANGLE (0, 0, width, height),
buffer->color_profile,
dest_buf,
GEGL_RECTANGLE (0, 0, 0, 0),
srgb_profile,
PIKA_COLOR_RENDERING_INTENT_PERCEPTUAL,
TRUE,
NULL);
g_object_unref (src_buf);
g_object_unref (dest_buf);
g_object_unref (srgb_profile);
}
else
{
gegl_buffer_get (buffer->buffer,
GEGL_RECTANGLE (0, 0, width, height),
scale,
pika_pixbuf_get_format (pixbuf),
gdk_pixbuf_get_pixels (pixbuf),
gdk_pixbuf_get_rowstride (pixbuf),
GEGL_ABYSS_CLAMP);
}
return pixbuf;
}
static gchar *
pika_buffer_get_description (PikaViewable *viewable,
gchar **tooltip)
{
PikaBuffer *buffer = PIKA_BUFFER (viewable);
return g_strdup_printf ("%s (%d × %d)",
pika_object_get_name (buffer),
pika_buffer_get_width (buffer),
pika_buffer_get_height (buffer));
}
static const guint8 *
pika_buffer_color_managed_get_icc_profile (PikaColorManaged *managed,
gsize *len)
{
PikaBuffer *buffer = PIKA_BUFFER (managed);
if (buffer->color_profile)
return pika_color_profile_get_icc_profile (buffer->color_profile, len);
/* creates buffer->format_profile */
pika_color_managed_get_color_profile (managed);
return pika_color_profile_get_icc_profile (buffer->format_profile, len);
}
static PikaColorProfile *
pika_buffer_color_managed_get_color_profile (PikaColorManaged *managed)
{
PikaBuffer *buffer = PIKA_BUFFER (managed);
if (buffer->color_profile)
return buffer->color_profile;
if (! buffer->format_profile)
buffer->format_profile =
pika_babl_format_get_color_profile (pika_buffer_get_format (buffer));
return buffer->format_profile;
}
static void
pika_buffer_color_managed_profile_changed (PikaColorManaged *managed)
{
pika_viewable_invalidate_preview (PIKA_VIEWABLE (managed));
}
/* public functions */
PikaBuffer *
pika_buffer_new (GeglBuffer *buffer,
const gchar *name,
gint offset_x,
gint offset_y,
gboolean copy_pixels)
{
PikaBuffer *pika_buffer;
g_return_val_if_fail (GEGL_IS_BUFFER (buffer), NULL);
g_return_val_if_fail (name != NULL, NULL);
pika_buffer = g_object_new (PIKA_TYPE_BUFFER,
"name", name,
NULL);
if (copy_pixels)
pika_buffer->buffer = pika_gegl_buffer_dup (buffer);
else
pika_buffer->buffer = g_object_ref (buffer);
pika_buffer->offset_x = offset_x;
pika_buffer->offset_y = offset_y;
return pika_buffer;
}
PikaBuffer *
pika_buffer_new_from_pixbuf (GdkPixbuf *pixbuf,
const gchar *name,
gint offset_x,
gint offset_y)
{
PikaBuffer *pika_buffer;
GeglBuffer *buffer;
guint8 *icc_data;
gsize icc_len;
PikaColorProfile *profile = NULL;
g_return_val_if_fail (GDK_IS_PIXBUF (pixbuf), NULL);
g_return_val_if_fail (name != NULL, NULL);
buffer = pika_pixbuf_create_buffer (pixbuf);
pika_buffer = pika_buffer_new (buffer, name,
offset_x, offset_y, FALSE);
icc_data = pika_pixbuf_get_icc_profile (pixbuf, &icc_len);
if (icc_data)
{
profile = pika_color_profile_new_from_icc_profile (icc_data, icc_len,
NULL);
g_free (icc_data);
}
if (! profile && gdk_pixbuf_get_colorspace (pixbuf) == GDK_COLORSPACE_RGB)
{
profile = pika_color_profile_new_rgb_srgb ();
}
if (profile)
{
pika_buffer_set_color_profile (pika_buffer, profile);
g_object_unref (profile);
}
g_object_unref (buffer);
return pika_buffer;
}
gint
pika_buffer_get_width (PikaBuffer *buffer)
{
g_return_val_if_fail (PIKA_IS_BUFFER (buffer), 0);
return gegl_buffer_get_width (buffer->buffer);
}
gint
pika_buffer_get_height (PikaBuffer *buffer)
{
g_return_val_if_fail (PIKA_IS_BUFFER (buffer), 0);
return gegl_buffer_get_height (buffer->buffer);
}
const Babl *
pika_buffer_get_format (PikaBuffer *buffer)
{
g_return_val_if_fail (PIKA_IS_BUFFER (buffer), NULL);
return gegl_buffer_get_format (buffer->buffer);
}
GeglBuffer *
pika_buffer_get_buffer (PikaBuffer *buffer)
{
g_return_val_if_fail (PIKA_IS_BUFFER (buffer), NULL);
return buffer->buffer;
}
void
pika_buffer_set_resolution (PikaBuffer *buffer,
gdouble resolution_x,
gdouble resolution_y)
{
g_return_if_fail (PIKA_IS_BUFFER (buffer));
g_return_if_fail (resolution_x >= 0.0 && resolution_x <= PIKA_MAX_RESOLUTION);
g_return_if_fail (resolution_y >= 0.0 && resolution_y <= PIKA_MAX_RESOLUTION);
buffer->resolution_x = resolution_x;
buffer->resolution_y = resolution_y;
}
gboolean
pika_buffer_get_resolution (PikaBuffer *buffer,
gdouble *resolution_x,
gdouble *resolution_y)
{
g_return_val_if_fail (PIKA_IS_BUFFER (buffer), FALSE);
if (buffer->resolution_x > 0.0 &&
buffer->resolution_y > 0.0)
{
if (resolution_x) *resolution_x = buffer->resolution_x;
if (resolution_y) *resolution_y = buffer->resolution_y;
return TRUE;
}
return FALSE;
}
void
pika_buffer_set_unit (PikaBuffer *buffer,
PikaUnit unit)
{
g_return_if_fail (PIKA_IS_BUFFER (buffer));
g_return_if_fail (unit > PIKA_UNIT_PIXEL);
buffer->unit = unit;
}
PikaUnit
pika_buffer_get_unit (PikaBuffer *buffer)
{
g_return_val_if_fail (PIKA_IS_BUFFER (buffer), PIKA_UNIT_PIXEL);
return buffer->unit;
}
void
pika_buffer_set_color_profile (PikaBuffer *buffer,
PikaColorProfile *profile)
{
g_return_if_fail (PIKA_IS_BUFFER (buffer));
g_return_if_fail (profile == NULL || PIKA_IS_COLOR_PROFILE (profile));
if (profile != buffer->color_profile)
{
g_set_object (&buffer->color_profile, profile);
}
g_clear_object (&buffer->format_profile);
}
PikaColorProfile *
pika_buffer_get_color_profile (PikaBuffer *buffer)
{
g_return_val_if_fail (PIKA_IS_BUFFER (buffer), NULL);
return buffer->color_profile;
}