*/
-#include <config.h>
+#include "config.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#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)
{
orient_tag_id = ENDIAN16_IT(0x112);
/* Read out the offset pointer to IFD0 */
- offset = DE_ENDIAN32(*((unsigned long*) (&exif_marker->data[i] + 4)));
+ 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 */
/* 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_ENDIAN16(*((unsigned short*) (&exif_marker->data[i])));
+ 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
/* Check through IFD0 for tags of interest */
while (tags--){
- type = DE_ENDIAN16(*((unsigned short*)(&exif_marker->data[i + 2])));
- count = DE_ENDIAN32(*((unsigned long*) (&exif_marker->data[i + 4])));
+ 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){
/* Return the orientation value. Within the 12-byte block, the
pointer to the actual data is at offset 8. */
- ret = DE_ENDIAN16(*((unsigned short*) (&exif_marker->data[i + 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. */
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)) {
* 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) {
- snprintf (otag_str, sizeof (otag_str), "%d", is_otag);
+ g_snprintf (otag_str, sizeof (otag_str), "%d", is_otag);
gdk_pixbuf_set_option (pixbuf, "orientation", otag_str);
}
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;
struct jpeg_decompress_struct *cinfo;
my_src_ptr src;
guint num_left, num_copy;
- guint last_bytes_left;
+ guint last_num_left, last_bytes_left;
guint spinguard;
gboolean first;
const guchar *bufhd;
if (num_left == 0)
return TRUE;
+ last_num_left = num_left;
last_bytes_left = 0;
spinguard = 0;
first = TRUE;
if (first) {
last_bytes_left = src->pub.bytes_in_buffer;
first = FALSE;
- } else if (src->pub.bytes_in_buffer == last_bytes_left)
+ } else if (src->pub.bytes_in_buffer == last_bytes_left
+ && num_left == last_num_left) {
spinguard++;
- else
+ } else {
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 */
if (spinguard > 2)
if (context->size_func) {
(* context->size_func) (&width, &height, context->user_data);
if (width == 0 || height == 0) {
- g_set_error (error,
- GDK_PIXBUF_ERROR,
- GDK_PIXBUF_ERROR_CORRUPT_IMAGE,
- _("Transformed JPEG has zero width or height."));
+ 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) {
- snprintf (otag_str, sizeof (otag_str), "%d", is_otag);
+ g_snprintf (otag_str, sizeof (otag_str), "%d", is_otag);
gdk_pixbuf_set_option (context->pixbuf, "orientation", otag_str);
}
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 ();
*/
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);
}
#ifndef INCLUDE_jpeg
-#define MODULE_ENTRY(type,function) function
+#define MODULE_ENTRY(function) G_MODULE_EXPORT void function
#else
-#define MODULE_ENTRY(type,function) _gdk_pixbuf__ ## type ## _ ## function
+#define MODULE_ENTRY(function) void _gdk_pixbuf__jpeg_ ## function
#endif
-void
-MODULE_ENTRY (jpeg, fill_vtable) (GdkPixbufModule *module)
+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 },
projects / ~andy / gtk / blobdiff