Updated Slovenian translation

[~andy/gtk] / gdk-pixbuf / io-jpeg.c

diff --git a/gdk-pixbuf/io-jpeg.c b/gdk-pixbuf/io-jpeg.c
index fdcc3e2cb45bdfba99fd6511d27f8d5eb5fc6634..da59386c164daa4f1a06b15d9d536405fb2b47ea 100644 (file)
--- a/gdk-pixbuf/io-jpeg.c
+++ b/gdk-pixbuf/io-jpeg.c
@@ -27,7 +27,7 @@
  */
 
 
-#include <config.h>
+#include "config.h"
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
@@ -523,10 +523,10 @@ gdk_pixbuf__jpeg_image_load (FILE *f, GError **error)
                  * 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;
@@ -662,10 +662,10 @@ gdk_pixbuf__jpeg_image_begin_load (GdkPixbufModuleSizeFunc size_func,
 
        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));
@@ -812,7 +812,7 @@ gdk_pixbuf__jpeg_image_load_increment (gpointer data,
        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;
@@ -853,6 +853,7 @@ gdk_pixbuf__jpeg_image_load_increment (gpointer data,
        if (num_left == 0)
                return TRUE;
 
+       last_num_left = num_left;
        last_bytes_left = 0;
        spinguard = 0;
        first = TRUE;
@@ -880,10 +881,13 @@ gdk_pixbuf__jpeg_image_load_increment (gpointer data,
                 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)
@@ -910,10 +914,10 @@ gdk_pixbuf__jpeg_image_load_increment (gpointer data,
                        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;
                                }
                        }
@@ -934,10 +938,10 @@ gdk_pixbuf__jpeg_image_load_increment (gpointer data,
                                                          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;
                        }
                
@@ -1054,10 +1058,10 @@ to_callback_do_write (j_compress_ptr cinfo, gsize length)
                 * 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 ();
@@ -1167,19 +1171,19 @@ real_save_jpeg (GdkPixbuf          *pixbuf,
        */
        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"));
                       return FALSE;
               }
        }
@@ -1268,13 +1272,12 @@ gdk_pixbuf__jpeg_image_save_to_callback (GdkPixbufSaveFunc   save_func,
 }
 
 #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;
@@ -1284,8 +1287,7 @@ MODULE_ENTRY (jpeg, fill_vtable) (GdkPixbufModule *module)
        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 },