dnrops
/
gimp
mirror of https://github.com/GNOME/gimp.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
gimp/plug-ins/common/animationplay.c

1461 lines
42 KiB
C
Raw Blame History

/*
* Animation Playback plug-in version 0.98.8
*
* (c) Adam D. Moss : 1997-2000 : adam@gimp.org : adam@foxbox.org
*
* The GIMP -- an image manipulation program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program 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 General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
/*
* BUGS:
* Gets understandably upset if the source image is deleted
* while the animation is playing. Decent solution welcome.
*
* In shaped mode, the shaped-window's mask and its pixmap contents
* can get way out of sync (specifically, the mask changes but
* the contents are frozen). Starvation of GTK's redrawing thread?
* How do I fix this?
*
* Any more? Let me know!
*/
/*
* TODO:
* pdb interface - should we bother?
*
* speedups (caching? most bottlenecks seem to be in pixelrgns)
* -> do pixelrgns properly!
*
* write other half of the user interface (default timing, disposal &c)
*/
#include "config.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <gtk/gtk.h>
#include <libgimp/gimp.h>
#include <libgimp/gimpui.h>
#include "libgimp/stdplugins-intl.h"
#define DITHERTYPE GDK_RGB_DITHER_NORMAL
typedef enum
{
DISPOSE_UNDEFINED = 0x00,
DISPOSE_COMBINE = 0x01,
DISPOSE_REPLACE = 0x02
} DisposeType;
/* Declare local functions. */
static void query (void);
static void run (const gchar *name,
gint nparams,
const GimpParam *param,
gint *nreturn_vals,
GimpParam **return_vals);
static void do_playback (void);
static void window_response (GtkWidget *widget,
gint response_id,
gpointer data);
static void playstop_callback (GtkWidget *widget,
gpointer data);
static void rewind_callback (GtkWidget *widget,
gpointer data);
static void step_callback (GtkWidget *widget,
gpointer data);
static gboolean repaint_sda (GtkWidget *darea,
GdkEventExpose *event,
gpointer data);
static gboolean repaint_da (GtkWidget *darea,
GdkEventExpose *event,
gpointer data);
static void render_frame (gint32 whichframe);
static void show_frame (void);
static void total_alpha_preview (guchar* ptr);
static void init_preview_misc (void);
/* tag util functions*/
static int parse_ms_tag (const char *str);
static DisposeType parse_disposal_tag (const char *str);
static DisposeType get_frame_disposal (guint whichframe);
static guint32 get_frame_duration (guint whichframe);
static int is_disposal_tag (const char *str,
DisposeType *disposal,
int *taglength);
static int is_ms_tag (const char *str,
int *duration,
int *taglength);
GimpPlugInInfo PLUG_IN_INFO =
{
NULL, /* init_proc */
NULL, /* quit_proc */
query, /* query_proc */
run, /* run_proc */
};
/* Global widgets'n'stuff */
static GtkWidget *dlg = NULL;
static guchar *preview_data = NULL;
static GtkWidget *drawing_area = NULL;
static GtkWidget *shape_drawing_area = NULL;
static guchar *shape_drawing_area_data = NULL;
static guchar *drawing_area_data = NULL;
static GtkProgressBar *progress;
static guint width, height;
static guchar *preview_alpha1_data;
static guchar *preview_alpha2_data;
static gint32 image_id;
static gint32 total_frames;
static guint frame_number;
static gint32 *layers;
static GimpDrawable *drawable;
static gboolean playing = FALSE;
static guint timer = 0;
static GimpImageBaseType imagetype;
static guchar *palette;
static gint ncolours;
static GtkWidget *psbutton;
/* for shaping */
typedef struct
{
gint x, y;
} CursorOffset;
static gchar *shape_preview_mask;
static GtkWidget *shape_window;
static gint shaping = 0;
static GdkWindow *root_win = NULL;
MAIN ()
static void
query (void)
{
static GimpParamDef args[] =
{
{ GIMP_PDB_INT32, "run_mode", "Interactive, non-interactive" },
{ GIMP_PDB_IMAGE, "image", "Input image" },
{ GIMP_PDB_DRAWABLE, "drawable", "Input drawable (unused)" }
};
gimp_install_procedure ("plug_in_animationplay",
"This plugin allows you to preview a GIMP layer-based animation.",
"",
"Adam D. Moss <adam@gimp.org>",
"Adam D. Moss <adam@gimp.org>",
"1997, 1998...",
N_("_Playback..."),
"RGB*, INDEXED*, GRAY*",
GIMP_PLUGIN,
G_N_ELEMENTS (args), 0,
args, NULL);
gimp_plugin_menu_register ("plug_in_animationplay",
N_("<Image>/Filters/Animation"));
}
static void
run (const gchar *name,
gint n_params,
const GimpParam *param,
gint *nreturn_vals,
GimpParam **return_vals)
{
static GimpParam values[1];
GimpRunMode run_mode;
GimpPDBStatusType status = GIMP_PDB_SUCCESS;
*nreturn_vals = 1;
*return_vals = values;
run_mode = param[0].data.d_int32;
INIT_I18N ();
if (run_mode == GIMP_RUN_NONINTERACTIVE && n_params != 3)
{
status = GIMP_PDB_CALLING_ERROR;
}
if (status == GIMP_PDB_SUCCESS)
{
image_id = param[1].data.d_image;
do_playback();
if (run_mode != GIMP_RUN_NONINTERACTIVE)
gimp_displays_flush();
}
values[0].type = GIMP_PDB_STATUS;
values[0].data.d_status = status;
}
static void
reshape_from_bitmap (gchar* bitmap)
{
GdkBitmap *shape_mask;
static gchar *prev_bitmap = NULL;
if ((!prev_bitmap) ||
(memcmp(prev_bitmap, bitmap, (width*height)/8 +height)))
{
shape_mask = gdk_bitmap_create_from_data(shape_window->window,
bitmap,
width, height);
gtk_widget_shape_combine_mask (shape_window, shape_mask, 0, 0);
g_object_unref (shape_mask);
if (!prev_bitmap)
{
prev_bitmap = g_malloc ((width*height)/8 +height);
}
memcpy (prev_bitmap, bitmap, (width*height)/8 +height);
}
}
static gboolean
shape_pressed (GtkWidget *widget,
GdkEventButton *event)
{
CursorOffset *p;
/* ignore double and triple click */
if (event->type != GDK_BUTTON_PRESS)
return FALSE;
p = g_object_get_data (G_OBJECT(widget), "cursor-offset");
if (!p)
return FALSE;
p->x = (int) event->x;
p->y = (int) event->y;
gtk_grab_add (widget);
gdk_pointer_grab (widget->window, TRUE,
GDK_BUTTON_RELEASE_MASK |
GDK_BUTTON_MOTION_MASK |
GDK_POINTER_MOTION_HINT_MASK,
NULL, NULL, 0);
gdk_window_raise (widget->window);
return FALSE;
}
static gboolean
maybeblocked_expose (GtkWidget *widget,
GdkEventExpose *event)
{
if (playing)
return TRUE;
return repaint_sda (widget, event, NULL);
}
static gboolean
shape_released (GtkWidget *widget)
{
gtk_grab_remove (widget);
gdk_display_pointer_ungrab (gtk_widget_get_display (widget), 0);
gdk_flush ();
return FALSE;
}
static gboolean
shape_motion (GtkWidget *widget,
GdkEventMotion *event)
{
gint xp, yp;
CursorOffset *p;
GdkModifierType mask;
gdk_window_get_pointer (root_win, &xp, &yp, &mask);
/* if a button is still held by the time we process this event... */
if (mask & (GDK_BUTTON1_MASK|
GDK_BUTTON2_MASK|
GDK_BUTTON3_MASK|
GDK_BUTTON4_MASK|
GDK_BUTTON5_MASK))
{
p = g_object_get_data (G_OBJECT (widget), "cursor-offset");
if (!p)
return FALSE;
gtk_window_move (GTK_WINDOW (widget), xp - p->x, yp - p->y);
}
else /* the user has released all buttons */
{
shape_released(widget);
}
return FALSE;
}
static gboolean
repaint_da (GtkWidget *darea,
GdkEventExpose *event,
gpointer data)
{
gdk_draw_rgb_image (drawing_area->window,
drawing_area->style->white_gc,
0, 0, width, height,
(total_frames==1)?GDK_RGB_DITHER_MAX:DITHERTYPE,
drawing_area_data, width * 3);
return TRUE;
}
static gboolean
repaint_sda (GtkWidget *darea,
GdkEventExpose *event,
gpointer data)
{
gdk_draw_rgb_image (shape_drawing_area->window,
shape_drawing_area->style->white_gc,
0, 0, width, height,
(total_frames==1)?GDK_RGB_DITHER_MAX:DITHERTYPE,
shape_drawing_area_data, width * 3);
return TRUE;
}
static gboolean
preview_pressed (GtkWidget *widget,
GdkEventButton *event)
{
gint xp, yp;
GdkModifierType mask;
if (shaping)
return FALSE;
/* Create a total-alpha buffer merely for the not-shaped
drawing area to now display. */
drawing_area_data = g_malloc (width * height * 3);
total_alpha_preview (drawing_area_data);
gdk_window_get_pointer (root_win, &xp, &yp, &mask);
gtk_window_move (GTK_WINDOW (shape_window),
xp - event->x, yp - event->y);
gtk_widget_show (shape_window);
gdk_window_set_back_pixmap (shape_window->window, NULL, 0);
gdk_window_set_back_pixmap (shape_drawing_area->window, NULL, 1);
show_frame ();
shaping = 1;
memset (shape_preview_mask, 0, (width*height)/8 + height);
render_frame (frame_number);
show_frame ();
repaint_da (NULL, NULL, NULL);
/* mildly amusing hack */
return shape_pressed (shape_window, event);
}
static void
build_dialog (GimpImageBaseType basetype,
gchar *imagename)
{
gchar *windowname;
CursorOffset *icon_pos;
GtkWidget *button;
GtkWidget *frame;
GtkWidget *frame2;
GtkWidget *vbox;
GtkWidget *hbox;
GtkWidget *hbox2;
GtkWidget *eventbox;
GdkCursor *cursor;
gimp_ui_init ("animationplay", TRUE);
windowname = g_strconcat (_("Animation Playback:"), " ", imagename, NULL);
dlg = gimp_dialog_new (windowname, "animationplay",
NULL, 0,
gimp_standard_help_func, "plug-in-animationplay",
GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE,
NULL);
g_free (windowname);
g_signal_connect (dlg, "response",
G_CALLBACK (window_response),
NULL);
/* The 'playback' half of the dialog */
if (total_frames > 1)
windowname = g_strconcat (_("Playback:"), " ",imagename, NULL);
else
windowname = g_strdup (imagename);
frame = gimp_frame_new (windowname);
g_free (windowname);
gtk_container_set_border_width (GTK_CONTAINER (frame), 12);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dlg)->vbox),
frame, TRUE, TRUE, 0);
gtk_widget_show (frame);
hbox = gtk_hbox_new (FALSE, 6);
gtk_container_add (GTK_CONTAINER (frame), hbox);
gtk_widget_show (hbox);
vbox = gtk_vbox_new (FALSE, 6);
gtk_container_add (GTK_CONTAINER (hbox), vbox);
gtk_widget_show (vbox);
hbox2 = gtk_hbox_new (FALSE, 0);
gtk_box_pack_start (GTK_BOX (vbox), hbox2, TRUE, TRUE, 0);
if (total_frames > 1)
gtk_widget_show (hbox2);
psbutton = gtk_toggle_button_new_with_label ( _("Play/Stop"));
g_signal_connect (psbutton, "toggled",
G_CALLBACK (playstop_callback), NULL);
gtk_box_pack_start (GTK_BOX (hbox2), psbutton, TRUE, TRUE, 0);
gtk_widget_show (psbutton);
button = gtk_button_new_with_label ( _("Rewind"));
g_signal_connect (button, "clicked",
G_CALLBACK (rewind_callback), NULL);
gtk_box_pack_start (GTK_BOX (hbox2), button, TRUE, TRUE, 0);
gtk_widget_show (button);
button = gtk_button_new_with_label ( _("Step"));
g_signal_connect (button, "clicked",
G_CALLBACK (step_callback), NULL);
gtk_box_pack_start (GTK_BOX (hbox2), button, TRUE, TRUE, 0);
gtk_widget_show (button);
hbox2 = gtk_hbox_new (TRUE, 0);
gtk_box_pack_start (GTK_BOX (vbox), hbox2, FALSE, FALSE, 0);
gtk_widget_show (hbox2);
frame2 = gtk_frame_new (NULL);
gtk_frame_set_shadow_type (GTK_FRAME (frame2), GTK_SHADOW_IN);
gtk_box_pack_start (GTK_BOX (hbox2), frame2, FALSE, FALSE, 0);
gtk_widget_show (frame2);
eventbox = gtk_event_box_new();
gtk_widget_add_events (eventbox, GDK_BUTTON_PRESS_MASK);
gtk_container_add (GTK_CONTAINER (frame2), GTK_WIDGET (eventbox));
gtk_widget_show (eventbox);
drawing_area = gtk_drawing_area_new ();
gtk_widget_set_size_request (drawing_area, width, height);
gtk_container_add (GTK_CONTAINER (eventbox), GTK_WIDGET (drawing_area));
gtk_widget_show (drawing_area);
progress = GTK_PROGRESS_BAR (gtk_progress_bar_new ());
gtk_box_pack_start (GTK_BOX (vbox), GTK_WIDGET (progress), TRUE, TRUE, 0);
if (total_frames > 1)
gtk_widget_show (GTK_WIDGET (progress));
gtk_widget_show (dlg);
/* let's get into shape. */
shape_window = gtk_window_new (GTK_WINDOW_POPUP);
shape_drawing_area = gtk_drawing_area_new ();
gtk_widget_set_size_request (shape_drawing_area, width, height);
gtk_container_add (GTK_CONTAINER (shape_window), shape_drawing_area);
gtk_widget_show (shape_drawing_area);
gtk_widget_add_events (shape_drawing_area, GDK_BUTTON_PRESS_MASK);
gtk_widget_realize (shape_window);
gdk_window_set_back_pixmap (shape_window->window, NULL, 0);
cursor = gdk_cursor_new_for_display (gtk_widget_get_display (shape_window),
GDK_CENTER_PTR);
gdk_window_set_cursor(shape_window->window, cursor);
gdk_cursor_unref (cursor);
g_signal_connect (shape_window, "button_press_event",
G_CALLBACK (shape_pressed),NULL);
g_signal_connect (shape_window, "button_release_event",
G_CALLBACK (shape_released),NULL);
g_signal_connect (shape_window, "motion_notify_event",
G_CALLBACK (shape_motion),NULL);
icon_pos = g_new (CursorOffset, 1);
g_object_set_data (G_OBJECT (shape_window), "cursor-offset", icon_pos);
/* gtk_widget_show (shape_window);*/
g_signal_connect (eventbox, "button_press_event",
G_CALLBACK (preview_pressed), NULL);
g_signal_connect (drawing_area, "expose_event",
G_CALLBACK (repaint_da), drawing_area);
g_signal_connect (shape_drawing_area, "expose_event",
G_CALLBACK (maybeblocked_expose), shape_drawing_area);
root_win = gdk_get_default_root_window ();
}
static void
do_playback (void)
{
int i;
width = gimp_image_width (image_id);
height = gimp_image_height (image_id);
layers = gimp_image_get_layers (image_id, &total_frames);
imagetype = gimp_image_base_type (image_id);
if (imagetype == GIMP_INDEXED)
palette = gimp_image_get_cmap (image_id, &ncolours);
else if (imagetype == GIMP_GRAY)
{
/* This is a bit sick, until this plugin ever gets
real GRAY support (not worth it?) */
palette = g_malloc(768);
for (i=0;i<256;i++)
{
palette[i*3] = palette[i*3+1] = palette[i*3+2] = i;
}
ncolours = 256;
}
frame_number = 0;
/* cache hint "cache nothing", since we iterate over every
tile in every layer. */
gimp_tile_cache_size (0);
init_preview_misc();
build_dialog (gimp_image_base_type (image_id),
gimp_image_get_name (image_id));
/* Make sure that whole preview is dirtied with pure-alpha */
total_alpha_preview(preview_data);
render_frame(0);
show_frame();
gtk_main ();
gdk_flush ();
}
/* Rendering Functions */
static void
render_frame (gint32 whichframe)
{
GimpPixelRgn pixel_rgn;
static guchar *rawframe = NULL;
static gint rawwidth = 0, rawheight = 0, rawbpp = 0;
gint rawx = 0, rawy = 0;
guchar *srcptr;
guchar *destptr;
gint i, j, k; /* imaginative loop variables */
DisposeType dispose;
if (whichframe >= total_frames)
{
printf( "playback: Asked for frame number %d in a %d-frame animation!\n",
(int) (whichframe+1), (int) total_frames);
exit(-1);
}
drawable = gimp_drawable_get (layers[total_frames-(whichframe+1)]);
/* Lame attempt to catch the case that a user has closed the image. */
if (! (drawable->width > 0 && drawable->height > 0))
{
gtk_main_quit ();
return;
}
dispose = get_frame_disposal (frame_number);
/* Image has been closed/etc since we got the layer list? */
/* FIXME - How do we tell if a gimp_drawable_get() fails? */
if (gimp_drawable_width (drawable->drawable_id) == 0)
gtk_dialog_response (GTK_DIALOG (dlg), GTK_RESPONSE_CLOSE);
if (((dispose==DISPOSE_REPLACE)||(whichframe==0)) &&
gimp_drawable_has_alpha (drawable->drawable_id))
{
total_alpha_preview (preview_data);
}
/* only get a new 'raw' drawable-data buffer if this and
the previous raw buffer were different sizes*/
if ((rawwidth*rawheight*rawbpp)
!=
((gimp_drawable_width(drawable->drawable_id)*
gimp_drawable_height(drawable->drawable_id)*
gimp_drawable_bpp(drawable->drawable_id))))
{
if (rawframe != NULL)
g_free(rawframe);
rawframe = g_malloc((gimp_drawable_width(drawable->drawable_id)) *
(gimp_drawable_height(drawable->drawable_id)) *
(gimp_drawable_bpp(drawable->drawable_id)));
}
rawwidth = gimp_drawable_width(drawable->drawable_id);
rawheight = gimp_drawable_height(drawable->drawable_id);
rawbpp = gimp_drawable_bpp(drawable->drawable_id);
/* Initialise and fetch the whole raw new frame */
gimp_pixel_rgn_init (&pixel_rgn,
drawable,
0, 0,
drawable->width, drawable->height,
FALSE,
FALSE);
gimp_pixel_rgn_get_rect (&pixel_rgn,
rawframe,
0, 0,
drawable->width, drawable->height);
/* gimp_pixel_rgns_register (1, &pixel_rgn);*/
gimp_drawable_offsets (drawable->drawable_id,
&rawx,
&rawy);
/* render... */
switch (imagetype)
{
case GIMP_RGB:
if ((rawwidth==width) &&
(rawheight==height) &&
(rawx==0) &&
(rawy==0))
{
/* --- These cases are for the best cases, in --- */
/* --- which this frame is the same size and position --- */
/* --- as the preview buffer itself --- */
if (gimp_drawable_has_alpha (drawable->drawable_id))
{ /* alpha */
destptr = preview_data;
srcptr = rawframe;
i = rawwidth*rawheight;
while (i--)
{
if (!(*(srcptr+3)&128))
{
srcptr += 4;
destptr += 3;
continue;
}
*(destptr++) = *(srcptr++);
*(destptr++) = *(srcptr++);
*(destptr++) = *(srcptr++);
srcptr++;
}
/* calculate the shape mask */
if (shaping)
{
srcptr = rawframe + 3;
for (j=0;j<rawheight;j++)
{
k = j * ((7 + rawwidth) / 8);
for (i=0;i<rawwidth;i++)
{
if ((*srcptr)&128)
shape_preview_mask[k+i/8] |= (1<<(i&7));
srcptr += 4;
}
}
}
}
else /* no alpha */
{
if ((rawwidth==width)&&(rawheight==height))
{
memcpy(preview_data, rawframe, width*height*3);
}
if (shaping)
{
/* opacify the shape mask */
memset(shape_preview_mask, 255,
(rawwidth*rawheight)/8 + rawheight);
}
}
/* Display the preview buffer... finally. */
if (shaping)
{
reshape_from_bitmap (shape_preview_mask);
gdk_draw_rgb_image (shape_drawing_area->window,
shape_drawing_area->style->white_gc,
0, 0, width, height,
(total_frames==1)?GDK_RGB_DITHER_MAX
:DITHERTYPE,
preview_data, width * 3);
}
else
{
reshape_from_bitmap (shape_preview_mask);
gdk_draw_rgb_image (drawing_area->window,
drawing_area->style->white_gc,
0, 0, width, height,
(total_frames==1)?GDK_RGB_DITHER_MAX
:DITHERTYPE,
preview_data, width * 3);
}
}
else
{
/* --- These are suboptimal catch-all cases for when --- */
/* --- this frame is bigger/smaller than the preview --- */
/* --- buffer, and/or offset within it. --- */
if (gimp_drawable_has_alpha (drawable->drawable_id))
{ /* alpha */
srcptr = rawframe;
for (j=rawy; j<rawheight+rawy; j++)
{
for (i=rawx; i<rawwidth+rawx; i++)
{
if ((i>=0 && i<width) &&
(j>=0 && j<height))
{
if (*(srcptr+3)&128)
{
preview_data[(j*width+i)*3 ] = *(srcptr);
preview_data[(j*width+i)*3 +1] = *(srcptr+1);
preview_data[(j*width+i)*3 +2] = *(srcptr+2);
}
}
srcptr += 4;
}
}
if (shaping)
{
srcptr = rawframe + 3;
for (j=rawy; j<rawheight+rawy; j++)
{
k = j * ((width+7)/8);
for (i=rawx; i<rawwidth+rawx; i++)
{
if ((i>=0 && i<width) &&
(j>=0 && j<height))
{
if ((*srcptr)&128)
shape_preview_mask[k+i/8] |= (1<<(i&7));
}
srcptr += 4;
}
}
}
}
else
{
/* noalpha */
srcptr = rawframe;
for (j=rawy; j<rawheight+rawy; j++)
{
for (i=rawx; i<rawwidth+rawx; i++)
{
if ((i>=0 && i<width) &&
(j>=0 && j<height))
{
preview_data[(j*width+i)*3 ] = *(srcptr);
preview_data[(j*width+i)*3 +1] = *(srcptr+1);
preview_data[(j*width+i)*3 +2] = *(srcptr+2);
}
srcptr += 3;
}
}
}
/* Display the preview buffer... finally. */
if (shaping)
{
if ((dispose!=DISPOSE_REPLACE)&&(whichframe!=0))
{
int top, bottom;
top = (rawy < 0) ? 0 : rawy;
bottom = (rawy+rawheight) < height ?
(rawy+rawheight) : height-1;
reshape_from_bitmap (shape_preview_mask);
gdk_draw_rgb_image (shape_drawing_area->window,
shape_drawing_area->style->white_gc,
0, top, width, bottom-top,
(total_frames==1)?GDK_RGB_DITHER_MAX
:DITHERTYPE,
&preview_data[3*top*width], width * 3);
}
else
{
reshape_from_bitmap (shape_preview_mask);
gdk_draw_rgb_image (shape_drawing_area->window,
shape_drawing_area->style->white_gc,
0, 0, width, height,
(total_frames==1)?GDK_RGB_DITHER_MAX
:DITHERTYPE,
preview_data, width * 3);
}
}
else
{
if ((dispose!=DISPOSE_REPLACE)&&(whichframe!=0))
{
int top, bottom;
top = (rawy < 0) ? 0 : rawy;
bottom = (rawy+rawheight) < height ?
(rawy+rawheight) : height-1;
gdk_draw_rgb_image (drawing_area->window,
drawing_area->style->white_gc,
0, top, width, bottom-top,
(total_frames==1)?GDK_RGB_DITHER_MAX
:DITHERTYPE,
&preview_data[3*top*width], width * 3);
}
else
{
gdk_draw_rgb_image (drawing_area->window,
drawing_area->style->white_gc,
0, 0, width, height,
(total_frames==1)?GDK_RGB_DITHER_MAX
:DITHERTYPE,
preview_data, width * 3);
}
}
}
break;
case GIMP_GRAY:
case GIMP_INDEXED:
if ((rawwidth==width) &&
(rawheight==height) &&
(rawx==0) &&
(rawy==0))
{
/* --- These cases are for the best cases, in --- */
/* --- which this frame is the same size and position --- */
/* --- as the preview buffer itself --- */
if (gimp_drawable_has_alpha (drawable->drawable_id))
{ /* alpha */
destptr = preview_data;
srcptr = rawframe;
i = rawwidth*rawheight;
while (i--)
{
if (!(*(srcptr+1)))
{
srcptr += 2;
destptr += 3;
continue;
}
*(destptr++) = palette[3*(*(srcptr))];
*(destptr++) = palette[1+3*(*(srcptr))];
*(destptr++) = palette[2+3*(*(srcptr))];
srcptr+=2;
}
/* calculate the shape mask */
if (shaping)
{
srcptr = rawframe + 1;
for (j=0;j<rawheight;j++)
{
k = j * ((7 + rawwidth) / 8);
for (i=0;i<rawwidth;i++)
{
if (*srcptr)
shape_preview_mask[k+i/8] |= (1<<(i&7));
srcptr += 2;
}
}
}
}
else /* no alpha */
{
destptr = preview_data;
srcptr = rawframe;
i = rawwidth*rawheight;
while (--i)
{
*(destptr++) = palette[3*(*(srcptr))];
*(destptr++) = palette[1+3*(*(srcptr))];
*(destptr++) = palette[2+3*(*(srcptr))];
srcptr++;
}
if (shaping)
{
/* opacify the shape mask */
memset(shape_preview_mask, 255,
(rawwidth*rawheight)/8 + rawheight);
}
}
/* Display the preview buffer... finally. */
if (shaping)
{
reshape_from_bitmap (shape_preview_mask);
gdk_draw_rgb_image (shape_drawing_area->window,
shape_drawing_area->style->white_gc,
0, 0, width, height,
(total_frames==1)?GDK_RGB_DITHER_MAX
:DITHERTYPE,
preview_data, width * 3);
}
else
{
gdk_draw_rgb_image (drawing_area->window,
drawing_area->style->white_gc,
0, 0, width, height,
(total_frames==1)?GDK_RGB_DITHER_MAX
:DITHERTYPE,
preview_data, width * 3);
}
}
else
{
/* --- These are suboptimal catch-all cases for when --- */
/* --- this frame is bigger/smaller than the preview --- */
/* --- buffer, and/or offset within it. --- */
if (gimp_drawable_has_alpha (drawable->drawable_id))
{ /* alpha */
srcptr = rawframe;
for (j=rawy; j<rawheight+rawy; j++)
{
for (i=rawx; i<rawwidth+rawx; i++)
{
if ((i>=0 && i<width) &&
(j>=0 && j<height))
{
if (*(srcptr+1))
{
preview_data[(j*width+i)*3 ] =
palette[3*(*(srcptr))];
preview_data[(j*width+i)*3 +1] =
palette[1+3*(*(srcptr))];
preview_data[(j*width+i)*3 +2] =
palette[2+3*(*(srcptr))];
}
}
srcptr += 2;
}
}
if (shaping)
{
srcptr = rawframe + 1;
for (j=rawy; j<rawheight+rawy; j++)
{
k = j * ((width+7)/8);
for (i=rawx; i<rawwidth+rawx; i++)
{
if ((i>=0 && i<width) &&
(j>=0 && j<height))
{
if (*srcptr)
shape_preview_mask[k+i/8] |= (1<<(i&7));
}
srcptr += 2;
}
}
}
}
else
{
/* noalpha */
srcptr = rawframe;
for (j=rawy; j<rawheight+rawy; j++)
{
for (i=rawx; i<rawwidth+rawx; i++)
{
if ((i>=0 && i<width) &&
(j>=0 && j<height))
{
preview_data[(j*width+i)*3 ] =
palette[3*(*(srcptr))];
preview_data[(j*width+i)*3 +1] =
palette[1+3*(*(srcptr))];
preview_data[(j*width+i)*3 +2] =
palette[2+3*(*(srcptr))];
}
srcptr ++;
}
}
}
/* Display the preview buffer... finally. */
if (shaping)
{
if ((dispose!=DISPOSE_REPLACE)&&(whichframe!=0))
{
int top, bottom;
top = (rawy < 0) ? 0 : rawy;
bottom = (rawy+rawheight) < height ?
(rawy+rawheight) : height-1;
reshape_from_bitmap (shape_preview_mask);
gdk_draw_rgb_image (shape_drawing_area->window,
shape_drawing_area->style->white_gc,
0, top, width, bottom-top,
(total_frames==1)?GDK_RGB_DITHER_MAX
:DITHERTYPE,
&preview_data[3*top*width], width * 3);
}
else
{
reshape_from_bitmap (shape_preview_mask);
gdk_draw_rgb_image (shape_drawing_area->window,
shape_drawing_area->style->white_gc,
0, 0, width, height,
(total_frames==1)?GDK_RGB_DITHER_MAX
:DITHERTYPE,
preview_data, width * 3);
}
}
else
{
if ((dispose!=DISPOSE_REPLACE)&&(whichframe!=0))
{
int top, bottom;
top = (rawy < 0) ? 0 : rawy;
bottom = (rawy+rawheight) < height ?
(rawy+rawheight) : height-1;
gdk_draw_rgb_image (drawing_area->window,
drawing_area->style->white_gc,
0, top, width, bottom-top,
(total_frames==1)?GDK_RGB_DITHER_MAX
:DITHERTYPE,
&preview_data[3*top*width], width * 3);
}
else
{
gdk_draw_rgb_image (drawing_area->window,
drawing_area->style->white_gc,
0, 0, width, height,
(total_frames==1)?GDK_RGB_DITHER_MAX
:DITHERTYPE,
preview_data, width * 3);
}
}
}
break;
}
/* clean up */
gimp_drawable_detach(drawable);
}
/* If we're using GDKRGB, we don't reshape in this function because
it's too late (GDKRGB is synchronous). So this just updates the
progress bar. */
static void
show_frame (void)
{
gchar *text;
/* update the dialog's progress bar */
gtk_progress_bar_set_fraction (progress,
((float)frame_number / (float)(total_frames-0.999)));
text = g_strdup_printf (_("Frame %d of %d"), frame_number + 1, total_frames);
gtk_progress_bar_set_text (progress, text);
g_free (text);
}
static void
init_preview_misc (void)
{
int i;
preview_data = g_malloc(width*height*3);
shape_preview_mask = g_malloc((width*height)/8 + 1 + height);
preview_alpha1_data = g_malloc(width*3);
preview_alpha2_data = g_malloc(width*3);
for (i=0;i<width;i++)
{
if (i&8)
{
preview_alpha1_data[i*3 +0] =
preview_alpha1_data[i*3 +1] =
preview_alpha1_data[i*3 +2] = 102;
preview_alpha2_data[i*3 +0] =
preview_alpha2_data[i*3 +1] =
preview_alpha2_data[i*3 +2] = 154;
}
else
{
preview_alpha1_data[i*3 +0] =
preview_alpha1_data[i*3 +1] =
preview_alpha1_data[i*3 +2] = 154;
preview_alpha2_data[i*3 +0] =
preview_alpha2_data[i*3 +1] =
preview_alpha2_data[i*3 +2] = 102;
}
}
drawing_area_data = preview_data;
shape_drawing_area_data = preview_data;
}
static void
total_alpha_preview (guchar* ptr)
{
if (shaping)
{
memset(shape_preview_mask, 0, (width*height)/8 + height);
}
else
{
gint i;
for (i = 0;i < height; i++)
{
if (i & 8)
memcpy (&ptr[i*3*width], preview_alpha1_data, 3*width);
else
memcpy (&ptr[i*3*width], preview_alpha2_data, 3*width);
}
}
}
/* Util. */
static void
remove_timer (void)
{
if (timer)
{
g_source_remove (timer);
timer = 0;
}
}
static void
do_step (void)
{
frame_number = (frame_number+1)%total_frames;
render_frame(frame_number);
}
/* Callbacks */
static void
window_response (GtkWidget *widget,
gint response_id,
gpointer data)
{
gtk_widget_destroy (widget);
if (playing)
playstop_callback (NULL, NULL);
if (shape_window)
gtk_widget_destroy (GTK_WIDGET (shape_window));
gdk_flush();
gtk_main_quit();
}
static gint
advance_frame_callback (gpointer data)
{
remove_timer();
timer = g_timeout_add (get_frame_duration((frame_number+1)%total_frames),
advance_frame_callback, NULL);
do_step();
show_frame();
return FALSE;
}
static void
playstop_callback (GtkWidget *widget,
gpointer data)
{
if (!playing)
{ /* START PLAYING */
playing = TRUE;
timer = g_timeout_add (get_frame_duration(frame_number),
advance_frame_callback, NULL);
}
else
{ /* STOP PLAYING */
playing = FALSE;
remove_timer();
}
}
static void
rewind_callback (GtkWidget *widget,
gpointer data)
{
if (playing)
{
playstop_callback(NULL, NULL); /* GTK weirdness workaround */
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (psbutton), FALSE);
playing = FALSE;
remove_timer();
}
frame_number = 0;
render_frame(frame_number);
show_frame();
}
static void
step_callback (GtkWidget *widget,
gpointer data)
{
if (playing)
{
playstop_callback(NULL, NULL); /* GTK weirdness workaround */
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (psbutton), FALSE);
playing = FALSE;
remove_timer();
}
do_step();
show_frame();
}
/* tag util. */
static DisposeType
get_frame_disposal (guint whichframe)
{
gchar *layer_name;
DisposeType disposal;
layer_name = gimp_drawable_get_name (layers[total_frames-(whichframe+1)]);
disposal = parse_disposal_tag (layer_name);
g_free (layer_name);
return disposal;
}
static guint32
get_frame_duration (guint whichframe)
{
gchar *layer_name;
gint duration = 0;
layer_name = gimp_drawable_get_name(layers[total_frames-(whichframe+1)]);
if (layer_name)
{
duration = parse_ms_tag(layer_name);
g_free(layer_name);
}
if (duration < 0) duration = 100; /* FIXME for default-if-not-said */
else
if (duration == 0) duration = 100; /* FIXME - 0-wait is nasty */
return (guint32) duration;
}
static int
is_ms_tag (const char *str,
int *duration,
int *taglength)
{
gint sum = 0;
gint offset;
gint length;
length = strlen(str);
if (str[0] != '(')
return 0;
offset = 1;
/* eat any spaces between open-parenthesis and number */
while ((offset<length) && (str[offset] == ' '))
offset++;
if ((offset>=length) || (!g_ascii_isdigit (str[offset])))
return 0;
do
{
sum *= 10;
sum += str[offset] - '0';
offset++;
}
while ((offset<length) && (g_ascii_isdigit (str[offset])));
if (length-offset <= 2)
return 0;
/* eat any spaces between number and 'ms' */
while ((offset<length) && (str[offset] == ' '))
offset++;
if (length-offset <= 2 ||
g_ascii_toupper (str[offset]) != 'M' ||
g_ascii_toupper (str[offset + 1]) != 'S')
return 0;
offset += 2;
/* eat any spaces between 'ms' and close-parenthesis */
while ((offset<length) && (str[offset] == ' '))
offset++;
if ((length-offset < 1) || (str[offset] != ')'))
return 0;
offset++;
*duration = sum;
*taglength = offset;
return 1;
}
static int
parse_ms_tag (const char *str)
{
int i;
int rtn;
int dummy;
int length;
length = strlen(str);
for (i = 0; i < length; i++)
{
if (is_ms_tag (&str[i], &rtn, &dummy))
return rtn;
}
return -1;
}
static int
is_disposal_tag (const char *str,
DisposeType *disposal,
int *taglength)
{
if (strlen(str) != 9)
return 0;
if (strncmp(str, "(combine)", 9) == 0)
{
*taglength = 9;
*disposal = DISPOSE_COMBINE;
return 1;
}
else if (strncmp(str, "(replace)", 9) == 0)
{
*taglength = 9;
*disposal = DISPOSE_REPLACE;
return 1;
}
return 0;
}
static DisposeType
parse_disposal_tag (const char *str)
{
DisposeType rtn;
int i, dummy;
gint length;
length = strlen(str);
for (i = 0; i < length; i++)
{
if (is_disposal_tag (&str[i], &rtn, &dummy))
{
return rtn;
}
}
return DISPOSE_UNDEFINED; /* FIXME */
}
Reference in New Issue View Git Blame Copy Permalink