/* GdkPixbuf library - Utilities and miscellaneous convenience functions * * Copyright (C) 1999 The Free Software Foundation * * Authors: Federico Mena-Quintero * Cody Russell * * This library 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 2 of the License, or (at your option) any later version. * * This library 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 this library; if not, see . */ #include "config.h" #include #include #include "gdk-pixbuf-transform.h" #include "gdk-pixbuf-private.h" /** * SECTION:util * @Short_description: Utility and miscellaneous convenience functions. * @Title: Utilities * @See_also: #GdkPixbuf * * These functions provide miscellaneous utilities for manipulating * pixbufs. The pixel data in pixbufs may of course be manipulated * directly by applications, but several common operations can be * performed by these functions instead. */ /** * gdk_pixbuf_add_alpha: * @pixbuf: A #GdkPixbuf. * @substitute_color: Whether to set a color to zero opacity. If this * is %FALSE, then the (@r, @g, @b) arguments will be ignored. * @r: Red value to substitute. * @g: Green value to substitute. * @b: Blue value to substitute. * * Takes an existing pixbuf and adds an alpha channel to it. * If the existing pixbuf already had an alpha channel, the channel * values are copied from the original; otherwise, the alpha channel * is initialized to 255 (full opacity). * * If @substitute_color is %TRUE, then the color specified by (@r, @g, @b) will be * assigned zero opacity. That is, if you pass (255, 255, 255) for the * substitute color, all white pixels will become fully transparent. * * Return value: (transfer full): A newly-created pixbuf with a reference count of 1. **/ GdkPixbuf * gdk_pixbuf_add_alpha (const GdkPixbuf *pixbuf, gboolean substitute_color, guchar r, guchar g, guchar b) { GdkPixbuf *new_pixbuf; int x, y; const guint8 *src_pixels; guint8 *ret_pixels; const guchar *src; guchar *dest; g_return_val_if_fail (GDK_IS_PIXBUF (pixbuf), NULL); g_return_val_if_fail (pixbuf->colorspace == GDK_COLORSPACE_RGB, NULL); g_return_val_if_fail (pixbuf->n_channels == 3 || pixbuf->n_channels == 4, NULL); g_return_val_if_fail (pixbuf->bits_per_sample == 8, NULL); src_pixels = gdk_pixbuf_read_pixels (pixbuf); if (pixbuf->has_alpha) { new_pixbuf = gdk_pixbuf_copy (pixbuf); if (!new_pixbuf) return NULL; if (!substitute_color) return new_pixbuf; } else { new_pixbuf = gdk_pixbuf_new (GDK_COLORSPACE_RGB, TRUE, 8, pixbuf->width, pixbuf->height); } if (!new_pixbuf) return NULL; ret_pixels = gdk_pixbuf_get_pixels (new_pixbuf); for (y = 0; y < pixbuf->height; y++, src_pixels += pixbuf->rowstride, ret_pixels += new_pixbuf->rowstride) { guchar tr, tg, tb; src = src_pixels; dest = ret_pixels; if (pixbuf->has_alpha) { /* Just subst color, we already copied everything else */ for (x = 0; x < pixbuf->width; x++) { if (src[0] == r && src[1] == g && src[2] == b) dest[3] = 0; src += 4; dest += 4; } } else { for (x = 0; x < pixbuf->width; x++) { tr = *dest++ = *src++; tg = *dest++ = *src++; tb = *dest++ = *src++; if (substitute_color && tr == r && tg == g && tb == b) *dest++ = 0; else *dest++ = 255; } } } return new_pixbuf; } /** * gdk_pixbuf_copy_area: * @src_pixbuf: Source pixbuf. * @src_x: Source X coordinate within @src_pixbuf. * @src_y: Source Y coordinate within @src_pixbuf. * @width: Width of the area to copy. * @height: Height of the area to copy. * @dest_pixbuf: Destination pixbuf. * @dest_x: X coordinate within @dest_pixbuf. * @dest_y: Y coordinate within @dest_pixbuf. * * Copies a rectangular area from @src_pixbuf to @dest_pixbuf. Conversion of * pixbuf formats is done automatically. * * If the source rectangle overlaps the destination rectangle on the * same pixbuf, it will be overwritten during the copy operation. * Therefore, you can not use this function to scroll a pixbuf. **/ void gdk_pixbuf_copy_area (const GdkPixbuf *src_pixbuf, int src_x, int src_y, int width, int height, GdkPixbuf *dest_pixbuf, int dest_x, int dest_y) { g_return_if_fail (src_pixbuf != NULL); g_return_if_fail (dest_pixbuf != NULL); g_return_if_fail (src_x >= 0 && src_x + width <= src_pixbuf->width); g_return_if_fail (src_y >= 0 && src_y + height <= src_pixbuf->height); g_return_if_fail (dest_x >= 0 && dest_x + width <= dest_pixbuf->width); g_return_if_fail (dest_y >= 0 && dest_y + height <= dest_pixbuf->height); g_return_if_fail (!(gdk_pixbuf_get_has_alpha (src_pixbuf) && !gdk_pixbuf_get_has_alpha (dest_pixbuf))); /* This will perform format conversions automatically */ gdk_pixbuf_scale (src_pixbuf, dest_pixbuf, dest_x, dest_y, width, height, (double) (dest_x - src_x), (double) (dest_y - src_y), 1.0, 1.0, GDK_INTERP_NEAREST); } /** * gdk_pixbuf_saturate_and_pixelate: * @src: source image * @dest: place to write modified version of @src * @saturation: saturation factor * @pixelate: whether to pixelate * * Modifies saturation and optionally pixelates @src, placing the result in * @dest. @src and @dest may be the same pixbuf with no ill effects. If * @saturation is 1.0 then saturation is not changed. If it's less than 1.0, * saturation is reduced (the image turns toward grayscale); if greater than * 1.0, saturation is increased (the image gets more vivid colors). If @pixelate * is %TRUE, then pixels are faded in a checkerboard pattern to create a * pixelated image. @src and @dest must have the same image format, size, and * rowstride. * **/ void gdk_pixbuf_saturate_and_pixelate(const GdkPixbuf *src, GdkPixbuf *dest, gfloat saturation, gboolean pixelate) { /* NOTE that src and dest MAY be the same pixbuf! */ g_return_if_fail (GDK_IS_PIXBUF (src)); g_return_if_fail (GDK_IS_PIXBUF (dest)); g_return_if_fail (gdk_pixbuf_get_height (src) == gdk_pixbuf_get_height (dest)); g_return_if_fail (gdk_pixbuf_get_width (src) == gdk_pixbuf_get_width (dest)); g_return_if_fail (gdk_pixbuf_get_has_alpha (src) == gdk_pixbuf_get_has_alpha (dest)); g_return_if_fail (gdk_pixbuf_get_colorspace (src) == gdk_pixbuf_get_colorspace (dest)); if (saturation == 1.0 && !pixelate) { if (dest != src) gdk_pixbuf_copy_area (src, 0, 0, gdk_pixbuf_get_width (src), gdk_pixbuf_get_height (src), dest, 0, 0); } else { int i, j, t; int width, height, has_alpha, src_rowstride, dest_rowstride, bytes_per_pixel; const guchar *src_line; guchar *dest_line; const guchar *src_pixel; guchar *dest_pixel; guchar intensity; has_alpha = gdk_pixbuf_get_has_alpha (src); bytes_per_pixel = has_alpha ? 4 : 3; width = gdk_pixbuf_get_width (src); height = gdk_pixbuf_get_height (src); src_rowstride = gdk_pixbuf_get_rowstride (src); dest_rowstride = gdk_pixbuf_get_rowstride (dest); dest_line = gdk_pixbuf_get_pixels (dest); src_line = gdk_pixbuf_read_pixels (src); #define DARK_FACTOR 0.7 #define INTENSITY(r, g, b) ((r) * 0.30 + (g) * 0.59 + (b) * 0.11) #define CLAMP_UCHAR(v) (t = (v), CLAMP (t, 0, 255)) #define SATURATE(v) ((1.0 - saturation) * intensity + saturation * (v)) for (i = 0 ; i < height ; i++) { src_pixel = src_line; src_line += src_rowstride; dest_pixel = dest_line; dest_line += dest_rowstride; for (j = 0 ; j < width ; j++) { intensity = INTENSITY (src_pixel[0], src_pixel[1], src_pixel[2]); if (pixelate && (i + j) % 2 == 0) { dest_pixel[0] = intensity / 2 + 127; dest_pixel[1] = intensity / 2 + 127; dest_pixel[2] = intensity / 2 + 127; } else if (pixelate) { dest_pixel[0] = CLAMP_UCHAR ((SATURATE (src_pixel[0])) * DARK_FACTOR); dest_pixel[1] = CLAMP_UCHAR ((SATURATE (src_pixel[1])) * DARK_FACTOR); dest_pixel[2] = CLAMP_UCHAR ((SATURATE (src_pixel[2])) * DARK_FACTOR); } else { dest_pixel[0] = CLAMP_UCHAR (SATURATE (src_pixel[0])); dest_pixel[1] = CLAMP_UCHAR (SATURATE (src_pixel[1])); dest_pixel[2] = CLAMP_UCHAR (SATURATE (src_pixel[2])); } if (has_alpha) dest_pixel[3] = src_pixel[3]; src_pixel += bytes_per_pixel; dest_pixel += bytes_per_pixel; } } } } /** * gdk_pixbuf_apply_embedded_orientation: * @src: A #GdkPixbuf. * * Takes an existing pixbuf and checks for the presence of an * associated "orientation" option, which may be provided by the * jpeg loader (which reads the exif orientation tag) or the * tiff loader (which reads the tiff orientation tag, and * compensates it for the partial transforms performed by * libtiff). If an orientation option/tag is present, the * appropriate transform will be performed so that the pixbuf * is oriented correctly. * * Return value: (transfer full): A newly-created pixbuf, %NULL if * not enough memory could be allocated for it, or a reference to the * input pixbuf (with an increased reference count). * * Since: 2.12 **/ GdkPixbuf * gdk_pixbuf_apply_embedded_orientation (GdkPixbuf *src) { const gchar *orientation_string; int transform = 0; GdkPixbuf *temp; GdkPixbuf *dest; g_return_val_if_fail (GDK_IS_PIXBUF (src), NULL); /* Read the orientation option associated with the pixbuf */ orientation_string = gdk_pixbuf_get_option (src, "orientation"); if (orientation_string) { /* If an orientation option was found, convert the orientation string into an integer. */ transform = (int) g_ascii_strtoll (orientation_string, NULL, 10); } /* Apply the actual transforms, which involve rotations and flips. The meaning of orientation values 1-8 and the required transforms are defined by the TIFF and EXIF (for JPEGs) standards. */ switch (transform) { case 1: dest = src; g_object_ref (dest); break; case 2: dest = gdk_pixbuf_flip (src, TRUE); break; case 3: dest = gdk_pixbuf_rotate_simple (src, GDK_PIXBUF_ROTATE_UPSIDEDOWN); break; case 4: dest = gdk_pixbuf_flip (src, FALSE); break; case 5: temp = gdk_pixbuf_rotate_simple (src, GDK_PIXBUF_ROTATE_CLOCKWISE); dest = gdk_pixbuf_flip (temp, TRUE); g_object_unref (temp); break; case 6: dest = gdk_pixbuf_rotate_simple (src, GDK_PIXBUF_ROTATE_CLOCKWISE); break; case 7: temp = gdk_pixbuf_rotate_simple (src, GDK_PIXBUF_ROTATE_CLOCKWISE); dest = gdk_pixbuf_flip (temp, FALSE); g_object_unref (temp); break; case 8: dest = gdk_pixbuf_rotate_simple (src, GDK_PIXBUF_ROTATE_COUNTERCLOCKWISE); break; default: /* if no orientation tag was present */ dest = src; g_object_ref (dest); break; } return dest; } #ifdef GDK_PIXBUF_RELOCATABLE static const gchar * get_localedir (void) { gchar *temp; temp = g_build_filename (gdk_pixbuf_get_toplevel (), "share/locale", NULL); #ifdef G_OS_WIN32 { gchar *retval; /* The localedir is passed to bindtextdomain() which isn't * UTF-8-aware. */ retval = g_win32_locale_filename_from_utf8 (temp); g_free (temp); return retval; } #else return temp; #endif } #undef GDK_PIXBUF_LOCALEDIR #define GDK_PIXBUF_LOCALEDIR get_localedir () #endif void _gdk_pixbuf_init_gettext (void) { static gsize gettext_initialized = FALSE; if (G_UNLIKELY (g_once_init_enter (&gettext_initialized))) { bindtextdomain (GETTEXT_PACKAGE, GDK_PIXBUF_LOCALEDIR); #ifdef HAVE_BIND_TEXTDOMAIN_CODESET bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8"); #endif g_once_init_leave (&gettext_initialized, TRUE); } } const gchar * gdk_pixbuf_gettext (const gchar *msgid) { return g_dgettext (GETTEXT_PACKAGE, msgid); }