diff options
34 files changed, 1127 insertions, 787 deletions
diff --git a/demos/testanimation.c b/demos/testanimation.c index 0663ae2e58..66db245656 100644 --- a/demos/testanimation.c +++ b/demos/testanimation.c @@ -19,12 +19,12 @@ */ #include <config.h> +#include <stdio.h> #include <stdlib.h> #include <unistd.h> #include <string.h> #include <gtk/gtk.h> #include "gdk-pixbuf.h" -#include "gdk-pixbuf-io.h" #include "gdk-pixbuf-loader.h" typedef struct { @@ -201,22 +201,17 @@ expose_func (GtkWidget *drawing_area, GdkEventExpose *event, gpointer data) pixbuf = (GdkPixbuf *)gtk_object_get_data(GTK_OBJECT(drawing_area), "pixbuf"); - if (!pixbuf->art_pixbuf) { - g_warning ("art_pixbuf is NULL in expose_func!!\n"); - return; - } - - if (pixbuf->art_pixbuf->has_alpha) { + if (gdk_pixbuf_get_has_alpha (pixbuf)) { gdk_draw_rgb_32_image (drawing_area->window, drawing_area->style->black_gc, event->area.x, event->area.y, event->area.width, event->area.height, GDK_RGB_DITHER_MAX, - pixbuf->art_pixbuf->pixels - + (event->area.y * pixbuf->art_pixbuf->rowstride) - + (event->area.x * pixbuf->art_pixbuf->n_channels), - pixbuf->art_pixbuf->rowstride); + gdk_pixbuf_get_pixels (pixbuf) + + (event->area.y * gdk_pixbuf_get_rowstride (pixbuf)) + + (event->area.x * gdk_pixbuf_get_n_channels (pixbuf)), + gdk_pixbuf_get_rowstride (pixbuf)); } else { gdk_draw_rgb_image (drawing_area->window, drawing_area->style->white_gc, @@ -224,10 +219,10 @@ expose_func (GtkWidget *drawing_area, GdkEventExpose *event, gpointer data) event->area.width, event->area.height, GDK_RGB_DITHER_NORMAL, - pixbuf->art_pixbuf->pixels - + (event->area.y * pixbuf->art_pixbuf->rowstride) - + (event->area.x * pixbuf->art_pixbuf->n_channels), - pixbuf->art_pixbuf->rowstride); + gdk_pixbuf_get_pixels (pixbuf) + + (event->area.y * gdk_pixbuf_get_rowstride (pixbuf)) + + (event->area.x * gdk_pixbuf_get_n_channels (pixbuf)), + gdk_pixbuf_get_rowstride (pixbuf)); } } @@ -239,8 +234,8 @@ config_func (GtkWidget *drawing_area, GdkEventConfigure *event, gpointer data) pixbuf = (GdkPixbuf *)gtk_object_get_data(GTK_OBJECT(drawing_area), "pixbuf"); #if 0 - if (((event->width) != (pixbuf->art_pixbuf->width)) || - ((event->height) != (pixbuf->art_pixbuf->height))) + if (((event->width) != gdk_pixbuf_get_width (pixbuf)) || + ((event->height) != gdk_pixbuf_get_height (pixbuf))) gdk_pixbuf_scale(pixbuf, event->width, event->height); #endif } @@ -255,8 +250,8 @@ new_testrgb_window (GdkPixbuf *pixbuf, gchar *title) GtkWidget *drawing_area; gint w, h; - w = pixbuf->art_pixbuf->width; - h = pixbuf->art_pixbuf->height; + w = gdk_pixbuf_get_width (pixbuf); + h = gdk_pixbuf_get_height (pixbuf); window = gtk_widget_new (gtk_window_get_type (), "GtkObject::user_data", NULL, @@ -306,6 +301,7 @@ new_testrgb_window (GdkPixbuf *pixbuf, gchar *title) return window; } +#if 0 static gint update_timeout(gpointer data) @@ -367,6 +363,8 @@ progressive_updated_callback(GdkPixbufLoader* loader, guint x, guint y, guint wi return; } +#endif + static int readlen = 4096; int @@ -376,7 +374,6 @@ main (int argc, char **argv) int found_valid = FALSE; GdkPixbufAnimation *animation; - GdkPixbufLoader *pixbuf_loader; gtk_init (&argc, &argv); @@ -414,16 +411,24 @@ main (int argc, char **argv) if (animation) { gint i = 0; GList *listptr; - for (listptr = animation->frames; listptr; listptr = listptr->next){ + for (listptr = gdk_pixbuf_animation_get_frames (animation); + listptr; + listptr = listptr->next) { + GdkPixbufFrame *frame; + GdkPixbuf *pixbuf; gchar *title; + + frame = listptr->data; + pixbuf = gdk_pixbuf_frame_get_pixbuf (frame); + title = g_strdup_printf ("Frame %d", i); g_print ("Frame %d x:%d y:%d width:%d height:%d\n", i, - ((GdkPixbufFrame *)listptr->data)->x_offset, - ((GdkPixbufFrame *)listptr->data)->y_offset, - gdk_pixbuf_get_width (((GdkPixbufFrame *)listptr->data)->pixbuf), - gdk_pixbuf_get_height (((GdkPixbufFrame *)listptr->data)->pixbuf)); - new_testrgb_window (((GdkPixbufFrame *)listptr->data)->pixbuf, title); + gdk_pixbuf_frame_get_x_offset (frame), + gdk_pixbuf_frame_get_y_offset (frame), + gdk_pixbuf_get_width (pixbuf), + gdk_pixbuf_get_height (pixbuf)); + new_testrgb_window (pixbuf, title); g_free (title); i++; } @@ -434,6 +439,7 @@ main (int argc, char **argv) { GtkWidget* rgb_window = NULL; ProgressFileStatus status; + GdkPixbufLoader *pixbuf_loader; pixbuf_loader = gdk_pixbuf_loader_new (); status.loader = pixbuf_loader; diff --git a/demos/testpixbuf-drawable.c b/demos/testpixbuf-drawable.c index a465aa4c82..c250f2dfb3 100644 --- a/demos/testpixbuf-drawable.c +++ b/demos/testpixbuf-drawable.c @@ -15,7 +15,7 @@ int expose_cb(GtkWidget *drawing_area, GdkEventExpose *evt, gpointer data) pixbuf = (GdkPixbuf *) gtk_object_get_data(GTK_OBJECT(drawing_area), "pixbuf"); - if(pixbuf->art_pixbuf->has_alpha) + if(gdk_pixbuf_get_has_alpha (pixbuf)) { gdk_draw_rgb_32_image(drawing_area->window, drawing_area->style->black_gc, @@ -23,10 +23,10 @@ int expose_cb(GtkWidget *drawing_area, GdkEventExpose *evt, gpointer data) evt->area.width, evt->area.height, GDK_RGB_DITHER_MAX, - pixbuf->art_pixbuf->pixels + - (evt->area.y * pixbuf->art_pixbuf->rowstride) + - (evt->area.x * pixbuf->art_pixbuf->n_channels), - pixbuf->art_pixbuf->rowstride); + gdk_pixbuf_get_pixels (pixbuf) + + (evt->area.y * gdk_pixbuf_get_rowstride (pixbuf)) + + (evt->area.x * gdk_pixbuf_get_n_channels (pixbuf)), + gdk_pixbuf_get_rowstride (pixbuf)); } else { @@ -36,10 +36,10 @@ int expose_cb(GtkWidget *drawing_area, GdkEventExpose *evt, gpointer data) evt->area.width, evt->area.height, GDK_RGB_DITHER_NORMAL, - pixbuf->art_pixbuf->pixels + - (evt->area.y * pixbuf->art_pixbuf->rowstride) + - (evt->area.x * pixbuf->art_pixbuf->n_channels), - pixbuf->art_pixbuf->rowstride); + gdk_pixbuf_get_pixels (pixbuf) + + (evt->area.y * gdk_pixbuf_get_rowstride (pixbuf)) + + (evt->area.x * gdk_pixbuf_get_n_channels (pixbuf)), + gdk_pixbuf_get_rowstride (pixbuf)); } return FALSE; } @@ -52,7 +52,7 @@ int configure_cb(GtkWidget *drawing_area, GdkEventConfigure *evt, gpointer data) "pixbuf"); g_print("X:%d Y:%d\n", evt->width, evt->height); - if(evt->width != pixbuf->art_pixbuf->width || evt->height != pixbuf->art_pixbuf->height) + if(evt->width != gdk_pixbuf_get_width (pixbuf) || evt->height != gdk_pixbuf_get_height (pixbuf)) { GdkWindow *root; GdkPixbuf *new_pixbuf; @@ -97,8 +97,8 @@ int main(int argc, char **argv) drawing_area = gtk_drawing_area_new(); gtk_drawing_area_size(GTK_DRAWING_AREA(drawing_area), - pixbuf->art_pixbuf->width, - pixbuf->art_pixbuf->height); + gdk_pixbuf_get_width (pixbuf), + gdk_pixbuf_get_height (pixbuf)); gtk_signal_connect(GTK_OBJECT(drawing_area), "expose_event", GTK_SIGNAL_FUNC(expose_cb), NULL); diff --git a/demos/testpixbuf-scale.c b/demos/testpixbuf-scale.c index 2efafd6da9..a99977fbda 100644 --- a/demos/testpixbuf-scale.c +++ b/demos/testpixbuf-scale.c @@ -3,15 +3,15 @@ #include <stdio.h> -ArtFilterLevel filter_level = ART_FILTER_BILINEAR; +GdkInterpType interp_type = GDK_INTERP_BILINEAR; int overall_alpha = 255; GdkPixbuf *pixbuf; GtkWidget *darea; void -set_filter_level (GtkWidget *widget, gpointer data) +set_interp_type (GtkWidget *widget, gpointer data) { - filter_level = GPOINTER_TO_UINT (data); + interp_type = GPOINTER_TO_UINT (data); gtk_widget_queue_draw (darea); } @@ -32,14 +32,14 @@ expose_cb (GtkWidget *widget, GdkEventExpose *event, gpointer data) gdk_window_set_back_pixmap (widget->window, NULL, FALSE); - dest = gdk_pixbuf_new (ART_PIX_RGB, FALSE, 8, event->area.width, event->area.height); + dest = gdk_pixbuf_new (GDK_COLORSPACE_RGB, FALSE, 8, event->area.width, event->area.height); gdk_pixbuf_composite_color (pixbuf, dest, 0, 0, event->area.width, event->area.height, -event->area.x, -event->area.y, - (double) widget->allocation.width / pixbuf->art_pixbuf->width, - (double) widget->allocation.height / pixbuf->art_pixbuf->height, - filter_level, overall_alpha, + (double) widget->allocation.width / gdk_pixbuf_get_width (pixbuf), + (double) widget->allocation.height / gdk_pixbuf_get_height (pixbuf), + interp_type, overall_alpha, event->area.x, event->area.y, 16, 0xaaaaaa, 0x555555); gdk_pixbuf_render_to_drawable (dest, widget->window, widget->style->fg_gc[GTK_STATE_NORMAL], @@ -87,28 +87,28 @@ main(int argc, char **argv) menuitem = gtk_menu_item_new_with_label ("NEAREST"); gtk_signal_connect (GTK_OBJECT (menuitem), "activate", - GTK_SIGNAL_FUNC (set_filter_level), - GUINT_TO_POINTER (ART_FILTER_NEAREST)); + GTK_SIGNAL_FUNC (set_interp_type), + GUINT_TO_POINTER (GDK_INTERP_NEAREST)); gtk_widget_show (menuitem); gtk_container_add (GTK_CONTAINER (menu), menuitem); menuitem = gtk_menu_item_new_with_label ("BILINEAR"); gtk_signal_connect (GTK_OBJECT (menuitem), "activate", - GTK_SIGNAL_FUNC (set_filter_level), - GUINT_TO_POINTER (ART_FILTER_BILINEAR)); + GTK_SIGNAL_FUNC (set_interp_type), + GUINT_TO_POINTER (GDK_INTERP_BILINEAR)); gtk_widget_show (menuitem); gtk_container_add (GTK_CONTAINER (menu), menuitem); menuitem = gtk_menu_item_new_with_label ("TILES"); gtk_signal_connect (GTK_OBJECT (menuitem), "activate", - GTK_SIGNAL_FUNC (set_filter_level), - GUINT_TO_POINTER (ART_FILTER_TILES)); + GTK_SIGNAL_FUNC (set_interp_type), + GUINT_TO_POINTER (GDK_INTERP_TILES)); gtk_container_add (GTK_CONTAINER (menu), menuitem); menuitem = gtk_menu_item_new_with_label ("HYPER"); gtk_signal_connect (GTK_OBJECT (menuitem), "activate", - GTK_SIGNAL_FUNC (set_filter_level), - GUINT_TO_POINTER (ART_FILTER_HYPER)); + GTK_SIGNAL_FUNC (set_interp_type), + GUINT_TO_POINTER (GDK_INTERP_HYPER)); gtk_container_add (GTK_CONTAINER (menu), menuitem); optionmenu = gtk_option_menu_new (); @@ -145,8 +145,8 @@ main(int argc, char **argv) GTK_SIGNAL_FUNC (expose_cb), NULL); gtk_window_set_default_size (GTK_WINDOW (window), - pixbuf->art_pixbuf->width, - scratch_requisition.height + pixbuf->art_pixbuf->height); + gdk_pixbuf_get_width (pixbuf), + scratch_requisition.height + gdk_pixbuf_get_height (pixbuf)); gtk_widget_show_all (window); diff --git a/demos/testpixbuf.c b/demos/testpixbuf.c index 423d7d3308..fe031877f6 100644 --- a/demos/testpixbuf.c +++ b/demos/testpixbuf.c @@ -1,4 +1,3 @@ - /* testpixbuf -- test program for gdk-pixbuf code * Copyright (C) 1999 Mark Crichton, Larry Ewing * @@ -19,12 +18,12 @@ */ #include <config.h> +#include <stdio.h> #include <stdlib.h> #include <unistd.h> #include <string.h> #include <gtk/gtk.h> #include "gdk-pixbuf.h" -#include "gdk-pixbuf-io.h" #include "gdk-pixbuf-loader.h" typedef struct { @@ -34,7 +33,6 @@ typedef struct { guchar *buf; guint timeout; guint readlen; - } ProgressFileStatus; @@ -321,22 +319,17 @@ expose_func (GtkWidget *drawing_area, GdkEventExpose *event, gpointer data) pixbuf = (GdkPixbuf *)gtk_object_get_data(GTK_OBJECT(drawing_area), "pixbuf"); - if (!pixbuf->art_pixbuf) { - g_warning ("art_pixbuf is NULL in expose_func!!\n"); - return; - } - - if (pixbuf->art_pixbuf->has_alpha) { + if (gdk_pixbuf_get_has_alpha (pixbuf)) { gdk_draw_rgb_32_image (drawing_area->window, drawing_area->style->black_gc, event->area.x, event->area.y, event->area.width, event->area.height, GDK_RGB_DITHER_MAX, - pixbuf->art_pixbuf->pixels - + (event->area.y * pixbuf->art_pixbuf->rowstride) - + (event->area.x * pixbuf->art_pixbuf->n_channels), - pixbuf->art_pixbuf->rowstride); + gdk_pixbuf_get_pixels (pixbuf) + + (event->area.y * gdk_pixbuf_get_rowstride (pixbuf)) + + (event->area.x * gdk_pixbuf_get_n_channels (pixbuf)), + gdk_pixbuf_get_rowstride (pixbuf)); } else { gdk_draw_rgb_image (drawing_area->window, drawing_area->style->white_gc, @@ -344,10 +337,10 @@ expose_func (GtkWidget *drawing_area, GdkEventExpose *event, gpointer data) event->area.width, event->area.height, GDK_RGB_DITHER_NORMAL, - pixbuf->art_pixbuf->pixels - + (event->area.y * pixbuf->art_pixbuf->rowstride) - + (event->area.x * pixbuf->art_pixbuf->n_channels), - pixbuf->art_pixbuf->rowstride); + gdk_pixbuf_get_pixels (pixbuf) + + (event->area.y * gdk_pixbuf_get_rowstride (pixbuf)) + + (event->area.x * gdk_pixbuf_get_n_channels (pixbuf)), + gdk_pixbuf_get_rowstride (pixbuf)); } } @@ -361,8 +354,8 @@ config_func (GtkWidget *drawing_area, GdkEventConfigure *event, gpointer data) g_print("X:%d Y:%d\n", event->width, event->height); #if 0 - if (((event->width) != (pixbuf->art_pixbuf->width)) || - ((event->height) != (pixbuf->art_pixbuf->height))) + if (((event->width) != gdk_pixbuf_get_width (pixbuf)) || + ((event->height) != gdk_pixbuf_get_height (pixbuf))) gdk_pixbuf_scale(pixbuf, event->width, event->height); #endif } @@ -377,8 +370,8 @@ new_testrgb_window (GdkPixbuf *pixbuf, gchar *title) GtkWidget *drawing_area; gint w, h; - w = pixbuf->art_pixbuf->width; - h = pixbuf->art_pixbuf->height; + w = gdk_pixbuf_get_width (pixbuf); + h = gdk_pixbuf_get_height (pixbuf); window = gtk_widget_new (gtk_window_get_type (), "GtkObject::user_data", NULL, @@ -529,7 +522,7 @@ main (int argc, char **argv) if (argc == 1) { const gchar*** xpmp; - pixbuf = gdk_pixbuf_new_from_data (default_image, ART_PIX_RGB, FALSE, + pixbuf = gdk_pixbuf_new_from_data (default_image, GDK_COLORSPACE_RGB, FALSE, 8, DEFAULT_WIDTH, DEFAULT_HEIGHT, DEFAULT_WIDTH * 3, NULL, NULL); new_testrgb_window (pixbuf, NULL); diff --git a/gdk-pixbuf/ChangeLog b/gdk-pixbuf/ChangeLog index 20bb05992e..2a1b8607f0 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 9e34123b3e..64419f7924 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 09e21c4593..b2fbbb8f40 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 247a67e4fd..e94aea7da9 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 491543a277..cb88dd2de7 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 777b767d14..5648258aa1 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 0000000000..278298c23b --- /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 0f621d1d61..8b5a159e48 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 96a8ca49bf..ece50aface 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 f118d9234a..1ca70cd604 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 1c7162267a..be67197bcd 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 aca5ab36bd..5b82e086bc 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 e9410558e9..ed6368ad52 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 2aa4fb4f3a..cf451241d3 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 926871a3dc..4f3bc88788 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 4cb699576e..aa78665c71 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 0845a3dc3c..0a21269252 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 3ad9bb3fd2..4514194842 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 c3ac215fa5..7f18b1952f 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 f14fea3399..b019a5ebb3 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 587ecf8558..602adb8468 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 f6fd6a9be3..e6b80dab8e 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 9cdb3b3197..3d5bce8a89 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 b6ed3c0599..bb0440f5ae 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 78bf44eda6..040f1df6d0 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 193d659180..8aa06b6309 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 d0ea257487..b835ff5424 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; } diff --git a/gdk/gdkpixbuf-drawable.c b/gdk/gdkpixbuf-drawable.c index d4834a8276..d49d744d3d 100644 --- a/gdk/gdkpixbuf-drawable.c +++ b/gdk/gdkpixbuf-drawable.c @@ -26,7 +26,7 @@ #include <config.h> #include <stdio.h> #include <string.h> -#include "gdk-pixbuf.h" +#include "gdk-pixbuf-private.h" #if (G_BYTE_ORDER == G_LITTLE_ENDIAN) #define LITTLE @@ -54,7 +54,7 @@ static guint32 mask_table[] = { no alpha */ static void -rgb1 (GdkImage *image, art_u8 *pixels, int rowstride, GdkColormap *colormap) +rgb1 (GdkImage *image, guchar *pixels, int rowstride, GdkColormap *colormap) { int xx, yy; int width, height; @@ -93,7 +93,7 @@ rgb1 (GdkImage *image, art_u8 *pixels, int rowstride, GdkColormap *colormap) with alpha */ static void -rgb1a (GdkImage *image, art_u8 *pixels, int rowstride, GdkColormap *colormap) +rgb1a (GdkImage *image, guchar *pixels, int rowstride, GdkColormap *colormap) { int xx, yy; int width, height; @@ -145,7 +145,7 @@ rgb1a (GdkImage *image, art_u8 *pixels, int rowstride, GdkColormap *colormap) no alpha */ static void -rgb8 (GdkImage *image, art_u8 *pixels, int rowstride, GdkColormap *colormap) +rgb8 (GdkImage *image, guchar *pixels, int rowstride, GdkColormap *colormap) { int xx, yy; int width, height; @@ -183,7 +183,7 @@ rgb8 (GdkImage *image, art_u8 *pixels, int rowstride, GdkColormap *colormap) with alpha */ static void -rgb8a (GdkImage *image, art_u8 *pixels, int rowstride, GdkColormap *colormap) +rgb8a (GdkImage *image, guchar *pixels, int rowstride, GdkColormap *colormap) { int xx, yy; int width, height; @@ -235,7 +235,7 @@ rgb8a (GdkImage *image, art_u8 *pixels, int rowstride, GdkColormap *colormap) data in lsb format */ static void -rgb565lsb (GdkImage *image, art_u8 *pixels, int rowstride, GdkColormap *colormap) +rgb565lsb (GdkImage *image, guchar *pixels, int rowstride, GdkColormap *colormap) { int xx, yy; int width, height; @@ -300,7 +300,7 @@ rgb565lsb (GdkImage *image, art_u8 *pixels, int rowstride, GdkColormap *colormap data in msb format */ static void -rgb565msb (GdkImage *image, art_u8 *pixels, int rowstride, GdkColormap *colormap) +rgb565msb (GdkImage *image, guchar *pixels, int rowstride, GdkColormap *colormap) { int xx, yy; int width, height; @@ -365,7 +365,7 @@ rgb565msb (GdkImage *image, art_u8 *pixels, int rowstride, GdkColormap *colormap data in lsb format */ static void -rgb565alsb (GdkImage *image, art_u8 *pixels, int rowstride, GdkColormap *colormap) +rgb565alsb (GdkImage *image, guchar *pixels, int rowstride, GdkColormap *colormap) { int xx, yy; int width, height; @@ -418,7 +418,7 @@ rgb565alsb (GdkImage *image, art_u8 *pixels, int rowstride, GdkColormap *colorma data in msb format */ static void -rgb565amsb (GdkImage *image, art_u8 *pixels, int rowstride, GdkColormap *colormap) +rgb565amsb (GdkImage *image, guchar *pixels, int rowstride, GdkColormap *colormap) { int xx, yy; int width, height; @@ -467,7 +467,7 @@ rgb565amsb (GdkImage *image, art_u8 *pixels, int rowstride, GdkColormap *colorma data in lsb format */ static void -rgb555lsb (GdkImage *image, art_u8 *pixels, int rowstride, GdkColormap *colormap) +rgb555lsb (GdkImage *image, guchar *pixels, int rowstride, GdkColormap *colormap) { int xx, yy; int width, height; @@ -532,7 +532,7 @@ rgb555lsb (GdkImage *image, art_u8 *pixels, int rowstride, GdkColormap *colormap data in msb format */ static void -rgb555msb (GdkImage *image, art_u8 *pixels, int rowstride, GdkColormap *colormap) +rgb555msb (GdkImage *image, guchar *pixels, int rowstride, GdkColormap *colormap) { int xx, yy; int width, height; @@ -593,7 +593,7 @@ rgb555msb (GdkImage *image, art_u8 *pixels, int rowstride, GdkColormap *colormap data in lsb format */ static void -rgb555alsb (GdkImage *image, art_u8 *pixels, int rowstride, GdkColormap *colormap) +rgb555alsb (GdkImage *image, guchar *pixels, int rowstride, GdkColormap *colormap) { int xx, yy; int width, height; @@ -646,7 +646,7 @@ rgb555alsb (GdkImage *image, art_u8 *pixels, int rowstride, GdkColormap *colorma data in msb format */ static void -rgb555amsb (GdkImage *image, art_u8 *pixels, int rowstride, GdkColormap *colormap) +rgb555amsb (GdkImage *image, guchar *pixels, int rowstride, GdkColormap *colormap) { int xx, yy; int width, height; @@ -695,7 +695,7 @@ rgb555amsb (GdkImage *image, art_u8 *pixels, int rowstride, GdkColormap *colorma static void -rgb888alsb (GdkImage *image, art_u8 *pixels, int rowstride, GdkColormap *colormap) +rgb888alsb (GdkImage *image, guchar *pixels, int rowstride, GdkColormap *colormap) { int xx, yy; int width, height; @@ -728,7 +728,7 @@ rgb888alsb (GdkImage *image, art_u8 *pixels, int rowstride, GdkColormap *colorma } static void -rgb888lsb (GdkImage *image, art_u8 *pixels, int rowstride, GdkColormap *colormap) +rgb888lsb (GdkImage *image, guchar *pixels, int rowstride, GdkColormap *colormap) { int xx, yy; int width, height; @@ -758,7 +758,7 @@ rgb888lsb (GdkImage *image, art_u8 *pixels, int rowstride, GdkColormap *colormap } static void -rgb888amsb (GdkImage *image, art_u8 *pixels, int rowstride, GdkColormap *colormap) +rgb888amsb (GdkImage *image, guchar *pixels, int rowstride, GdkColormap *colormap) { int xx, yy; int width, height; @@ -806,7 +806,7 @@ rgb888amsb (GdkImage *image, art_u8 *pixels, int rowstride, GdkColormap *colorma } static void -rgb888msb (GdkImage *image, art_u8 *pixels, int rowstride, GdkColormap *colormap) +rgb888msb (GdkImage *image, guchar *pixels, int rowstride, GdkColormap *colormap) { int xx, yy; int width, height; @@ -841,7 +841,7 @@ rgb888msb (GdkImage *image, art_u8 *pixels, int rowstride, GdkColormap *colormap run quite slow */ static void -convert_real_slow (GdkImage *image, art_u8 *pixels, int rowstride, GdkColormap *cmap, int alpha) +convert_real_slow (GdkImage *image, guchar *pixels, int rowstride, GdkColormap *cmap, int alpha) { int xx, yy; int width, height; @@ -899,7 +899,7 @@ convert_real_slow (GdkImage *image, art_u8 *pixels, int rowstride, GdkColormap * } } -typedef void (* cfunc) (GdkImage *image, art_u8 *pixels, int rowstride, GdkColormap *cmap); +typedef void (* cfunc) (GdkImage *image, guchar *pixels, int rowstride, GdkColormap *cmap); static cfunc convert_map[] = { rgb1,rgb1,rgb1a,rgb1a, @@ -917,7 +917,7 @@ static cfunc convert_map[] = { conversion function. */ static void -rgbconvert (GdkImage *image, art_u8 *pixels, int rowstride, int alpha, GdkColormap *cmap) +rgbconvert (GdkImage *image, guchar *pixels, int rowstride, int alpha, GdkColormap *cmap) { int index = (image->byte_order == GDK_MSB_FIRST) | (alpha != 0) << 1; int bank=5; /* default fallback converter */ @@ -1020,7 +1020,9 @@ rgbconvert (GdkImage *image, art_u8 *pixels, int rowstride, int alpha, GdkColorm * be undefined. * * Return value: The same pixbuf as @dest if it was non-NULL, or a newly-created - * pixbuf with a reference count of 1 if no destination pixbuf was specified. + * pixbuf with a reference count of 1 if no destination pixbuf was specified; in + * the latter case, NULL will be returned if not enough memory could be + * allocated for the pixbuf to be created. **/ GdkPixbuf * gdk_pixbuf_get_from_drawable (GdkPixbuf *dest, @@ -1031,7 +1033,6 @@ gdk_pixbuf_get_from_drawable (GdkPixbuf *dest, { GdkWindowType window_type; int src_width, src_height; - ArtPixBuf *apb = NULL; GdkImage *image; int rowstride, bpp, alpha; @@ -1054,11 +1055,9 @@ gdk_pixbuf_get_from_drawable (GdkPixbuf *dest, if (!dest) g_return_val_if_fail (dest_x == 0 && dest_y == 0, NULL); else { - apb = dest->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); + g_return_val_if_fail (dest->colorspace == GDK_COLORSPACE_RGB, NULL); + g_return_val_if_fail (dest->n_channels == 3 || dest->n_channels == 4, NULL); + g_return_val_if_fail (dest->bits_per_sample == 8, NULL); } /* Coordinate sanity checks */ @@ -1070,8 +1069,8 @@ gdk_pixbuf_get_from_drawable (GdkPixbuf *dest, if (dest) { g_return_val_if_fail (dest_x >= 0 && dest_y >= 0, NULL); - g_return_val_if_fail (dest_x + width <= apb->width, NULL); - g_return_val_if_fail (dest_y + height <= apb->height, NULL); + g_return_val_if_fail (dest_x + width <= dest->width, NULL); + g_return_val_if_fail (dest_y + height <= dest->height, NULL); } if (window_type != GDK_WINDOW_PIXMAP) { @@ -1096,33 +1095,31 @@ gdk_pixbuf_get_from_drawable (GdkPixbuf *dest, /* Get Image in ZPixmap format (packed bits). */ image = gdk_image_get (src, src_x, src_y, width, height); - g_return_val_if_fail( image != NULL, NULL); + g_return_val_if_fail (image != NULL, NULL); /* Create the pixbuf if needed */ if (!dest) { - dest = gdk_pixbuf_new (ART_PIX_RGB, FALSE, 8, width, height); + dest = gdk_pixbuf_new (GDK_COLORSPACE_RGB, FALSE, 8, width, height); if (!dest) { gdk_image_destroy(image); return NULL; } - - apb = dest->art_pixbuf; } /* Get the colormap if needed */ if (window_type != GDK_WINDOW_PIXMAP) cmap = gdk_window_get_colormap (src); - alpha = gdk_pixbuf_get_has_alpha(dest); - rowstride = gdk_pixbuf_get_rowstride(dest); - bpp = alpha?4:3; + alpha = dest->has_alpha; + rowstride = dest->rowstride; + bpp = alpha ? 4 : 3; /* we offset into the image data based on the position we are retrieving from */ - rgbconvert(image, gdk_pixbuf_get_pixels(dest) + - (dest_y * rowstride) + (dest_x * bpp), - rowstride, - alpha, - cmap); + rgbconvert (image, dest->pixels + + (dest_y * rowstride) + (dest_x * bpp), + rowstride, + alpha, + cmap); gdk_image_destroy(image); diff --git a/gdk/gdkpixbuf-render.c b/gdk/gdkpixbuf-render.c index 19bf30deab..706d43b595 100644 --- a/gdk/gdkpixbuf-render.c +++ b/gdk/gdkpixbuf-render.c @@ -22,8 +22,7 @@ #include <config.h> #include <gdk/gdk.h> -#include <libart_lgpl/art_rect.h> -#include "gdk-pixbuf.h" +#include "gdk-pixbuf-private.h" @@ -52,7 +51,6 @@ gdk_pixbuf_render_threshold_alpha (GdkPixbuf *pixbuf, GdkBitmap *bitmap, int width, int height, int alpha_threshold) { - ArtPixBuf *apb; GdkGC *gc; GdkColor color; int x, y; @@ -61,16 +59,14 @@ gdk_pixbuf_render_threshold_alpha (GdkPixbuf *pixbuf, GdkBitmap *bitmap, int status; g_return_if_fail (pixbuf != NULL); - apb = pixbuf->art_pixbuf; - - g_return_if_fail (apb->format == ART_PIX_RGB); - g_return_if_fail (apb->n_channels == 3 || apb->n_channels == 4); - g_return_if_fail (apb->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); g_return_if_fail (bitmap != NULL); g_return_if_fail (width >= 0 && height >= 0); - g_return_if_fail (src_x >= 0 && src_x + width <= apb->width); - g_return_if_fail (src_y >= 0 && src_y + height <= apb->height); + g_return_if_fail (src_x >= 0 && src_x + width <= pixbuf->width); + g_return_if_fail (src_y >= 0 && src_y + height <= pixbuf->height); g_return_if_fail (alpha_threshold >= 0 && alpha_threshold <= 255); @@ -79,7 +75,7 @@ gdk_pixbuf_render_threshold_alpha (GdkPixbuf *pixbuf, GdkBitmap *bitmap, gc = gdk_gc_new (bitmap); - if (!apb->has_alpha) { + if (!pixbuf->has_alpha) { color.pixel = (alpha_threshold == 255) ? 0 : 1; gdk_gc_set_foreground (gc, &color); gdk_draw_rectangle (bitmap, gc, TRUE, dest_x, dest_y, width, height); @@ -95,8 +91,8 @@ gdk_pixbuf_render_threshold_alpha (GdkPixbuf *pixbuf, GdkBitmap *bitmap, gdk_gc_set_foreground (gc, &color); for (y = 0; y < height; y++) { - p = (apb->pixels + (y + src_y) * apb->rowstride + src_x * apb->n_channels - + apb->n_channels - 1); + p = (pixbuf->pixels + (y + src_y) * pixbuf->rowstride + src_x * pixbuf->n_channels + + pixbuf->n_channels - 1); start = 0; start_status = *p < alpha_threshold; @@ -114,7 +110,7 @@ gdk_pixbuf_render_threshold_alpha (GdkPixbuf *pixbuf, GdkBitmap *bitmap, start_status = status; } - p += apb->n_channels; + p += pixbuf->n_channels; } if (!start_status) @@ -130,24 +126,24 @@ gdk_pixbuf_render_threshold_alpha (GdkPixbuf *pixbuf, GdkBitmap *bitmap, /* Creates a buffer by stripping the alpha channel of a pixbuf */ static guchar * -remove_alpha (ArtPixBuf *apb, int x, int y, int width, int height, int *rowstride) +remove_alpha (GdkPixbuf *pixbuf, int x, int y, int width, int height, int *rowstride) { guchar *buf; int xx, yy; guchar *src, *dest; - g_assert (apb->n_channels == 4); - g_assert (apb->has_alpha); + g_assert (pixbuf->n_channels == 4); + g_assert (pixbuf->has_alpha); g_assert (width > 0 && height > 0); - g_assert (x >= 0 && x + width <= apb->width); - g_assert (y >= 0 && y + height <= apb->height); + g_assert (x >= 0 && x + width <= pixbuf->width); + g_assert (y >= 0 && y + height <= pixbuf->height); *rowstride = 4 * ((width * 3 + 3) / 4); buf = g_new (guchar, *rowstride * height); for (yy = 0; yy < height; yy++) { - src = apb->pixels + apb->rowstride * (yy + y) + x * apb->n_channels; + src = pixbuf->pixels + pixbuf->rowstride * (yy + y) + x * pixbuf->n_channels; dest = buf + *rowstride * yy; for (xx = 0; xx < width; xx++) { @@ -198,37 +194,34 @@ gdk_pixbuf_render_to_drawable (GdkPixbuf *pixbuf, GdkRgbDither dither, int x_dither, int y_dither) { - ArtPixBuf *apb; guchar *buf; int rowstride; g_return_if_fail (pixbuf != NULL); - apb = pixbuf->art_pixbuf; - - g_return_if_fail (apb->format == ART_PIX_RGB); - g_return_if_fail (apb->n_channels == 3 || apb->n_channels == 4); - g_return_if_fail (apb->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); g_return_if_fail (drawable != NULL); g_return_if_fail (gc != NULL); g_return_if_fail (width >= 0 && height >= 0); - g_return_if_fail (src_x >= 0 && src_x + width <= apb->width); - g_return_if_fail (src_y >= 0 && src_y + height <= apb->height); + g_return_if_fail (src_x >= 0 && src_x + width <= pixbuf->width); + g_return_if_fail (src_y >= 0 && src_y + height <= pixbuf->height); if (width == 0 || height == 0) return; - /* This will have to be modified once libart supports other image types. + /* This will have to be modified once we support other image types. * Also, GdkRGB does not have gdk_draw_rgb_32_image_dithalign(), so we - * have to pack the buffer first. + * have to pack the buffer first. Sigh. */ - if (apb->has_alpha) - buf = remove_alpha (apb, src_x, src_y, width, height, &rowstride); + if (pixbuf->has_alpha) + buf = remove_alpha (pixbuf, src_x, src_y, width, height, &rowstride); else { - buf = apb->pixels + src_y * apb->rowstride + src_x * 3; - rowstride = apb->rowstride; + buf = pixbuf->pixels + src_y * pixbuf->rowstride + src_x * 3; + rowstride = pixbuf->rowstride; } gdk_draw_rgb_image_dithalign (drawable, gc, @@ -238,7 +231,7 @@ gdk_pixbuf_render_to_drawable (GdkPixbuf *pixbuf, buf, rowstride, x_dither, y_dither); - if (apb->has_alpha) + if (pixbuf->has_alpha) g_free (buf); } @@ -284,28 +277,25 @@ gdk_pixbuf_render_to_drawable_alpha (GdkPixbuf *pixbuf, GdkDrawable *drawable, GdkRgbDither dither, int x_dither, int y_dither) { - ArtPixBuf *apb; GdkBitmap *bitmap = NULL; GdkGC *gc; g_return_if_fail (pixbuf != NULL); - apb = pixbuf->art_pixbuf; - - g_return_if_fail (apb->format == ART_PIX_RGB); - g_return_if_fail (apb->n_channels == 3 || apb->n_channels == 4); - g_return_if_fail (apb->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); g_return_if_fail (drawable != NULL); g_return_if_fail (width >= 0 && height >= 0); - g_return_if_fail (src_x >= 0 && src_x + width <= apb->width); - g_return_if_fail (src_y >= 0 && src_y + height <= apb->height); + g_return_if_fail (src_x >= 0 && src_x + width <= pixbuf->width); + g_return_if_fail (src_y >= 0 && src_y + height <= pixbuf->height); if (width == 0 || height == 0) return; gc = gdk_gc_new (drawable); - if (apb->has_alpha) { + if (pixbuf->has_alpha) { /* Right now we only support GDK_PIXBUF_ALPHA_BILEVEL, so we * unconditionally create the clipping mask. */ @@ -330,12 +320,13 @@ gdk_pixbuf_render_to_drawable_alpha (GdkPixbuf *pixbuf, GdkDrawable *drawable, if (bitmap) gdk_bitmap_unref (bitmap); + gdk_gc_unref (gc); } /** * gdk_pixbuf_render_pixmap_and_mask: - * @pixbuf: A pixbuf + * @pixbuf: A pixbuf. * @pixmap_return: Return value for the created pixmap. * @mask_return: Return value for the created mask. * @alpha_threshold: Threshold value for opacity values. @@ -346,37 +337,39 @@ gdk_pixbuf_render_to_drawable_alpha (GdkPixbuf *pixbuf, GdkDrawable *drawable, * function; applications that need to render pixbufs with dither offsets or to * given drawables should use gdk_pixbuf_render_to_drawable_alpha() or * gdk_pixbuf_render_to_drawable(), and gdk_pixbuf_render_threshold_alpha(). + * + * If the pixbuf does not have an alpha channel, then *@mask_return will be set + * to NULL. **/ void gdk_pixbuf_render_pixmap_and_mask (GdkPixbuf *pixbuf, GdkPixmap **pixmap_return, GdkBitmap **mask_return, int alpha_threshold) { - ArtPixBuf *apb; - g_return_if_fail (pixbuf != NULL); - apb = pixbuf->art_pixbuf; - if (pixmap_return) { GdkGC *gc; - *pixmap_return = gdk_pixmap_new (NULL, apb->width, apb->height, + *pixmap_return = gdk_pixmap_new (NULL, pixbuf->width, pixbuf->height, gdk_rgb_get_visual ()->depth); gc = gdk_gc_new (*pixmap_return); gdk_pixbuf_render_to_drawable (pixbuf, *pixmap_return, gc, 0, 0, 0, 0, - apb->width, apb->height, + pixbuf->width, pixbuf->height, GDK_RGB_DITHER_NORMAL, 0, 0); gdk_gc_unref (gc); } if (mask_return) { - *mask_return = gdk_pixmap_new (NULL, apb->width, apb->height, 1); - gdk_pixbuf_render_threshold_alpha (pixbuf, *mask_return, - 0, 0, 0, 0, - apb->width, apb->height, - alpha_threshold); + if (pixbuf->has_alpha) { + *mask_return = gdk_pixmap_new (NULL, pixbuf->width, pixbuf->height, 1); + gdk_pixbuf_render_threshold_alpha (pixbuf, *mask_return, + 0, 0, 0, 0, + pixbuf->width, pixbuf->height, + alpha_threshold); + } else + *mask_return = NULL; } } diff --git a/gtk/gdk-pixbuf-loader.c b/gtk/gdk-pixbuf-loader.c index 777b767d14..5648258aa1 100644 --- a/gtk/gdk-pixbuf-loader.c +++ b/gtk/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" |