forked from AuroraMiddleware/gtk
94218b8cfe
* gdk-pixbuf-io.c (generic_image_load): New function for loading an image from a file either via module->load or incrementally. (prepared_notify): ModulePreparedNotifyFunc for generic_image_load. (gdk_pixbuf_new_from_file): Use generic_image_load. * io-bmp.c, io-ico.c, io-ras.c, io-wbmp.c: Remove trivial implementations of module->load. (#71266)
929 lines
25 KiB
C
929 lines
25 KiB
C
/* -*- mode: C; c-file-style: "linux" -*- */
|
||
/* GdkPixbuf library - Main loading interface.
|
||
*
|
||
* Copyright (C) 1999 The Free Software Foundation
|
||
*
|
||
* Authors: Miguel de Icaza <miguel@gnu.org>
|
||
* Federico Mena-Quintero <federico@gimp.org>
|
||
*
|
||
* 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 <config.h>
|
||
#include <string.h>
|
||
#include <glib.h>
|
||
#include <errno.h>
|
||
#include "gdk-pixbuf-private.h"
|
||
#include "gdk-pixbuf-io.h"
|
||
|
||
#ifdef G_OS_WIN32
|
||
#define STRICT
|
||
#include <windows.h>
|
||
#undef STRICT
|
||
#endif
|
||
|
||
|
||
|
||
static gboolean
|
||
pixbuf_check_png (guchar *buffer, int size)
|
||
{
|
||
if (size < 28)
|
||
return FALSE;
|
||
|
||
if (buffer [0] != 0x89 ||
|
||
buffer [1] != 'P' ||
|
||
buffer [2] != 'N' ||
|
||
buffer [3] != 'G' ||
|
||
buffer [4] != 0x0d ||
|
||
buffer [5] != 0x0a ||
|
||
buffer [6] != 0x1a ||
|
||
buffer [7] != 0x0a)
|
||
return FALSE;
|
||
|
||
return TRUE;
|
||
}
|
||
|
||
static gboolean
|
||
pixbuf_check_jpeg (guchar *buffer, int size)
|
||
{
|
||
if (size < 10)
|
||
return FALSE;
|
||
|
||
if (buffer [0] != 0xff || buffer [1] != 0xd8)
|
||
return FALSE;
|
||
|
||
return TRUE;
|
||
}
|
||
|
||
static gboolean
|
||
pixbuf_check_tiff (guchar *buffer, int size)
|
||
{
|
||
if (size < 10)
|
||
return FALSE;
|
||
|
||
if (buffer [0] == 'M' &&
|
||
buffer [1] == 'M' &&
|
||
buffer [2] == 0 &&
|
||
buffer [3] == 0x2a)
|
||
return TRUE;
|
||
|
||
if (buffer [0] == 'I' &&
|
||
buffer [1] == 'I' &&
|
||
buffer [2] == 0x2a &&
|
||
buffer [3] == 0)
|
||
return TRUE;
|
||
|
||
return FALSE;
|
||
}
|
||
|
||
static gboolean
|
||
pixbuf_check_gif (guchar *buffer, int size)
|
||
{
|
||
if (size < 20)
|
||
return FALSE;
|
||
|
||
if (strncmp (buffer, "GIF8", 4) == 0)
|
||
return TRUE;
|
||
|
||
return FALSE;
|
||
}
|
||
|
||
static gboolean
|
||
pixbuf_check_xpm (guchar *buffer, int size)
|
||
{
|
||
if (size < 20)
|
||
return FALSE;
|
||
|
||
if (strncmp (buffer, "/* XPM */", 9) == 0)
|
||
return TRUE;
|
||
|
||
return FALSE;
|
||
}
|
||
|
||
static gboolean
|
||
pixbuf_check_pnm (guchar *buffer, int size)
|
||
{
|
||
if (size < 20)
|
||
return FALSE;
|
||
|
||
if (buffer [0] == 'P') {
|
||
if (buffer [1] == '1' ||
|
||
buffer [1] == '2' ||
|
||
buffer [1] == '3' ||
|
||
buffer [1] == '4' ||
|
||
buffer [1] == '5' ||
|
||
buffer [1] == '6')
|
||
return TRUE;
|
||
}
|
||
return FALSE;
|
||
}
|
||
static gboolean
|
||
pixbuf_check_sunras (guchar *buffer, int size)
|
||
{
|
||
if (size < 32)
|
||
return FALSE;
|
||
|
||
if (buffer [0] != 0x59 ||
|
||
buffer [1] != 0xA6 ||
|
||
buffer [2] != 0x6A ||
|
||
buffer [3] != 0x95)
|
||
return FALSE;
|
||
|
||
return TRUE;
|
||
}
|
||
|
||
static gboolean
|
||
pixbuf_check_ico (guchar *buffer, int size)
|
||
{
|
||
/* Note that this may cause false positives, but .ico's don't
|
||
have a magic number.*/
|
||
if (size < 6)
|
||
return FALSE;
|
||
if (buffer [0] != 0x0 ||
|
||
buffer [1] != 0x0 ||
|
||
((buffer [2] != 0x1)&&(buffer[2]!=0x2)) ||
|
||
buffer [3] != 0x0 ||
|
||
buffer [5] != 0x0 )
|
||
return FALSE;
|
||
|
||
return TRUE;
|
||
}
|
||
|
||
|
||
static gboolean
|
||
pixbuf_check_bmp (guchar *buffer, int size)
|
||
{
|
||
if (size < 20)
|
||
return FALSE;
|
||
|
||
if (buffer [0] != 'B' || buffer [1] != 'M')
|
||
return FALSE;
|
||
|
||
return TRUE;
|
||
}
|
||
|
||
static gboolean
|
||
pixbuf_check_wbmp (guchar *buffer, int size)
|
||
{
|
||
if(size < 10) /* at least */
|
||
return FALSE;
|
||
|
||
if(buffer[0] == '\0' /* We only handle type 0 wbmp's for now */)
|
||
return TRUE;
|
||
|
||
return FALSE;
|
||
}
|
||
|
||
|
||
static gboolean
|
||
pixbuf_check_xbm (guchar *buffer, int size)
|
||
{
|
||
if (size < 20)
|
||
return FALSE;
|
||
|
||
if (buffer [0] == '#'
|
||
&& buffer [1] == 'd'
|
||
&& buffer [2] == 'e'
|
||
&& buffer [3] == 'f'
|
||
&& buffer [4] == 'i'
|
||
&& buffer [5] == 'n'
|
||
&& buffer [6] == 'e'
|
||
&& buffer [7] == ' ')
|
||
return TRUE;
|
||
|
||
/* Note that this requires xpm to be checked before xbm. */
|
||
if (buffer [0] == '/'
|
||
&& buffer [1] != '*')
|
||
return TRUE;
|
||
|
||
return FALSE;
|
||
}
|
||
|
||
static gboolean
|
||
pixbuf_check_tga (guchar *buffer, int size)
|
||
{
|
||
if (size < 18)
|
||
return FALSE;
|
||
/* buffer[1] is a boolean telling if in the file a colormap is
|
||
present, while buffer[2] is the byte which specifies the image
|
||
type. (GrayScale/PseudoColor/TrueColor/RLE) */
|
||
if ((buffer[2] == 1) || (buffer[2] == 9)) {
|
||
if (buffer[1] != 1)
|
||
return FALSE;
|
||
} else {
|
||
if (buffer[1] != 0)
|
||
return FALSE;
|
||
}
|
||
return TRUE;
|
||
}
|
||
|
||
static GdkPixbufModule file_formats [] = {
|
||
{ "png", pixbuf_check_png, NULL, NULL, NULL, NULL, NULL, NULL, NULL, },
|
||
{ "jpeg", pixbuf_check_jpeg, NULL, NULL, NULL, NULL, NULL, NULL, NULL },
|
||
{ "tiff", pixbuf_check_tiff, NULL, NULL, NULL, NULL, NULL, NULL, NULL },
|
||
{ "gif", pixbuf_check_gif, NULL, NULL, NULL, NULL, NULL, NULL, NULL },
|
||
#define XPM_FILE_FORMAT_INDEX 4
|
||
{ "xpm", pixbuf_check_xpm, NULL, NULL, NULL, NULL, NULL, NULL, NULL },
|
||
{ "pnm", pixbuf_check_pnm, NULL, NULL, NULL, NULL, NULL, NULL, NULL },
|
||
{ "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 },
|
||
{ "tga", pixbuf_check_tga, NULL, NULL, NULL, NULL, NULL, NULL, NULL },
|
||
/* Moved at the bottom, because it causes false positives against many
|
||
of my TGA files. */
|
||
{ "ico", pixbuf_check_ico, 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 }
|
||
};
|
||
|
||
#ifdef USE_GMODULE
|
||
static gboolean
|
||
pixbuf_module_symbol (GModule *module, const char *module_name, const char *symbol_name, gpointer *symbol)
|
||
{
|
||
char *full_symbol_name = g_strconcat ("gdk_pixbuf__", module_name, "_", symbol_name, NULL);
|
||
gboolean return_value;
|
||
|
||
return_value = g_module_symbol (module, full_symbol_name, symbol);
|
||
g_free (full_symbol_name);
|
||
|
||
return return_value;
|
||
}
|
||
|
||
#ifdef G_OS_WIN32
|
||
|
||
/* DllMain function needed to tuck away the gdk-pixbuf DLL name */
|
||
|
||
G_WIN32_DLLMAIN_FOR_DLL_NAME (static, dll_name)
|
||
|
||
static char *
|
||
get_libdir (void)
|
||
{
|
||
static char *libdir = NULL;
|
||
|
||
if (libdir == NULL)
|
||
libdir = g_win32_get_package_installation_subdirectory
|
||
(GETTEXT_PACKAGE, dll_name, "lib\\gtk-2.0\\" GTK_BINARY_VERSION "\\loaders");
|
||
|
||
return libdir;
|
||
}
|
||
|
||
#undef PIXBUF_LIBDIR
|
||
#define PIXBUF_LIBDIR get_libdir ()
|
||
|
||
#endif
|
||
|
||
/* Like g_module_path, but use .la as the suffix
|
||
*/
|
||
static gchar*
|
||
module_build_la_path (const gchar *directory,
|
||
const gchar *module_name)
|
||
{
|
||
gchar *filename;
|
||
gchar *result;
|
||
|
||
if (strncmp (module_name, "lib", 3) == 0)
|
||
filename = (gchar *)module_name;
|
||
else
|
||
filename = g_strconcat ("lib", module_name, ".la", NULL);
|
||
|
||
if (directory && *directory)
|
||
result = g_build_filename (directory, filename, NULL);
|
||
else
|
||
result = g_strdup (filename);
|
||
|
||
if (filename != module_name)
|
||
g_free (filename);
|
||
|
||
return result;
|
||
}
|
||
|
||
/* actually load the image handler - gdk_pixbuf_get_module only get a */
|
||
/* reference to the module to load, it doesn't actually load it */
|
||
/* perhaps these actions should be combined in one function */
|
||
gboolean
|
||
_gdk_pixbuf_load_module (GdkPixbufModule *image_module,
|
||
GError **error)
|
||
{
|
||
char *module_name;
|
||
char *path;
|
||
GModule *module;
|
||
gpointer sym;
|
||
char *name;
|
||
gboolean retval;
|
||
const char *dir;
|
||
|
||
g_return_val_if_fail (image_module->module == NULL, FALSE);
|
||
|
||
name = image_module->module_name;
|
||
|
||
module_name = g_strconcat ("pixbufloader-", name, NULL);
|
||
|
||
/* This would be an exploit in an suid binary using gdk-pixbuf,
|
||
* but see http://www.gtk.org/setuid.html or the BugTraq
|
||
* archives for why you should report this as a bug against
|
||
* setuid apps using this library rather than the library
|
||
* itself.
|
||
*/
|
||
dir = g_getenv ("GDK_PIXBUF_MODULEDIR");
|
||
if (dir == NULL || *dir == '\0')
|
||
dir = PIXBUF_LIBDIR;
|
||
|
||
path = g_module_build_path (dir, module_name);
|
||
module = g_module_open (path, G_MODULE_BIND_LAZY);
|
||
|
||
if (!module) {
|
||
g_free (path);
|
||
path = module_build_la_path (dir, module_name);
|
||
module = g_module_open (path, G_MODULE_BIND_LAZY);
|
||
}
|
||
|
||
if (!module) {
|
||
g_free (path);
|
||
path = g_module_build_path (dir, module_name);
|
||
|
||
g_set_error (error,
|
||
GDK_PIXBUF_ERROR,
|
||
GDK_PIXBUF_ERROR_FAILED,
|
||
_("Unable to load image-loading module: %s: %s"),
|
||
path, g_module_error ());
|
||
g_free (module_name);
|
||
g_free (path);
|
||
return FALSE;
|
||
}
|
||
|
||
g_free (module_name);
|
||
|
||
image_module->module = module;
|
||
|
||
if (pixbuf_module_symbol (module, name, "fill_vtable", &sym)) {
|
||
ModuleFillVtableFunc func = (ModuleFillVtableFunc) sym;
|
||
(* func) (image_module);
|
||
retval = TRUE;
|
||
} else {
|
||
g_set_error (error,
|
||
GDK_PIXBUF_ERROR,
|
||
GDK_PIXBUF_ERROR_FAILED,
|
||
_("Image-loading module %s does not export the proper interface; perhaps it's from a different GTK version?"),
|
||
path);
|
||
retval = FALSE;
|
||
}
|
||
|
||
g_free (path);
|
||
|
||
return retval;
|
||
}
|
||
#else
|
||
|
||
#define mname(type,fn) gdk_pixbuf__ ## type ## _ ##fn
|
||
#define m_fill_vtable(type) extern void mname(type,fill_vtable) (GdkPixbufModule *module)
|
||
|
||
m_fill_vtable (png);
|
||
m_fill_vtable (bmp);
|
||
m_fill_vtable (wbmp);
|
||
m_fill_vtable (gif);
|
||
m_fill_vtable (ico);
|
||
m_fill_vtable (jpeg);
|
||
m_fill_vtable (pnm);
|
||
m_fill_vtable (ras);
|
||
m_fill_vtable (tiff);
|
||
m_fill_vtable (xpm);
|
||
m_fill_vtable (xbm);
|
||
m_fill_vtable (tga);
|
||
|
||
gboolean
|
||
_gdk_pixbuf_load_module (GdkPixbufModule *image_module,
|
||
GError **error)
|
||
{
|
||
ModuleFillVtableFunc fill_vtable = NULL;
|
||
image_module->module = (void *) 1;
|
||
|
||
if (FALSE) {
|
||
/* Ugly hack so we can use else if unconditionally below ;-) */
|
||
}
|
||
|
||
#ifdef INCLUDE_png
|
||
else if (strcmp (image_module->module_name, "png") == 0){
|
||
fill_vtable = mname (png, fill_vtable);
|
||
}
|
||
#endif
|
||
|
||
#ifdef INCLUDE_bmp
|
||
else if (strcmp (image_module->module_name, "bmp") == 0){
|
||
fill_vtable = mname (bmp, fill_vtable);
|
||
}
|
||
#endif
|
||
|
||
#ifdef INCLUDE_wbmp
|
||
else if (strcmp (image_module->module_name, "wbmp") == 0){
|
||
fill_vtable = mname (wbmp, fill_vtable);
|
||
}
|
||
#endif
|
||
|
||
#ifdef INCLUDE_gif
|
||
else if (strcmp (image_module->module_name, "gif") == 0){
|
||
fill_vtable = mname (gif, fill_vtable);
|
||
}
|
||
#endif
|
||
|
||
#ifdef INCLUDE_ico
|
||
else if (strcmp (image_module->module_name, "ico") == 0){
|
||
fill_vtable = mname (ico, fill_vtable);
|
||
}
|
||
#endif
|
||
|
||
#ifdef INCLUDE_jpeg
|
||
else if (strcmp (image_module->module_name, "jpeg") == 0){
|
||
fill_vtable = mname (jpeg, fill_vtable);
|
||
}
|
||
#endif
|
||
|
||
#ifdef INCLUDE_pnm
|
||
else if (strcmp (image_module->module_name, "pnm") == 0){
|
||
fill_vtable = mname (pnm, fill_vtable);
|
||
}
|
||
#endif
|
||
|
||
#ifdef INCLUDE_ras
|
||
else if (strcmp (image_module->module_name, "ras") == 0){
|
||
fill_vtable = mname (ras, fill_vtable);
|
||
}
|
||
#endif
|
||
|
||
#ifdef INCLUDE_tiff
|
||
else if (strcmp (image_module->module_name, "tiff") == 0){
|
||
fill_vtable = mname (tiff, fill_vtable);
|
||
}
|
||
#endif
|
||
|
||
#ifdef INCLUDE_xpm
|
||
else if (strcmp (image_module->module_name, "xpm") == 0){
|
||
fill_vtable = mname (xpm, fill_vtable);
|
||
}
|
||
#endif
|
||
|
||
#ifdef INCLUDE_xbm
|
||
else if (strcmp (image_module->module_name, "xbm") == 0){
|
||
fill_vtable = mname (xbm, fill_vtable);
|
||
}
|
||
#endif
|
||
|
||
#ifdef INCLUDE_tga
|
||
else if (strcmp (image_module->module_name, "tga") == 0){
|
||
fill_vtable = mname (tga, fill_vtable);
|
||
}
|
||
#endif
|
||
|
||
if (fill_vtable) {
|
||
(* fill_vtable) (image_module);
|
||
return TRUE;
|
||
} else {
|
||
g_set_error (error,
|
||
GDK_PIXBUF_ERROR,
|
||
GDK_PIXBUF_ERROR_UNKNOWN_TYPE,
|
||
_("Image type '%s' is not supported"),
|
||
image_module->module_name);
|
||
|
||
return FALSE;
|
||
}
|
||
}
|
||
|
||
|
||
#endif
|
||
|
||
|
||
|
||
GdkPixbufModule *
|
||
_gdk_pixbuf_get_named_module (const char *name,
|
||
GError **error)
|
||
{
|
||
int i;
|
||
|
||
for (i = 0; file_formats [i].module_name; i++) {
|
||
if (!strcmp(name, file_formats[i].module_name))
|
||
return &(file_formats[i]);
|
||
}
|
||
|
||
g_set_error (error,
|
||
GDK_PIXBUF_ERROR,
|
||
GDK_PIXBUF_ERROR_UNKNOWN_TYPE,
|
||
_("Image type '%s' is not supported"),
|
||
name);
|
||
|
||
return NULL;
|
||
}
|
||
|
||
GdkPixbufModule *
|
||
_gdk_pixbuf_get_module (guchar *buffer, guint size,
|
||
const gchar *filename,
|
||
GError **error)
|
||
{
|
||
int i;
|
||
|
||
for (i = 0; file_formats [i].module_name; i++) {
|
||
if ((* file_formats [i].format_check) (buffer, size))
|
||
return &(file_formats[i]);
|
||
}
|
||
|
||
if (filename)
|
||
g_set_error (error,
|
||
GDK_PIXBUF_ERROR,
|
||
GDK_PIXBUF_ERROR_UNKNOWN_TYPE,
|
||
_("Couldn't recognize the image file format for file '%s'"),
|
||
filename);
|
||
else
|
||
g_set_error (error,
|
||
GDK_PIXBUF_ERROR,
|
||
GDK_PIXBUF_ERROR_UNKNOWN_TYPE,
|
||
_("Unrecognized image file format"));
|
||
|
||
|
||
return NULL;
|
||
}
|
||
|
||
|
||
static void
|
||
prepared_notify (GdkPixbuf *pixbuf,
|
||
GdkPixbufAnimation *anim,
|
||
gpointer user_data)
|
||
{
|
||
if (pixbuf != NULL)
|
||
g_object_ref (pixbuf);
|
||
*((GdkPixbuf **)user_data) = pixbuf;
|
||
}
|
||
|
||
static GdkPixbuf *
|
||
generic_image_load (GdkPixbufModule *module,
|
||
FILE *f,
|
||
GError **error)
|
||
{
|
||
guchar buffer[4096];
|
||
size_t length;
|
||
GdkPixbuf *pixbuf = NULL;
|
||
gpointer context;
|
||
|
||
if (module->load != NULL)
|
||
return (* module->load) (f, error);
|
||
|
||
context = module->begin_load (NULL, prepared_notify, NULL, &pixbuf, error);
|
||
|
||
if (!context)
|
||
return NULL;
|
||
|
||
while (!feof (f)) {
|
||
length = fread (buffer, 1, sizeof (buffer), f);
|
||
if (length > 0)
|
||
if (!module->load_increment (context, buffer, length, error)) {
|
||
module->stop_load (context, NULL);
|
||
if (pixbuf != NULL)
|
||
g_object_unref (pixbuf);
|
||
return NULL;
|
||
}
|
||
}
|
||
|
||
if (!module->stop_load (context, error)) {
|
||
if (pixbuf != NULL)
|
||
g_object_unref (pixbuf);
|
||
return NULL;
|
||
}
|
||
|
||
return pixbuf;
|
||
}
|
||
|
||
/**
|
||
* gdk_pixbuf_new_from_file:
|
||
* @filename: Name of file to load.
|
||
* @error: Return location for an error
|
||
*
|
||
* Creates a new pixbuf by loading an image from a file. The file format is
|
||
* detected automatically. If %NULL is returned, then @error will be set.
|
||
* Possible errors are in the #GDK_PIXBUF_ERROR and #G_FILE_ERROR domains.
|
||
*
|
||
* Return value: A newly-created pixbuf with a reference count of 1, or %NULL if
|
||
* any of several error conditions occurred: the file could not be opened,
|
||
* there was no loader for the file's format, there was not enough memory to
|
||
* allocate the image buffer, or the image file contained invalid data.
|
||
**/
|
||
GdkPixbuf *
|
||
gdk_pixbuf_new_from_file (const char *filename,
|
||
GError **error)
|
||
{
|
||
GdkPixbuf *pixbuf;
|
||
int size;
|
||
FILE *f;
|
||
guchar buffer [128];
|
||
GdkPixbufModule *image_module;
|
||
|
||
g_return_val_if_fail (filename != NULL, NULL);
|
||
|
||
f = fopen (filename, "rb");
|
||
if (!f) {
|
||
g_set_error (error,
|
||
G_FILE_ERROR,
|
||
g_file_error_from_errno (errno),
|
||
_("Failed to open file '%s': %s"),
|
||
filename, g_strerror (errno));
|
||
return NULL;
|
||
}
|
||
|
||
size = fread (&buffer, 1, sizeof (buffer), f);
|
||
if (size == 0) {
|
||
g_set_error (error,
|
||
GDK_PIXBUF_ERROR,
|
||
GDK_PIXBUF_ERROR_CORRUPT_IMAGE,
|
||
_("Image file '%s' contains no data"),
|
||
filename);
|
||
|
||
fclose (f);
|
||
return NULL;
|
||
}
|
||
|
||
image_module = _gdk_pixbuf_get_module (buffer, size, filename, error);
|
||
if (image_module == NULL) {
|
||
fclose (f);
|
||
return NULL;
|
||
}
|
||
|
||
if (image_module->module == NULL)
|
||
if (!_gdk_pixbuf_load_module (image_module, error)) {
|
||
fclose (f);
|
||
return NULL;
|
||
}
|
||
|
||
fseek (f, 0, SEEK_SET);
|
||
pixbuf = generic_image_load (image_module, f, error);
|
||
fclose (f);
|
||
|
||
if (pixbuf == NULL && error != NULL && *error == NULL) {
|
||
/* I don't trust these crufty longjmp()'ing image libs
|
||
* to maintain proper error invariants, and I don't
|
||
* want user code to segfault as a result. We need to maintain
|
||
* the invariant that error gets set if NULL is returned.
|
||
*/
|
||
|
||
g_warning ("Bug! gdk-pixbuf loader '%s' didn't set an error on failure.", image_module->module_name);
|
||
g_set_error (error,
|
||
GDK_PIXBUF_ERROR,
|
||
GDK_PIXBUF_ERROR_FAILED,
|
||
_("Failed to load image '%s': reason not known, probably a corrupt image file"),
|
||
filename);
|
||
|
||
} else if (error != NULL && *error != NULL) {
|
||
|
||
/* Add the filename to the error message */
|
||
GError *e = *error;
|
||
gchar *old;
|
||
|
||
old = e->message;
|
||
|
||
e->message = g_strdup_printf (_("Failed to load image '%s': %s"),
|
||
filename, old);
|
||
|
||
g_free (old);
|
||
}
|
||
|
||
return pixbuf;
|
||
}
|
||
|
||
/**
|
||
* gdk_pixbuf_new_from_xpm_data:
|
||
* @data: Pointer to inline XPM data.
|
||
*
|
||
* Creates a new pixbuf by parsing XPM data in memory. This data is commonly
|
||
* the result of including an XPM file into a program's C source.
|
||
*
|
||
* Return value: A newly-created pixbuf with a reference count of 1.
|
||
**/
|
||
GdkPixbuf *
|
||
gdk_pixbuf_new_from_xpm_data (const char **data)
|
||
{
|
||
GdkPixbuf *(* load_xpm_data) (const char **data);
|
||
GdkPixbuf *pixbuf;
|
||
GError *error = NULL;
|
||
|
||
if (file_formats[XPM_FILE_FORMAT_INDEX].module == NULL) {
|
||
if (!_gdk_pixbuf_load_module (&file_formats[XPM_FILE_FORMAT_INDEX], &error)) {
|
||
g_warning ("Error loading XPM image loader: %s", error->message);
|
||
g_error_free (error);
|
||
return FALSE;
|
||
}
|
||
}
|
||
|
||
if (file_formats[XPM_FILE_FORMAT_INDEX].module == NULL) {
|
||
g_warning ("Can't find gdk-pixbuf module for parsing inline XPM data");
|
||
return NULL;
|
||
} else if (file_formats[XPM_FILE_FORMAT_INDEX].load_xpm_data == NULL) {
|
||
g_warning ("gdk-pixbuf XPM module lacks XPM data capability");
|
||
return NULL;
|
||
} else
|
||
load_xpm_data = file_formats[XPM_FILE_FORMAT_INDEX].load_xpm_data;
|
||
|
||
pixbuf = (* load_xpm_data) (data);
|
||
return pixbuf;
|
||
}
|
||
|
||
static void
|
||
collect_save_options (va_list opts,
|
||
gchar ***keys,
|
||
gchar ***vals)
|
||
{
|
||
gchar *key;
|
||
gchar *val;
|
||
gchar *next;
|
||
gint count;
|
||
|
||
count = 0;
|
||
*keys = NULL;
|
||
*vals = NULL;
|
||
|
||
next = va_arg (opts, gchar*);
|
||
while (next)
|
||
{
|
||
key = next;
|
||
val = va_arg (opts, gchar*);
|
||
|
||
++count;
|
||
|
||
/* woo, slow */
|
||
*keys = g_realloc (*keys, sizeof(gchar*) * (count + 1));
|
||
*vals = g_realloc (*vals, sizeof(gchar*) * (count + 1));
|
||
|
||
(*keys)[count-1] = g_strdup (key);
|
||
(*vals)[count-1] = g_strdup (val);
|
||
|
||
(*keys)[count] = NULL;
|
||
(*vals)[count] = NULL;
|
||
|
||
next = va_arg (opts, gchar*);
|
||
}
|
||
}
|
||
|
||
static gboolean
|
||
gdk_pixbuf_real_save (GdkPixbuf *pixbuf,
|
||
FILE *filehandle,
|
||
const char *type,
|
||
gchar **keys,
|
||
gchar **values,
|
||
GError **error)
|
||
{
|
||
GdkPixbufModule *image_module = NULL;
|
||
|
||
image_module = _gdk_pixbuf_get_named_module (type, error);
|
||
|
||
if (image_module == NULL)
|
||
return FALSE;
|
||
|
||
if (image_module->module == NULL)
|
||
if (!_gdk_pixbuf_load_module (image_module, error))
|
||
return FALSE;
|
||
|
||
if (image_module->save == NULL) {
|
||
g_set_error (error,
|
||
GDK_PIXBUF_ERROR,
|
||
GDK_PIXBUF_ERROR_UNSUPPORTED_OPERATION,
|
||
_("This build of gdk-pixbuf does not support saving the image format: %s"),
|
||
type);
|
||
return FALSE;
|
||
}
|
||
|
||
return (* image_module->save) (filehandle, pixbuf,
|
||
keys, values,
|
||
error);
|
||
}
|
||
|
||
|
||
/**
|
||
* gdk_pixbuf_save:
|
||
* @pixbuf: a #GdkPixbuf.
|
||
* @filename: name of file to save.
|
||
* @type: name of file format.
|
||
* @error: return location for error, or %NULL
|
||
* @Varargs: list of key-value save options
|
||
*
|
||
* Saves pixbuf to a file in @type, which is currently "jpeg" or
|
||
* "png". If @error is set, %FALSE will be returned. Possible errors include
|
||
* those in the #GDK_PIXBUF_ERROR domain and those in the #G_FILE_ERROR domain.
|
||
*
|
||
* The variable argument list should be %NULL-terminated; if not empty,
|
||
* it should contain pairs of strings that modify the save
|
||
* parameters. For example:
|
||
* <informalexample><programlisting>
|
||
* gdk_pixbuf_save (pixbuf, handle, "jpeg", &error,
|
||
* "quality", "100", NULL);
|
||
* </programlisting></informalexample>
|
||
*
|
||
* Currently only few parameters exist. JPEG images can be saved with a
|
||
* "quality" parameter; its value should be in the range [0,100].
|
||
* Text chunks can be attached to PNG images by specifying parameters of
|
||
* the form "tEXt::key", where key is an ASCII string of length 1-79.
|
||
* The values are UTF-8 encoded strings.
|
||
*
|
||
* Return value: whether an error was set
|
||
**/
|
||
|
||
gboolean
|
||
gdk_pixbuf_save (GdkPixbuf *pixbuf,
|
||
const char *filename,
|
||
const char *type,
|
||
GError **error,
|
||
...)
|
||
{
|
||
gchar **keys = NULL;
|
||
gchar **values = NULL;
|
||
va_list args;
|
||
gboolean result;
|
||
|
||
va_start (args, error);
|
||
|
||
collect_save_options (args, &keys, &values);
|
||
|
||
va_end (args);
|
||
|
||
result = gdk_pixbuf_savev (pixbuf, filename, type,
|
||
keys, values,
|
||
error);
|
||
|
||
g_strfreev (keys);
|
||
g_strfreev (values);
|
||
|
||
return result;
|
||
}
|
||
|
||
/**
|
||
* gdk_pixbuf_savev:
|
||
* @pixbuf: a #GdkPixbuf.
|
||
* @filename: name of file to save.
|
||
* @type: name of file format.
|
||
* @option_keys: name of options to set, %NULL-terminated
|
||
* @option_values: values for named options
|
||
* @error: return location for error, or %NULL
|
||
*
|
||
* Saves pixbuf to a file in @type, which is currently "jpeg" or "png".
|
||
* If @error is set, %FALSE will be returned. See gdk_pixbuf_save () for more
|
||
* details.
|
||
*
|
||
* Return value: whether an error was set
|
||
**/
|
||
|
||
gboolean
|
||
gdk_pixbuf_savev (GdkPixbuf *pixbuf,
|
||
const char *filename,
|
||
const char *type,
|
||
char **option_keys,
|
||
char **option_values,
|
||
GError **error)
|
||
{
|
||
FILE *f = NULL;
|
||
gboolean result;
|
||
|
||
|
||
g_return_val_if_fail (filename != NULL, FALSE);
|
||
g_return_val_if_fail (type != NULL, FALSE);
|
||
|
||
f = fopen (filename, "wb");
|
||
|
||
if (f == NULL) {
|
||
g_set_error (error,
|
||
G_FILE_ERROR,
|
||
g_file_error_from_errno (errno),
|
||
_("Failed to open '%s' for writing: %s"),
|
||
filename, g_strerror (errno));
|
||
return FALSE;
|
||
}
|
||
|
||
|
||
result = gdk_pixbuf_real_save (pixbuf, f, type,
|
||
option_keys, option_values,
|
||
error);
|
||
|
||
|
||
if (!result) {
|
||
g_return_val_if_fail (error == NULL || *error != NULL, FALSE);
|
||
fclose (f);
|
||
return FALSE;
|
||
}
|
||
|
||
if (fclose (f) < 0) {
|
||
g_set_error (error,
|
||
G_FILE_ERROR,
|
||
g_file_error_from_errno (errno),
|
||
_("Failed to close '%s' while writing image, all data may not have been saved: %s"),
|
||
filename, g_strerror (errno));
|
||
return FALSE;
|
||
}
|
||
|
||
return TRUE;
|
||
}
|