From 8a1a091f87b279ad36d6ec09f49d686fe3341807 Mon Sep 17 00:00:00 2001 From: Matthias Clasen Date: Fri, 6 Sep 2002 21:14:15 +0000 Subject: [PATCH] New loader, for .ANI animations. * io-ani.c, io-ani-animation.h, io-ani-animation.c, pixbufloader_ani.def, Makefile.am, gdk-pixbuf-io.c: New loader, for .ANI animations. --- gdk-pixbuf/Makefile.am | 14 + gdk-pixbuf/gdk-pixbuf-io.c | 31 +- gdk-pixbuf/io-ani-animation.c | 347 +++++++++++++++++ gdk-pixbuf/io-ani-animation.h | 112 ++++++ gdk-pixbuf/io-ani.c | 656 ++++++++++++++++++++++++++++++++ gdk-pixbuf/pixbufloader_ani.def | 2 + 6 files changed, 1161 insertions(+), 1 deletion(-) create mode 100644 gdk-pixbuf/io-ani-animation.c create mode 100644 gdk-pixbuf/io-ani-animation.h create mode 100644 gdk-pixbuf/io-ani.c create mode 100644 gdk-pixbuf/pixbufloader_ani.def diff --git a/gdk-pixbuf/Makefile.am b/gdk-pixbuf/Makefile.am index 6d4533ae4c..40aa4635d7 100644 --- a/gdk-pixbuf/Makefile.am +++ b/gdk-pixbuf/Makefile.am @@ -86,6 +86,14 @@ libpixbufloader_ico_la_SOURCES = io-ico.c libpixbufloader_ico_la_LDFLAGS = -avoid-version -module $(no_undefined) libpixbufloader_ico_la_LIBADD = $(module_libs) +# +# The ANI loader +# +libpixbufloader_static_ani_la_SOURCES = io-ani.c io-ani-animation.c io-ani-animation.h +libpixbufloader_ani_la_SOURCES = io-ani.c io-ani-animation.c io-ani-animation.h +libpixbufloader_ani_la_LDFLAGS = -avoid-version -module $(no_undefined) +libpixbufloader_ani_la_LIBADD = $(module_libs) + # # The RAS loader # @@ -158,6 +166,9 @@ STATIC_GIF_LIB = libpixbufloader-static-gif.la ICO_LIB = libpixbufloader-ico.la STATIC_ICO_LIB = libpixbufloader-static-ico.la +ANI_LIB = libpixbufloader-ani.la +STATIC_ANI_LIB = libpixbufloader-static-ani.la + RAS_LIB = libpixbufloader-ras.la STATIC_RAS_LIB = libpixbufloader-static-ras.la @@ -191,6 +202,7 @@ loader_LTLIBRARIES = \ $(JPEG_LIB) \ $(GIF_LIB) \ $(ICO_LIB) \ + $(ANI_LIB) \ $(RAS_LIB) \ $(XPM_LIB) \ $(TIFF_LIB) \ @@ -211,6 +223,7 @@ noinst_LTLIBRARIES = \ $(STATIC_JPEG_LIB) \ $(STATIC_GIF_LIB) \ $(STATIC_ICO_LIB) \ + $(STATIC_ANI_LIB) \ $(STATIC_RAS_LIB) \ $(STATIC_XPM_LIB) \ $(STATIC_TIFF_LIB) \ @@ -379,6 +392,7 @@ EXTRA_DIST = \ gdk-pixbuf-marshal.c \ gdk-pixbuf-marshal.list \ pixbufloader_ico.def \ + pixbufloader_ani.def \ pixbufloader_pnm.def \ pixbufloader_xpm.def \ pixbufloader_bmp.def \ diff --git a/gdk-pixbuf/gdk-pixbuf-io.c b/gdk-pixbuf/gdk-pixbuf-io.c index aa64867524..dc760ac0af 100644 --- a/gdk-pixbuf/gdk-pixbuf-io.c +++ b/gdk-pixbuf/gdk-pixbuf-io.c @@ -163,6 +163,26 @@ pixbuf_check_ico (guchar *buffer, int size) return TRUE; } +static gboolean +pixbuf_check_ani (guchar *buffer, int size) +{ + if (size < 12) + return FALSE; + + if (buffer [0] != 'R' || + buffer [1] != 'I' || + buffer [2] != 'F' || + buffer [3] != 'F' || + buffer [8] != 'A' || + buffer [9] != 'C' || + buffer[10] != 'O' || + buffer[11] != 'N') + return FALSE; + + return TRUE; +} + + static gboolean pixbuf_check_bmp (guchar *buffer, int size) { @@ -241,7 +261,9 @@ static GdkPixbufModule file_formats [] = { { "ras", pixbuf_check_sunras, NULL, NULL, NULL, NULL, NULL, NULL, NULL }, { "bmp", pixbuf_check_bmp, NULL, NULL, NULL, NULL, NULL, NULL, NULL }, { "xbm", pixbuf_check_xbm, NULL, NULL, NULL, NULL, NULL, NULL, NULL }, - { "ico", pixbuf_check_ico, NULL, NULL, NULL, NULL, NULL, NULL, NULL }, { "tga", pixbuf_check_tga, NULL, NULL, NULL, NULL, NULL, NULL, NULL }, + { "ico", pixbuf_check_ico, NULL, NULL, NULL, NULL, NULL, NULL, NULL }, + { "ani", pixbuf_check_ani, NULL, NULL, NULL, NULL, NULL, NULL, NULL }, + { "tga", pixbuf_check_tga, NULL, NULL, NULL, NULL, NULL, NULL, NULL }, { "wbmp", pixbuf_check_wbmp, NULL, NULL, NULL, NULL, NULL, NULL, NULL }, { NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL } }; @@ -392,6 +414,7 @@ m_fill_vtable (bmp); m_fill_vtable (wbmp); m_fill_vtable (gif); m_fill_vtable (ico); +m_fill_vtable (ani); m_fill_vtable (jpeg); m_fill_vtable (pnm); m_fill_vtable (ras); @@ -441,6 +464,12 @@ _gdk_pixbuf_load_module (GdkPixbufModule *image_module, } #endif +#ifdef INCLUDE_ani + else if (strcmp (image_module->module_name, "ani") == 0){ + fill_vtable = mname (ani, fill_vtable); + } +#endif + #ifdef INCLUDE_jpeg else if (strcmp (image_module->module_name, "jpeg") == 0){ fill_vtable = mname (jpeg, fill_vtable); diff --git a/gdk-pixbuf/io-ani-animation.c b/gdk-pixbuf/io-ani-animation.c new file mode 100644 index 0000000000..07e70368a5 --- /dev/null +++ b/gdk-pixbuf/io-ani-animation.c @@ -0,0 +1,347 @@ +/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 -*- */ +/* GdkPixbuf library - ani support + * + * Copyright (C) 2002 The Free Software Foundation + * + * Author: Matthias Clasen + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the + * Free Software Foundation, Inc., 59 Temple Place - Suite 330, + * Boston, MA 02111-1307, USA. + */ + +#include +#include +#include "gdk-pixbuf-io.h" +#include "gdk-pixbuf-private.h" +#include "io-ani-animation.h" + +static void gdk_pixbuf_ani_anim_class_init (GdkPixbufAniAnimClass *klass); +static void gdk_pixbuf_ani_anim_finalize (GObject *object); + +static gboolean gdk_pixbuf_ani_anim_is_static_image (GdkPixbufAnimation *animation); +static GdkPixbuf* gdk_pixbuf_ani_anim_get_static_image (GdkPixbufAnimation *animation); +static void gdk_pixbuf_ani_anim_get_size (GdkPixbufAnimation *anim, + int *width, + int *height); +static GdkPixbufAnimationIter* gdk_pixbuf_ani_anim_get_iter (GdkPixbufAnimation *anim, + const GTimeVal *start_time); + + + + +static gpointer parent_class; + +GType +gdk_pixbuf_ani_anim_get_type (void) +{ + static GType object_type = 0; + + if (!object_type) { + static const GTypeInfo object_info = { + sizeof (GdkPixbufAniAnimClass), + (GBaseInitFunc) NULL, + (GBaseFinalizeFunc) NULL, + (GClassInitFunc) gdk_pixbuf_ani_anim_class_init, + NULL, /* class_finalize */ + NULL, /* class_data */ + sizeof (GdkPixbufAniAnim), + 0, /* n_preallocs */ + (GInstanceInitFunc) NULL, + }; + + object_type = g_type_register_static (GDK_TYPE_PIXBUF_ANIMATION, + "GdkPixbufAniAnim", + &object_info, 0); + } + + return object_type; +} + +static void +gdk_pixbuf_ani_anim_class_init (GdkPixbufAniAnimClass *klass) +{ + GObjectClass *object_class = G_OBJECT_CLASS (klass); + GdkPixbufAnimationClass *anim_class = GDK_PIXBUF_ANIMATION_CLASS (klass); + + parent_class = g_type_class_peek_parent (klass); + + object_class->finalize = gdk_pixbuf_ani_anim_finalize; + + anim_class->is_static_image = gdk_pixbuf_ani_anim_is_static_image; + anim_class->get_static_image = gdk_pixbuf_ani_anim_get_static_image; + anim_class->get_size = gdk_pixbuf_ani_anim_get_size; + anim_class->get_iter = gdk_pixbuf_ani_anim_get_iter; +} + +static void +gdk_pixbuf_ani_anim_finalize (GObject *object) +{ + GdkPixbufAniAnim *ani_anim = GDK_PIXBUF_ANI_ANIM (object); + gint i; + + for (i = 0; i < ani_anim->n_pixbufs; i++) { + if (ani_anim->pixbufs[i]) + g_object_unref (ani_anim->pixbufs[i]); + } + g_free (ani_anim->pixbufs); + g_free (ani_anim->sequence); + g_free (ani_anim->delay); + + G_OBJECT_CLASS (parent_class)->finalize (object); +} + +static gboolean +gdk_pixbuf_ani_anim_is_static_image (GdkPixbufAnimation *animation) +{ + GdkPixbufAniAnim *ani_anim; + + ani_anim = GDK_PIXBUF_ANI_ANIM (animation); + + return ani_anim->n_frames == 1; +} + +static GdkPixbuf* +gdk_pixbuf_ani_anim_get_static_image (GdkPixbufAnimation *animation) +{ + GdkPixbufAniAnim *ani_anim; + + ani_anim = GDK_PIXBUF_ANI_ANIM (animation); + + if (ani_anim->pixbufs == NULL) + return NULL; + else + return ani_anim->pixbufs[0]; +} + +static void +gdk_pixbuf_ani_anim_get_size (GdkPixbufAnimation *anim, + int *width, + int *height) +{ + GdkPixbufAniAnim *ani_anim; + + ani_anim = GDK_PIXBUF_ANI_ANIM (anim); + + if (width) + *width = ani_anim->width; + + if (height) + *height = ani_anim->height; +} + + +static void +iter_restart (GdkPixbufAniAnimIter *iter) +{ + iter->current_frame = 0; + iter->position = 0; + iter->elapsed = 0; +} + +static GdkPixbufAnimationIter* +gdk_pixbuf_ani_anim_get_iter (GdkPixbufAnimation *anim, + const GTimeVal *start_time) +{ + GdkPixbufAniAnimIter *iter; + + iter = g_object_new (GDK_TYPE_PIXBUF_ANI_ANIM_ITER, NULL); + + iter->ani_anim = GDK_PIXBUF_ANI_ANIM (anim); + + g_object_ref (iter->ani_anim); + + iter_restart (iter); + + iter->start_time = *start_time; + iter->current_time = *start_time; + + return GDK_PIXBUF_ANIMATION_ITER (iter); +} + + + +static void gdk_pixbuf_ani_anim_iter_class_init (GdkPixbufAniAnimIterClass *klass); +static void gdk_pixbuf_ani_anim_iter_finalize (GObject *object); + +static int gdk_pixbuf_ani_anim_iter_get_delay_time (GdkPixbufAnimationIter *iter); +static GdkPixbuf* gdk_pixbuf_ani_anim_iter_get_pixbuf (GdkPixbufAnimationIter *iter); +static gboolean gdk_pixbuf_ani_anim_iter_on_currently_loading_frame (GdkPixbufAnimationIter *iter); +static gboolean gdk_pixbuf_ani_anim_iter_advance (GdkPixbufAnimationIter *iter, + const GTimeVal *current_time); + + + +static gpointer iter_parent_class; + +GType +gdk_pixbuf_ani_anim_iter_get_type (void) +{ + static GType object_type = 0; + + if (!object_type) { + static const GTypeInfo object_info = { + sizeof (GdkPixbufAniAnimIterClass), + (GBaseInitFunc) NULL, + (GBaseFinalizeFunc) NULL, + (GClassInitFunc) gdk_pixbuf_ani_anim_iter_class_init, + NULL, /* class_finalize */ + NULL, /* class_data */ + sizeof (GdkPixbufAniAnimIter), + 0, /* n_preallocs */ + (GInstanceInitFunc) NULL, + }; + + object_type = g_type_register_static (GDK_TYPE_PIXBUF_ANIMATION_ITER, + "GdkPixbufAniAnimIter", + &object_info, 0); + } + + return object_type; +} + +static void +gdk_pixbuf_ani_anim_iter_class_init (GdkPixbufAniAnimIterClass *klass) +{ + GObjectClass *object_class = G_OBJECT_CLASS (klass); + GdkPixbufAnimationIterClass *anim_iter_class = + GDK_PIXBUF_ANIMATION_ITER_CLASS (klass); + + iter_parent_class = g_type_class_peek_parent (klass); + + object_class->finalize = gdk_pixbuf_ani_anim_iter_finalize; + + anim_iter_class->get_delay_time = gdk_pixbuf_ani_anim_iter_get_delay_time; + anim_iter_class->get_pixbuf = gdk_pixbuf_ani_anim_iter_get_pixbuf; + anim_iter_class->on_currently_loading_frame = gdk_pixbuf_ani_anim_iter_on_currently_loading_frame; + anim_iter_class->advance = gdk_pixbuf_ani_anim_iter_advance; +} + +static void +gdk_pixbuf_ani_anim_iter_finalize (GObject *object) +{ + GdkPixbufAniAnimIter *iter = GDK_PIXBUF_ANI_ANIM_ITER (object); + + g_object_unref (iter->ani_anim); + + G_OBJECT_CLASS (iter_parent_class)->finalize (object); +} + +static gboolean +gdk_pixbuf_ani_anim_iter_advance (GdkPixbufAnimationIter *anim_iter, + const GTimeVal *current_time) +{ + GdkPixbufAniAnimIter *iter; + gint elapsed; + gint tmp; + gint old; + + iter = GDK_PIXBUF_ANI_ANIM_ITER (anim_iter); + + iter->current_time = *current_time; + + /* We use milliseconds for all times */ + elapsed = + (((iter->current_time.tv_sec - iter->start_time.tv_sec) * G_USEC_PER_SEC + + iter->current_time.tv_usec - iter->start_time.tv_usec)) / 1000; + + if (elapsed < 0) { + /* Try to compensate; probably the system clock + * was set backwards + */ + iter->start_time = iter->current_time; + elapsed = 0; + } + + g_assert (iter->ani_anim->total_time > 0); + + /* See how many times we've already played the full animation, + * and subtract time for that. + */ + elapsed = elapsed % iter->ani_anim->total_time; + + iter->position = elapsed; + + /* Now move to the proper frame */ + + iter->elapsed = 0; + for (tmp = 0; tmp < iter->ani_anim->n_frames; tmp++) { + if (iter->position >= iter->elapsed && + iter->position < (iter->elapsed + iter->ani_anim->delay[tmp])) + break; + iter->elapsed += iter->ani_anim->delay[tmp]; + } + + old = iter->current_frame; + + iter->current_frame = tmp; + + return iter->current_frame != old; +} + +int +gdk_pixbuf_ani_anim_iter_get_delay_time (GdkPixbufAnimationIter *anim_iter) +{ + GdkPixbufAniAnimIter *iter; + + iter = GDK_PIXBUF_ANI_ANIM_ITER (anim_iter); + + return iter->ani_anim->delay[iter->current_frame] - (iter->position - iter->elapsed); +} + +GdkPixbuf* +gdk_pixbuf_ani_anim_iter_get_pixbuf (GdkPixbufAnimationIter *anim_iter) +{ + GdkPixbufAniAnimIter *iter; + gint frame; + + iter = GDK_PIXBUF_ANI_ANIM_ITER (anim_iter); + + frame = iter->ani_anim->sequence[iter->current_frame]; + + /* this is necessary if the animation is displayed while loading */ + while (frame > 0 && !iter->ani_anim->pixbufs[frame]) + frame--; + + return iter->ani_anim->pixbufs[frame]; +} + +static gboolean +gdk_pixbuf_ani_anim_iter_on_currently_loading_frame (GdkPixbufAnimationIter *anim_iter) +{ + GdkPixbufAniAnimIter *iter; + gint frame; + + iter = GDK_PIXBUF_ANI_ANIM_ITER (anim_iter); + + if (iter->current_frame >= iter->ani_anim->n_frames - 1) + return TRUE; + + frame = iter->ani_anim->sequence[iter->current_frame + 1]; + + if (!iter->ani_anim->pixbufs[frame]) + return TRUE; + + return FALSE; +} + + + + + + + + + + diff --git a/gdk-pixbuf/io-ani-animation.h b/gdk-pixbuf/io-ani-animation.h new file mode 100644 index 0000000000..4fc86b3f2f --- /dev/null +++ b/gdk-pixbuf/io-ani-animation.h @@ -0,0 +1,112 @@ +/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 -*- */ +/* GdkPixbuf library - ANI loader declarations + * + * Copyright (C) 2002 The Free Software Foundation + * + * Author: Matthias Clasen + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the + * Free Software Foundation, Inc., 59 Temple Place - Suite 330, + * Boston, MA 02111-1307, USA. + */ + +#ifndef GDK_PIXBUF_ANI_ANIMATION_H +#define GDK_PIXBUF_ANI_ANIMATION_H + +#include "gdk-pixbuf-private.h" + +typedef struct _GdkPixbufAniAnim GdkPixbufAniAnim; +typedef struct _GdkPixbufAniAnimClass GdkPixbufAniAnimClass; + +#define GDK_TYPE_PIXBUF_ANI_ANIM (gdk_pixbuf_ani_anim_get_type ()) +#define GDK_PIXBUF_ANI_ANIM(object) (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_PIXBUF_ANI_ANIM, GdkPixbufAniAnim)) +#define GDK_IS_PIXBUF_ANI_ANIM(object) (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_PIXBUF_ANI_ANIM)) + +#define GDK_PIXBUF_ANI_ANIM_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GDK_TYPE_PIXBUF_ANI_ANIM, GdkPixbufAniAnimClass)) +#define GDK_IS_PIXBUF_ANI_ANIM_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GDK_TYPE_PIXBUF_ANI_ANIM)) +#define GDK_PIXBUF_ANI_ANIM_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GDK_TYPE_PIXBUF_ANI_ANIM, GdkPixbufAniAnimClass)) + +/* Private part of the GdkPixbufAniAnim structure */ +struct _GdkPixbufAniAnim { + GdkPixbufAnimation parent_instance; + + /* Total length of animation */ + int total_time; + + /* Number of frames */ + int n_frames; + + /* Number of pixbufs */ + int n_pixbufs; + + GdkPixbuf **pixbufs; + + /* Maps frame number to pixbuf */ + int *sequence; + + /* The duration of each frame, in milliseconds */ + int *delay; + + /* bounding box size */ + int width, height; +}; + +struct _GdkPixbufAniAnimClass { + GdkPixbufAnimationClass parent_class; + +}; + +GType gdk_pixbuf_ani_anim_get_type (void) G_GNUC_CONST; + + + +typedef struct _GdkPixbufAniAnimIter GdkPixbufAniAnimIter; +typedef struct _GdkPixbufAniAnimIterClass GdkPixbufAniAnimIterClass; + + +#define GDK_TYPE_PIXBUF_ANI_ANIM_ITER (gdk_pixbuf_ani_anim_iter_get_type ()) +#define GDK_PIXBUF_ANI_ANIM_ITER(object) (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_PIXBUF_ANI_ANIM_ITER, GdkPixbufAniAnimIter)) +#define GDK_IS_PIXBUF_ANI_ANIM_ITER(object) (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_PIXBUF_ANI_ANIM_ITER)) + +#define GDK_PIXBUF_ANI_ANIM_ITER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GDK_TYPE_PIXBUF_ANI_ANIM_ITER, GdkPixbufAniAnimIterClass)) +#define GDK_IS_PIXBUF_ANI_ANIM_ITER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GDK_TYPE_PIXBUF_ANI_ANIM_ITER)) +#define GDK_PIXBUF_ANI_ANIM_ITER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GDK_TYPE_PIXBUF_ANI_ANIM_ITER, GdkPixbufAniAnimIterClass)) + +struct _GdkPixbufAniAnimIter { + GdkPixbufAnimationIter parent_instance; + + GdkPixbufAniAnim *ani_anim; + + GTimeVal start_time; + GTimeVal current_time; + + /* Time in milliseconds into this run of the animation */ + gint position; + + /* Index of the current frame */ + gint current_frame; + + /* Time in milliseconds from the start of the animation till the + begin of the current frame */ + gint elapsed; +}; + +struct _GdkPixbufAniAnimIterClass { + GdkPixbufAnimationIterClass parent_class; + +}; + +GType gdk_pixbuf_ani_anim_iter_get_type (void) G_GNUC_CONST; + +#endif diff --git a/gdk-pixbuf/io-ani.c b/gdk-pixbuf/io-ani.c new file mode 100644 index 0000000000..cc47901371 --- /dev/null +++ b/gdk-pixbuf/io-ani.c @@ -0,0 +1,656 @@ +/* -*- mode: C; c-file-style: "linux" -*- */ +/* GdkPixbuf library - ANI image loader + * + * Copyright (C) 2002 The Free Software Foundation + * + * Authors: Matthias Clasen + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the + * Free Software Foundation, Inc., 59 Temple Place - Suite 330, + * Boston, MA 02111-1307, USA. + */ + +#undef DEBUG_ANI + +#include +#include +#include +#include "gdk-pixbuf-private.h" +#include "gdk-pixbuf-io.h" +#include "io-ani-animation.h" + +static int +lsb_32 (guchar *src) +{ + return src[0] | (src[1] << 8) | (src[2] << 16) | (src[3] << 24); +} + +#define MAKE_TAG(a,b,c,d) ( (guint32)d << 24 | \ + (guint32)c << 16 | \ + (guint32)b << 8 | \ + (guint32)a ) + +#define TAG_RIFF MAKE_TAG('R','I','F','F') +#define TAG_ACON MAKE_TAG('A','C','O','N') +#define TAG_LIST MAKE_TAG('L','I','S','T') +#define TAG_INAM MAKE_TAG('I','N','A','M') +#define TAG_IART MAKE_TAG('I','A','R','T') +#define TAG_anih MAKE_TAG('a','n','i','h') +#define TAG_seq MAKE_TAG('s','e','q',' ') +#define TAG_rate MAKE_TAG('r','a','t','e') +#define TAG_icon MAKE_TAG('i','c','o','n') + +typedef struct _AniLoaderContext +{ + guint32 cp; + + guchar *buffer; + guchar *byte; + guint n_bytes; + guint buffer_size; + + ModulePreparedNotifyFunc prepared_func; + ModuleUpdatedNotifyFunc updated_func; + gpointer user_data; + + guint32 data_size; + + guint32 HeaderSize; + guint32 NumFrames; + guint32 NumSteps; + guint32 Width; + guint32 Height; + guint32 BitCount; + guint32 NumPlanes; + guint32 DisplayRate; + guint32 Flags; + + guint32 chunk_id; + guint32 chunk_size; + + gchar *title; + gchar *author; + + GdkPixbufAniAnim *animation; + GdkPixbufLoader *loader; + + int pos; +} AniLoaderContext; + + +#define BYTES_LEFT(context) \ + ((context)->n_bytes - ((context)->byte - (context)->buffer)) + +static void +read_int8 (AniLoaderContext *context, + guchar *data, + int count) +{ + int total = MIN (count, BYTES_LEFT (context)); + memcpy (data, context->byte, total); + context->byte += total; + context->cp += total; +} + + +static guint32 +read_int32 (AniLoaderContext *context) +{ + guint32 result; + + read_int8 (context, (guchar*) &result, 4); + return lsb_32 ((guchar *) &result); +} + +static void +context_free (AniLoaderContext *context) +{ + if (!context) + return; + + if (context->loader) + { + gdk_pixbuf_loader_close (context->loader, NULL); + g_object_unref (context->loader); + } + if (context->animation) + g_object_unref (context->animation); + g_free (context->buffer); + g_free (context->title); + g_free (context->author); + + g_free (context); +} + +static void +prepared_callback (GdkPixbufLoader *loader, + gpointer data) +{ + AniLoaderContext *context = (AniLoaderContext*)data; + +#ifdef DEBUG_ANI + g_print ("%d pixbuf prepared\n", context->pos); +#endif + + GdkPixbuf *pixbuf = gdk_pixbuf_loader_get_pixbuf (loader); + if (!pixbuf) + return; + + if (gdk_pixbuf_get_width (pixbuf) > context->animation->width) + context->animation->width = gdk_pixbuf_get_width (pixbuf); + + if (gdk_pixbuf_get_height (pixbuf) > context->animation->height) + context->animation->height = gdk_pixbuf_get_height (pixbuf); + + if (context->title != NULL) + gdk_pixbuf_set_option (pixbuf, "Title", context->title); + + if (context->author != NULL) + gdk_pixbuf_set_option (pixbuf, "Author", context->author); + + g_object_ref (pixbuf); + context->animation->pixbufs[context->pos] = pixbuf; + + if (context->pos == 0) + { + if (context->prepared_func) + (* context->prepared_func) (pixbuf, + GDK_PIXBUF_ANIMATION (context->animation), + context->user_data); + } + else { + /* FIXME - this is necessary for nice display of loading + animations because GtkImage ignores + gdk_pixbuf_animation_iter_on_currently_loading_frame() + and always exposes the full frame */ + GdkPixbuf *last = context->animation->pixbufs[context->pos - 1]; + gint width = MIN (gdk_pixbuf_get_width (last), gdk_pixbuf_get_width (pixbuf)); + gint height = MIN (gdk_pixbuf_get_height (last), gdk_pixbuf_get_height (pixbuf)); + gdk_pixbuf_copy_area (last, 0, 0, width, height, pixbuf, 0, 0); + } + + context->pos++; +} + +static void +updated_callback (GdkPixbufLoader* loader, + gint x, gint y, gint width, gint height, + gpointer data) +{ + AniLoaderContext *context = (AniLoaderContext*)data; + + GdkPixbuf *pixbuf = gdk_pixbuf_loader_get_pixbuf (loader); + + if (context->updated_func) + (* context->updated_func) (pixbuf, + x, y, width, height, + context->user_data); +} + +static gboolean +ani_load_chunk (AniLoaderContext *context, GError **error) +{ + int i; + + if (context->chunk_id == 0x0) { + if (BYTES_LEFT (context) < 8) + return FALSE; + context->chunk_id = read_int32 (context); + context->chunk_size = read_int32 (context); + /* Pad it up to word length */ + if (context->chunk_size % 2) + context->chunk_size += (2 - (context->chunk_size % 2)); + + } + + while (context->chunk_id == TAG_LIST) + { + if (BYTES_LEFT (context) < 12) + return FALSE; + + read_int32 (context); + context->chunk_id = read_int32 (context); + context->chunk_size = read_int32 (context); + /* Pad it up to word length */ + if (context->chunk_size % 2) + context->chunk_size += (2 - (context->chunk_size % 2)); + + } + + if (context->chunk_id == TAG_icon) + { + GError *loader_error = NULL; + guchar *data; + guint32 towrite; + + if (context->loader == NULL) + { + if (context->pos >= context->NumFrames) + { + g_set_error (error, + GDK_PIXBUF_ERROR, + GDK_PIXBUF_ERROR_CORRUPT_IMAGE, + _("Unexpected icon chunk in animation")); + return FALSE; + } + +#ifdef DEBUG_ANI + g_print ("opening loader\n"); +#endif + context->loader = gdk_pixbuf_loader_new_with_type ("ico", &loader_error); + if (loader_error) + { + g_propagate_error (error, loader_error); + return FALSE; + } + g_signal_connect (context->loader, "area_prepared", + G_CALLBACK (prepared_callback), context); + g_signal_connect (context->loader, "area_updated", + G_CALLBACK (updated_callback), context); + } + + towrite = MIN (context->chunk_size, BYTES_LEFT (context)); + data = context->byte; + context->byte += towrite; + context->cp += towrite; +#ifdef DEBUG_ANI + g_print ("miss %d, get %d, leftover %d\n", context->chunk_size, towrite, BYTES_LEFT (context)); +#endif + context->chunk_size -= towrite; + if (!gdk_pixbuf_loader_write (context->loader, data, towrite, &loader_error)) + { + g_propagate_error (error, loader_error); + gdk_pixbuf_loader_close (context->loader, NULL); + g_object_unref (context->loader); + context->loader = NULL; + return FALSE; + } + if (context->chunk_size == 0) + { +#ifdef DEBUG_ANI + g_print ("closing loader\n"); +#endif + if (!gdk_pixbuf_loader_close (context->loader, &loader_error)) + { + g_propagate_error (error, loader_error); + g_object_unref (context->loader); + context->loader = NULL; + return FALSE; + } + g_object_unref (context->loader); + context->loader = NULL; + context->chunk_id = 0x0; + } + return BYTES_LEFT (context) > 0; + } + + if (BYTES_LEFT (context) < context->chunk_size) + return FALSE; + + if (context->chunk_id == TAG_anih) + { + context->HeaderSize = read_int32 (context); + context->NumFrames = read_int32 (context); + context->NumSteps = read_int32 (context); + context->Width = read_int32 (context); + context->Height = read_int32 (context); + context->BitCount = read_int32 (context); + context->NumPlanes = read_int32 (context); + context->DisplayRate = read_int32 (context); + context->Flags = read_int32 (context); + +#ifdef DEBUG_ANI + g_print ("HeaderSize \t%" G_GUINT32_FORMAT + "\nNumFrames \t%" G_GUINT32_FORMAT + "\nNumSteps \t%" G_GUINT32_FORMAT + "\nWidth \t%" G_GUINT32_FORMAT + "\nHeight \t%" G_GUINT32_FORMAT + "\nBitCount \t%" G_GUINT32_FORMAT + "\nNumPlanes \t%" G_GUINT32_FORMAT + "\nDisplayRate \t%" G_GUINT32_FORMAT + "\nSequenceFlag \t%d" + "\nIconFlag \t%d" + "\n", + context->HeaderSize, context->NumFrames, + context->NumSteps, context->Width, + context->Height, context->BitCount, + context->NumPlanes, context->DisplayRate, + (context->Flags & 0x2) != 0, + (context->Flags & 0x1) != 0); +#endif + if (!context->Flags & 0x2) + { + g_set_error (error, + GDK_PIXBUF_ERROR, + GDK_PIXBUF_ERROR_CORRUPT_IMAGE, + _("Unsupported animation type")); + return FALSE; + } + if (context->NumFrames == 0 || + context->NumFrames >= 1024 || + context->NumSteps == 0 || + context->NumSteps >= 1024) + { + g_set_error (error, + GDK_PIXBUF_ERROR, + GDK_PIXBUF_ERROR_CORRUPT_IMAGE, + _("Invalid header in animation")); + return FALSE; + } + + context->animation = g_object_new (GDK_TYPE_PIXBUF_ANI_ANIM, NULL); + if (!context->animation) + { + g_set_error (error, + GDK_PIXBUF_ERROR, + GDK_PIXBUF_ERROR_INSUFFICIENT_MEMORY, + _("Not enough memory to load animation")); + return FALSE; + } + + context->animation->n_pixbufs = context->NumFrames; + context->animation->n_frames = context->NumSteps; + + context->animation->total_time = context->NumSteps * (context->DisplayRate * 1000 / 60); + context->animation->width = 0; + context->animation->height = 0; + + context->animation->pixbufs = (GdkPixbuf**) g_try_malloc (sizeof (GdkPixbuf*) * context->NumFrames); + if (context->animation->pixbufs) + memset (context->animation->pixbufs, 0, sizeof (GdkPixbuf*) * context->NumFrames); + + context->animation->delay = (guint32*) g_try_malloc (sizeof (guint32) * context->NumSteps); + context->animation->sequence = (guint32*) g_try_malloc (sizeof (guint32) * context->NumSteps); + if (!context->animation->pixbufs || + !context->animation->delay || + !context->animation->sequence) + { + g_set_error (error, + GDK_PIXBUF_ERROR, + GDK_PIXBUF_ERROR_INSUFFICIENT_MEMORY, + _("Not enough memory to load animation")); + return FALSE; + } + + for (i = 0; i < context->NumSteps; i++) + { + /* default values if the corresponding chunks are absent */ + context->animation->delay[i] = context->DisplayRate * 1000 / 60; + context->animation->sequence[i] = MIN (i, context->NumFrames - 1); + } + } + else if (context->chunk_id == TAG_rate) + { + if (context->chunk_size != 4 * context->NumSteps) + { + g_set_error (error, + GDK_PIXBUF_ERROR, + GDK_PIXBUF_ERROR_CORRUPT_IMAGE, + _("Malformed chunk in animation")); + return FALSE; + } + context->animation->total_time = 0; + for (i = 0; i < context->NumSteps; i++) + { + context->animation->delay[i] = read_int32 (context) * 1000 / 60; + context->animation->total_time += context->animation->delay[i]; + } + } + else if (context->chunk_id == TAG_seq) + { + if (context->chunk_size != 4 * context->NumSteps) + { + g_set_error (error, + GDK_PIXBUF_ERROR, + GDK_PIXBUF_ERROR_CORRUPT_IMAGE, + _("Malformed chunk in animation")); + return FALSE; + } + for (i = 0; i < context->NumSteps; i++) + { + context->animation->sequence[i] = read_int32 (context); + if (context->animation->sequence[i] >= context->NumFrames) + { + g_set_error (error, + GDK_PIXBUF_ERROR, + GDK_PIXBUF_ERROR_CORRUPT_IMAGE, + _("Malformed chunk in animation")); + return FALSE; + } + } + } + else if (context->chunk_id == TAG_INAM) + { + context->title = g_try_malloc (context->chunk_size + 1); + if (!context->title) + { + g_set_error (error, + GDK_PIXBUF_ERROR, + GDK_PIXBUF_ERROR_INSUFFICIENT_MEMORY, + _("Not enough memory to load animation")); + return FALSE; + } + context->title[context->chunk_size] = 0; + read_int8 (context, context->title, context->chunk_size); +#ifdef DEBUG_ANI + g_print ("INAM %s\n", context->title); +#endif + for (i = 0; i < context->pos; i++) + gdk_pixbuf_set_option (context->animation->pixbufs[i], "Title", context->title); + } + else if (context->chunk_id == TAG_IART) + { + context->author = g_try_malloc (context->chunk_size + 1); + if (!context->author) + { + g_set_error (error, + GDK_PIXBUF_ERROR, + GDK_PIXBUF_ERROR_INSUFFICIENT_MEMORY, + _("Not enough memory to load animation")); + return FALSE; + } + context->author[context->chunk_size] = 0; + read_int8 (context, context->author, context->chunk_size); +#ifdef DEBUG_ANI + g_print ("IART %s\n", context->author); +#endif + for (i = 0; i < context->pos; i++) + gdk_pixbuf_set_option (context->animation->pixbufs[i], "Author", context->author); + } + +#ifdef DEBUG_ANI + { + gint32 dummy = lsb_32 ((guchar *)&context->chunk_id); + + g_print ("Loaded chunk with ID '%c%c%c%c' and length %" G_GUINT32_FORMAT "\n", + ((char*)&dummy)[0], ((char*)&dummy)[1], + ((char*)&dummy)[2], ((char*)&dummy)[3], + context->chunk_size); + } +#endif + + context->chunk_id = 0x0; + return TRUE; +} + +static gboolean +gdk_pixbuf__ani_image_load_increment (gpointer data, + const guchar *buf, guint size, + GError **error) +{ + AniLoaderContext *context = (AniLoaderContext *)data; + + if (context->n_bytes + size >= context->buffer_size) { + int drop = context->byte - context->buffer; + memmove (context->buffer, context->byte, context->n_bytes - drop); + context->n_bytes -= drop; + context->byte = context->buffer; + if (context->n_bytes + size >= context->buffer_size) { + guchar *tmp; + context->buffer_size = MAX (context->n_bytes + size, context->buffer_size + 4096); +#ifdef DEBUG_ANI + g_print ("growing buffer to %" G_GUINT32_FORMAT "\n", context->buffer_size); +#endif + tmp = g_try_realloc (context->buffer, context->buffer_size); + if (!tmp) + { + g_set_error (error, + GDK_PIXBUF_ERROR, + GDK_PIXBUF_ERROR_INSUFFICIENT_MEMORY, + _("Not enough memory to load animation")); + return FALSE; + } + context->byte = context->buffer = tmp; + } + } + memcpy (context->buffer + context->n_bytes, buf, size); + context->n_bytes += size; + + if (context->data_size == 0) + { + guint32 riff_id, chunk_id; + + if (BYTES_LEFT (context) < 12) + return TRUE; + + riff_id = read_int32 (context); + context->data_size = read_int32 (context); + chunk_id = read_int32 (context); + + if (riff_id != TAG_RIFF || + context->data_size == 0 || + chunk_id != TAG_ACON) + { + g_set_error (error, + GDK_PIXBUF_ERROR, + GDK_PIXBUF_ERROR_CORRUPT_IMAGE, + _("Invalid header in animation")); + return FALSE; + } + } + + if (context->cp < context->data_size + 8) + { + GError *chunk_error = NULL; + + while (ani_load_chunk (context, &chunk_error)) ; + if (chunk_error) + { + g_propagate_error (error, chunk_error); + return FALSE; + } + } + + return TRUE; +} + +static gpointer +gdk_pixbuf__ani_image_begin_load (ModuleSizeFunc size_func, + ModulePreparedNotifyFunc prepared_func, + ModuleUpdatedNotifyFunc updated_func, + gpointer user_data, + GError **error) +{ + AniLoaderContext *context; + + context = g_new0 (AniLoaderContext, 1); + + context->prepared_func = prepared_func; + context->updated_func = updated_func; + context->user_data = user_data; + + context->pos = 0; + + context->buffer_size = 4096; + context->buffer = g_try_malloc (context->buffer_size); + if (!context->buffer) + { + context_free (context); + g_set_error (error, + GDK_PIXBUF_ERROR, + GDK_PIXBUF_ERROR_INSUFFICIENT_MEMORY, + _("Not enough memory to load animation")); + return NULL; + } + + context->byte = context->buffer; + context->n_bytes = 0; + + return (gpointer) context; +} + +static gboolean +gdk_pixbuf__ani_image_stop_load (gpointer data, + GError **error) +{ + AniLoaderContext *context = (AniLoaderContext *) data; + + g_return_val_if_fail (context != NULL, TRUE); + context_free (context); + + return TRUE; +} + +static void +prepared_notify (GdkPixbuf *pixbuf, + GdkPixbufAnimation *anim, + gpointer user_data) +{ + if (anim != NULL) + g_object_ref (anim); + *((GdkPixbufAnimation **)user_data) = anim; +} + +static GdkPixbufAnimation * +gdk_pixbuf__ani_image_load_animation (FILE *f, GError **error) +{ + guchar buffer[4096]; + size_t length; + GdkPixbufAnimation *anim = NULL; + gpointer context; + + context = gdk_pixbuf__ani_image_begin_load (NULL, prepared_notify, + NULL, &anim, error); + + if (!context) + return NULL; + + while (!feof (f)) { + length = fread (buffer, 1, sizeof (buffer), f); + if (length > 0) + if (!gdk_pixbuf__ani_image_load_increment (context, buffer, length, error)) { + gdk_pixbuf__ani_image_stop_load (context, NULL); + if (anim != NULL) + g_object_unref (anim); + return NULL; + } + } + + if (!gdk_pixbuf__ani_image_stop_load (context, error)) { + if (anim != NULL) + g_object_unref (anim); + return NULL; + } + + return anim; +} + +void +gdk_pixbuf__ani_fill_vtable (GdkPixbufModule *module) +{ + module->load_animation = gdk_pixbuf__ani_image_load_animation; + module->begin_load = gdk_pixbuf__ani_image_begin_load; + module->stop_load = gdk_pixbuf__ani_image_stop_load; + module->load_increment = gdk_pixbuf__ani_image_load_increment; +} diff --git a/gdk-pixbuf/pixbufloader_ani.def b/gdk-pixbuf/pixbufloader_ani.def new file mode 100644 index 0000000000..ac6ceff69d --- /dev/null +++ b/gdk-pixbuf/pixbufloader_ani.def @@ -0,0 +1,2 @@ +EXPORTS + gdk_pixbuf__ani_fill_vtable