*/
-#include <config.h>
+#include "config.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <setjmp.h>
#include <jpeglib.h>
+#include <jerror.h>
#include "gdk-pixbuf-private.h"
#include "gdk-pixbuf-io.h"
if (errmgr->error && *errmgr->error == NULL) {
g_set_error (errmgr->error,
GDK_PIXBUF_ERROR,
- GDK_PIXBUF_ERROR_CORRUPT_IMAGE,
+ cinfo->err->msg_code == JERR_OUT_OF_MEMORY
+ ? GDK_PIXBUF_ERROR_INSUFFICIENT_MEMORY
+ : GDK_PIXBUF_ERROR_CORRUPT_IMAGE,
_("Error interpreting JPEG image file (%s)"),
buffer);
}
}
}
+
+const char leth[] = {0x49, 0x49, 0x2a, 0x00}; // Little endian TIFF header
+const char beth[] = {0x4d, 0x4d, 0x00, 0x2a}; // Big endian TIFF header
+const char types[] = {0x00, 0x01, 0x01, 0x02, 0x04, 0x08, 0x00,
+ 0x08, 0x00, 0x04, 0x08}; // size in bytes for EXIF types
+
+#define DE_ENDIAN16(val) endian == G_BIG_ENDIAN ? GUINT16_FROM_BE(val) : GUINT16_FROM_LE(val)
+#define DE_ENDIAN32(val) endian == G_BIG_ENDIAN ? GUINT32_FROM_BE(val) : GUINT32_FROM_LE(val)
+
+#define ENDIAN16_IT(val) endian == G_BIG_ENDIAN ? GUINT16_TO_BE(val) : GUINT16_TO_LE(val)
+#define ENDIAN32_IT(val) endian == G_BIG_ENDIAN ? GUINT32_TO_BE(val) : GUINT32_TO_LE(val)
+
+#define EXIF_JPEG_MARKER JPEG_APP0+1
+#define EXIF_IDENT_STRING "Exif\000\000"
+
+static unsigned short de_get16(void *ptr, guint endian)
+{
+ unsigned short val;
+
+ memcpy(&val, ptr, sizeof(val));
+ val = DE_ENDIAN16(val);
+
+ return val;
+}
+
+static unsigned int de_get32(void *ptr, guint endian)
+{
+ unsigned int val;
+
+ memcpy(&val, ptr, sizeof(val));
+ val = DE_ENDIAN32(val);
+
+ return val;
+}
+
+static gint
+get_orientation (j_decompress_ptr cinfo)
+{
+ /* This function looks through the meta data in the libjpeg decompress structure to
+ determine if an EXIF Orientation tag is present and if so return its value (1-8).
+ If no EXIF Orientation tag is found 0 (zero) is returned. */
+
+ guint i; /* index into working buffer */
+ guint orient_tag_id; /* endianed version of orientation tag ID */
+ guint ret; /* Return value */
+ guint offset; /* de-endianed offset in various situations */
+ guint tags; /* number of tags in current ifd */
+ guint type; /* de-endianed type of tag used as index into types[] */
+ guint count; /* de-endianed count of elements in a tag */
+ guint tiff = 0; /* offset to active tiff header */
+ guint endian = 0; /* detected endian of data */
+
+ jpeg_saved_marker_ptr exif_marker; /* Location of the Exif APP1 marker */
+ jpeg_saved_marker_ptr cmarker; /* Location to check for Exif APP1 marker */
+
+ /* check for Exif marker (also called the APP1 marker) */
+ exif_marker = NULL;
+ cmarker = cinfo->marker_list;
+ while (cmarker) {
+ if (cmarker->marker == EXIF_JPEG_MARKER) {
+ /* The Exif APP1 marker should contain a unique
+ identification string ("Exif\0\0"). Check for it. */
+ if (!memcmp (cmarker->data, EXIF_IDENT_STRING, 6)) {
+ exif_marker = cmarker;
+ }
+ }
+ cmarker = cmarker->next;
+ }
+
+ /* Did we find the Exif APP1 marker? */
+ if (exif_marker == NULL)
+ return 0;
+
+ /* Do we have enough data? */
+ if (exif_marker->data_length < 32)
+ return 0;
+
+ /* Check for TIFF header and catch endianess */
+ i = 0;
+
+ /* Just skip data until TIFF header - it should be within 16 bytes from marker start.
+ Normal structure relative to APP1 marker -
+ 0x0000: APP1 marker entry = 2 bytes
+ 0x0002: APP1 length entry = 2 bytes
+ 0x0004: Exif Identifier entry = 6 bytes
+ 0x000A: Start of TIFF header (Byte order entry) - 4 bytes
+ - This is what we look for, to determine endianess.
+ 0x000E: 0th IFD offset pointer - 4 bytes
+
+ exif_marker->data points to the first data after the APP1 marker
+ and length entries, which is the exif identification string.
+ The TIFF header should thus normally be found at i=6, below,
+ and the pointer to IFD0 will be at 6+4 = 10.
+ */
+
+ while (i < 16) {
+
+ /* Little endian TIFF header */
+ if (memcmp (&exif_marker->data[i], leth, 4) == 0){
+ endian = G_LITTLE_ENDIAN;
+ }
+
+ /* Big endian TIFF header */
+ else if (memcmp (&exif_marker->data[i], beth, 4) == 0){
+ endian = G_BIG_ENDIAN;
+ }
+
+ /* Keep looking through buffer */
+ else {
+ i++;
+ continue;
+ }
+ /* We have found either big or little endian TIFF header */
+ tiff = i;
+ break;
+ }
+
+ /* So did we find a TIFF header or did we just hit end of buffer? */
+ if (tiff == 0)
+ return 0;
+
+ /* Endian the orientation tag ID, to locate it more easily */
+ orient_tag_id = ENDIAN16_IT(0x112);
+
+ /* Read out the offset pointer to IFD0 */
+ offset = de_get32(&exif_marker->data[i] + 4, endian);
+ i = i + offset;
+
+ /* Check that we still are within the buffer and can read the tag count */
+ if ((i + 2) > exif_marker->data_length)
+ return 0;
+
+ /* Find out how many tags we have in IFD0. As per the TIFF spec, the first
+ two bytes of the IFD contain a count of the number of tags. */
+ tags = de_get16(&exif_marker->data[i], endian);
+ i = i + 2;
+
+ /* Check that we still have enough data for all tags to check. The tags
+ are listed in consecutive 12-byte blocks. The tag ID, type, size, and
+ a pointer to the actual value, are packed into these 12 byte entries. */
+ if ((i + tags * 12) > exif_marker->data_length)
+ return 0;
+
+ /* Check through IFD0 for tags of interest */
+ while (tags--){
+ type = de_get16(&exif_marker->data[i + 2], endian);
+ count = de_get32(&exif_marker->data[i + 4], endian);
+
+ /* Is this the orientation tag? */
+ if (memcmp (&exif_marker->data[i], (char *) &orient_tag_id, 2) == 0){
+
+ /* Check that type and count fields are OK. The orientation field
+ will consist of a single (count=1) 2-byte integer (type=3). */
+ if (type != 3 || count != 1) return 0;
+
+ /* Return the orientation value. Within the 12-byte block, the
+ pointer to the actual data is at offset 8. */
+ ret = de_get16(&exif_marker->data[i + 8], endian);
+ return ret <= 8 ? ret : 0;
+ }
+ /* move the pointer to the next 12-byte tag field. */
+ i = i + 12;
+ }
+
+ return 0; /* No EXIF Orientation tag found */
+}
+
+
/* Shared library entry point */
static GdkPixbuf *
gdk_pixbuf__jpeg_image_load (FILE *f, GError **error)
{
- gint i;
+ gint i;
+ int is_otag;
+ char otag_str[5];
GdkPixbuf * volatile pixbuf = NULL;
guchar *dptr;
guchar *lines[4]; /* Used to expand rows, via rec_outbuf_height,
cinfo.err = jpeg_std_error (&jerr.pub);
jerr.pub.error_exit = fatal_error_handler;
jerr.pub.output_message = output_message_handler;
-
jerr.error = error;
if (sigsetjmp (jerr.setjmp_buffer, 1)) {
g_object_unref (pixbuf);
jpeg_destroy_decompress (&cinfo);
+
+ /* error should have been set by fatal_error_handler () */
return NULL;
}
src->pub.bytes_in_buffer = 0; /* forces fill_input_buffer on first read */
src->pub.next_input_byte = NULL; /* until buffer loaded */
+ jpeg_save_markers (&cinfo, EXIF_JPEG_MARKER, 0xffff);
jpeg_read_header (&cinfo, TRUE);
+
+ /* check for orientation tag */
+ is_otag = get_orientation (&cinfo);
+
jpeg_start_decompress (&cinfo);
cinfo.do_fancy_upsampling = FALSE;
cinfo.do_block_smoothing = FALSE;
* crappy JPEG library
*/
if (error && *error == NULL) {
- g_set_error (error,
- GDK_PIXBUF_ERROR,
- GDK_PIXBUF_ERROR_INSUFFICIENT_MEMORY,
- _("Insufficient memory to load image, try exiting some applications to free memory"));
+ g_set_error_literal (error,
+ GDK_PIXBUF_ERROR,
+ GDK_PIXBUF_ERROR_INSUFFICIENT_MEMORY,
+ _("Insufficient memory to load image, try exiting some applications to free memory"));
}
return NULL;
}
+ /* if orientation tag was found set an option to remember its value */
+ if (is_otag) {
+ g_snprintf (otag_str, sizeof (otag_str), "%d", is_otag);
+ gdk_pixbuf_set_option (pixbuf, "orientation", otag_str);
+ }
+
+
dptr = pixbuf->pixels;
/* decompress all the lines, a few at a time */
context->src_initialized = FALSE;
context->in_output = FALSE;
+ /* From jpeglib.h: "NB: you must set up the error-manager
+ * BEFORE calling jpeg_create_xxx". */
+ context->cinfo.err = jpeg_std_error (&context->jerr.pub);
+ context->jerr.pub.error_exit = fatal_error_handler;
+ context->jerr.pub.output_message = output_message_handler;
+ context->jerr.error = error;
+
/* create libjpeg structures */
jpeg_create_decompress (&context->cinfo);
context->cinfo.src = (struct jpeg_source_mgr *) g_try_malloc (sizeof (my_source_mgr));
if (!context->cinfo.src) {
- g_set_error (error,
- GDK_PIXBUF_ERROR,
- GDK_PIXBUF_ERROR_INSUFFICIENT_MEMORY,
- _("Couldn't allocate memory for loading JPEG file"));
+ g_set_error_literal (error,
+ GDK_PIXBUF_ERROR,
+ GDK_PIXBUF_ERROR_INSUFFICIENT_MEMORY,
+ _("Couldn't allocate memory for loading JPEG file"));
return NULL;
}
memset (context->cinfo.src, 0, sizeof (my_source_mgr));
-
- src = (my_src_ptr) context->cinfo.src;
- context->cinfo.err = jpeg_std_error (&context->jerr.pub);
- context->jerr.pub.error_exit = fatal_error_handler;
- context->jerr.pub.output_message = output_message_handler;
- context->jerr.error = error;
-
src = (my_src_ptr) context->cinfo.src;
src->pub.init_source = init_source;
src->pub.fill_input_buffer = fill_input_buffer;
gdk_pixbuf__jpeg_image_stop_load (gpointer data, GError **error)
{
JpegProgContext *context = (JpegProgContext *) data;
+ gboolean retval;
g_return_val_if_fail (context != NULL, TRUE);
g_object_unref (context->pixbuf);
/* if we have an error? */
+ context->jerr.error = error;
if (sigsetjmp (context->jerr.setjmp_buffer, 1)) {
- jpeg_destroy_decompress (&context->cinfo);
+ retval = FALSE;
} else {
- jpeg_finish_decompress(&context->cinfo);
- jpeg_destroy_decompress(&context->cinfo);
+ jpeg_finish_decompress (&context->cinfo);
+ retval = TRUE;
}
+ jpeg_destroy_decompress (&context->cinfo);
+
if (context->cinfo.src) {
my_src_ptr src = (my_src_ptr) context->cinfo.src;
g_free (context);
- return TRUE;
+ return retval;
}
+static gboolean
+gdk_pixbuf__jpeg_image_load_lines (JpegProgContext *context,
+ GError **error)
+{
+ struct jpeg_decompress_struct *cinfo = &context->cinfo;
+ guchar *lines[4];
+ guchar **lptr;
+ guchar *rowptr;
+ gint nlines, i;
+
+ /* keep going until we've done all scanlines */
+ while (cinfo->output_scanline < cinfo->output_height) {
+ lptr = lines;
+ rowptr = context->dptr;
+ for (i=0; i < cinfo->rec_outbuf_height; i++) {
+ *lptr++ = rowptr;
+ rowptr += context->pixbuf->rowstride;
+ }
+
+ nlines = jpeg_read_scanlines (cinfo, lines,
+ cinfo->rec_outbuf_height);
+ if (nlines == 0)
+ break;
+
+ switch (cinfo->out_color_space) {
+ case JCS_GRAYSCALE:
+ explode_gray_into_buf (cinfo, lines);
+ break;
+ case JCS_RGB:
+ /* do nothing */
+ break;
+ case JCS_CMYK:
+ convert_cmyk_to_rgb (cinfo, lines);
+ break;
+ default:
+ if (error && *error == NULL) {
+ g_set_error (error,
+ GDK_PIXBUF_ERROR,
+ GDK_PIXBUF_ERROR_UNKNOWN_TYPE,
+ _("Unsupported JPEG color space (%s)"),
+ colorspace_name (cinfo->out_color_space));
+ }
+
+ return FALSE;
+ }
+
+ context->dptr += nlines * context->pixbuf->rowstride;
+
+ /* send updated signal */
+ if (context->updated_func)
+ (* context->updated_func) (context->pixbuf,
+ 0,
+ cinfo->output_scanline - 1,
+ cinfo->image_width,
+ nlines,
+ context->user_data);
+ }
+
+ return TRUE;
+}
/*
GError **error)
{
JpegProgContext *context = (JpegProgContext *)data;
- struct jpeg_decompress_struct *cinfo;
- my_src_ptr src;
- guint num_left, num_copy;
- guint last_bytes_left;
- guint spinguard;
- gboolean first;
- const guchar *bufhd;
- gint width, height;
+ struct jpeg_decompress_struct *cinfo;
+ my_src_ptr src;
+ guint num_left, num_copy;
+ guint last_num_left, last_bytes_left;
+ guint spinguard;
+ gboolean first;
+ const guchar *bufhd;
+ gint width, height;
+ int is_otag;
+ char otag_str[5];
g_return_val_if_fail (context != NULL, FALSE);
g_return_val_if_fail (buf != NULL, FALSE);
if (num_left == 0)
return TRUE;
+ last_num_left = num_left;
last_bytes_left = 0;
spinguard = 0;
first = TRUE;
src->pub.bytes_in_buffer += num_copy;
bufhd += num_copy;
num_left -= num_copy;
+ }
+
+ /* did anything change from last pass, if not return */
+ if (first) {
+ last_bytes_left = src->pub.bytes_in_buffer;
+ first = FALSE;
+ } else if (src->pub.bytes_in_buffer == last_bytes_left
+ && num_left == last_num_left) {
+ spinguard++;
} else {
- /* did anything change from last pass, if not return */
- if (first) {
- last_bytes_left = src->pub.bytes_in_buffer;
- first = FALSE;
- } else if (src->pub.bytes_in_buffer == last_bytes_left)
- spinguard++;
- else
- last_bytes_left = src->pub.bytes_in_buffer;
+ last_bytes_left = src->pub.bytes_in_buffer;
+ last_num_left = num_left;
}
/* should not go through twice and not pull bytes out of buf */
/* try to load jpeg header */
if (!context->got_header) {
int rc;
-
+
+ jpeg_save_markers (cinfo, EXIF_JPEG_MARKER, 0xffff);
rc = jpeg_read_header (cinfo, TRUE);
context->src_initialized = TRUE;
continue;
context->got_header = TRUE;
-
+
+ /* check for orientation tag */
+ is_otag = get_orientation (cinfo);
+
width = cinfo->image_width;
height = cinfo->image_height;
if (context->size_func) {
(* context->size_func) (&width, &height, context->user_data);
- if (width == 0 || height == 0)
+ if (width == 0 || height == 0) {
+ g_set_error_literal (error,
+ GDK_PIXBUF_ERROR,
+ GDK_PIXBUF_ERROR_CORRUPT_IMAGE,
+ _("Transformed JPEG has zero width or height."));
return FALSE;
+ }
}
+ cinfo->scale_num = 1;
for (cinfo->scale_denom = 2; cinfo->scale_denom <= 8; cinfo->scale_denom *= 2) {
jpeg_calc_output_dimensions (cinfo);
if (cinfo->output_width < width || cinfo->output_height < height) {
cinfo->output_height);
if (context->pixbuf == NULL) {
- g_set_error (error,
- GDK_PIXBUF_ERROR,
- GDK_PIXBUF_ERROR_INSUFFICIENT_MEMORY,
- _("Couldn't allocate memory for loading JPEG file"));
+ g_set_error_literal (error,
+ GDK_PIXBUF_ERROR,
+ GDK_PIXBUF_ERROR_INSUFFICIENT_MEMORY,
+ _("Couldn't allocate memory for loading JPEG file"));
return FALSE;
}
-
+
+ /* if orientation tag was found set an option to remember its value */
+ if (is_otag) {
+ g_snprintf (otag_str, sizeof (otag_str), "%d", is_otag);
+ gdk_pixbuf_set_option (context->pixbuf, "orientation", otag_str);
+ }
+
/* Use pixbuf buffer to store decompressed data */
context->dptr = context->pixbuf->pixels;
/* Notify the client that we are ready to go */
- (* context->prepared_func) (context->pixbuf,
- NULL,
- context->user_data);
+ if (context->prepared_func)
+ (* context->prepared_func) (context->pixbuf,
+ NULL,
+ context->user_data);
} else if (!context->did_prescan) {
int rc;
/* start decompression */
- cinfo->buffered_image = TRUE;
+ cinfo->buffered_image = cinfo->progressive_mode;
rc = jpeg_start_decompress (cinfo);
cinfo->do_fancy_upsampling = FALSE;
cinfo->do_block_smoothing = FALSE;
continue;
context->did_prescan = TRUE;
+ } else if (!cinfo->buffered_image) {
+ /* we're decompressing unbuffered so
+ * simply get scanline by scanline from jpeg lib
+ */
+ if (! gdk_pixbuf__jpeg_image_load_lines (context,
+ error))
+ return FALSE;
+
+ if (cinfo->output_scanline >= cinfo->output_height)
+ return TRUE;
} else {
- /* we're decompressing so feed jpeg lib scanlines */
- guchar *lines[4];
- guchar **lptr;
- guchar *rowptr;
- gint nlines, i;
+ /* we're decompressing buffered (progressive)
+ * so feed jpeg lib scanlines
+ */
/* keep going until we've done all passes */
while (!jpeg_input_complete (cinfo)) {
else
break;
}
- /* keep going until we've done all scanlines */
- while (cinfo->output_scanline < cinfo->output_height) {
- lptr = lines;
- rowptr = context->dptr;
- for (i=0; i < cinfo->rec_outbuf_height; i++) {
- *lptr++ = rowptr;
- rowptr += context->pixbuf->rowstride;
- }
-
- nlines = jpeg_read_scanlines (cinfo, lines,
- cinfo->rec_outbuf_height);
- if (nlines == 0)
- break;
- switch (cinfo->out_color_space) {
- case JCS_GRAYSCALE:
- explode_gray_into_buf (cinfo, lines);
- break;
- case JCS_RGB:
- /* do nothing */
- break;
- case JCS_CMYK:
- convert_cmyk_to_rgb (cinfo, lines);
- break;
- default:
- if (error && *error == NULL) {
- g_set_error (error,
- GDK_PIXBUF_ERROR,
- GDK_PIXBUF_ERROR_UNKNOWN_TYPE,
- _("Unsupported JPEG color space (%s)"),
- colorspace_name (cinfo->out_color_space));
- }
-
- return FALSE;
- }
+ /* get scanlines from jpeg lib */
+ if (! gdk_pixbuf__jpeg_image_load_lines (context,
+ error))
+ return FALSE;
- context->dptr += nlines * context->pixbuf->rowstride;
-
- /* send updated signal */
- (* context->updated_func) (context->pixbuf,
- 0,
- cinfo->output_scanline-1,
- cinfo->image_width,
- nlines,
- context->user_data);
- }
- if (cinfo->output_scanline >= cinfo->output_height &&
+ if (cinfo->output_scanline >= cinfo->output_height &&
jpeg_finish_output (cinfo))
context->in_output = FALSE;
else
continue;
}
}
-
- return TRUE;
}
/* Save */
ToFunctionDestinationManager *destmgr;
destmgr = (ToFunctionDestinationManager*) cinfo->dest;
- if (!destmgr->save_func (destmgr->buffer,
+ if (!destmgr->save_func ((gchar *)destmgr->buffer,
length,
destmgr->error,
destmgr->user_data)) {
* which it should have.
*/
if (errmgr->error && *errmgr->error == NULL) {
- g_set_error (errmgr->error,
- GDK_PIXBUF_ERROR,
- GDK_PIXBUF_ERROR_CORRUPT_IMAGE,
- "write function failed");
+ g_set_error_literal (errmgr->error,
+ GDK_PIXBUF_ERROR,
+ GDK_PIXBUF_ERROR_CORRUPT_IMAGE,
+ "write function failed");
}
siglongjmp (errmgr->setjmp_buffer, 1);
g_assert_not_reached ();
int i, j;
int w, h = 0;
int rowstride = 0;
+ int n_channels;
struct error_handler_data jerr;
ToFunctionDestinationManager to_callback_destmgr;
return FALSE;
}
} else {
- g_warning ("Bad option name '%s' passed to JPEG saver",
- *kiter);
- return FALSE;
+ g_warning ("Unrecognized parameter (%s) passed to JPEG saver.", *kiter);
}
++kiter;
}
rowstride = gdk_pixbuf_get_rowstride (pixbuf);
+ n_channels = gdk_pixbuf_get_n_channels (pixbuf);
w = gdk_pixbuf_get_width (pixbuf);
h = gdk_pixbuf_get_height (pixbuf);
-
- /* no image data? abort */
pixels = gdk_pixbuf_get_pixels (pixbuf);
- g_return_val_if_fail (pixels != NULL, FALSE);
/* Allocate a small buffer to convert image data,
* and a larger buffer if doing to_callback save.
*/
buf = g_try_malloc (w * 3 * sizeof (guchar));
if (!buf) {
- g_set_error (error,
- GDK_PIXBUF_ERROR,
- GDK_PIXBUF_ERROR_INSUFFICIENT_MEMORY,
- _("Couldn't allocate memory for loading JPEG file"));
+ g_set_error_literal (error,
+ GDK_PIXBUF_ERROR,
+ GDK_PIXBUF_ERROR_INSUFFICIENT_MEMORY,
+ _("Couldn't allocate memory for loading JPEG file"));
return FALSE;
}
if (to_callback) {
to_callback_destmgr.buffer = g_try_malloc (TO_FUNCTION_BUF_SIZE);
if (!to_callback_destmgr.buffer) {
- g_set_error (error,
- GDK_PIXBUF_ERROR,
- GDK_PIXBUF_ERROR_INSUFFICIENT_MEMORY,
- _("Couldn't allocate memory for loading JPEG file"));
+ g_set_error_literal (error,
+ GDK_PIXBUF_ERROR,
+ GDK_PIXBUF_ERROR_INSUFFICIENT_MEMORY,
+ _("Couldn't allocate memory for loading JPEG file"));
+ g_free (buf);
return FALSE;
}
}
/* set up error handling */
+ cinfo.err = jpeg_std_error (&(jerr.pub));
jerr.pub.error_exit = fatal_error_handler;
jerr.pub.output_message = output_message_handler;
jerr.error = error;
- cinfo.err = jpeg_std_error (&(jerr.pub));
if (sigsetjmp (jerr.setjmp_buffer, 1)) {
jpeg_destroy_compress (&cinfo);
g_free (buf);
while (cinfo.next_scanline < cinfo.image_height) {
/* convert scanline from ARGB to RGB packed */
for (j = 0; j < w; j++)
- memcpy (&(buf[j*3]), &(ptr[i*rowstride + j*3]), 3);
+ memcpy (&(buf[j*3]), &(ptr[i*rowstride + j*n_channels]), 3);
/* write scanline */
jbuf = (JSAMPROW *)(&buf);
TRUE, NULL, save_func, user_data);
}
-void
-MODULE_ENTRY (jpeg, fill_vtable) (GdkPixbufModule *module)
+#ifndef INCLUDE_jpeg
+#define MODULE_ENTRY(function) G_MODULE_EXPORT void function
+#else
+#define MODULE_ENTRY(function) void _gdk_pixbuf__jpeg_ ## function
+#endif
+
+MODULE_ENTRY (fill_vtable) (GdkPixbufModule *module)
{
module->load = gdk_pixbuf__jpeg_image_load;
module->begin_load = gdk_pixbuf__jpeg_image_begin_load;
module->save_to_callback = gdk_pixbuf__jpeg_image_save_to_callback;
}
-void
-MODULE_ENTRY (jpeg, fill_info) (GdkPixbufFormat *info)
+MODULE_ENTRY (fill_info) (GdkPixbufFormat *info)
{
static GdkPixbufModulePattern signature[] = {
{ "\xff\xd8", NULL, 100 },
info->description = N_("The JPEG image format");
info->mime_types = mime_types;
info->extensions = extensions;
- info->flags = GDK_PIXBUF_FORMAT_WRITABLE;
+ info->flags = GDK_PIXBUF_FORMAT_WRITABLE | GDK_PIXBUF_FORMAT_THREADSAFE;
info->license = "LGPL";
}
projects / ~andy / gtk / blobdiff