gdk_pixbuf_scale() with GDK_INTERP_NEAREST crashes?

[Angelo Cano <acano systec com>]

In the following program, GDK_INTERP_(TILES | BILINEAR | HYPER)
seem to work fine when used with gdk_pixbuf_scale(), but
if GdkInterpType is GDK_INTERP_NEAREST the program crashes :(

Am I doing something wrong?

#include <gtk/gtk.h>
#include <gdk-pixbuf/gdk-pixbuf.h>

GdkPixbuf *original_pixbuf;
GdkPixbuf *scaled_pixbuf;
GtkWidget *drawing_area;
gint original_width, original_height;
gboolean pixbuf_has_alpha;

gint zoom_in_and_out_of_image (gpointer data)
{
        static double scale = 1.0;
        static gboolean zoom_in = TRUE;
        gint new_width, new_height;

        if (zoom_in == TRUE)
                scale += 0.1;
        else
                scale -= 0.1;

        if (scale >= 1.5)
                zoom_in = FALSE;
        if (scale <= 0.5)
                zoom_in = TRUE;

        gdk_pixbuf_scale (original_pixbuf,
                          scaled_pixbuf,
                          0, 0,
                          original_width, original_height,
                          0, 0,
                          scale, scale,
                          //GDK_INTERP_NEAREST); // <--- this crashes app???
                          //GDK_INTERP_TILES);
                          //GDK_INTERP_BILINEAR);
                          GDK_INTERP_HYPER);

        new_width = MIN (original_width, (original_width * scale));
        new_height = MIN (original_height, (original_height * scale));

        gdk_window_clear (drawing_area->window); 

        if (pixbuf_has_alpha) {
                gdk_pixbuf_render_to_drawable_alpha (scaled_pixbuf,
                                                     drawing_area->window,
                                                     0, 0,
                                                     0, 0,
                                                     new_width, new_height,
                                                     GDK_PIXBUF_ALPHA_FULL,
                                                     0,
                                                     GDK_RGB_DITHER_NORMAL,
                                                     0, 0);
        }
        else {
                gdk_pixbuf_render_to_drawable (scaled_pixbuf,
                                               drawing_area->window,
                                               drawing_area->style->black_gc,
                                               0, 0,
                                               0, 0,
                                               new_width, new_height,
                                               GDK_RGB_DITHER_NORMAL,
                                               0, 0);
        }

        return TRUE;
}       

int main (int argc, char *argv[])
{
        GtkWidget *window;
        gchar *filename;

        gtk_init (&argc, &argv);
        gdk_rgb_init (); 

        if (argc != 2) {
                g_print ("usage: %s <image file>\n", argv[0]);
                exit (1);
        }
        filename = argv[1];

        window = gtk_window_new (GTK_WINDOW_TOPLEVEL);

        drawing_area = gtk_drawing_area_new (); 
        gtk_container_add (GTK_CONTAINER (window), drawing_area);

        original_pixbuf = gdk_pixbuf_new_from_file (filename);
        scaled_pixbuf = gdk_pixbuf_copy (original_pixbuf);

        pixbuf_has_alpha = gdk_pixbuf_get_has_alpha (original_pixbuf);
        original_width = gdk_pixbuf_get_width (original_pixbuf);
        original_height = gdk_pixbuf_get_height (original_pixbuf);

        gtk_widget_set_usize (window, original_width, original_height);
        gtk_drawing_area_size (GTK_DRAWING_AREA (drawing_area), 
                               original_width, 
                               original_height);

        gtk_widget_show_all (window);
        gtk_timeout_add (500, zoom_in_and_out_of_image, NULL);
        gtk_main ();
        return 0;
}