gdk-pixbuf-loader.c 9.88 KB
Newer Older
1
2
/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */

3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
/* GdkPixbuf library - Main header file
 *
 * 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>
 *          Jonathan Blandford <jrb@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 "gdk-pixbuf-loader.h"
29
#include "gdk-pixbuf-io.h"
Jonathan Blandford's avatar
Jonathan Blandford committed
30
#include <gtk/gtksignal.h>
31

32
33


34
35
36
37
38
39
enum {
	AREA_UPDATED,
	AREA_PREPARED,
	CLOSED,
	LAST_SIGNAL
};
40

41
static GtkObjectClass *parent_class;
42
43
44

static void gdk_pixbuf_loader_class_init    (GdkPixbufLoaderClass   *klass);
static void gdk_pixbuf_loader_init          (GdkPixbufLoader        *loader);
45
46
static void gdk_pixbuf_loader_destroy       (GtkObject              *loader);
static void gdk_pixbuf_loader_finalize      (GtkObject              *loader);
47

48
49
50
static guint pixbuf_loader_signals[LAST_SIGNAL] = { 0 };


51

52
/* Internal data */
53
54
55

#define LOADER_HEADER_SIZE 128

56
typedef struct {
57
58
	GdkPixbuf *pixbuf;
	gboolean closed;
59
60
	gchar header_buf[LOADER_HEADER_SIZE];
	gint header_buf_offset;
61
	GdkPixbufModule *image_module;
62
	gpointer context;
63
} GdkPixbufLoaderPrivate;
64

65

66
67

/* our marshaller */
68
69
70
71
72
typedef void (* GtkSignal_NONE__INT_INT_INT_INT) (GtkObject *object,
						  gint arg1, gint arg2, gint arg3, gint arg4,
						  gpointer user_data);
static void
gtk_marshal_NONE__INT_INT_INT_INT (GtkObject *object, GtkSignalFunc func, gpointer func_data,
73
74
				   GtkArg * args)
{
75
76
77
78
79
80
81
82
83
	GtkSignal_NONE__INT_INT_INT_INT rfunc;

	rfunc = (GtkSignal_NONE__INT_INT_INT_INT) func;
	(*rfunc) (object,
		  GTK_VALUE_INT (args[0]),
		  GTK_VALUE_INT (args[1]),
		  GTK_VALUE_INT (args[2]),
		  GTK_VALUE_INT (args[3]),
		  func_data);
84
}
85

86
87
88
89
90
91
92
93
94
95
96


/**
 * gdk_pixbuf_loader_get_type:
 * @void: 
 * 
 * Registers the &GdkPixubfLoader class if necessary, and returns the type ID
 * associated to it.
 * 
 * Return value: The type ID of the &GdkPixbufLoader class.
 **/
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
GtkType
gdk_pixbuf_loader_get_type (void)
{
	static GtkType loader_type = 0;

	if (!loader_type) {
		static const GtkTypeInfo loader_info = {
			"GdkPixbufLoader",
			sizeof (GdkPixbufLoader),
			sizeof (GdkPixbufLoaderClass),
			(GtkClassInitFunc) gdk_pixbuf_loader_class_init,
			(GtkObjectInitFunc) gdk_pixbuf_loader_init,
			/* reserved_1 */ NULL,
			/* reserved_2 */ NULL,
			(GtkClassInitFunc) NULL,
		};

		loader_type = gtk_type_unique (GTK_TYPE_OBJECT, &loader_info);
	}

	return loader_type;
}

static void
121
gdk_pixbuf_loader_class_init (GdkPixbufLoaderClass *class)
122
{
123
124
125
126
127
	GtkObjectClass *object_class;

	object_class = (GtkObjectClass *) class;

	parent_class = gtk_type_class (gtk_object_get_type ());
128

129
130
131
132
133
134
135
136
137
138
139
140
141
142
	pixbuf_loader_signals[AREA_PREPARED] =
		gtk_signal_new ("area_prepared",
				GTK_RUN_LAST,
				parent_class->type,
				GTK_SIGNAL_OFFSET (GdkPixbufLoaderClass, area_prepared),
				gtk_marshal_NONE__NONE,
				GTK_TYPE_NONE, 0);

	pixbuf_loader_signals[AREA_UPDATED] =
		gtk_signal_new ("area_updated",
				GTK_RUN_LAST,
				parent_class->type,
				GTK_SIGNAL_OFFSET (GdkPixbufLoaderClass, area_updated),
				gtk_marshal_NONE__INT_INT_INT_INT,
143
144
145
146
147
				GTK_TYPE_NONE, 4,
				GTK_TYPE_INT,
				GTK_TYPE_INT,
				GTK_TYPE_INT,
				GTK_TYPE_INT);
148
149
150
151
152
153
154
155
156

	pixbuf_loader_signals[CLOSED] =
		gtk_signal_new ("closed",
				GTK_RUN_LAST,
				parent_class->type,
				GTK_SIGNAL_OFFSET (GdkPixbufLoaderClass, closed),
				gtk_marshal_NONE__NONE,
				GTK_TYPE_NONE, 0);

157
	gtk_object_class_add_signals (object_class, pixbuf_loader_signals, LAST_SIGNAL);
158

159
160
	object_class->destroy = gdk_pixbuf_loader_destroy;
	object_class->finalize = gdk_pixbuf_loader_finalize;
161
162
163
164
165
}

static void
gdk_pixbuf_loader_init (GdkPixbufLoader *loader)
{
166
	GdkPixbufLoaderPrivate *priv;
167

168
	priv = g_new0 (GdkPixbufLoaderPrivate, 1);
169
	loader->private = priv;
170
171
172
}

static void
Arturo Espinosa's avatar
Arturo Espinosa committed
173
gdk_pixbuf_loader_destroy (GtkObject *object)
174
{
Arturo Espinosa's avatar
Arturo Espinosa committed
175
	GdkPixbufLoader *loader;
176
	GdkPixbufLoaderPrivate *priv = NULL;
177

Arturo Espinosa's avatar
Arturo Espinosa committed
178
179
	g_return_if_fail (object != NULL);
	g_return_if_fail (GDK_IS_PIXBUF_LOADER (object));
180

Arturo Espinosa's avatar
Arturo Espinosa committed
181
182
	loader = GDK_PIXBUF_LOADER (object);
	priv = loader->private;
183

184
	if (!priv->closed)
Arturo Espinosa's avatar
Arturo Espinosa committed
185
		gdk_pixbuf_loader_close (loader);
186
187
188

	if (priv->pixbuf)
		gdk_pixbuf_unref (priv->pixbuf);
189
190

	if (GTK_OBJECT_CLASS (parent_class)->destroy)
Arturo Espinosa's avatar
Arturo Espinosa committed
191
		(* GTK_OBJECT_CLASS (parent_class)->destroy) (object);
192
193
194
}

static void
Arturo Espinosa's avatar
Arturo Espinosa committed
195
gdk_pixbuf_loader_finalize (GtkObject *object)
196
{
Arturo Espinosa's avatar
Arturo Espinosa committed
197
	GdkPixbufLoader *loader;
198
	GdkPixbufLoaderPrivate *priv = NULL;
199

Arturo Espinosa's avatar
Arturo Espinosa committed
200
201
202
	loader = GDK_PIXBUF_LOADER (object);
	priv = loader->private;

203
	g_free (priv);
204
205

	if (GTK_OBJECT_CLASS (parent_class)->finalize)
Arturo Espinosa's avatar
Arturo Espinosa committed
206
		(* GTK_OBJECT_CLASS (parent_class)->finalize) (object);
207
208
}

209
210
211
212
213
214
215
216
217
218
static void
gdk_pixbuf_loader_prepare (GdkPixbuf *pixbuf, gpointer loader)
{
	GdkPixbufLoaderPrivate *priv = NULL;

	priv = GDK_PIXBUF_LOADER (loader)->private;
	gdk_pixbuf_ref (pixbuf);
	g_assert (priv->pixbuf == NULL);

	priv->pixbuf = pixbuf;
Jonathan Blandford's avatar
Jonathan Blandford committed
219
	gtk_signal_emit (GTK_OBJECT (loader), pixbuf_loader_signals[AREA_PREPARED]);
220
221
}

222
223
224
225
226
227
228
229
230
231
232


/**
 * gdk_pixbuf_loader_new:
 * @void: 
 * 
 * Creates a new pixbuf loader object.
 * 
 * Return value: A newly-created pixbuf loader.
 **/
GdkPixbufLoader *
233
234
gdk_pixbuf_loader_new (void)
{
235
	return gtk_type_new (gdk_pixbuf_loader_get_type ());
236
237
}

238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
static int
gdk_pixbuf_loader_load_module(GdkPixbufLoader *loader)
{
	GdkPixbufLoaderPrivate *priv = loader->private;

	priv->image_module = gdk_pixbuf_get_module (priv->header_buf, priv->header_buf_offset);

	if (priv->image_module == NULL)
		return 0;

	if (priv->image_module->module == NULL)
		gdk_pixbuf_load_module (priv->image_module);

	if (priv->image_module->module == NULL)
		return 0;

	if ((priv->image_module->begin_load == NULL) ||
	    (priv->image_module->stop_load == NULL) ||
	    (priv->image_module->load_increment == NULL)) {
		g_warning ("module %s does not support incremental loading.\n",
			   priv->image_module->module_name);
		return 0;
	}

	priv->context = (*priv->image_module->begin_load) (gdk_pixbuf_loader_prepare, loader);

	if (priv->context == NULL) {
		g_warning("Failed to begin progressive load");
		return 0;
	}

	if( (* priv->image_module->load_increment) (priv->context, priv->header_buf, priv->header_buf_offset) )
		return priv->header_buf_offset;
 
	return 0;
}

static int
gdk_pixbuf_loader_eat_header_write (GdkPixbufLoader *loader, guchar *buf, size_t count)
{
	int nbytes;
	GdkPixbufLoaderPrivate *priv = loader->private;

	nbytes = MIN(LOADER_HEADER_SIZE - priv->header_buf_offset, count);
	memcpy (priv->header_buf + priv->header_buf_offset, buf, nbytes);
	    
	priv->header_buf_offset += nbytes;
	    
	if(priv->header_buf_offset >= LOADER_HEADER_SIZE) {
		return gdk_pixbuf_loader_load_module(loader);
	} else
		return nbytes;
}

292
293
/**
 * gdk_pixbuf_loader_write:
294
 * @loader: A pixbuf loader.
295
296
 * @buf: The image data.
 * @count: The length of @buf in bytes.
297
 *
298
299
300
 * This will load the next @size bytes of the image.  It will return TRUE if the
 * data was loaded successfully, and FALSE if an error occurred. In this case,
 * the loader will be closed, and will not accept further writes.
301
 *
302
303
304
305
 * Return value: Returns TRUE if the write was successful -- FALSE if the loader
 * cannot parse the buf.
 **/
gboolean
306
gdk_pixbuf_loader_write (GdkPixbufLoader *loader, guchar *buf, size_t count)
307
308
309
310
311
{
	GdkPixbufLoaderPrivate *priv;

	g_return_val_if_fail (loader != NULL, FALSE);
	g_return_val_if_fail (GDK_IS_PIXBUF_LOADER (loader), FALSE);
312

313
314
	g_return_val_if_fail (buf != NULL, FALSE);
	g_return_val_if_fail (count >= 0, FALSE);
315
316
317
318
319
320

	priv = loader->private;

	/* we expect it's not to be closed */
	g_return_val_if_fail (priv->closed == FALSE, FALSE);

321
	if (priv->image_module == NULL) {
322
323
324
325
326
327
328
329
		int eaten;

		eaten = gdk_pixbuf_loader_eat_header_write(loader, buf, count);
		if (eaten <= 0)
			return FALSE;

		count -= eaten;
		buf += eaten;
330
	}
331

332
	if (count > 0 && priv->image_module->load_increment)
333
334
		return (* priv->image_module->load_increment) (priv->context, buf, count);

335
	return TRUE;
336
337
338
339
}

/**
 * gdk_pixbuf_loader_get_pixbuf:
340
 * @loader: A pixbuf loader.
341
 *
342
343
344
345
346
347
 * Gets the GdkPixbuf that the loader is currently loading.  If the loader
 * hasn't been enough data via gdk_pixbuf_loader_write, then NULL is returned.
 * Any application using this function should check for this value when it is
 * used.  The pixbuf returned will be the same in all future calls to the
 * loader, so simply calling a gdk_pixbuf_ref() should be sufficient to continue
 * using it.
348
 *
349
350
351
352
353
354
355
356
357
 * Return value: The GdkPixbuf that the loader is loading.
 **/
GdkPixbuf *
gdk_pixbuf_loader_get_pixbuf (GdkPixbufLoader *loader)
{
	GdkPixbufLoaderPrivate *priv;

	g_return_val_if_fail (loader != NULL, NULL);
	g_return_val_if_fail (GDK_IS_PIXBUF_LOADER (loader), NULL);
358

359
360
361
362
363
364
365
	priv = loader->private;

	return priv->pixbuf;
}

/**
 * gdk_pixbuf_loader_close:
366
 * @loader: A pixbuf loader.
367
 *
368
 * Tells the loader to stop accepting writes.
369
370
371
372
373
374
375
376
377
378
379
380
381
 **/
void
gdk_pixbuf_loader_close (GdkPixbufLoader *loader)
{
	GdkPixbufLoaderPrivate *priv;

	g_return_if_fail (loader != NULL);
	g_return_if_fail (GDK_IS_PIXBUF_LOADER (loader));

	priv = loader->private;

	/* we expect it's not closed */
	g_return_if_fail (priv->closed == FALSE);
382
383

	/* We have less the 128 bytes in the image.  Flush it, and keep going. */
384
385
	if (priv->image_module == NULL)
		gdk_pixbuf_loader_load_module (loader);
386
387

	if (priv->image_module && priv->image_module->stop_load)
388
		(* priv->image_module->stop_load) (priv->context);
389

390
391
	priv->closed = TRUE;
}