1999-12-08 21:17:53 +00:00
|
|
|
/* GdkPixbuf library - convert X drawable information to RGB
|
|
|
|
*
|
|
|
|
* Copyright (C) 1999 Michael Zucchi
|
|
|
|
*
|
|
|
|
* Authors: Michael Zucchi <zucchi@zedzone.mmc.com.au>
|
|
|
|
* Cody Russell <bratsche@dfw.net>
|
2000-01-02 03:59:22 +00:00
|
|
|
* Federico Mena-Quintero <federico@gimp.org>
|
1999-12-08 21:17:53 +00:00
|
|
|
*
|
|
|
|
* This library is free software; you can redistribute it and/or
|
2000-07-26 11:33:08 +00:00
|
|
|
* modify it under the terms of the GNU Lesser General Public
|
1999-12-08 21:17:53 +00:00
|
|
|
* License as published by the Free Software Foundation; either
|
|
|
|
* version 2 of the License, or (at your option) any later version.
|
1999-10-07 05:11:27 +00:00
|
|
|
*
|
1999-12-08 21:17:53 +00:00
|
|
|
* 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
|
2000-07-26 11:33:08 +00:00
|
|
|
* Lesser General Public License for more details.
|
1999-11-20 05:39:54 +00:00
|
|
|
*
|
2000-07-26 11:33:08 +00:00
|
|
|
* You should have received a copy of the GNU Lesser General Public
|
2012-02-27 13:01:10 +00:00
|
|
|
* License along with this library. If not, see <http://www.gnu.org/licenses/>.
|
1999-10-07 05:11:27 +00:00
|
|
|
*/
|
1999-11-13 01:27:21 +00:00
|
|
|
|
2008-06-22 14:28:52 +00:00
|
|
|
#include "config.h"
|
2010-10-15 02:05:51 +00:00
|
|
|
|
|
|
|
#include "gdkpixbuf.h"
|
2010-06-26 05:06:30 +00:00
|
|
|
|
2018-03-20 10:46:11 +00:00
|
|
|
#include "gdksurface.h"
|
2019-08-30 18:51:47 +00:00
|
|
|
#include "gdktextureprivate.h"
|
2010-07-09 00:34:45 +00:00
|
|
|
|
2010-10-15 02:05:51 +00:00
|
|
|
#include <gdk-pixbuf/gdk-pixbuf.h>
|
1999-11-13 01:27:21 +00:00
|
|
|
|
2010-10-04 01:35:42 +00:00
|
|
|
|
2010-07-13 17:44:41 +00:00
|
|
|
static cairo_format_t
|
|
|
|
gdk_cairo_format_for_content (cairo_content_t content)
|
|
|
|
{
|
|
|
|
switch (content)
|
|
|
|
{
|
|
|
|
case CAIRO_CONTENT_COLOR:
|
|
|
|
return CAIRO_FORMAT_RGB24;
|
2015-10-27 12:38:14 +00:00
|
|
|
case CAIRO_CONTENT_ALPHA:
|
2010-07-13 17:44:41 +00:00
|
|
|
return CAIRO_FORMAT_A8;
|
|
|
|
case CAIRO_CONTENT_COLOR_ALPHA:
|
|
|
|
default:
|
|
|
|
return CAIRO_FORMAT_ARGB32;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static cairo_surface_t *
|
|
|
|
gdk_cairo_surface_coerce_to_image (cairo_surface_t *surface,
|
2011-02-09 07:43:07 +00:00
|
|
|
cairo_content_t content,
|
|
|
|
int src_x,
|
|
|
|
int src_y,
|
|
|
|
int width,
|
|
|
|
int height)
|
2010-07-13 17:44:41 +00:00
|
|
|
{
|
|
|
|
cairo_surface_t *copy;
|
|
|
|
cairo_t *cr;
|
|
|
|
|
|
|
|
copy = cairo_image_surface_create (gdk_cairo_format_for_content (content),
|
|
|
|
width,
|
|
|
|
height);
|
|
|
|
|
|
|
|
cr = cairo_create (copy);
|
|
|
|
cairo_set_operator (cr, CAIRO_OPERATOR_SOURCE);
|
2010-10-19 12:05:24 +00:00
|
|
|
cairo_set_source_surface (cr, surface, -src_x, -src_y);
|
2010-07-13 17:44:41 +00:00
|
|
|
cairo_paint (cr);
|
|
|
|
cairo_destroy (cr);
|
|
|
|
|
|
|
|
return copy;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2011-02-09 07:43:07 +00:00
|
|
|
convert_alpha (guchar *dest_data,
|
|
|
|
int dest_stride,
|
|
|
|
guchar *src_data,
|
|
|
|
int src_stride,
|
|
|
|
int src_x,
|
|
|
|
int src_y,
|
|
|
|
int width,
|
|
|
|
int height)
|
2010-07-13 17:44:41 +00:00
|
|
|
{
|
|
|
|
int x, y;
|
|
|
|
|
|
|
|
src_data += src_stride * src_y + src_x * 4;
|
|
|
|
|
|
|
|
for (y = 0; y < height; y++) {
|
|
|
|
guint32 *src = (guint32 *) src_data;
|
|
|
|
|
|
|
|
for (x = 0; x < width; x++) {
|
|
|
|
guint alpha = src[x] >> 24;
|
|
|
|
|
|
|
|
if (alpha == 0)
|
|
|
|
{
|
|
|
|
dest_data[x * 4 + 0] = 0;
|
|
|
|
dest_data[x * 4 + 1] = 0;
|
|
|
|
dest_data[x * 4 + 2] = 0;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
dest_data[x * 4 + 0] = (((src[x] & 0xff0000) >> 16) * 255 + alpha / 2) / alpha;
|
|
|
|
dest_data[x * 4 + 1] = (((src[x] & 0x00ff00) >> 8) * 255 + alpha / 2) / alpha;
|
|
|
|
dest_data[x * 4 + 2] = (((src[x] & 0x0000ff) >> 0) * 255 + alpha / 2) / alpha;
|
|
|
|
}
|
|
|
|
dest_data[x * 4 + 3] = alpha;
|
|
|
|
}
|
|
|
|
|
|
|
|
src_data += src_stride;
|
|
|
|
dest_data += dest_stride;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2011-02-09 07:43:07 +00:00
|
|
|
convert_no_alpha (guchar *dest_data,
|
|
|
|
int dest_stride,
|
|
|
|
guchar *src_data,
|
|
|
|
int src_stride,
|
|
|
|
int src_x,
|
|
|
|
int src_y,
|
|
|
|
int width,
|
|
|
|
int height)
|
2010-07-13 17:44:41 +00:00
|
|
|
{
|
|
|
|
int x, y;
|
|
|
|
|
|
|
|
src_data += src_stride * src_y + src_x * 4;
|
|
|
|
|
|
|
|
for (y = 0; y < height; y++) {
|
|
|
|
guint32 *src = (guint32 *) src_data;
|
|
|
|
|
|
|
|
for (x = 0; x < width; x++) {
|
|
|
|
dest_data[x * 3 + 0] = src[x] >> 16;
|
|
|
|
dest_data[x * 3 + 1] = src[x] >> 8;
|
|
|
|
dest_data[x * 3 + 2] = src[x];
|
|
|
|
}
|
|
|
|
|
|
|
|
src_data += src_stride;
|
|
|
|
dest_data += dest_stride;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* gdk_pixbuf_get_from_surface:
|
|
|
|
* @surface: surface to copy from
|
2010-10-01 13:38:36 +00:00
|
|
|
* @src_x: Source X coordinate within @surface
|
|
|
|
* @src_y: Source Y coordinate within @surface
|
|
|
|
* @width: Width in pixels of region to get
|
|
|
|
* @height: Height in pixels of region to get
|
2010-07-13 17:44:41 +00:00
|
|
|
*
|
2021-02-21 14:19:37 +00:00
|
|
|
* Transfers image data from a `cairo_surface_t` and converts it
|
|
|
|
* to a `GdkPixbuf`.
|
|
|
|
*
|
|
|
|
* This allows you to efficiently read individual pixels from cairo surfaces.
|
2010-07-13 17:44:41 +00:00
|
|
|
*
|
2011-02-09 07:43:07 +00:00
|
|
|
* This function will create an RGB pixbuf with 8 bits per channel.
|
|
|
|
* The pixbuf will contain an alpha channel if the @surface contains one.
|
2010-07-13 17:44:41 +00:00
|
|
|
*
|
2014-05-08 19:55:50 +00:00
|
|
|
* Returns: (nullable) (transfer full): A newly-created pixbuf with a
|
2021-05-18 21:05:26 +00:00
|
|
|
* reference count of 1
|
2011-02-09 07:43:07 +00:00
|
|
|
*/
|
2010-07-13 17:44:41 +00:00
|
|
|
GdkPixbuf *
|
2021-05-18 21:05:26 +00:00
|
|
|
gdk_pixbuf_get_from_surface (cairo_surface_t *surface,
|
|
|
|
int src_x,
|
|
|
|
int src_y,
|
|
|
|
int width,
|
|
|
|
int height)
|
2010-07-13 17:44:41 +00:00
|
|
|
{
|
|
|
|
cairo_content_t content;
|
2010-10-02 00:47:55 +00:00
|
|
|
GdkPixbuf *dest;
|
2011-02-09 07:43:07 +00:00
|
|
|
|
2010-07-13 17:44:41 +00:00
|
|
|
/* General sanity checks */
|
|
|
|
g_return_val_if_fail (surface != NULL, NULL);
|
|
|
|
g_return_val_if_fail (width > 0 && height > 0, NULL);
|
|
|
|
|
2010-10-02 00:47:55 +00:00
|
|
|
content = cairo_surface_get_content (surface) | CAIRO_CONTENT_COLOR;
|
|
|
|
dest = gdk_pixbuf_new (GDK_COLORSPACE_RGB,
|
|
|
|
!!(content & CAIRO_CONTENT_ALPHA),
|
|
|
|
8,
|
|
|
|
width, height);
|
2010-07-13 17:44:41 +00:00
|
|
|
|
2013-09-06 15:44:57 +00:00
|
|
|
if (cairo_surface_get_type (surface) == CAIRO_SURFACE_TYPE_IMAGE &&
|
|
|
|
cairo_image_surface_get_format (surface) == gdk_cairo_format_for_content (content))
|
2013-08-06 14:18:13 +00:00
|
|
|
surface = cairo_surface_reference (surface);
|
|
|
|
else
|
|
|
|
{
|
|
|
|
surface = gdk_cairo_surface_coerce_to_image (surface, content,
|
|
|
|
src_x, src_y,
|
|
|
|
width, height);
|
|
|
|
src_x = 0;
|
|
|
|
src_y = 0;
|
|
|
|
}
|
2010-07-13 17:44:41 +00:00
|
|
|
cairo_surface_flush (surface);
|
|
|
|
if (cairo_surface_status (surface) || dest == NULL)
|
|
|
|
{
|
|
|
|
cairo_surface_destroy (surface);
|
2020-12-14 12:39:42 +00:00
|
|
|
g_clear_object (&dest);
|
2010-07-13 17:44:41 +00:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (gdk_pixbuf_get_has_alpha (dest))
|
|
|
|
convert_alpha (gdk_pixbuf_get_pixels (dest),
|
|
|
|
gdk_pixbuf_get_rowstride (dest),
|
|
|
|
cairo_image_surface_get_data (surface),
|
|
|
|
cairo_image_surface_get_stride (surface),
|
2013-08-06 14:18:13 +00:00
|
|
|
src_x, src_y,
|
2010-07-13 17:44:41 +00:00
|
|
|
width, height);
|
|
|
|
else
|
|
|
|
convert_no_alpha (gdk_pixbuf_get_pixels (dest),
|
|
|
|
gdk_pixbuf_get_rowstride (dest),
|
|
|
|
cairo_image_surface_get_data (surface),
|
|
|
|
cairo_image_surface_get_stride (surface),
|
2013-08-06 14:18:13 +00:00
|
|
|
src_x, src_y,
|
2010-07-13 17:44:41 +00:00
|
|
|
width, height);
|
|
|
|
|
|
|
|
cairo_surface_destroy (surface);
|
|
|
|
return dest;
|
|
|
|
}
|
2019-08-30 18:51:47 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* gdk_pixbuf_get_from_texture:
|
2021-02-21 14:19:37 +00:00
|
|
|
* @texture: a `GdkTexture`
|
|
|
|
*
|
|
|
|
* Creates a new pixbuf from @texture.
|
2019-08-30 18:51:47 +00:00
|
|
|
*
|
2021-02-21 14:19:37 +00:00
|
|
|
* This should generally not be used in newly written code as later
|
|
|
|
* stages will almost certainly convert the pixbuf back into a texture
|
|
|
|
* to draw it on screen.
|
2019-08-30 18:51:47 +00:00
|
|
|
*
|
2021-05-20 03:39:18 +00:00
|
|
|
* Returns: (transfer full) (nullable): a new `GdkPixbuf`
|
2019-08-30 18:51:47 +00:00
|
|
|
*/
|
|
|
|
GdkPixbuf *
|
|
|
|
gdk_pixbuf_get_from_texture (GdkTexture *texture)
|
|
|
|
{
|
|
|
|
GdkPixbuf *pixbuf;
|
|
|
|
cairo_surface_t *surface;
|
|
|
|
int width, height;
|
|
|
|
|
|
|
|
g_return_val_if_fail (GDK_IS_TEXTURE (texture), NULL);
|
|
|
|
|
|
|
|
width = gdk_texture_get_width (texture);
|
|
|
|
height = gdk_texture_get_height (texture);
|
|
|
|
surface = gdk_texture_download_surface (texture);
|
|
|
|
pixbuf = gdk_pixbuf_get_from_surface (surface, 0, 0, width, height);
|
|
|
|
cairo_surface_destroy (surface);
|
|
|
|
|
|
|
|
return pixbuf;
|
|
|
|
}
|