diff options
Diffstat (limited to 'gdk-pixbuf')
27 files changed, 963 insertions, 613 deletions
diff --git a/gdk-pixbuf/ChangeLog b/gdk-pixbuf/ChangeLog index 20bb05992..2a1b8607f 100644 --- a/gdk-pixbuf/ChangeLog +++ b/gdk-pixbuf/ChangeLog @@ -1,3 +1,97 @@ +2000-04-11 Federico Mena Quintero <federico@helixcode.com> + + Most of this patch is based on a patch by Havoc Pennington + (hp@redhat.com) to make GdkPixbuf's structures opaque and to + remove the libart dependency. + + * gdk-pixbuf/gdk-pixbuf.h: Removed the public structures. + (GdkColorspace): New enum that for now only contains + GDK_COLORSPACE_RGB. + (GdkPixbufDestroyNotify): New type for the pixbuf's pixels destroy + notification function. + (GdkInterpType): New num with interpolation types. + + * *.[ch]: Replace the libart stuff with our own stuff. + + * pixops/*.[ch]: Likewise. + + * gdk-pixbuf/gdk-pixbuf-private.h: New file with the private + declarations of the GdkPixbuf structures. + + * gdk-pixbuf/gdk-pixbuf.c (gdk_pixbuf_new_from_art_pixbuf): + Removed function. + (gdk_pixbuf_get_format): Constify. + (gdk_pixbuf_get_n_channels): Constify. + (gdk_pixbuf_get_has_alpha): Constify. + (gdk_pixbuf_get_bits_per_sample): Constify. + (gdk_pixbuf_get_pixels): Constify. + (gdk_pixbuf_get_width): Constify. + (gdk_pixbuf_get_height): Constify. + (gdk_pixbuf_get_rowstride): Constify. + + * gdk-pixbuf/gdk-pixbuf.c (gdk_pixbuf_copy): New function to copy + a pixbuf. + + * gdk-pixbuf/gdk-pixbuf-data.c (gdk_pixbuf_new_from_data): Added a + bits_per_sample argument; currently only 8 bits per sample are + supported. + + * gdk-pixbuf/gdk-pixbuf-animation.c (gdk_pixbuf_frame_get_pixbuf): + New accessor. + (gdk_pixbuf_frame_get_x_offset): New accessor. + (gdk_pixbuf_frame_get_y_offset): New accessor. + (gdk_pixbuf_frame_get_delay_time): New accessor. + (gdk_pixbuf_frame_get_action): New accessor. + + * gdk-pixbuf/gdk-pixbuf-render.c + (gdk_pixbuf_render_pixmap_and_mask): Instead of returning a solid + mask rectangle for pixbufs without an alpha channel, set the + *mask_return to NULL. + + * gdk-pixbuf/gdk-pixbuf-util.c (gdk_pixbuf_add_alpha): Constify. + + * gdk-pixbuf/gdk-pixbuf-scale.c: Fix includes. + + * gdk-pixbuf/gdk-pixbuf-scale.c (gdk_pixbuf_scale): Added some + preconditions. Maybe we should also check for the colorspace, + bits per pixel, and such. + (gdk_pixbuf_composite): Likewise. + (gdk_pixbuf_composite_color): Likewise. + (gdk_pixbuf_scale_simple): Likewise, and fail gracefully if we + cannot allocate the new pixbuf. + (gdk_pixbuf_composite_color_simple): Likewise. + + * gdk-pixbuf/gnome-canvas-pixbuf.c (gnome_canvas_pixbuf_render): + Use art_rgb_rgba_affine() or art_rgb_affine() since we no longer + have an ArtPixBuf. + + * gdk-pixbuf/io-bmp.c: Fix includes. + + * gdk-pixbuf/pixops/pixops.c (pixops_scale_nearest): Fixed cast in + an lvalue. + + * TODO: Populated. + + * configure.in: Removed checks for libart. + + * gdk-pixbuf/Makefile.am: Removed references to libart. + (noinst_HEADERS): Added gdk-pixbuf-private.h. + + * gdk-pixbuf/Makefile.am (libgdk_pixbuf_la_LDFLAGS): Incremented + the version number of the libtool library to indicate that this + definitely is not compatible with the old usage. I know you love + me. I know you do. + + * configure.in: Bumped version number to 0.7.0. + + * README: Updated. + + * gdk-pixbuf-config.in (--libs): We no longer require libart. + + * DEPENDS.libgdk_pixbuf: We no longer depend on libart. + + * gdk-pixbuf.spec.in: Updated, but I don't guarantee anything. + 2000-04-06 Jonathan Blandford <jrb@redhat.com> * gdk-pixbuf/testanimation.c (main): add more info to the diff --git a/gdk-pixbuf/Makefile.am b/gdk-pixbuf/Makefile.am index 9e34123b3..64419f792 100644 --- a/gdk-pixbuf/Makefile.am +++ b/gdk-pixbuf/Makefile.am @@ -144,25 +144,25 @@ DEPS = libgdk_pixbuf.la INCLUDES = -I$(top_srcdir) -I$(top_builddir) \ -I$(top_srcdir)/gdk-pixbuf \ -I$(top_builddir)/gdk-pixbuf \ - $(GLIB_CFLAGS) $(LIBART_CFLAGS) $(GTK_CFLAGS) + $(GLIB_CFLAGS) $(GTK_CFLAGS) AM_CPPFLAGS = "-DPIXBUF_LIBDIR=\"$(libexecdir)\"" -LDADDS = libgdk_pixbuf.la $(LIBART_LIBS) $(GLIB_LIBS) $(GTK_LIBS) $(STATIC_LIB_DEPS) +LDADDS = libgdk_pixbuf.la $(GLIB_LIBS) $(GTK_LIBS) $(STATIC_LIB_DEPS) if INSIDE_GNOME_LIBS -testpixbuf_LDADD = $(LDADDS) $(LIBART_LIBS) -lgmodule +testpixbuf_LDADD = $(LDADDS) -lgmodule testpixbuf_drawable_LDADD = $(LDADDS) testpixbuf_scale_LDADD = $(LDADDS) -testanimation_LDADD = $(LDADDS) $(LIBART_LIBS) -lgmodule +testanimation_LDADD = $(LDADDS) -lgmodule else -testpixbuf_LDADD = $(LDADDS) $(LIBART_LIBS) $(GNOME_LIBS) -lgmodule +testpixbuf_LDADD = $(LDADDS) $(GNOME_LIBS) -lgmodule testpixbuf_drawable_LDADD = $(LDADDS) $(GNOME_LIBS) testpixbuf_scale_LDADD = $(LDADDS) $(GNOME_LIBS) -testanimation_LDADD = $(LDADDS) $(LIBART_LIBS) $(GNOME_LIBS) -lgmodule +testanimation_LDADD = $(LDADDS) $(GNOME_LIBS) -lgmodule endif -GDK_PIXBUF_LIBS = $(LIBART_LIBS) $(GLIB_LIBS) $(GTK_LIBS) +GDK_PIXBUF_LIBS = $(GLIB_LIBS) $(GTK_LIBS) # # The GdkPixBuf library @@ -182,8 +182,8 @@ libgdk_pixbuf_la_SOURCES = \ gdk-pixbuf-util.c \ $(extra_sources) -libgdk_pixbuf_la_LDFLAGS = -version-info 1:0:0 $(LIBART_LIBS) $(GLIB_LIBS) $(GTK_LIBS) -libgdk_pixbuf_la_LIBADD = pixops/libpixops.la +libgdk_pixbuf_la_LDFLAGS = -version-info 2:0:0 $(GLIB_LIBS) $(GTK_LIBS) +libgdk_pixbuf_la_LIBADD = pixops/libpixops.la libgdk_pixbufinclude_HEADERS = \ gdk-pixbuf.h \ @@ -191,6 +191,6 @@ libgdk_pixbufinclude_HEADERS = \ gdk-pixbuf-features.h \ $(CANVAS_PIXBUF_HEADERFILES) -noinst_HEADERS = \ - gdk-pixbuf-io.h - +noinst_HEADERS = \ + gdk-pixbuf-io.h \ + gdk-pixbuf-private.h diff --git a/gdk-pixbuf/gdk-pixbuf-animation.c b/gdk-pixbuf/gdk-pixbuf-animation.c index 09e21c459..b2fbbb8f4 100644 --- a/gdk-pixbuf/gdk-pixbuf-animation.c +++ b/gdk-pixbuf/gdk-pixbuf-animation.c @@ -23,6 +23,7 @@ #include <config.h> #include "gdk-pixbuf-io.h" +#include "gdk-pixbuf-private.h" @@ -223,3 +224,85 @@ gdk_pixbuf_animation_get_frames (GdkPixbufAnimation *animation) return animation->frames; } + + + +/** + * gdk_pixbuf_frame_get_pixbuf: + * @frame: A pixbuf animation frame. + * + * Queries the pixbuf of an animation frame. + * + * Return value: A pixbuf. + **/ +GdkPixbuf * +gdk_pixbuf_frame_get_pixbuf (GdkPixbufFrame *frame) +{ + g_return_val_if_fail (frame != NULL, NULL); + + return frame->pixbuf; +} + +/** + * gdk_pixbuf_frame_get_x_offset: + * @frame: A pixbuf animation frame. + * + * Queries the X offset of an animation frame. + * + * Return value: X offset from the top left corner of the animation. + **/ +int +gdk_pixbuf_frame_get_x_offset (GdkPixbufFrame *frame) +{ + g_return_val_if_fail (frame != NULL, -1); + + return frame->x_offset; +} + +/** + * gdk_pixbuf_frame_get_y_offset: + * @frame: A pixbuf animation frame. + * + * Queries the Y offset of an animation frame. + * + * Return value: Y offset from the top left corner of the animation. + **/ +int +gdk_pixbuf_frame_get_y_offset (GdkPixbufFrame *frame) +{ + g_return_val_if_fail (frame != NULL, -1); + + return frame->y_offset; +} + +/** + * gdk_pixbuf_frame_get_delay_time: + * @frame: A pixbuf animation frame. + * + * Queries the delay time in milliseconds of an animation frame. + * + * Return value: Delay time in milliseconds. + **/ +int +gdk_pixbuf_frame_get_delay_time (GdkPixbufFrame *frame) +{ + g_return_val_if_fail (frame != NULL, -1); + + return frame->delay_time; +} + +/** + * gdk_pixbuf_frame_get_action: + * @frame: A pixbuf animation frame. + * + * Queries the overlay action of an animation frame. + * + * Return value: Overlay action for this frame. + **/ +GdkPixbufFrameAction +gdk_pixbuf_frame_get_action (GdkPixbufFrame *frame) +{ + g_return_val_if_fail (frame != NULL, GDK_PIXBUF_FRAME_RETAIN); + + return frame->action; +} diff --git a/gdk-pixbuf/gdk-pixbuf-data.c b/gdk-pixbuf/gdk-pixbuf-data.c index 247a67e4f..e94aea7da 100644 --- a/gdk-pixbuf/gdk-pixbuf-data.c +++ b/gdk-pixbuf/gdk-pixbuf-data.c @@ -22,48 +22,56 @@ #include <config.h> #include "gdk-pixbuf.h" +#include "gdk-pixbuf-private.h" /** * gdk_pixbuf_new_from_data: * @data: Image data in 8-bit/sample packed format. - * @format: Color format used for the data. + * @colorspace: Colorspace for the image data. * @has_alpha: Whether the data has an opacity channel. + * @bits_per_sample: Number of bits per sample. * @width: Width of the image in pixels. * @height: Height of the image in pixels. * @rowstride: Distance in bytes between rows. - * @dfunc: Function used to free the data when the pixbuf's reference count + * @destroy_fn: Function used to free the data when the pixbuf's reference count * drops to zero, or NULL if the data should not be freed. - * @dfunc_data: Closure data to pass to the destroy notification function. + * @destroy_fn_data: Closure data to pass to the destroy notification function. * - * Creates a new #GdkPixbuf out of in-memory RGB data. + * Creates a new #GdkPixbuf out of in-memory image data. Currently only RGB + * images with 8 bits per sample are supported. * * Return value: A newly-created #GdkPixbuf structure with a reference count of * 1. **/ GdkPixbuf * -gdk_pixbuf_new_from_data (const guchar *data, ArtPixFormat format, gboolean has_alpha, - int width, int height, int rowstride, - ArtDestroyNotify dfunc, gpointer dfunc_data) +gdk_pixbuf_new_from_data (const guchar *data, GdkColorspace colorspace, gboolean has_alpha, + int bits_per_sample, int width, int height, int rowstride, + GdkPixbufDestroyNotify destroy_fn, gpointer destroy_fn_data) { - ArtPixBuf *art_pixbuf; + GdkPixbuf *pixbuf; /* Only 8-bit/sample RGB buffers are supported for now */ g_return_val_if_fail (data != NULL, NULL); - g_return_val_if_fail (format == ART_PIX_RGB, NULL); + g_return_val_if_fail (colorspace == GDK_COLORSPACE_RGB, NULL); + g_return_val_if_fail (bits_per_sample == 8, NULL); g_return_val_if_fail (width > 0, NULL); g_return_val_if_fail (height > 0, NULL); - if (has_alpha) - art_pixbuf = art_pixbuf_new_rgba_dnotify ((art_u8 *)data, width, height, rowstride, - dfunc_data, dfunc); - else - art_pixbuf = art_pixbuf_new_rgb_dnotify ((art_u8 *)data, width, height, rowstride, - dfunc_data, dfunc); + pixbuf = g_new (GdkPixbuf, 1); + pixbuf->ref_count = 1; + pixbuf->colorspace = colorspace; + pixbuf->n_channels = has_alpha ? 4 : 3; + pixbuf->bits_per_sample = bits_per_sample; + pixbuf->has_alpha = has_alpha ? TRUE : FALSE; + pixbuf->width = width; + pixbuf->height = height; + pixbuf->rowstride = rowstride; + pixbuf->pixels = (guchar *) data; + pixbuf->destroy_fn = destroy_fn; + pixbuf->destroy_fn_data = destroy_fn_data; - g_assert (art_pixbuf != NULL); - - return gdk_pixbuf_new_from_art_pixbuf (art_pixbuf); + return pixbuf; } diff --git a/gdk-pixbuf/gdk-pixbuf-io.c b/gdk-pixbuf/gdk-pixbuf-io.c index 491543a27..cb88dd2de 100644 --- a/gdk-pixbuf/gdk-pixbuf-io.c +++ b/gdk-pixbuf/gdk-pixbuf-io.c @@ -24,6 +24,7 @@ #include <config.h> #include <string.h> #include <glib.h> +#include "gdk-pixbuf-private.h" #include "gdk-pixbuf-io.h" diff --git a/gdk-pixbuf/gdk-pixbuf-loader.c b/gdk-pixbuf/gdk-pixbuf-loader.c index 777b767d1..5648258aa 100644 --- a/gdk-pixbuf/gdk-pixbuf-loader.c +++ b/gdk-pixbuf/gdk-pixbuf-loader.c @@ -27,6 +27,7 @@ #include <config.h> #include <gtk/gtksignal.h> +#include "gdk-pixbuf-private.h" #include "gdk-pixbuf-loader.h" #include "gdk-pixbuf-io.h" diff --git a/gdk-pixbuf/gdk-pixbuf-private.h b/gdk-pixbuf/gdk-pixbuf-private.h new file mode 100644 index 000000000..278298c23 --- /dev/null +++ b/gdk-pixbuf/gdk-pixbuf-private.h @@ -0,0 +1,99 @@ +/* GdkPixbuf library - Private declarations + * + * Copyright (C) 1999 The Free Software Foundation + * + * Authors: Mark Crichton <crichton@gimp.org> + * Miguel de Icaza <miguel@gnu.org> + * Federico Mena-Quintero <federico@gimp.org> + * Havoc Pennington <hp@redhat.com> + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library 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 + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with this library; if not, write to the + * Free Software Foundation, Inc., 59 Temple Place - Suite 330, + * Boston, MA 02111-1307, USA. + */ + +#ifndef GDK_PIXBUF_PRIVATE_H +#define GDK_PIXBUF_PRIVATE_H + +#include "gdk-pixbuf.h" + + + +/* Private part of the GdkPixbuf structure */ +struct _GdkPixbuf { + /* Reference count */ + int ref_count; + + /* Color space */ + GdkColorspace colorspace; + + /* Number of channels, alpha included */ + int n_channels; + + /* Bits per channel */ + int bits_per_sample; + + /* Size */ + int width, height; + + /* Offset between rows */ + int rowstride; + + /* The pixel array */ + guchar *pixels; + + /* Destroy notification function; it is supposed to free the pixel array */ + GdkPixbufDestroyNotify destroy_fn; + + /* User data for the destroy notification function */ + gpointer destroy_fn_data; + + /* Do we have an alpha channel? */ + guint has_alpha : 1; +}; + +/* Private part of the GdkPixbufFrame structure */ +struct _GdkPixbufFrame { + /* The pixbuf with this frame's image data */ + GdkPixbuf *pixbuf; + + /* Offsets for overlaying onto the animation's area */ + int x_offset; + int y_offset; + + /* Frame duration in ms */ + int delay_time; + + /* Overlay mode */ + GdkPixbufFrameAction action; +}; + +/* Private part of the GdkPixbufAnimation structure */ +struct _GdkPixbufAnimation { + /* Reference count */ + int ref_count; + + /* Number of frames */ + int n_frames; + + /* List of GdkPixbufFrame structures */ + GList *frames; + + /* bounding box size */ + int width, height; +}; + + + +#endif diff --git a/gdk-pixbuf/gdk-pixbuf-scale.c b/gdk-pixbuf/gdk-pixbuf-scale.c index 0f621d1d6..8b5a159e4 100644 --- a/gdk-pixbuf/gdk-pixbuf-scale.c +++ b/gdk-pixbuf/gdk-pixbuf-scale.c @@ -1,6 +1,31 @@ -#include "gdk-pixbuf.h" +/* GdkPixbuf library - Scaling and compositing functions + * + * Copyright (C) 1999 The Free Software Foundation + * + * Author: Owen Taylor <otaylor@redhat.com> + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library 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 + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with this library; if not, write to the + * Free Software Foundation, Inc., 59 Temple Place - Suite 330, + * Boston, MA 02111-1307, USA. + */ + +#include <config.h> +#include <math.h> +#include "gdk-pixbuf-private.h" #include "pixops/pixops.h" -#include "math.h" + + /** * gdk_pixbuf_scale: @@ -14,7 +39,7 @@ * @offset_y: the offset in the Y direction (currently rounded to an integer) * @scale_x: the scale factor in the X direction * @scale_y: the scale factor in the Y direction - * @filter_level: the filter quality for the transformation. + * @interp_type: the interpolation type for the transformation. * * Transforms the image by source image by scaling by @scale_x and @scale_y then * translating by @offset_x and @offset_y, then renders the rectangle @@ -32,17 +57,22 @@ gdk_pixbuf_scale (const GdkPixbuf *src, double offset_y, double scale_x, double scale_y, - ArtFilterLevel filter_level) + GdkInterpType interp_type) { + g_return_if_fail (src != NULL); + g_return_if_fail (dest != NULL); + g_return_if_fail (dest_x >= 0 && dest_x + dest_width <= dest->width); + g_return_if_fail (dest_y >= 0 && dest_y + dest_height <= dest->height); + offset_x = floor (offset_x + 0.5); offset_y = floor (offset_y + 0.5); - pixops_scale (dest->art_pixbuf->pixels + dest_y * dest->art_pixbuf->rowstride + dest_x * dest->art_pixbuf->n_channels, + pixops_scale (dest->pixels + dest_y * dest->rowstride + dest_x * dest->n_channels, -offset_x, -offset_y, dest_width - offset_x, dest_height - offset_y, - dest->art_pixbuf->rowstride, dest->art_pixbuf->n_channels, dest->art_pixbuf->has_alpha, - src->art_pixbuf->pixels, src->art_pixbuf->width, src->art_pixbuf->height, - src->art_pixbuf->rowstride, src->art_pixbuf->n_channels, src->art_pixbuf->has_alpha, - scale_x, scale_y, filter_level); + dest->rowstride, dest->n_channels, dest->has_alpha, + src->pixels, src->width, src->height, + src->rowstride, src->n_channels, src->has_alpha, + scale_x, scale_y, interp_type); } /** @@ -57,7 +87,7 @@ gdk_pixbuf_scale (const GdkPixbuf *src, * @offset_y: the offset in the Y direction (currently rounded to an integer) * @scale_x: the scale factor in the X direction * @scale_y: the scale factor in the Y direction - * @filter_level: the filter quality for the transformation. + * @interp_type: the interpolation type for the transformation. * @overall_alpha: overall alpha for source image (0..255) * * Transforms the image by source image by scaling by @scale_x and @scale_y then @@ -76,17 +106,23 @@ gdk_pixbuf_composite (const GdkPixbuf *src, double offset_y, double scale_x, double scale_y, - ArtFilterLevel filter_level, + GdkInterpType interp_type, int overall_alpha) { + g_return_if_fail (src != NULL); + g_return_if_fail (dest != NULL); + g_return_if_fail (dest_x >= 0 && dest_x + dest_width <= dest->width); + g_return_if_fail (dest_y >= 0 && dest_y + dest_height <= dest->height); + g_return_if_fail (overall_alpha >= 0 && overall_alpha <= 255); + offset_x = floor (offset_x + 0.5); offset_y = floor (offset_y + 0.5); - pixops_composite (dest->art_pixbuf->pixels + dest_y * dest->art_pixbuf->rowstride + dest_x * dest->art_pixbuf->n_channels, + pixops_composite (dest->pixels + dest_y * dest->rowstride + dest_x * dest->n_channels, -offset_x, -offset_y, dest_width - offset_x, dest_height - offset_y, - dest->art_pixbuf->rowstride, dest->art_pixbuf->n_channels, dest->art_pixbuf->has_alpha, - src->art_pixbuf->pixels, src->art_pixbuf->width, src->art_pixbuf->height, - src->art_pixbuf->rowstride, src->art_pixbuf->n_channels, src->art_pixbuf->has_alpha, - scale_x, scale_y, filter_level, overall_alpha); + dest->rowstride, dest->n_channels, dest->has_alpha, + src->pixels, src->width, src->height, + src->rowstride, src->n_channels, src->has_alpha, + scale_x, scale_y, interp_type, overall_alpha); } /** @@ -101,7 +137,7 @@ gdk_pixbuf_composite (const GdkPixbuf *src, * @offset_y: the offset in the Y direction (currently rounded to an integer) * @scale_x: the scale factor in the X direction * @scale_y: the scale factor in the Y direction - * @filter_level: the filter quality for the transformation. + * @interp_type: the interpolation type for the transformation. * @overall_alpha: overall alpha for source image (0..255) * @check_x: the X offset for the checkboard (origin of checkboard is at -@check_x, -@check_y) * @check_y: the Y offset for the checkboard @@ -126,23 +162,30 @@ gdk_pixbuf_composite_color (const GdkPixbuf *src, double offset_y, double scale_x, double scale_y, - ArtFilterLevel filter_level, + GdkInterpType interp_type, int overall_alpha, int check_x, int check_y, int check_size, - art_u32 color1, - art_u32 color2) + guint32 color1, + guint32 color2) { + g_return_if_fail (src != NULL); + g_return_if_fail (dest != NULL); + g_return_if_fail (dest_x >= 0 && dest_x + dest_width <= dest->width); + g_return_if_fail (dest_y >= 0 && dest_y + dest_height <= dest->height); + g_return_if_fail (overall_alpha >= 0 && overall_alpha <= 255); + offset_x = floor (offset_x + 0.5); offset_y = floor (offset_y + 0.5); - pixops_composite_color (dest->art_pixbuf->pixels + dest_y * dest->art_pixbuf->rowstride + dest_x * dest->art_pixbuf->n_channels, + pixops_composite_color (dest->pixels + dest_y * dest->rowstride + dest_x * dest->n_channels, -offset_x, -offset_y, dest_width - offset_x, dest_height - offset_y, - dest->art_pixbuf->rowstride, dest->art_pixbuf->n_channels, dest->art_pixbuf->has_alpha, - src->art_pixbuf->pixels, src->art_pixbuf->width, src->art_pixbuf->height, - src->art_pixbuf->rowstride, src->art_pixbuf->n_channels, src->art_pixbuf->has_alpha, - scale_x, scale_y, filter_level, overall_alpha, check_x, check_y, check_size, color1, color2); + dest->rowstride, dest->n_channels, dest->has_alpha, + src->pixels, src->width, src->height, + src->rowstride, src->n_channels, src->has_alpha, + scale_x, scale_y, interp_type, overall_alpha, check_x, check_y, + check_size, color1, color2); } /** @@ -150,25 +193,34 @@ gdk_pixbuf_composite_color (const GdkPixbuf *src, * @src: a #GdkPixbuf * @dest_width: the width of destination image * @dest_height: the height of destination image - * @filter_level: the filter quality for the transformation. + * @interp_type: the interpolation type for the transformation. * * Scale the #GdkPixbuf @src to @dest_width x @dest_height and render the result into * a new #GdkPixbuf. * - * Return value: the new #GdkPixbuf + * Return value: the new #GdkPixbuf, or NULL if not enough memory could be + * allocated for it. **/ GdkPixbuf * gdk_pixbuf_scale_simple (const GdkPixbuf *src, int dest_width, int dest_height, - ArtFilterLevel filter_level) + GdkInterpType interp_type) { - GdkPixbuf *dest = gdk_pixbuf_new (ART_PIX_RGB, src->art_pixbuf->has_alpha, 8, dest_width, dest_height); + GdkPixbuf *dest; + + g_return_val_if_fail (src != NULL, NULL); + g_return_val_if_fail (dest_width > 0, NULL); + g_return_val_if_fail (dest_height > 0, NULL); + + dest = gdk_pixbuf_new (GDK_COLORSPACE_RGB, src->has_alpha, 8, dest_width, dest_height); + if (!dest) + return NULL; gdk_pixbuf_scale (src, dest, 0, 0, dest_width, dest_height, 0, 0, - (double)dest_width / src->art_pixbuf->width, - (double)dest_height / src->art_pixbuf->height, - filter_level); + (double) dest_width / src->width, + (double) dest_height / src->height, + interp_type); return dest; } @@ -178,7 +230,7 @@ gdk_pixbuf_scale_simple (const GdkPixbuf *src, * @src: a #GdkPixbuf * @dest_width: the width of destination image * @dest_height: the height of destination image - * @filter_level: the filter quality for the transformation. + * @interp_type: the interpolation type for the transformation. * @overall_alpha: overall alpha for source image (0..255) * @check_size: the size of checks in the checkboard (must be a power of two) * @color1: the color of check at upper left @@ -188,27 +240,34 @@ gdk_pixbuf_scale_simple (const GdkPixbuf *src, * a checkboard of colors @color1 and @color2 and render the result into * a new #GdkPixbuf. * - * Return value: the new #GdkPixbuf + * Return value: the new #GdkPixbuf, or NULL if not enough memory could be + * allocated for it. **/ GdkPixbuf * gdk_pixbuf_composite_color_simple (const GdkPixbuf *src, int dest_width, int dest_height, - ArtFilterLevel filter_level, + GdkInterpType interp_type, int overall_alpha, int check_size, - art_u32 color1, - art_u32 color2) + guint32 color1, + guint32 color2) { - GdkPixbuf *dest = gdk_pixbuf_new (ART_PIX_RGB, src->art_pixbuf->has_alpha, 8, dest_width, dest_height); + GdkPixbuf *dest; + + g_return_val_if_fail (src != NULL, NULL); + g_return_val_if_fail (dest_width > 0, NULL); + g_return_val_if_fail (dest_height > 0, NULL); + g_return_val_if_fail (overall_alpha >= 0 && overall_alpha <= 255, NULL); + + dest = gdk_pixbuf_new (GDK_COLORSPACE_RGB, src->has_alpha, 8, dest_width, dest_height); + if (!dest) + return NULL; gdk_pixbuf_composite_color (src, dest, 0, 0, dest_width, dest_height, 0, 0, - (double)dest_width / src->art_pixbuf->width, - (double)dest_height / src->art_pixbuf->height, - filter_level, overall_alpha, 0, 0, check_size, color1, color2); + (double) dest_width / src->width, + (double) dest_height / src->height, + interp_type, overall_alpha, 0, 0, check_size, color1, color2); return dest; } - - - diff --git a/gdk-pixbuf/gdk-pixbuf-util.c b/gdk-pixbuf/gdk-pixbuf-util.c index 96a8ca49b..ece50afac 100644 --- a/gdk-pixbuf/gdk-pixbuf-util.c +++ b/gdk-pixbuf/gdk-pixbuf-util.c @@ -22,7 +22,7 @@ */ #include <config.h> -#include "gdk-pixbuf.h" +#include "gdk-pixbuf-private.h" @@ -45,42 +45,37 @@ * Return value: A newly-created pixbuf with a reference count of 1. **/ GdkPixbuf * -gdk_pixbuf_add_alpha (GdkPixbuf *pixbuf, gboolean substitute_color, guchar r, guchar g, guchar b) +gdk_pixbuf_add_alpha (const GdkPixbuf *pixbuf, + gboolean substitute_color, guchar r, guchar g, guchar b) { - ArtPixBuf *apb; - ArtPixBuf *new_apb; GdkPixbuf *new_pixbuf; int x, y; g_return_val_if_fail (pixbuf != NULL, 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); - apb = pixbuf->art_pixbuf; - g_return_val_if_fail (apb->format == ART_PIX_RGB, NULL); - g_return_val_if_fail (apb->n_channels == 3 || apb->n_channels == 4, NULL); - g_return_val_if_fail (apb->bits_per_sample == 8, NULL); - - if (apb->has_alpha) { - new_apb = art_pixbuf_duplicate (apb); - if (!new_apb) + if (pixbuf->has_alpha) { + new_pixbuf = gdk_pixbuf_copy (pixbuf); + if (!new_pixbuf) return NULL; - return gdk_pixbuf_new_from_art_pixbuf (new_apb); + return new_pixbuf; } - new_pixbuf = gdk_pixbuf_new (ART_PIX_RGB, TRUE, 8, apb->width, apb->height); + new_pixbuf = gdk_pixbuf_new (GDK_COLORSPACE_RGB, TRUE, 8, pixbuf->width, pixbuf->height); if (!new_pixbuf) return NULL; - new_apb = new_pixbuf->art_pixbuf; - - for (y = 0; y < apb->height; y++) { + for (y = 0; y < pixbuf->height; y++) { guchar *src, *dest; guchar tr, tg, tb; - src = apb->pixels + y * apb->rowstride; - dest = new_apb->pixels + y * new_apb->rowstride; + src = pixbuf->pixels + y * pixbuf->rowstride; + dest = new_pixbuf->pixels + y * new_pixbuf->rowstride; - for (x = 0; x < apb->width; x++) { + for (x = 0; x < pixbuf->width; x++) { tr = *dest++ = *src++; tg = *dest++ = *src++; tb = *dest++ = *src++; @@ -116,20 +111,14 @@ gdk_pixbuf_copy_area (const GdkPixbuf *src_pixbuf, GdkPixbuf *dest_pixbuf, int dest_x, int dest_y) { - const ArtPixBuf *src_apb; - ArtPixBuf *dest_apb; - g_return_if_fail (src_pixbuf != NULL); g_return_if_fail (dest_pixbuf != NULL); - src_apb = src_pixbuf->art_pixbuf; - dest_apb = dest_pixbuf->art_pixbuf; - - g_return_if_fail (src_x >= 0 && src_x + width <= src_apb->width); - g_return_if_fail (src_y >= 0 && src_y + height <= src_apb->height); + 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_apb->width); - g_return_if_fail (dest_y >= 0 && dest_y + height <= dest_apb->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); /* This will perform format conversions automatically */ @@ -140,5 +129,5 @@ gdk_pixbuf_copy_area (const GdkPixbuf *src_pixbuf, (double) (dest_x - src_x), (double) (dest_y - src_y), 1.0, 1.0, - ART_FILTER_NEAREST); + GDK_INTERP_NEAREST); } diff --git a/gdk-pixbuf/gdk-pixbuf-xform.c b/gdk-pixbuf/gdk-pixbuf-xform.c index f118d9234..1ca70cd60 100644 --- a/gdk-pixbuf/gdk-pixbuf-xform.c +++ b/gdk-pixbuf/gdk-pixbuf-xform.c @@ -1,7 +1,16 @@ +/* FIXME FIXME FIXME + * + * This file is not being used. The gdk_pixbuf_scale() here is not useful + * anymore, since we have the new functions in gdk-pixbuf-scale.c. + * + * The rotation function needs to be implemented without libart if it is + * to go inside the GdkPixbuf library. + */ + GdkPixbuf * gdk_pixbuf_scale (const GdkPixbuf *pixbuf, gint w, gint h) { - art_u8 *pixels; + guchar *pixels; gint rowstride; double affine[6]; ArtAlphaGamma *alphagamma; @@ -12,10 +21,10 @@ gdk_pixbuf_scale (const GdkPixbuf *pixbuf, gint w, gint h) affine[1] = affine[2] = affine[4] = affine[5] = 0; - affine[0] = w / (double)(pixbuf->art_pixbuf->width); - affine[3] = h / (double)(pixbuf->art_pixbuf->height); + affine[0] = w / (double)(pixbuf->width); + affine[3] = h / (double)(pixbuf->height); - /* rowstride = w * pixbuf->art_pixbuf->n_channels; */ + /* rowstride = w * pixbuf->n_channels; */ rowstride = w * 3; pixels = art_alloc (h * rowstride); diff --git a/gdk-pixbuf/gdk-pixbuf.c b/gdk-pixbuf/gdk-pixbuf.c index 1c7162267..be67197bc 100644 --- a/gdk-pixbuf/gdk-pixbuf.c +++ b/gdk-pixbuf/gdk-pixbuf.c @@ -24,12 +24,9 @@ #include <config.h> #include <math.h> -#include <libart_lgpl/art_misc.h> -#include <libart_lgpl/art_affine.h> -#include <libart_lgpl/art_pixbuf.h> -#include <libart_lgpl/art_rgb_pixbuf_affine.h> -#include <libart_lgpl/art_alphagamma.h> +#include <stdlib.h> #include "gdk-pixbuf.h" +#include "gdk-pixbuf-private.h" @@ -58,7 +55,7 @@ gdk_pixbuf_ref (GdkPixbuf *pixbuf) * gdk_pixbuf_unref: * @pixbuf: A pixbuf. * - * Removes a reference from a pixbuf. It will be destroyed when the reference + * Removes a reference from a pixbuf, which will be destroyed when the reference * count drops to zero. **/ void @@ -70,53 +67,25 @@ gdk_pixbuf_unref (GdkPixbuf *pixbuf) pixbuf->ref_count--; if (pixbuf->ref_count == 0) { - art_pixbuf_free (pixbuf->art_pixbuf); - pixbuf->art_pixbuf = NULL; + if (pixbuf->destroy_fn) + (* pixbuf->destroy_fn) (pixbuf->pixels, pixbuf->destroy_fn_data); + g_free (pixbuf); } } -/* Wrap a libart pixbuf */ - -/** - * gdk_pixbuf_new_from_art_pixbuf: - * @art_pixbuf: A libart pixbuf. - * - * Creates a #GdkPixbuf by wrapping a libart pixbuf. - * - * Return value: A newly-created #GdkPixbuf structure with a reference count of - * 1. - **/ -GdkPixbuf * -gdk_pixbuf_new_from_art_pixbuf (ArtPixBuf *art_pixbuf) -{ - GdkPixbuf *pixbuf; - - g_return_val_if_fail (art_pixbuf != NULL, NULL); - - pixbuf = g_new (GdkPixbuf, 1); - pixbuf->ref_count = 1; - pixbuf->art_pixbuf = art_pixbuf; - - return pixbuf; -} - -/* Destroy notification function for gdk_pixbuf_new() */ +/* Used as the destroy notification function for gdk_pixbuf_new() */ static void -free_buffer (gpointer user_data, gpointer data) +free_buffer (guchar *pixels, gpointer data) { - free (data); + free (pixels); } - - -/* Create an empty pixbuf */ - /** * gdk_pixbuf_new: - * @format: Image format. + * @colorspace: Color space for image. * @has_alpha: Whether the image should have transparency information. * @bits_per_sample: Number of bits per color sample. * @width: Width of image in pixels. @@ -124,20 +93,20 @@ free_buffer (gpointer user_data, gpointer data) * * Creates a new #GdkPixbuf structure and allocates a buffer for it. The buffer * has an optimal rowstride. Note that the buffer is not cleared; you will have - * to fill it completely. + * to fill it completely yourself. * * Return value: A newly-created #GdkPixbuf with a reference count of 1, or NULL * if not enough memory could be allocated for the image buffer. **/ GdkPixbuf * -gdk_pixbuf_new (ArtPixFormat format, gboolean has_alpha, int bits_per_sample, +gdk_pixbuf_new (GdkColorspace colorspace, gboolean has_alpha, int bits_per_sample, int width, int height) { guchar *buf; int channels; int rowstride; - g_return_val_if_fail (format == ART_PIX_RGB, NULL); + g_return_val_if_fail (colorspace == GDK_COLORSPACE_RGB, NULL); g_return_val_if_fail (bits_per_sample == 8, NULL); g_return_val_if_fail (width > 0, NULL); g_return_val_if_fail (height > 0, NULL); @@ -151,29 +120,70 @@ gdk_pixbuf_new (ArtPixFormat format, gboolean has_alpha, int bits_per_sample, if (!buf) return NULL; - return gdk_pixbuf_new_from_data (buf, format, has_alpha, width, height, rowstride, + return gdk_pixbuf_new_from_data (buf, colorspace, has_alpha, bits_per_sample, + width, height, rowstride, free_buffer, NULL); } +/** + * gdk_pixbuf_copy: + * @pixbuf: A pixbuf. + * + * Creates a new #GdkPixbuf with a copy of the information in the specified + * @pixbuf. + * + * Return value: A newly-created pixbuf with a reference count of 1, or NULL if + * not enough memory could be allocated. + **/ +GdkPixbuf * +gdk_pixbuf_copy (const GdkPixbuf *pixbuf) +{ + guchar *buf; + int size; + + g_return_val_if_fail (pixbuf != NULL, NULL); + + /* Calculate a semi-exact size. Here we copy with full rowstrides; + * maybe we should copy each row individually with the minimum + * rowstride? + */ + + size = ((pixbuf->height - 1) * pixbuf->rowstride + + pixbuf->width * ((pixbuf->n_channels * pixbuf->bits_per_sample + 7) / 8)); + + buf = malloc (size * sizeof (guchar)); + if (!buf) + return NULL; + + memcpy (buf, pixbuf->pixels, size); + + return gdk_pixbuf_new_from_data (buf, + pixbuf->colorspace, pixbuf->has_alpha, + pixbuf->bits_per_sample, + pixbuf->width, pixbuf->height, + pixbuf->rowstride, + free_buffer, + NULL); +} + -/* Convenience functions */ +/* Accessors */ /** - * gdk_pixbuf_get_format: + * gdk_pixbuf_get_colorspace: * @pixbuf: A pixbuf. * - * Queries the image format (color model) of a pixbuf. + * Queries the color space of a pixbuf. * - * Return value: Image format. + * Return value: Color space. **/ -ArtPixFormat -gdk_pixbuf_get_format (GdkPixbuf *pixbuf) +GdkColorspace +gdk_pixbuf_get_colorspace (const GdkPixbuf *pixbuf) { - g_return_val_if_fail (pixbuf != NULL, ART_PIX_RGB); - g_assert (pixbuf->art_pixbuf != NULL); + g_return_val_if_fail (pixbuf != NULL, GDK_COLORSPACE_RGB); - return pixbuf->art_pixbuf->format; + return pixbuf->colorspace; } /** @@ -185,12 +195,11 @@ gdk_pixbuf_get_format (GdkPixbuf *pixbuf) * Return value: Number of channels. **/ int -gdk_pixbuf_get_n_channels (GdkPixbuf *pixbuf) +gdk_pixbuf_get_n_channels (const GdkPixbuf *pixbuf) { g_return_val_if_fail (pixbuf != NULL, -1); - g_assert (pixbuf->art_pixbuf != NULL); - return pixbuf->art_pixbuf->n_channels; + return pixbuf->n_channels; } /** @@ -202,12 +211,11 @@ gdk_pixbuf_get_n_channels (GdkPixbuf *pixbuf) * Return value: TRUE if it has an alpha channel, FALSE otherwise. **/ gboolean -gdk_pixbuf_get_has_alpha (GdkPixbuf *pixbuf) +gdk_pixbuf_get_has_alpha (const GdkPixbuf *pixbuf) { g_return_val_if_fail (pixbuf != NULL, -1); - g_assert (pixbuf->art_pixbuf != NULL); - return pixbuf->art_pixbuf->has_alpha; + return pixbuf->has_alpha ? TRUE : FALSE; } /** @@ -219,12 +227,11 @@ gdk_pixbuf_get_has_alpha (GdkPixbuf *pixbuf) * Return value: Number of bits per color sample. **/ int -gdk_pixbuf_get_bits_per_sample (GdkPixbuf *pixbuf) +gdk_pixbuf_get_bits_per_sample (const GdkPixbuf *pixbuf) { g_return_val_if_fail (pixbuf != NULL, -1); - g_assert (pixbuf->art_pixbuf != NULL); - return pixbuf->art_pixbuf->bits_per_sample; + return pixbuf->bits_per_sample; } /** @@ -236,12 +243,11 @@ gdk_pixbuf_get_bits_per_sample (GdkPixbuf *pixbuf) * Return value: A pointer to the pixbuf's pixel data. **/ guchar * -gdk_pixbuf_get_pixels (GdkPixbuf *pixbuf) +gdk_pixbuf_get_pixels (const GdkPixbuf *pixbuf) { g_return_val_if_fail (pixbuf != NULL, NULL); - g_assert (pixbuf->art_pixbuf != NULL); - return pixbuf->art_pixbuf->pixels; + return pixbuf->pixels; } /** @@ -253,12 +259,11 @@ gdk_pixbuf_get_pixels (GdkPixbuf *pixbuf) * Return value: Width in pixels. **/ int -gdk_pixbuf_get_width (GdkPixbuf *pixbuf) +gdk_pixbuf_get_width (const GdkPixbuf *pixbuf) { g_return_val_if_fail (pixbuf != NULL, -1); - g_assert (pixbuf->art_pixbuf != NULL); - return pixbuf->art_pixbuf->width; + return pixbuf->width; } /** @@ -270,46 +275,44 @@ gdk_pixbuf_get_width (GdkPixbuf *pixbuf) * Return value: Height in pixels. **/ int -gdk_pixbuf_get_height (GdkPixbuf *pixbuf) +gdk_pixbuf_get_height (const GdkPixbuf *pixbuf) { g_return_val_if_fail (pixbuf != NULL, -1); - g_assert (pixbuf->art_pixbuf != NULL); - return pixbuf->art_pixbuf->height; + return pixbuf->height; } /** * gdk_pixbuf_get_rowstride: * @pixbuf: A pixbuf. * - * Queries the rowstride of a pixbuf, or the number of bytes between rows. + * Queries the rowstride of a pixbuf, which is the number of bytes between rows. * * Return value: Number of bytes between rows. **/ int -gdk_pixbuf_get_rowstride (GdkPixbuf *pixbuf) +gdk_pixbuf_get_rowstride (const GdkPixbuf *pixbuf) { g_return_val_if_fail (pixbuf != NULL, -1); - g_assert (pixbuf->art_pixbuf != NULL); - return pixbuf->art_pixbuf->rowstride; + return pixbuf->rowstride; } /* General initialization hooks */ -const guint gdk_pixbuf_major_version=GDK_PIXBUF_MAJOR, - gdk_pixbuf_minor_version=GDK_PIXBUF_MINOR, - gdk_pixbuf_micro_version=GDK_PIXBUF_MICRO; +const guint gdk_pixbuf_major_version = GDK_PIXBUF_MAJOR; +const guint gdk_pixbuf_minor_version = GDK_PIXBUF_MINOR; +const guint gdk_pixbuf_micro_version = GDK_PIXBUF_MICRO; const char *gdk_pixbuf_version = GDK_PIXBUF_VERSION; void -gdk_pixbuf_preinit(gpointer app, gpointer modinfo) +gdk_pixbuf_preinit (gpointer app, gpointer modinfo) { } void -gdk_pixbuf_postinit(gpointer app, gpointer modinfo) +gdk_pixbuf_postinit (gpointer app, gpointer modinfo) { } diff --git a/gdk-pixbuf/gdk-pixbuf.h b/gdk-pixbuf/gdk-pixbuf.h index aca5ab36b..5b82e086b 100644 --- a/gdk-pixbuf/gdk-pixbuf.h +++ b/gdk-pixbuf/gdk-pixbuf.h @@ -5,6 +5,7 @@ * Authors: Mark Crichton <crichton@gimp.org> * Miguel de Icaza <miguel@gnu.org> * Federico Mena-Quintero <federico@gimp.org> + * Havoc Pennington <hp@redhat.com> * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Library General Public @@ -25,9 +26,6 @@ #ifndef GDK_PIXBUF_H #define GDK_PIXBUF_H -#include <libart_lgpl/art_misc.h> -#include <libart_lgpl/art_pixbuf.h> -#include <libart_lgpl/art_filterlevel.h> #include <gdk/gdk.h> #ifdef __cplusplus @@ -36,98 +34,76 @@ extern "C" { #include <gdk-pixbuf/gdk-pixbuf-features.h> -/* GdkPixbuf structures */ -typedef struct _GdkPixbuf GdkPixbuf; -typedef struct _GdkPixbufFrame GdkPixbufFrame; -typedef struct _GdkPixbufAnimation GdkPixbufAnimation; - -struct _GdkPixbuf { - /* Reference count */ - int ref_count; - - /* Libart pixbuf */ - ArtPixBuf *art_pixbuf; -}; + -/* GIF-like animation overlay modes for frames */ +/* Color spaces; right now only RGB is supported */ typedef enum { - GDK_PIXBUF_FRAME_RETAIN, - GDK_PIXBUF_FRAME_DISPOSE, - GDK_PIXBUF_FRAME_REVERT -} GdkPixbufFrameAction; - -struct _GdkPixbufFrame { - /* The pixbuf with this frame's image data */ - GdkPixbuf *pixbuf; - - /* Offsets for overlaying onto the animation's area */ - int x_offset; - int y_offset; - - /* Frame duration in ms */ - int delay_time; - - /* Overlay mode */ - GdkPixbufFrameAction action; -}; - -struct _GdkPixbufAnimation { - /* Reference count */ - int ref_count; + GDK_COLORSPACE_RGB +} GdkColorspace; - /* Number of frames */ - int n_frames; - - /* List of GdkPixbufFrame structures */ - GList *frames; +/* All of these are opaque structures */ +typedef struct _GdkPixbuf GdkPixbuf; +typedef struct _GdkPixbufFrame GdkPixbufFrame; +typedef struct _GdkPixbufAnimation GdkPixbufAnimation; - /* bounding box size */ - int width, height; -}; +typedef void (* GdkPixbufDestroyNotify) (guchar *pixels, gpointer data); -/* Convenience functions */ - -ArtPixFormat gdk_pixbuf_get_format (GdkPixbuf *pixbuf); -int gdk_pixbuf_get_n_channels (GdkPixbuf *pixbuf); -gboolean gdk_pixbuf_get_has_alpha (GdkPixbuf *pixbuf); -int gdk_pixbuf_get_bits_per_sample (GdkPixbuf *pixbuf); -guchar *gdk_pixbuf_get_pixels (GdkPixbuf *pixbuf); -int gdk_pixbuf_get_width (GdkPixbuf *pixbuf); -int gdk_pixbuf_get_height (GdkPixbuf *pixbuf); -int gdk_pixbuf_get_rowstride (GdkPixbuf *pixbuf); - /* Reference counting */ GdkPixbuf *gdk_pixbuf_ref (GdkPixbuf *pixbuf); void gdk_pixbuf_unref (GdkPixbuf *pixbuf); -/* Wrap a libart pixbuf */ -GdkPixbuf *gdk_pixbuf_new_from_art_pixbuf (ArtPixBuf *art_pixbuf); +/* GdkPixbuf accessors */ + +GdkColorspace gdk_pixbuf_get_colorspace (const GdkPixbuf *pixbuf); +int gdk_pixbuf_get_n_channels (const GdkPixbuf *pixbuf); +gboolean gdk_pixbuf_get_has_alpha (const GdkPixbuf *pixbuf); +int gdk_pixbuf_get_bits_per_sample (const GdkPixbuf *pixbuf); +guchar *gdk_pixbuf_get_pixels (const GdkPixbuf *pixbuf); +int gdk_pixbuf_get_width (const GdkPixbuf *pixbuf); +int gdk_pixbuf_get_height (const GdkPixbuf *pixbuf); +int gdk_pixbuf_get_rowstride (const GdkPixbuf *pixbuf); + + /* Create a blank pixbuf with an optimal rowstride and a new buffer */ -GdkPixbuf *gdk_pixbuf_new (ArtPixFormat format, gboolean has_alpha, int bits_per_sample, +GdkPixbuf *gdk_pixbuf_new (GdkColorspace colorspace, gboolean has_alpha, int bits_per_sample, int width, int height); +/* Copy a pixbuf */ + +GdkPixbuf *gdk_pixbuf_copy (const GdkPixbuf *pixbuf); + /* Simple loading */ GdkPixbuf *gdk_pixbuf_new_from_file (const char *filename); GdkPixbuf *gdk_pixbuf_new_from_data (const guchar *data, - ArtPixFormat format, + GdkColorspace colorspace, gboolean has_alpha, + int bits_per_sample, int width, int height, int rowstride, - ArtDestroyNotify dfunc, - gpointer dfunc_data); + GdkPixbufDestroyNotify destroy_fn, + gpointer destroy_fn_data); GdkPixbuf *gdk_pixbuf_new_from_xpm_data (const char **data); /* Adding an alpha channel */ -GdkPixbuf *gdk_pixbuf_add_alpha (GdkPixbuf *pixbuf, gboolean substitute_color, +GdkPixbuf *gdk_pixbuf_add_alpha (const GdkPixbuf *pixbuf, gboolean substitute_color, guchar r, guchar g, guchar b); +/* Copy an area of a pixbuf onto another one */ +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); + + + /* Rendering to a drawable */ /* Alpha compositing mode */ @@ -159,26 +135,29 @@ void gdk_pixbuf_render_to_drawable_alpha (GdkPixbuf *pixbuf, GdkDrawable *drawab GdkRgbDither dither, int x_dither, int y_dither); -void gdk_pixbuf_render_pixmap_and_mask (GdkPixbuf *pixbuf, - GdkPixmap **pixmap_return, GdkBitmap **mask_return, - int alpha_threshold); +void gdk_pixbuf_render_pixmap_and_mask (GdkPixbuf *pixbuf, + GdkPixmap **pixmap_return, GdkBitmap **mask_return, + int alpha_threshold); /* Fetching a region from a drawable */ -GdkPixbuf *gdk_pixbuf_get_from_drawable (GdkPixbuf *dest, - GdkDrawable *src, GdkColormap *cmap, - int src_x, int src_y, - int dest_x, int dest_y, - int width, int height); +GdkPixbuf *gdk_pixbuf_get_from_drawable (GdkPixbuf *dest, + GdkDrawable *src, GdkColormap *cmap, + int src_x, int src_y, + int dest_x, int dest_y, + int width, int height); -/* Copy an area of a pixbuf onto another one */ -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); + /* Scaling */ +/* Interpolation modes */ +typedef enum { + GDK_INTERP_NEAREST, + GDK_INTERP_TILES, + GDK_INTERP_BILINEAR, + GDK_INTERP_HYPER +} GdkInterpType; + void gdk_pixbuf_scale (const GdkPixbuf *src, GdkPixbuf *dest, int dest_x, @@ -189,7 +168,7 @@ void gdk_pixbuf_scale (const GdkPixbuf *src, double offset_y, double scale_x, double scale_y, - ArtFilterLevel filter_level); + GdkInterpType interp_type); void gdk_pixbuf_composite (const GdkPixbuf *src, GdkPixbuf *dest, int dest_x, @@ -200,7 +179,7 @@ void gdk_pixbuf_composite (const GdkPixbuf *src, double offset_y, double scale_x, double scale_y, - ArtFilterLevel filter_level, + GdkInterpType interp_type, int overall_alpha); void gdk_pixbuf_composite_color (const GdkPixbuf *src, GdkPixbuf *dest, @@ -212,29 +191,39 @@ void gdk_pixbuf_composite_color (const GdkPixbuf *src, double offset_y, double scale_x, double scale_y, - ArtFilterLevel filter_level, + GdkInterpType interp_type, int overall_alpha, int check_x, int check_y, int check_size, - art_u32 color1, - art_u32 color2); + guint32 color1, + guint32 color2); GdkPixbuf *gdk_pixbuf_scale_simple (const GdkPixbuf *src, int dest_width, int dest_height, - ArtFilterLevel filter_level); + GdkInterpType interp_type); + GdkPixbuf *gdk_pixbuf_composite_color_simple (const GdkPixbuf *src, int dest_width, int dest_height, - ArtFilterLevel filter_level, + GdkInterpType interp_type, int overall_alpha, int check_size, - art_u32 color1, - art_u32 color2); + guint32 color1, + guint32 color2); + + /* Animation support */ +/* GIF-like animation overlay modes for frames */ +typedef enum { + GDK_PIXBUF_FRAME_RETAIN, + GDK_PIXBUF_FRAME_DISPOSE, + GDK_PIXBUF_FRAME_REVERT +} GdkPixbufFrameAction; + GdkPixbufAnimation *gdk_pixbuf_animation_new_from_file (const char *filename); GdkPixbufAnimation *gdk_pixbuf_animation_ref (GdkPixbufAnimation *animation); @@ -245,6 +234,15 @@ int gdk_pixbuf_animation_get_height (GdkPixbufAnimation *an GList *gdk_pixbuf_animation_get_frames (GdkPixbufAnimation *animation); int gdk_pixbuf_animation_get_num_frames (GdkPixbufAnimation *animation); +/* Frame accessors */ + +GdkPixbuf *gdk_pixbuf_frame_get_pixbuf (GdkPixbufFrame *frame); +int gdk_pixbuf_frame_get_x_offset (GdkPixbufFrame *frame); +int gdk_pixbuf_frame_get_y_offset (GdkPixbufFrame *frame); +int gdk_pixbuf_frame_get_delay_time (GdkPixbufFrame *frame); +GdkPixbufFrameAction gdk_pixbuf_frame_get_action (GdkPixbufFrame *frame); + + /* General (presently empty) initialization hooks, primarily for gnome-libs */ void gdk_pixbuf_preinit (gpointer app, gpointer modinfo); void gdk_pixbuf_postinit (gpointer app, gpointer modinfo); diff --git a/gdk-pixbuf/gnome-canvas-pixbuf.c b/gdk-pixbuf/gnome-canvas-pixbuf.c index e9410558e..ed6368ad5 100644 --- a/gdk-pixbuf/gnome-canvas-pixbuf.c +++ b/gdk-pixbuf/gnome-canvas-pixbuf.c @@ -24,8 +24,9 @@ #include <math.h> #include <libgnomeui/gnome-canvas.h> #include <libgnomeui/gnome-canvas-util.h> -#include "gdk-pixbuf.h" -#include <libart_lgpl/art_rgb_pixbuf_affine.h> +#include <libart_lgpl/art_rgb_affine.h> +#include <libart_lgpl/art_rgb_rgba_affine.h> +#include "gdk-pixbuf-private.h" #include "gnome-canvas-pixbuf.h" @@ -242,10 +243,9 @@ gnome_canvas_pixbuf_set_arg (GtkObject *object, GtkArg *arg, guint arg_id) pixbuf = GTK_VALUE_POINTER (*arg); if (pixbuf != priv->pixbuf) { if (pixbuf) { - g_return_if_fail (pixbuf->art_pixbuf->format == ART_PIX_RGB); - g_return_if_fail (pixbuf->art_pixbuf->n_channels == 3 - || pixbuf->art_pixbuf->n_channels == 4); - g_return_if_fail (pixbuf->art_pixbuf->bits_per_sample == 8); + g_return_if_fail (pixbuf->colorspace == GDK_COLORSPACE_RGB); + g_return_if_fail (pixbuf->n_channels == 3 || pixbuf->n_channels == 4); + g_return_if_fail (pixbuf->bits_per_sample == 8); gdk_pixbuf_ref (pixbuf); } @@ -451,12 +451,12 @@ compute_viewport_affine (GnomeCanvasPixbuf *gcp, double *viewport_affine, double if (priv->width_set) w = priv->width; else - w = priv->pixbuf->art_pixbuf->width; + w = priv->pixbuf->width; if (priv->height_set) h = priv->height; else - h = priv->pixbuf->art_pixbuf->height; + h = priv->pixbuf->height; /* Convert i_len and j_len into scaling factors */ @@ -468,7 +468,7 @@ compute_viewport_affine (GnomeCanvasPixbuf *gcp, double *viewport_affine, double } else si_len = 1.0; - si_len *= w / priv->pixbuf->art_pixbuf->width; + si_len *= w / priv->pixbuf->width; if (priv->height_in_pixels) { if (j_len > GNOME_CANVAS_EPSILON) @@ -478,7 +478,7 @@ compute_viewport_affine (GnomeCanvasPixbuf *gcp, double *viewport_affine, double } else sj_len = 1.0; - sj_len *= h / priv->pixbuf->art_pixbuf->height; + sj_len *= h / priv->pixbuf->height; /* Calculate translation offsets */ @@ -544,10 +544,10 @@ recompute_bounding_box (GnomeCanvasPixbuf *gcp) } rect.x0 = 0.0; - rect.x1 = priv->pixbuf->art_pixbuf->width; + rect.x1 = priv->pixbuf->width; rect.y0 = 0.0; - rect.y1 = priv->pixbuf->art_pixbuf->height; + rect.y1 = priv->pixbuf->height; gnome_canvas_item_i2c_affine (item, i2c); compute_render_affine (gcp, render_affine, i2c); @@ -611,7 +611,6 @@ static void transform_pixbuf (guchar *dest, int x, int y, int width, int height, int rowstride, GdkPixbuf *pixbuf, double *affine) { - ArtPixBuf *apb; int xx, yy; double inv[6]; guchar *src, *d; @@ -620,8 +619,6 @@ transform_pixbuf (guchar *dest, int x, int y, int width, int height, int rowstri int src_x, src_y; int i; - apb = pixbuf->art_pixbuf; - art_affine_invert (inv, affine); for (yy = 0; yy < height; yy++) { @@ -630,7 +627,7 @@ transform_pixbuf (guchar *dest, int x, int y, int width, int height, int rowstri run_x1 = x; run_x2 = x + width; art_rgb_affine_run (&run_x1, &run_x2, yy + y, - apb->width, apb->height, + pixbuf->width, pixbuf->height, inv); d = dest + yy * rowstride + (run_x1 - x) * 4; @@ -641,12 +638,12 @@ transform_pixbuf (guchar *dest, int x, int y, int width, int height, int rowstri src_x = floor (src_p.x); src_y = floor (src_p.y); - src = apb->pixels + src_y * apb->rowstride + src_x * apb->n_channels; + src = pixbuf->pixels + src_y * pixbuf->rowstride + src_x * pixbuf->n_channels; - for (i = 0; i < apb->n_channels; i++) + for (i = 0; i < pixbuf->n_channels; i++) *d++ = *src++; - if (!apb->has_alpha) + if (!pixbuf->has_alpha) *d++ = 255; /* opaque */ } } @@ -702,7 +699,7 @@ gnome_canvas_pixbuf_draw (GnomeCanvasItem *item, GdkDrawable *drawable, w * 4, priv->pixbuf, render_affine); - pixbuf = gdk_pixbuf_new_from_data (buf, ART_PIX_RGB, TRUE, w, h, w * 4, NULL, NULL); + pixbuf = gdk_pixbuf_new_from_data (buf, GDK_COLORSPACE_RGB, TRUE, 8, w, h, w * 4, NULL, NULL); gdk_pixbuf_render_to_drawable_alpha (pixbuf, drawable, 0, 0, @@ -735,14 +732,28 @@ gnome_canvas_pixbuf_render (GnomeCanvasItem *item, GnomeCanvasBuf *buf) compute_render_affine (gcp, render_affine, i2c); gnome_canvas_buf_ensure_buf (buf); - art_rgb_pixbuf_affine (buf->buf, - buf->rect.x0, buf->rect.y0, buf->rect.x1, buf->rect.y1, - buf->buf_rowstride, - priv->pixbuf->art_pixbuf, - render_affine, - ART_FILTER_NEAREST, NULL); - - buf->is_bg = 0; + if (priv->pixbuf->has_alpha) + art_rgb_rgba_affine (buf->buf, + buf->rect.x0, buf->rect.y0, buf->rect.x1, buf->rect.y1, + buf->buf_rowstride, + priv->pixbuf->pixels, + priv->pixbuf->width, priv->pixbuf->height, + priv->pixbuf->rowstride, + render_affine, + ART_FILTER_NEAREST, + NULL); + else + art_rgb_affine (buf->buf, + buf->rect.x0, buf->rect.y0, buf->rect.x1, buf->rect.y1, + buf->buf_rowstride, + priv->pixbuf->pixels, + priv->pixbuf->width, priv->pixbuf->height, + priv->pixbuf->rowstride, + render_affine, + ART_FILTER_NEAREST, + NULL); + + buf->is_bg = FALSE; } @@ -758,7 +769,6 @@ gnome_canvas_pixbuf_point (GnomeCanvasItem *item, double x, double y, int cx, in ArtPoint c, p; int px, py; double no_hit; - ArtPixBuf *apb; guchar *src; gcp = GNOME_CANVAS_PIXBUF (item); @@ -771,8 +781,6 @@ gnome_canvas_pixbuf_point (GnomeCanvasItem *item, double x, double y, int cx, in if (!priv->pixbuf) return no_hit; - apb = priv->pixbuf->art_pixbuf; - gnome_canvas_item_i2c_affine (item, i2c); compute_render_affine (gcp, render_affine, i2c); art_affine_invert (inv, render_affine); @@ -783,13 +791,13 @@ gnome_canvas_pixbuf_point (GnomeCanvasItem *item, double x, double y, int cx, in px = p.x; py = p.y; - if (px < 0 || px >= apb->width || py < 0 || py >= apb->height) + if (px < 0 || px >= priv->pixbuf->width || py < 0 || py >= priv->pixbuf->height) return no_hit; - if (!apb->has_alpha) + if (!priv->pixbuf->has_alpha) return 0.0; - src = apb->pixels + py * apb->rowstride + px * apb->n_channels; + src = priv->pixbuf->pixels + py * priv->pixbuf->rowstride + px * priv->pixbuf->n_channels; if (src[3] < 128) return no_hit; @@ -817,10 +825,10 @@ gnome_canvas_pixbuf_bounds (GnomeCanvasItem *item, double *x1, double *y1, doubl } rect.x0 = 0.0; - rect.x1 = priv->pixbuf->art_pixbuf->width; + rect.x1 = priv->pixbuf->width; rect.y0 = 0.0; - rect.y1 = priv->pixbuf->art_pixbuf->height; + rect.y1 = priv->pixbuf->height; gnome_canvas_item_i2c_affine (item, i2c); compute_viewport_affine (gcp, viewport_affine, i2c); diff --git a/gdk-pixbuf/io-bmp.c b/gdk-pixbuf/io-bmp.c index 2aa4fb4f3..cf451241d 100644 --- a/gdk-pixbuf/io-bmp.c +++ b/gdk-pixbuf/io-bmp.c @@ -35,12 +35,10 @@ Known bugs: #include <stdio.h> #include <unistd.h> #include <string.h> -#include <gdk-pixbuf/gdk-pixbuf.h> -#include <gdk-pixbuf/gdk-pixbuf-io.h> - - - +#include "gdk-pixbuf-private.h" +#include "gdk-pixbuf-io.h" + /* @@ -287,12 +285,12 @@ static void DecodeHeader(unsigned char *BFH, unsigned char *BIH, if (State->pixbuf == NULL) { if (State->Type == 32) State->pixbuf = - gdk_pixbuf_new(ART_PIX_RGB, TRUE, 8, + gdk_pixbuf_new(GDK_COLORSPACE_RGB, TRUE, 8, (gint) State->Header.width, (gint) State->Header.height); else State->pixbuf = - gdk_pixbuf_new(ART_PIX_RGB, FALSE, 8, + gdk_pixbuf_new(GDK_COLORSPACE_RGB, FALSE, 8, (gint) State->Header.width, (gint) State->Header.height); @@ -387,14 +385,13 @@ static void OneLine32(struct bmp_progressive_state *context) X = 0; if (context->Header.Negative == 0) - Pixels = context->pixbuf->art_pixbuf->pixels + - gdk_pixbuf_get_rowstride(context->pixbuf) * - (context->Header.height - context->Lines - 1); + Pixels = (context->pixbuf->pixels + + context->pixbuf->rowstride * + (context->Header.height - context->Lines - 1)); else - Pixels = - context->pixbuf->art_pixbuf->pixels + - gdk_pixbuf_get_rowstride(context->pixbuf) * - context->Lines; + Pixels = (context->pixbuf->pixels + + context->pixbuf->rowstride * + context->Lines); while (X < context->Header.width) { Pixels[X * 4 + 0] = context->LineBuf[X * 4 + 2]; Pixels[X * 4 + 1] = context->LineBuf[X * 4 + 1]; @@ -412,14 +409,13 @@ static void OneLine24(struct bmp_progressive_state *context) X = 0; if (context->Header.Negative == 0) - Pixels = context->pixbuf->art_pixbuf->pixels + - gdk_pixbuf_get_rowstride(context->pixbuf) * - (context->Header.height - context->Lines - 1); + Pixels = (context->pixbuf->pixels + + context->pixbuf->rowstride * + (context->Header.height - context->Lines - 1)); else - Pixels = - context->pixbuf->art_pixbuf->pixels + - gdk_pixbuf_get_rowstride(context->pixbuf) * - context->Lines; + Pixels = (context->pixbuf->pixels + + context->pixbuf->rowstride * + context->Lines); while (X < context->Header.width) { Pixels[X * 3 + 0] = context->LineBuf[X * 3 + 2]; Pixels[X * 3 + 1] = context->LineBuf[X * 3 + 1]; @@ -436,14 +432,13 @@ static void OneLine8(struct bmp_progressive_state *context) X = 0; if (context->Header.Negative == 0) - Pixels = context->pixbuf->art_pixbuf->pixels + - gdk_pixbuf_get_rowstride(context->pixbuf) * - (context->Header.height - context->Lines - 1); + Pixels = (context->pixbuf->pixels + + context->pixbuf->rowstride * + (context->Header.height - context->Lines - 1)); else - Pixels = - context->pixbuf->art_pixbuf->pixels + - gdk_pixbuf_get_rowstride(context->pixbuf) * - context->Lines; + Pixels = (context->pixbuf->pixels + + context->pixbuf->rowstride * + context->Lines); while (X < context->Header.width) { Pixels[X * 3 + 0] = context->HeaderBuf[4 * context->LineBuf[X] + 56]; @@ -462,14 +457,13 @@ static void OneLine4(struct bmp_progressive_state *context) X = 0; if (context->Header.Negative == 0) - Pixels = context->pixbuf->art_pixbuf->pixels + - gdk_pixbuf_get_rowstride(context->pixbuf) * - (context->Header.height - context->Lines - 1); + Pixels = (context->pixbuf->pixels + + context->pixbuf->rowstride * + (context->Header.height - context->Lines - 1)); else - Pixels = - context->pixbuf->art_pixbuf->pixels + - gdk_pixbuf_get_rowstride(context->pixbuf) * - context->Lines; + Pixels = (context->pixbuf->pixels + + context->pixbuf->rowstride * + context->Lines); while (X < context->Header.width) { guchar Pix; @@ -504,14 +498,13 @@ static void OneLine1(struct bmp_progressive_state *context) X = 0; if (context->Header.Negative == 0) - Pixels = context->pixbuf->art_pixbuf->pixels + - gdk_pixbuf_get_rowstride(context->pixbuf) * - (context->Header.height - context->Lines - 1); + Pixels = (context->pixbuf->pixels + + context->pixbuf->rowstride * + (context->Header.height - context->Lines - 1)); else - Pixels = - context->pixbuf->art_pixbuf->pixels + - gdk_pixbuf_get_rowstride(context->pixbuf) * - context->Lines; + Pixels = (context->pixbuf->pixels + + context->pixbuf->rowstride * + context->Lines); while (X < context->Header.width) { gint Bit; diff --git a/gdk-pixbuf/io-gif.c b/gdk-pixbuf/io-gif.c index 926871a3d..4f3bc8878 100644 --- a/gdk-pixbuf/io-gif.c +++ b/gdk-pixbuf/io-gif.c @@ -59,7 +59,7 @@ #include <config.h> #include <stdio.h> #include <string.h> -#include "gdk-pixbuf.h" +#include "gdk-pixbuf-private.h" #include "gdk-pixbuf-io.h" @@ -666,7 +666,7 @@ gif_get_lzw (GifContext *context) gint v; if (context->pixbuf == NULL) { - context->pixbuf = gdk_pixbuf_new (ART_PIX_RGB, + context->pixbuf = gdk_pixbuf_new (GDK_COLORSPACE_RGB, context->gif89.transparent != -1, 8, context->frame_len, diff --git a/gdk-pixbuf/io-ico.c b/gdk-pixbuf/io-ico.c index 4cb699576..aa78665c7 100644 --- a/gdk-pixbuf/io-ico.c +++ b/gdk-pixbuf/io-ico.c @@ -37,11 +37,10 @@ Known bugs: #include <stdio.h> #include <unistd.h> #include <string.h> -#include "gdk-pixbuf.h" +#include "gdk-pixbuf-private.h" #include "gdk-pixbuf-io.h" - - + /* @@ -345,7 +344,7 @@ static void DecodeHeader(guchar *Data, gint Bytes, if (State->pixbuf == NULL) { State->pixbuf = - gdk_pixbuf_new(ART_PIX_RGB, TRUE, 8, + gdk_pixbuf_new(GDK_COLORSPACE_RGB, TRUE, 8, (gint) State->Header.width, (gint) State->Header.height); @@ -433,13 +432,13 @@ static void OneLine24(struct ico_progressive_state *context) X = 0; if (context->Header.Negative == 0) - Pixels = context->pixbuf->art_pixbuf->pixels + - gdk_pixbuf_get_rowstride(context->pixbuf) * - (context->Header.height - context->Lines - 1); + Pixels = (context->pixbuf->pixels + + context->pixbuf->rowstride * + (context->Header.height - context->Lines - 1)); else - Pixels = context->pixbuf->art_pixbuf->pixels + - gdk_pixbuf_get_rowstride(context->pixbuf) * - context->Lines; + Pixels = (context->pixbuf->pixels + + context->pixbuf->rowstride * + context->Lines); while (X < context->Header.width) { Pixels[X * 4 + 0] = context->LineBuf[X * 3 + 2]; Pixels[X * 4 + 1] = context->LineBuf[X * 3 + 1]; @@ -456,13 +455,13 @@ static void OneLine8(struct ico_progressive_state *context) X = 0; if (context->Header.Negative == 0) - Pixels = context->pixbuf->art_pixbuf->pixels + - gdk_pixbuf_get_rowstride(context->pixbuf) * - (context->Header.height - context->Lines - 1); + Pixels = (context->pixbuf->pixels + + context->pixbuf->rowstride * + (context->Header.height - context->Lines - 1)); else - Pixels = context->pixbuf->art_pixbuf->pixels + - gdk_pixbuf_get_rowstride(context->pixbuf) * - context->Lines; + Pixels = (context->pixbuf->pixels + + context->pixbuf->rowstride * + context->Lines); while (X < context->Header.width) { /* The joys of having a BGR byteorder */ Pixels[X * 4 + 0] = @@ -481,13 +480,13 @@ static void OneLine4(struct ico_progressive_state *context) X = 0; if (context->Header.Negative == 0) - Pixels = context->pixbuf->art_pixbuf->pixels + - gdk_pixbuf_get_rowstride(context->pixbuf) * - (context->Header.height - context->Lines - 1); + Pixels = (context->pixbuf->pixels + + context->pixbuf->rowstride * + (context->Header.height - context->Lines - 1)); else - Pixels = context->pixbuf->art_pixbuf->pixels + - gdk_pixbuf_get_rowstride(context->pixbuf) * - context->Lines; + Pixels = (context->pixbuf->pixels + + context->pixbuf->rowstride * + context->Lines); while (X < context->Header.width) { guchar Pix; @@ -522,13 +521,13 @@ static void OneLine1(struct ico_progressive_state *context) X = 0; if (context->Header.Negative == 0) - Pixels = context->pixbuf->art_pixbuf->pixels + - gdk_pixbuf_get_rowstride(context->pixbuf) * - (context->Header.height - context->Lines - 1); + Pixels = (context->pixbuf->pixels + + context->pixbuf->rowstride * + (context->Header.height - context->Lines - 1)); else - Pixels = context->pixbuf->art_pixbuf->pixels + - gdk_pixbuf_get_rowstride(context->pixbuf) * - context->Lines; + Pixels = (context->pixbuf->pixels + + context->pixbuf->rowstride * + context->Lines); while (X < context->Header.width) { int Bit; @@ -549,13 +548,13 @@ static void OneLineTransp(struct ico_progressive_state *context) X = 0; if (context->Header.Negative == 0) - Pixels = context->pixbuf->art_pixbuf->pixels + - gdk_pixbuf_get_rowstride(context->pixbuf) * - (2*context->Header.height - context->Lines - 1); + Pixels = (context->pixbuf->pixels + + context->pixbuf->rowstride * + (2*context->Header.height - context->Lines - 1)); else - Pixels = context->pixbuf->art_pixbuf->pixels + - gdk_pixbuf_get_rowstride(context->pixbuf) * - (context->Lines-context->Header.height); + Pixels = (context->pixbuf->pixels + + context->pixbuf->rowstride * + (context->Lines-context->Header.height)); while (X < context->Header.width) { int Bit; diff --git a/gdk-pixbuf/io-jpeg.c b/gdk-pixbuf/io-jpeg.c index 0845a3dc3..0a2126925 100644 --- a/gdk-pixbuf/io-jpeg.c +++ b/gdk-pixbuf/io-jpeg.c @@ -47,7 +47,7 @@ #include <string.h> #include <setjmp.h> #include <jpeglib.h> -#include "gdk-pixbuf.h" +#include "gdk-pixbuf-private.h" #include "gdk-pixbuf-io.h" @@ -111,11 +111,11 @@ fatal_error_handler (j_common_ptr cinfo) return; } -/* Destroy notification function for the libart pixbuf */ +/* Destroy notification function for the pixbuf */ static void -free_buffer (gpointer user_data, gpointer data) +free_buffer (guchar *pixels, gpointer data) { - free (data); + free (pixels); } @@ -215,7 +215,7 @@ gdk_pixbuf__jpeg_image_load (FILE *f) jpeg_finish_decompress (&cinfo); jpeg_destroy_decompress (&cinfo); - return gdk_pixbuf_new_from_data (pixels, ART_PIX_RGB, FALSE, + return gdk_pixbuf_new_from_data (pixels, GDK_COLORSPACE_RGB, FALSE, 8, w, h, w * 3, free_buffer, NULL); } @@ -451,8 +451,8 @@ gdk_pixbuf__jpeg_image_load_increment (gpointer data, guchar *buf, guint size) return FALSE; } #endif - context->pixbuf = gdk_pixbuf_new(ART_PIX_RGB, - /*have_alpha*/ FALSE, + context->pixbuf = gdk_pixbuf_new(GDK_COLORSPACE_RGB, + FALSE, 8, cinfo->image_width, cinfo->image_height); @@ -463,7 +463,7 @@ gdk_pixbuf__jpeg_image_load_increment (gpointer data, guchar *buf, guint size) } /* Use pixbuf buffer to store decompressed data */ - context->dptr = context->pixbuf->art_pixbuf->pixels; + context->dptr = context->pixbuf->pixels; /* Notify the client that we are ready to go */ (* context->prepared_func) (context->pixbuf, @@ -497,7 +497,7 @@ gdk_pixbuf__jpeg_image_load_increment (gpointer data, guchar *buf, guint size) rowptr = context->dptr; for (i=0; i < cinfo->rec_outbuf_height; i++) { *lptr++ = rowptr; - rowptr += context->pixbuf->art_pixbuf->rowstride; + rowptr += context->pixbuf->rowstride; } nlines = jpeg_read_scanlines (cinfo, lines, @@ -509,7 +509,7 @@ gdk_pixbuf__jpeg_image_load_increment (gpointer data, guchar *buf, guint size) if (cinfo->output_components == 1) explode_gray_into_buf (cinfo, lines); - context->dptr += nlines * context->pixbuf->art_pixbuf->rowstride; + context->dptr += nlines * context->pixbuf->rowstride; /* send updated signal */ (* context->updated_func) (context->pixbuf, diff --git a/gdk-pixbuf/io-png.c b/gdk-pixbuf/io-png.c index 3ad9bb3fd..451419484 100644 --- a/gdk-pixbuf/io-png.c +++ b/gdk-pixbuf/io-png.c @@ -24,8 +24,9 @@ #include <config.h> #include <stdio.h> +#include <stdlib.h> #include <png.h> -#include "gdk-pixbuf.h" +#include "gdk-pixbuf-private.h" #include "gdk-pixbuf-io.h" @@ -139,11 +140,11 @@ setup_png_transformations(png_structp png_read_ptr, png_infop png_info_ptr, #endif } -/* Destroy notification function for the libart pixbuf */ +/* Destroy notification function for the pixbuf */ static void -free_buffer (gpointer user_data, gpointer data) +free_buffer (guchar *pixels, gpointer data) { - free (data); + free (pixels); } /* Shared library entry point */ @@ -210,11 +211,11 @@ gdk_pixbuf__png_image_load (FILE *f) g_free (rows); if (ctype & PNG_COLOR_MASK_ALPHA) - return gdk_pixbuf_new_from_data (pixels, ART_PIX_RGB, TRUE, + return gdk_pixbuf_new_from_data (pixels, GDK_COLORSPACE_RGB, TRUE, 8, w, h, w * 4, free_buffer, NULL); else - return gdk_pixbuf_new_from_data (pixels, ART_PIX_RGB, FALSE, + return gdk_pixbuf_new_from_data (pixels, GDK_COLORSPACE_RGB, FALSE, 8, w, h, w * 3, free_buffer, NULL); } @@ -371,7 +372,7 @@ gdk_pixbuf__png_image_load_increment(gpointer context, guchar *buf, guint size) /* start and end row were in the same pass */ (lc->update_func)(lc->pixbuf, 0, lc->first_row_seen_in_chunk, - lc->pixbuf->art_pixbuf->width, + lc->pixbuf->width, (lc->last_row_seen_in_chunk - lc->first_row_seen_in_chunk) + 1, lc->notify_user_data); @@ -383,14 +384,14 @@ gdk_pixbuf__png_image_load_increment(gpointer context, guchar *buf, guint size) /* first row to end */ (lc->update_func)(lc->pixbuf, 0, lc->first_row_seen_in_chunk, - lc->pixbuf->art_pixbuf->width, + lc->pixbuf->width, (lc->max_row_seen_in_chunk - lc->first_row_seen_in_chunk) + 1, lc->notify_user_data); /* top to last row */ (lc->update_func)(lc->pixbuf, 0, 0, - lc->pixbuf->art_pixbuf->width, + lc->pixbuf->width, lc->last_row_seen_in_chunk + 1, lc->notify_user_data); } else { @@ -398,7 +399,7 @@ gdk_pixbuf__png_image_load_increment(gpointer context, guchar *buf, guint size) whole image */ (lc->update_func)(lc->pixbuf, 0, 0, - lc->pixbuf->art_pixbuf->width, + lc->pixbuf->width, lc->max_row_seen_in_chunk + 1, lc->notify_user_data); } @@ -439,7 +440,7 @@ png_info_callback (png_structp png_read_ptr, if (color_type & PNG_COLOR_MASK_ALPHA) have_alpha = TRUE; - lc->pixbuf = gdk_pixbuf_new(ART_PIX_RGB, have_alpha, 8, width, height); + lc->pixbuf = gdk_pixbuf_new(GDK_COLORSPACE_RGB, have_alpha, 8, width, height); if (lc->pixbuf == NULL) { /* Failed to allocate memory */ @@ -480,7 +481,7 @@ png_row_callback (png_structp png_read_ptr, lc->last_row_seen_in_chunk = row_num; lc->last_pass_seen_in_chunk = pass_num; - old_row = lc->pixbuf->art_pixbuf->pixels + (row_num * lc->pixbuf->art_pixbuf->rowstride); + old_row = lc->pixbuf->pixels + (row_num * lc->pixbuf->rowstride); png_progressive_combine_row(lc->png_read_ptr, old_row, new_row); } @@ -521,4 +522,3 @@ png_warning_callback(png_structp png_read_ptr, fprintf(stderr, "Warning loading PNG: %s\n", warning_msg); } - diff --git a/gdk-pixbuf/io-pnm.c b/gdk-pixbuf/io-pnm.c index c3ac215fa..7f18b1952 100644 --- a/gdk-pixbuf/io-pnm.c +++ b/gdk-pixbuf/io-pnm.c @@ -26,7 +26,7 @@ #include <stdlib.h> #include <string.h> #include <setjmp.h> -#include "gdk-pixbuf.h" +#include "gdk-pixbuf-private.h" #include "gdk-pixbuf-io.h" @@ -87,11 +87,11 @@ gboolean gdk_pixbuf__pnm_image_load_increment(gpointer context, guchar *buf, gui static void explode_bitmap_into_buf (PnmLoaderContext *context); static void explode_gray_into_buf (PnmLoaderContext *context); -/* Destroy notification function for the libart pixbuf */ +/* Destroy notification function for the pixbuf */ static void -free_buffer (gpointer user_data, gpointer data) +free_buffer (guchar *pixels, gpointer data) { - free (data); + free (pixels); } @@ -675,7 +675,7 @@ gdk_pixbuf__pnm_image_load (FILE *f) break; } - return gdk_pixbuf_new_from_data (context.pixels, ART_PIX_RGB, FALSE, + return gdk_pixbuf_new_from_data (context.pixels, GDK_COLORSPACE_RGB, FALSE, 8, context.width, context.height, context.width * 3, free_buffer, NULL); @@ -807,8 +807,8 @@ gdk_pixbuf__pnm_image_load_increment (gpointer data, guchar *buf, guint size) context->output_row = 0; context->output_col = 0; - context->pixbuf = gdk_pixbuf_new(ART_PIX_RGB, - /*have_alpha*/ FALSE, + context->pixbuf = gdk_pixbuf_new(GDK_COLORSPACE_RGB, + FALSE, 8, context->width, context->height); @@ -818,8 +818,8 @@ gdk_pixbuf__pnm_image_load_increment (gpointer data, guchar *buf, guint size) g_error ("Couldn't allocate gdkpixbuf"); } - context->pixels = context->pixbuf->art_pixbuf->pixels; - context->rowstride = context->pixbuf->art_pixbuf->rowstride; + context->pixels = context->pixbuf->pixels; + context->rowstride = context->pixbuf->rowstride; /* Notify the client that we are ready to go */ (* context->prepared_func) (context->pixbuf, diff --git a/gdk-pixbuf/io-ras.c b/gdk-pixbuf/io-ras.c index f14fea339..b019a5ebb 100644 --- a/gdk-pixbuf/io-ras.c +++ b/gdk-pixbuf/io-ras.c @@ -34,12 +34,11 @@ Known bugs: #include <stdio.h> #include <unistd.h> #include <string.h> -#include "gdk-pixbuf.h" +#include "gdk-pixbuf-private.h" #include "gdk-pixbuf-io.h" - /* Header structure for sunras files. All values are in big-endian order on disk @@ -171,7 +170,7 @@ static void RAS2State(struct rasterfile *RAS, if (State->pixbuf == NULL) { if (State->RasType == 32) - State->pixbuf = gdk_pixbuf_new(ART_PIX_RGB, TRUE, + State->pixbuf = gdk_pixbuf_new(GDK_COLORSPACE_RGB, TRUE, 8, (gint) State->Header.width, @@ -180,7 +179,7 @@ static void RAS2State(struct rasterfile *RAS, height); else State->pixbuf = - gdk_pixbuf_new(ART_PIX_RGB, FALSE, 8, + gdk_pixbuf_new(GDK_COLORSPACE_RGB, FALSE, 8, (gint) State->Header.width, (gint) State->Header.height); if (State->prepared_func != NULL) @@ -278,8 +277,7 @@ static void OneLine32(struct ras_progressive_state *context) guchar *Pixels; X = 0; - Pixels = context->pixbuf->art_pixbuf->pixels + - context->pixbuf->art_pixbuf->rowstride * context->Lines; + Pixels = context->pixbuf->pixels + context->pixbuf->rowstride * context->Lines; while (X < context->Header.width) { /* The joys of having a BGR byteorder */ Pixels[X * 4 + 0] = context->LineBuf[X * 4 + 2]; @@ -296,8 +294,7 @@ static void OneLine24(struct ras_progressive_state *context) guchar *Pixels; X = 0; - Pixels = context->pixbuf->art_pixbuf->pixels + - context->pixbuf->art_pixbuf->rowstride * context->Lines; + Pixels = context->pixbuf->pixels + context->pixbuf->rowstride * context->Lines; while (X < context->Header.width) { /* The joys of having a BGR byteorder */ Pixels[X * 3 + 0] = context->LineBuf[X * 3 + 2]; @@ -314,8 +311,7 @@ static void OneLine8(struct ras_progressive_state *context) guchar *Pixels; X = 0; - Pixels = context->pixbuf->art_pixbuf->pixels + - context->pixbuf->art_pixbuf->rowstride * context->Lines; + Pixels = context->pixbuf->pixels + context->pixbuf->rowstride * context->Lines; while (X < context->Header.width) { /* The joys of having a BGR byteorder */ Pixels[X * 3 + 0] = @@ -334,8 +330,7 @@ static void OneLine1(struct ras_progressive_state *context) guchar *Pixels; X = 0; - Pixels = context->pixbuf->art_pixbuf->pixels + - context->pixbuf->art_pixbuf->rowstride * context->Lines; + Pixels = context->pixbuf->pixels + context->pixbuf->rowstride * context->Lines; while (X < context->Header.width) { int Bit; diff --git a/gdk-pixbuf/io-tiff.c b/gdk-pixbuf/io-tiff.c index 587ecf855..602adb846 100644 --- a/gdk-pixbuf/io-tiff.c +++ b/gdk-pixbuf/io-tiff.c @@ -30,7 +30,7 @@ #include <string.h> #include <unistd.h> #include <tiffio.h> -#include "gdk-pixbuf.h" +#include "gdk-pixbuf-private.h" #include "gdk-pixbuf-io.h" @@ -68,7 +68,7 @@ gdk_pixbuf__tiff_image_load_real (FILE *f, TiffData *context) TIFFGetField (tiff, TIFFTAG_IMAGEWIDTH, &w); TIFFGetField (tiff, TIFFTAG_IMAGELENGTH, &h); num_pixs = w * h; - pixbuf = gdk_pixbuf_new (ART_PIX_RGB, TRUE, 8, w, h); + pixbuf = gdk_pixbuf_new (GDK_COLORSPACE_RGB, TRUE, 8, w, h); if (context) (* context->prepare_func) (pixbuf, context->user_data); diff --git a/gdk-pixbuf/io-xpm.c b/gdk-pixbuf/io-xpm.c index f6fd6a9be..e6b80dab8 100644 --- a/gdk-pixbuf/io-xpm.c +++ b/gdk-pixbuf/io-xpm.c @@ -24,10 +24,11 @@ #include <config.h> #include <stdio.h> +#include <stdlib.h> #include <string.h> #include <glib.h> #include <gdk/gdk.h> -#include "gdk-pixbuf.h" +#include "gdk-pixbuf-private.h" @@ -309,11 +310,11 @@ mem_buffer (enum buf_op op, gpointer handle) return NULL; } -/* Destroy notification function for the libart pixbuf */ +/* Destroy notification function for the pixbuf */ static void -free_buffer (gpointer user_data, gpointer data) +free_buffer (guchar *pixels, gpointer data) { - free (data); + free (pixels); } /* This function does all the work. */ @@ -429,7 +430,7 @@ pixbuf_create_from_xpm (const gchar * (*get_buf) (enum buf_op op, gpointer handl g_free (colors); g_free (name_buf); - return gdk_pixbuf_new_from_data (pixels, ART_PIX_RGB, is_trans, + return gdk_pixbuf_new_from_data (pixels, GDK_COLORSPACE_RGB, is_trans, 8, w, h, is_trans ? (w * 4) : (w * 3), free_buffer, NULL); } diff --git a/gdk-pixbuf/pixops/Makefile.am b/gdk-pixbuf/pixops/Makefile.am index 9cdb3b319..3d5bce8a8 100644 --- a/gdk-pixbuf/pixops/Makefile.am +++ b/gdk-pixbuf/pixops/Makefile.am @@ -1,6 +1,6 @@ noinst_LTLIBRARIES = libpixops.la -INCLUDES = $(GLIB_CFLAGS) $(LIBART_CFLAGS) +INCLUDES = $(GLIB_CFLAGS) $(LIBART_CFLAGS) -I$(top_srcdir)/gdk-pixbuf noinst_PROGRAMS = timescale diff --git a/gdk-pixbuf/pixops/pixops-internal.h b/gdk-pixbuf/pixops/pixops-internal.h index b6ed3c059..bb0440f5a 100644 --- a/gdk-pixbuf/pixops/pixops-internal.h +++ b/gdk-pixbuf/pixops/pixops-internal.h @@ -1,7 +1,7 @@ #ifdef USE_MMX -art_u8 *pixops_scale_line_22_33_mmx (art_u32 weights[16][8], art_u8 *p, art_u8 *q1, art_u8 *q2, int x_step, art_u8 *p_stop, int x_init); -art_u8 *pixops_composite_line_22_4a4_mmx (art_u32 weights[16][8], art_u8 *p, art_u8 *q1, art_u8 *q2, int x_step, art_u8 *p_stop, int x_init); -art_u8 *pixops_composite_line_color_22_4a4_mmx (art_u32 weights[16][8], art_u8 *p, art_u8 *q1, art_u8 *q2, int x_step, art_u8 *p_stop, int x_init, int dest_x, int check_shift, int *colors); +guchar *pixops_scale_line_22_33_mmx (guint32 weights[16][8], guchar *p, guchar *q1, guchar *q2, int x_step, guchar *p_stop, int x_init); +guchar *pixops_composite_line_22_4a4_mmx (guint32 weights[16][8], guchar *p, guchar *q1, guchar *q2, int x_step, guchar *p_stop, int x_init); +guchar *pixops_composite_line_color_22_4a4_mmx (guint32 weights[16][8], guchar *p, guchar *q1, guchar *q2, int x_step, guchar *p_stop, int x_init, int dest_x, int check_shift, int *colors); int pixops_have_mmx (void); #endif diff --git a/gdk-pixbuf/pixops/pixops.c b/gdk-pixbuf/pixops/pixops.c index 78bf44eda..040f1df6d 100644 --- a/gdk-pixbuf/pixops/pixops.c +++ b/gdk-pixbuf/pixops/pixops.c @@ -21,15 +21,15 @@ struct _PixopsFilter double y_offset; }; -typedef art_u8 *(*PixopsLineFunc) (int *weights, int n_x, int n_y, - art_u8 *dest, int dest_x, art_u8 *dest_end, int dest_channels, int dest_has_alpha, - art_u8 **src, int src_channels, art_boolean src_has_alpha, +typedef guchar *(*PixopsLineFunc) (int *weights, int n_x, int n_y, + guchar *dest, int dest_x, guchar *dest_end, int dest_channels, int dest_has_alpha, + guchar **src, int src_channels, gboolean src_has_alpha, int x_init, int x_step, int src_width, - int check_size, art_u32 color1, art_u32 color2); + int check_size, guint32 color1, guint32 color2); -typedef void (*PixopsPixelFunc) (art_u8 *dest, int dest_x, int dest_channels, int dest_has_alpha, - int src_has_alpha, int check_size, art_u32 color1, - art_u32 color2, +typedef void (*PixopsPixelFunc) (guchar *dest, int dest_x, int dest_channels, int dest_has_alpha, + int src_has_alpha, int check_size, guint32 color1, + guint32 color2, int r, int g, int b, int a); static int @@ -48,20 +48,20 @@ get_check_shift (int check_size) } static void -pixops_scale_nearest (art_u8 *dest_buf, +pixops_scale_nearest (guchar *dest_buf, int render_x0, int render_y0, int render_x1, int render_y1, int dest_rowstride, int dest_channels, - art_boolean dest_has_alpha, - const art_u8 *src_buf, + gboolean dest_has_alpha, + const guchar *src_buf, int src_width, int src_height, int src_rowstride, int src_channels, - art_boolean src_has_alpha, + gboolean src_has_alpha, double scale_x, double scale_y) { @@ -73,7 +73,7 @@ pixops_scale_nearest (art_u8 *dest_buf, #define INNER_LOOP(SRC_CHANNELS,DEST_CHANNELS) \ for (j=0; j < (render_x1 - render_x0); j++) \ { \ - const art_u8 *p = src + (x >> SCALE_SHIFT) * SRC_CHANNELS; \ + const guchar *p = src + (x >> SCALE_SHIFT) * SRC_CHANNELS; \ \ dest[0] = p[0]; \ dest[1] = p[1]; \ @@ -93,8 +93,8 @@ pixops_scale_nearest (art_u8 *dest_buf, for (i = 0; i < (render_y1 - render_y0); i++) { - const art_u8 *src = src_buf + ((i * y_step + y_step / 2) >> SCALE_SHIFT) * src_rowstride; - art_u8 *dest = dest_buf + i * dest_rowstride; + const guchar *src = src_buf + ((i * y_step + y_step / 2) >> SCALE_SHIFT) * src_rowstride; + guchar *dest = dest_buf + i * dest_rowstride; x = render_x0 * x_step + x_step / 2; @@ -119,34 +119,36 @@ pixops_scale_nearest (art_u8 *dest_buf, { for (j=0; j < (render_x1 - render_x0); j++) { - const art_u8 *p = src + (x >> SCALE_SHIFT) * 4; + const guchar *p = src + (x >> SCALE_SHIFT) * 4; + guint32 *p32; + + p32 = (guint32 *) dest; + *p32 = *((guint32 *) p); - *(art_u32 *)dest = *(art_u32 *)p; - dest += 4; x += x_step; } } } } -#undef INNER_LOOP +#undef INNER_LOOP } static void -pixops_composite_nearest (art_u8 *dest_buf, +pixops_composite_nearest (guchar *dest_buf, int render_x0, int render_y0, int render_x1, int render_y1, int dest_rowstride, int dest_channels, - art_boolean dest_has_alpha, - const art_u8 *src_buf, + gboolean dest_has_alpha, + const guchar *src_buf, int src_width, int src_height, int src_rowstride, int src_channels, - art_boolean src_has_alpha, + gboolean src_has_alpha, double scale_x, double scale_y, int overall_alpha) @@ -158,14 +160,14 @@ pixops_composite_nearest (art_u8 *dest_buf, for (i = 0; i < (render_y1 - render_y0); i++) { - const art_u8 *src = src_buf + (((i + render_y0) * y_step + y_step / 2) >> SCALE_SHIFT) * src_rowstride; - art_u8 *dest = dest_buf + i * dest_rowstride + render_x0 * dest_channels; + const guchar *src = src_buf + (((i + render_y0) * y_step + y_step / 2) >> SCALE_SHIFT) * src_rowstride; + guchar *dest = dest_buf + i * dest_rowstride + render_x0 * dest_channels; x = render_x0 * x_step + x_step / 2; for (j=0; j < (render_x1 - render_x0); j++) { - const art_u8 *p = src + (x >> SCALE_SHIFT) * src_channels; + const guchar *p = src + (x >> SCALE_SHIFT) * src_channels; unsigned int a0; if (src_has_alpha) @@ -210,28 +212,28 @@ pixops_composite_nearest (art_u8 *dest_buf, } static void -pixops_composite_color_nearest (art_u8 *dest_buf, +pixops_composite_color_nearest (guchar *dest_buf, int render_x0, int render_y0, int render_x1, int render_y1, int dest_rowstride, int dest_channels, - art_boolean dest_has_alpha, - const art_u8 *src_buf, + gboolean dest_has_alpha, + const guchar *src_buf, int src_width, int src_height, int src_rowstride, int src_channels, - art_boolean src_has_alpha, + gboolean src_has_alpha, double scale_x, double scale_y, int overall_alpha, int check_x, int check_y, int check_size, - art_u32 color1, - art_u32 color2) + guint32 color1, + guint32 color2) { int i, j; int x; @@ -242,8 +244,8 @@ pixops_composite_color_nearest (art_u8 *dest_buf, for (i = 0; i < (render_y1 - render_y0); i++) { - const art_u8 *src = src_buf + (((i + render_y0) * y_step + y_step/2) >> SCALE_SHIFT) * src_rowstride; - art_u8 *dest = dest_buf + i * dest_rowstride; + const guchar *src = src_buf + (((i + render_y0) * y_step + y_step/2) >> SCALE_SHIFT) * src_rowstride; + guchar *dest = dest_buf + i * dest_rowstride; x = render_x0 * x_step + x_step / 2; @@ -270,7 +272,7 @@ pixops_composite_color_nearest (art_u8 *dest_buf, for (j=0 ; j < (render_x1 - render_x0); j++) { - const art_u8 *p = src + (x >> SCALE_SHIFT) * src_channels; + const guchar *p = src + (x >> SCALE_SHIFT) * src_channels; unsigned int a0; if (src_has_alpha) @@ -301,8 +303,8 @@ pixops_composite_color_nearest (art_u8 *dest_buf, } static void -composite_pixel (art_u8 *dest, int dest_x, int dest_channels, int dest_has_alpha, - int src_has_alpha, int check_size, art_u32 color1, art_u32 color2, +composite_pixel (guchar *dest, int dest_x, int dest_channels, int dest_has_alpha, + int src_has_alpha, int check_size, guint32 color1, guint32 color2, int r, int g, int b, int a) { if (dest_has_alpha) @@ -333,12 +335,12 @@ composite_pixel (art_u8 *dest, int dest_x, int dest_channels, int dest_has_alpha } } -static art_u8 * +static guchar * composite_line (int *weights, int n_x, int n_y, - art_u8 *dest, int dest_x, art_u8 *dest_end, int dest_channels, int dest_has_alpha, - art_u8 **src, int src_channels, art_boolean src_has_alpha, + guchar *dest, int dest_x, guchar *dest_end, int dest_channels, int dest_has_alpha, + guchar **src, int src_channels, gboolean src_has_alpha, int x_init, int x_step, int src_width, - int check_size, art_u32 color1, art_u32 color2) + int check_size, guint32 color1, guint32 color2) { int x = x_init; int i, j; @@ -353,7 +355,7 @@ composite_line (int *weights, int n_x, int n_y, for (i=0; i<n_y; i++) { - art_u8 *q = src[i] + x_scaled * src_channels; + guchar *q = src[i] + x_scaled * src_channels; int *line_weights = pixel_weights + n_x * i; for (j=0; j<n_x; j++) @@ -408,16 +410,16 @@ composite_line (int *weights, int n_x, int n_y, return dest; } -static art_u8 * +static guchar * composite_line_22_4a4 (int *weights, int n_x, int n_y, - art_u8 *dest, int dest_x, art_u8 *dest_end, int dest_channels, int dest_has_alpha, - art_u8 **src, int src_channels, art_boolean src_has_alpha, + guchar *dest, int dest_x, guchar *dest_end, int dest_channels, int dest_has_alpha, + guchar **src, int src_channels, gboolean src_has_alpha, int x_init, int x_step, int src_width, - int check_size, art_u32 color1, art_u32 color2) + int check_size, guint32 color1, guint32 color2) { int x = x_init; - art_u8 *src0 = src[0]; - art_u8 *src1 = src[1]; + guchar *src0 = src[0]; + guchar *src1 = src[1]; g_return_val_if_fail (src_channels != 3, dest); g_return_val_if_fail (src_has_alpha, dest); @@ -427,7 +429,7 @@ composite_line_22_4a4 (int *weights, int n_x, int n_y, int x_scaled = x >> SCALE_SHIFT; unsigned int r, g, b, a, ta; int *pixel_weights; - art_u8 *q0, *q1; + guchar *q0, *q1; int w1, w2, w3, w4; q0 = src0 + x_scaled * 4; @@ -476,14 +478,14 @@ composite_line_22_4a4 (int *weights, int n_x, int n_y, } #ifdef USE_MMX -static art_u8 * +static guchar * composite_line_22_4a4_mmx_stub (int *weights, int n_x, int n_y, - art_u8 *dest, int dest_x, art_u8 *dest_end, int dest_channels, int dest_has_alpha, - art_u8 **src, int src_channels, art_boolean src_has_alpha, + guchar *dest, int dest_x, guchar *dest_end, int dest_channels, int dest_has_alpha, + guchar **src, int src_channels, gboolean src_has_alpha, int x_init, int x_step, int src_width, - int check_size, art_u32 color1, art_u32 color2) + int check_size, guint32 color1, guint32 color2) { - art_u32 mmx_weights[16][8]; + guint32 mmx_weights[16][8]; int j; for (j=0; j<16; j++) @@ -503,8 +505,8 @@ composite_line_22_4a4_mmx_stub (int *weights, int n_x, int n_y, #endif /* USE_MMX */ static void -composite_pixel_color (art_u8 *dest, int dest_x, int dest_channels, int dest_has_alpha, - int src_has_alpha, int check_size, art_u32 color1, art_u32 color2, +composite_pixel_color (guchar *dest, int dest_x, int dest_channels, int dest_has_alpha, + int src_has_alpha, int check_size, guint32 color1, guint32 color2, int r, int g, int b, int a) { int dest_r, dest_g, dest_b; @@ -533,12 +535,12 @@ composite_pixel_color (art_u8 *dest, int dest_x, int dest_channels, int dest_has dest[3] = a >> 16; } -static art_u8 * +static guchar * composite_line_color (int *weights, int n_x, int n_y, - art_u8 *dest, int dest_x, art_u8 *dest_end, int dest_channels, int dest_has_alpha, - art_u8 **src, int src_channels, art_boolean src_has_alpha, + guchar *dest, int dest_x, guchar *dest_end, int dest_channels, int dest_has_alpha, + guchar **src, int src_channels, gboolean src_has_alpha, int x_init, int x_step, int src_width, - int check_size, art_u32 color1, art_u32 color2) + int check_size, guint32 color1, guint32 color2) { int x = x_init; int i, j; @@ -566,7 +568,7 @@ composite_line_color (int *weights, int n_x, int n_y, for (i=0; i<n_y; i++) { - art_u8 *q = src[i] + x_scaled * src_channels; + guchar *q = src[i] + x_scaled * src_channels; int *line_weights = pixel_weights + n_x * i; for (j=0; j<n_x; j++) @@ -614,14 +616,14 @@ composite_line_color (int *weights, int n_x, int n_y, } #ifdef USE_MMX -static art_u8 * +static guchar * composite_line_color_22_4a4_mmx_stub (int *weights, int n_x, int n_y, - art_u8 *dest, int dest_x, art_u8 *dest_end, int dest_channels, int dest_has_alpha, - art_u8 **src, int src_channels, art_boolean src_has_alpha, + guchar *dest, int dest_x, guchar *dest_end, int dest_channels, int dest_has_alpha, + guchar **src, int src_channels, gboolean src_has_alpha, int x_init, int x_step, int src_width, - int check_size, art_u32 color1, art_u32 color2) + int check_size, guint32 color1, guint32 color2) { - art_u32 mmx_weights[16][8]; + guint32 mmx_weights[16][8]; int check_shift = get_check_shift (check_size); int colors[4]; int j; @@ -649,8 +651,8 @@ composite_line_color_22_4a4_mmx_stub (int *weights, int n_x, int n_y, #endif /* USE_MMX */ static void -scale_pixel (art_u8 *dest, int dest_x, int dest_channels, int dest_has_alpha, - int src_has_alpha, int check_size, art_u32 color1, art_u32 color2, +scale_pixel (guchar *dest, int dest_x, int dest_channels, int dest_has_alpha, + int src_has_alpha, int check_size, guint32 color1, guint32 color2, int r, int g, int b, int a) { if (src_has_alpha) @@ -681,12 +683,12 @@ scale_pixel (art_u8 *dest, int dest_x, int dest_channels, int dest_has_alpha, } } -static art_u8 * +static guchar * scale_line (int *weights, int n_x, int n_y, - art_u8 *dest, int dest_x, art_u8 *dest_end, int dest_channels, int dest_has_alpha, - art_u8 **src, int src_channels, art_boolean src_has_alpha, + guchar *dest, int dest_x, guchar *dest_end, int dest_channels, int dest_has_alpha, + guchar **src, int src_channels, gboolean src_has_alpha, int x_init, int x_step, int src_width, - int check_size, art_u32 color1, art_u32 color2) + int check_size, guint32 color1, guint32 color2) { int x = x_init; int i, j; @@ -703,7 +705,7 @@ scale_line (int *weights, int n_x, int n_y, unsigned int r = 0, g = 0, b = 0, a = 0; for (i=0; i<n_y; i++) { - art_u8 *q = src[i] + x_scaled * src_channels; + guchar *q = src[i] + x_scaled * src_channels; int *line_weights = pixel_weights + n_x * i; for (j=0; j<n_x; j++) @@ -740,7 +742,7 @@ scale_line (int *weights, int n_x, int n_y, unsigned int r = 0, g = 0, b = 0; for (i=0; i<n_y; i++) { - art_u8 *q = src[i] + x_scaled * src_channels; + guchar *q = src[i] + x_scaled * src_channels; int *line_weights = pixel_weights + n_x * i; for (j=0; j<n_x; j++) @@ -772,14 +774,14 @@ scale_line (int *weights, int n_x, int n_y, } #ifdef USE_MMX -static art_u8 * +static guchar * scale_line_22_33_mmx_stub (int *weights, int n_x, int n_y, - art_u8 *dest, int dest_x, art_u8 *dest_end, int dest_channels, int dest_has_alpha, - art_u8 **src, int src_channels, art_boolean src_has_alpha, + guchar *dest, int dest_x, guchar *dest_end, int dest_channels, int dest_has_alpha, + guchar **src, int src_channels, gboolean src_has_alpha, int x_init, int x_step, int src_width, - int check_size, art_u32 color1, art_u32 color2) + int check_size, guint32 color1, guint32 color2) { - art_u32 mmx_weights[16][8]; + guint32 mmx_weights[16][8]; int j; for (j=0; j<16; j++) @@ -798,23 +800,23 @@ scale_line_22_33_mmx_stub (int *weights, int n_x, int n_y, } #endif /* USE_MMX */ -static art_u8 * +static guchar * scale_line_22_33 (int *weights, int n_x, int n_y, - art_u8 *dest, art_u8 *dest_end, int dest_channels, int dest_has_alpha, - art_u8 **src, int src_channels, art_boolean src_has_alpha, + guchar *dest, guchar *dest_end, int dest_channels, int dest_has_alpha, + guchar **src, int src_channels, gboolean src_has_alpha, int x_init, int x_step, int src_width, - int check_size, art_u32 color1, art_u32 color2) + int check_size, guint32 color1, guint32 color2) { int x = x_init; - art_u8 *src0 = src[0]; - art_u8 *src1 = src[1]; + guchar *src0 = src[0]; + guchar *src1 = src[1]; while (dest < dest_end) { unsigned int r, g, b; int x_scaled = x >> SCALE_SHIFT; int *pixel_weights; - art_u8 *q0, *q1; + guchar *q0, *q1; int w1, w2, w3, w4; q0 = src0 + x_scaled * 3; @@ -857,10 +859,10 @@ scale_line_22_33 (int *weights, int n_x, int n_y, static void process_pixel (int *weights, int n_x, int n_y, - art_u8 *dest, int dest_x, int dest_channels, int dest_has_alpha, - art_u8 **src, int src_channels, art_boolean src_has_alpha, + guchar *dest, int dest_x, int dest_channels, int dest_has_alpha, + guchar **src, int src_channels, gboolean src_has_alpha, int x_start, int src_width, - int check_size, art_u32 color1, art_u32 color2, + int check_size, guint32 color1, guint32 color2, PixopsPixelFunc pixel_func) { unsigned int r = 0, g = 0, b = 0, a = 0; @@ -873,7 +875,7 @@ process_pixel (int *weights, int n_x, int n_y, for (j=0; j<n_x; j++) { unsigned int ta; - art_u8 *q; + guchar *q; if (x_start + j < 0) q = src[i]; @@ -898,34 +900,34 @@ process_pixel (int *weights, int n_x, int n_y, } static void -pixops_process (art_u8 *dest_buf, +pixops_process (guchar *dest_buf, int render_x0, int render_y0, int render_x1, int render_y1, int dest_rowstride, int dest_channels, - art_boolean dest_has_alpha, - const art_u8 *src_buf, + gboolean dest_has_alpha, + const guchar *src_buf, int src_width, int src_height, int src_rowstride, int src_channels, - art_boolean src_has_alpha, + gboolean src_has_alpha, double scale_x, double scale_y, int check_x, int check_y, int check_size, - art_u32 color1, - art_u32 color2, + guint32 color1, + guint32 color2, PixopsFilter *filter, PixopsLineFunc line_func, PixopsPixelFunc pixel_func) { int i, j; int x, y; - art_u8 **line_bufs = g_new (art_u8 *, filter->n_y); + guchar **line_bufs = g_new (guchar *, filter->n_y); int x_step = (1 << SCALE_SHIFT) / scale_x; int y_step = (1 << SCALE_SHIFT) / scale_y; @@ -942,11 +944,11 @@ pixops_process (art_u8 *dest_buf, int y_start = y >> SCALE_SHIFT; int x_start; int *run_weights = filter->weights + ((y >> (SCALE_SHIFT - SUBSAMPLE_BITS)) & SUBSAMPLE_MASK) * filter->n_x * filter->n_y * SUBSAMPLE; - art_u8 *new_outbuf; - art_u32 tcolor1, tcolor2; + guchar *new_outbuf; + guint32 tcolor1, tcolor2; - art_u8 *outbuf = dest_buf + dest_rowstride * i; - art_u8 *outbuf_end = outbuf + dest_channels * (render_x1 - render_x0); + guchar *outbuf = dest_buf + dest_rowstride * i; + guchar *outbuf_end = outbuf + dest_channels * (render_x1 - render_x0); if (((i + check_y) >> check_shift) & 1) { @@ -962,11 +964,11 @@ pixops_process (art_u8 *dest_buf, for (j=0; j<filter->n_y; j++) { if (y_start < 0) - line_bufs[j] = (art_u8 *)src_buf; + line_bufs[j] = (guchar *)src_buf; else if (y_start < src_height) - line_bufs[j] = (art_u8 *)src_buf + src_rowstride * y_start; + line_bufs[j] = (guchar *)src_buf + src_rowstride * y_start; else - line_bufs[j] = (art_u8 *)src_buf + src_rowstride * (src_height - 1); + line_bufs[j] = (guchar *)src_buf + src_rowstride * (src_height - 1); y_start++; } @@ -1288,35 +1290,35 @@ bilinear_make_weights (PixopsFilter *filter, double x_scale, double y_scale, dou } void -pixops_composite_color (art_u8 *dest_buf, +pixops_composite_color (guchar *dest_buf, int render_x0, int render_y0, int render_x1, int render_y1, int dest_rowstride, int dest_channels, - art_boolean dest_has_alpha, - const art_u8 *src_buf, + gboolean dest_has_alpha, + const guchar *src_buf, int src_width, int src_height, int src_rowstride, int src_channels, - art_boolean src_has_alpha, + gboolean src_has_alpha, double scale_x, double scale_y, - ArtFilterLevel filter_level, + GdkInterpType interp_type, int overall_alpha, int check_x, int check_y, int check_size, - art_u32 color1, - art_u32 color2) + guint32 color1, + guint32 color2) { PixopsFilter filter; PixopsLineFunc line_func; #ifdef USE_MMX - art_boolean found_mmx = pixops_have_mmx(); + gboolean found_mmx = pixops_have_mmx(); #endif g_return_if_fail (!(dest_channels == 3 && dest_has_alpha)); @@ -1329,11 +1331,11 @@ pixops_composite_color (art_u8 *dest_buf, pixops_scale (dest_buf, render_x0, render_y0, render_x1, render_y1, dest_rowstride, dest_channels, dest_has_alpha, src_buf, src_width, src_height, src_rowstride, src_channels, - src_has_alpha, scale_x, scale_y, filter_level); + src_has_alpha, scale_x, scale_y, interp_type); - switch (filter_level) + switch (interp_type) { - case ART_FILTER_NEAREST: + case GDK_INTERP_NEAREST: pixops_composite_color_nearest (dest_buf, render_x0, render_y0, render_x1, render_y1, dest_rowstride, dest_channels, dest_has_alpha, src_buf, src_width, src_height, src_rowstride, src_channels, src_has_alpha, @@ -1341,15 +1343,15 @@ pixops_composite_color (art_u8 *dest_buf, check_x, check_y, check_size, color1, color2); return; - case ART_FILTER_TILES: + case GDK_INTERP_TILES: tile_make_weights (&filter, scale_x, scale_y, overall_alpha / 255.); break; - case ART_FILTER_BILINEAR: + case GDK_INTERP_BILINEAR: bilinear_make_fast_weights (&filter, scale_x, scale_y, overall_alpha / 255.); break; - case ART_FILTER_HYPER: + case GDK_INTERP_HYPER: bilinear_make_weights (&filter, scale_x, scale_y, overall_alpha / 255.); break; } @@ -1372,30 +1374,30 @@ pixops_composite_color (art_u8 *dest_buf, } void -pixops_composite (art_u8 *dest_buf, +pixops_composite (guchar *dest_buf, int render_x0, int render_y0, int render_x1, int render_y1, int dest_rowstride, int dest_channels, - art_boolean dest_has_alpha, - const art_u8 *src_buf, + gboolean dest_has_alpha, + const guchar *src_buf, int src_width, int src_height, int src_rowstride, int src_channels, - art_boolean src_has_alpha, + gboolean src_has_alpha, double scale_x, double scale_y, - ArtFilterLevel filter_level, + GdkInterpType interp_type, int overall_alpha) { PixopsFilter filter; PixopsLineFunc line_func; #ifdef USE_MMX - art_boolean found_mmx = pixops_have_mmx(); + gboolean found_mmx = pixops_have_mmx(); #endif g_return_if_fail (!(dest_channels == 3 && dest_has_alpha)); @@ -1408,26 +1410,26 @@ pixops_composite (art_u8 *dest_buf, pixops_scale (dest_buf, render_x0, render_y0, render_x1, render_y1, dest_rowstride, dest_channels, dest_has_alpha, src_buf, src_width, src_height, src_rowstride, src_channels, - src_has_alpha, scale_x, scale_y, filter_level); + src_has_alpha, scale_x, scale_y, interp_type); - switch (filter_level) + switch (interp_type) { - case ART_FILTER_NEAREST: + case GDK_INTERP_NEAREST: pixops_composite_nearest (dest_buf, render_x0, render_y0, render_x1, render_y1, dest_rowstride, dest_channels, dest_has_alpha, src_buf, src_width, src_height, src_rowstride, src_channels, src_has_alpha, scale_x, scale_y, overall_alpha); return; - case ART_FILTER_TILES: + case GDK_INTERP_TILES: tile_make_weights (&filter, scale_x, scale_y, overall_alpha / 255.); break; - case ART_FILTER_BILINEAR: + case GDK_INTERP_BILINEAR: bilinear_make_fast_weights (&filter, scale_x, scale_y, overall_alpha / 255.); break; - case ART_FILTER_HYPER: + case GDK_INTERP_HYPER: bilinear_make_weights (&filter, scale_x, scale_y, overall_alpha / 255.); break; } @@ -1455,29 +1457,29 @@ pixops_composite (art_u8 *dest_buf, } void -pixops_scale (art_u8 *dest_buf, +pixops_scale (guchar *dest_buf, int render_x0, int render_y0, int render_x1, int render_y1, int dest_rowstride, int dest_channels, - art_boolean dest_has_alpha, - const art_u8 *src_buf, + gboolean dest_has_alpha, + const guchar *src_buf, int src_width, int src_height, int src_rowstride, int src_channels, - art_boolean src_has_alpha, + gboolean src_has_alpha, double scale_x, double scale_y, - ArtFilterLevel filter_level) + GdkInterpType interp_type) { PixopsFilter filter; PixopsLineFunc line_func; #ifdef USE_MMX - art_boolean found_mmx = pixops_have_mmx(); + gboolean found_mmx = pixops_have_mmx(); #endif g_return_if_fail (!(dest_channels == 3 && dest_has_alpha)); @@ -1487,24 +1489,24 @@ pixops_scale (art_u8 *dest_buf, if (scale_x == 0 || scale_y == 0) return; - switch (filter_level) + switch (interp_type) { - case ART_FILTER_NEAREST: + case GDK_INTERP_NEAREST: pixops_scale_nearest (dest_buf, render_x0, render_y0, render_x1, render_y1, dest_rowstride, dest_channels, dest_has_alpha, src_buf, src_width, src_height, src_rowstride, src_channels, src_has_alpha, scale_x, scale_y); return; - case ART_FILTER_TILES: + case GDK_INTERP_TILES: tile_make_weights (&filter, scale_x, scale_y, 1.0); break; - case ART_FILTER_BILINEAR: + case GDK_INTERP_BILINEAR: bilinear_make_fast_weights (&filter, scale_x, scale_y, 1.0); break; - case ART_FILTER_HYPER: + case GDK_INTERP_HYPER: bilinear_make_weights (&filter, scale_x, scale_y, 1.0); break; } diff --git a/gdk-pixbuf/pixops/pixops.h b/gdk-pixbuf/pixops/pixops.h index 193d65918..8aa06b630 100644 --- a/gdk-pixbuf/pixops/pixops.h +++ b/gdk-pixbuf/pixops/pixops.h @@ -1,12 +1,17 @@ -#include <libart_lgpl/art_misc.h> -#include <libart_lgpl/art_filterlevel.h> +#ifndef PIXOPS_H +#define PIXOPS_H + +#include <glib.h> +#include "gdk-pixbuf.h" + + /* Scale src_buf from src_width / src_height by factors scale_x, scale_y * and composite the portion corresponding to * render_x, render_y, render_width, render_height in the new * coordinate system into dest_buf starting at 0, 0 */ -void pixops_composite (art_u8 *dest_buf, +void pixops_composite (guchar *dest_buf, int render_x0, int render_y0, int render_x1, @@ -14,7 +19,7 @@ void pixops_composite (art_u8 *dest_buf, int dest_rowstride, int dest_channels, int dest_has_alpha, - const art_u8 *src_buf, + const guchar *src_buf, int src_width, int src_height, int src_rowstride, @@ -22,7 +27,7 @@ void pixops_composite (art_u8 *dest_buf, int src_has_alpha, double scale_x, double scale_y, - ArtFilterLevel filter_level, + GdkInterpType interp_type, int overall_alpha); /* Scale src_buf from src_width / src_height by factors scale_x, scale_y @@ -31,7 +36,7 @@ void pixops_composite (art_u8 *dest_buf, * coordinate system against a checkboard with checks of size check_size * of the colors color1 and color2 into dest_buf starting at 0, 0 */ -void pixops_composite_color (art_u8 *dest_buf, +void pixops_composite_color (guchar *dest_buf, int render_x0, int render_y0, int render_x1, @@ -39,7 +44,7 @@ void pixops_composite_color (art_u8 *dest_buf, int dest_rowstride, int dest_channels, int dest_has_alpha, - const art_u8 *src_buf, + const guchar *src_buf, int src_width, int src_height, int src_rowstride, @@ -47,20 +52,20 @@ void pixops_composite_color (art_u8 *dest_buf, int src_has_alpha, double scale_x, double scale_y, - ArtFilterLevel filter_level, + GdkInterpType interp_type, int overall_alpha, int check_x, int check_y, int check_size, - art_u32 color1, - art_u32 color2); + guint32 color1, + guint32 color2); /* Scale src_buf from src_width / src_height by factors scale_x, scale_y * and composite the portion corresponding to * render_x, render_y, render_width, render_height in the new * coordinate system into dest_buf starting at 0, 0 */ -void pixops_scale (art_u8 *dest_buf, +void pixops_scale (guchar *dest_buf, int render_x0, int render_y0, int render_x1, @@ -68,7 +73,7 @@ void pixops_scale (art_u8 *dest_buf, int dest_rowstride, int dest_channels, int dest_has_alpha, - const art_u8 *src_buf, + const guchar *src_buf, int src_width, int src_height, int src_rowstride, @@ -76,5 +81,8 @@ void pixops_scale (art_u8 *dest_buf, int src_has_alpha, double scale_x, double scale_y, - ArtFilterLevel filter_level); + GdkInterpType interp_type); + + +#endif diff --git a/gdk-pixbuf/pixops/timescale.c b/gdk-pixbuf/pixops/timescale.c index d0ea25748..b835ff542 100644 --- a/gdk-pixbuf/pixops/timescale.c +++ b/gdk-pixbuf/pixops/timescale.c @@ -76,16 +76,16 @@ dump_array (double times[3][3][4]) switch (j) { - case ART_FILTER_NEAREST: + case GDK_INTERP_NEAREST: printf (" NEAREST\n"); break; - case ART_FILTER_TILES: + case GDK_INTERP_TILES: printf (" TILES\n"); break; - case ART_FILTER_BILINEAR: + case GDK_INTERP_BILINEAR: printf (" BILINEAR\n"); break; - case ART_FILTER_HYPER: + case GDK_INTERP_HYPER: printf (" HYPER\n"); break; } @@ -152,24 +152,24 @@ int main (int argc, char **argv) dest_buf = malloc(dest_rowstride * dest_height); memset (dest_buf, 0x80, dest_rowstride * dest_height); - for (filter_level = ART_FILTER_NEAREST ; filter_level <= ART_FILTER_HYPER; filter_level++) + for (filter_level = GDK_INTERP_NEAREST ; filter_level <= GDK_INTERP_HYPER; filter_level++) { printf ("src_channels = %d (%s); dest_channels = %d (%s); filter_level=", src_channels, src_has_alpha ? "alpha" : "no alpha", dest_channels, dest_has_alpha ? "alpha" : "no alpha"); switch (filter_level) { - case ART_FILTER_NEAREST: - printf ("ART_FILTER_NEAREST\n"); + case GDK_INTERP_NEAREST: + printf ("GDK_INTERP_NEAREST\n"); break; - case ART_FILTER_TILES: - printf ("ART_FILTER_TILES\n"); + case GDK_INTERP_TILES: + printf ("GDK_INTERP_TILES\n"); break; - case ART_FILTER_BILINEAR: - printf ("ART_FILTER_BILINEAR\n"); + case GDK_INTERP_BILINEAR: + printf ("GDK_INTERP_BILINEAR\n"); break; - case ART_FILTER_HYPER: - printf ("ART_FILTER_HYPER\n"); + case GDK_INTERP_HYPER: + printf ("GDK_INTERP_HYPER\n"); break; } |