src/image_load_jpeg.c

   1
   2 #include "main.h"
   3 #include "image-load.h"
   4 #include "image_load_jpeg.h"
   5 #include "jpeg_parser.h"
   6
   7 #include <setjmp.h>
   8 #include <jpeglib.h>
   9 #include <jerror.h>
  10
  11 typedef struct _ImageLoaderJpeg ImageLoaderJpeg;
  12 struct _ImageLoaderJpeg {
  13         ImageLoaderBackendCbAreaUpdated area_updated_cb;
  14         ImageLoaderBackendCbSize size_cb;
  15         ImageLoaderBackendCbAreaPrepared area_prepared_cb;
  16
  17         gpointer data;
  18
  19         GdkPixbuf *pixbuf;
  20         guint requested_width;
  21         guint requested_height;
  22
  23         gboolean abort;
  24
  25 };
  26
  27 /* error handler data */
  28 struct error_handler_data {
  29         struct jpeg_error_mgr pub;
  30         sigjmp_buf setjmp_buffer;
  31         GError **error;
  32 };
  33
  34 /* explode gray image data from jpeg library into rgb components in pixbuf */
  35 static void
  36 explode_gray_into_buf (struct jpeg_decompress_struct *cinfo,
  37                        guchar **lines)
  38 {
  39         gint i, j;
  40         guint w;
  41
  42         g_return_if_fail (cinfo != NULL);
  43         g_return_if_fail (cinfo->output_components == 1);
  44         g_return_if_fail (cinfo->out_color_space == JCS_GRAYSCALE);
  45
  46         /* Expand grey->colour.  Expand from the end of the
  47          * memory down, so we can use the same buffer.
  48          */
  49         w = cinfo->output_width;
  50         for (i = cinfo->rec_outbuf_height - 1; i >= 0; i--) {
  51                 guchar *from, *to;
  52
  53                 from = lines[i] + w - 1;
  54                 to = lines[i] + (w - 1) * 3;
  55                 for (j = w - 1; j >= 0; j--) {
  56                         to[0] = from[0];
  57                         to[1] = from[0];
  58                         to[2] = from[0];
  59                         to -= 3;
  60                         from--;
  61                 }
  62         }
  63 }
  64
  65
  66 static void
  67 convert_cmyk_to_rgb (struct jpeg_decompress_struct *cinfo,
  68                      guchar **lines)
  69 {
  70         gint i, j;
  71
  72         g_return_if_fail (cinfo != NULL);
  73         g_return_if_fail (cinfo->output_components == 4);
  74         g_return_if_fail (cinfo->out_color_space == JCS_CMYK);
  75
  76         for (i = cinfo->rec_outbuf_height - 1; i >= 0; i--) {
  77                 guchar *p;
  78
  79                 p = lines[i];
  80                 for (j = 0; j < cinfo->output_width; j++) {
  81                         int c, m, y, k;
  82                         c = p[0];
  83                         m = p[1];
  84                         y = p[2];
  85                         k = p[3];
  86                         if (cinfo->saw_Adobe_marker) {
  87                                 p[0] = k*c / 255;
  88                                 p[1] = k*m / 255;
  89                                 p[2] = k*y / 255;
  90                         }
  91                         else {
  92                                 p[0] = (255 - k)*(255 - c) / 255;
  93                                 p[1] = (255 - k)*(255 - m) / 255;
  94                                 p[2] = (255 - k)*(255 - y) / 255;
  95                         }
  96                         p[3] = 255;
  97                         p += 4;
  98                 }
  99         }
 100 }
 101
 102
 103 static gpointer image_loader_jpeg_new(ImageLoaderBackendCbAreaUpdated area_updated_cb, ImageLoaderBackendCbSize size_cb, ImageLoaderBackendCbAreaPrepared area_prepared_cb, gpointer data)
 104 {
 105         ImageLoaderJpeg *loader = g_new0(ImageLoaderJpeg, 1);
 106
 107         loader->area_updated_cb = area_updated_cb;
 108         loader->size_cb = size_cb;
 109         loader->area_prepared_cb = area_prepared_cb;
 110         loader->data = data;
 111         return (gpointer) loader;
 112 }
 113
 114 static void
 115 fatal_error_handler (j_common_ptr cinfo)
 116 {
 117         struct error_handler_data *errmgr;
 118         char buffer[JMSG_LENGTH_MAX];
 119
 120         errmgr = (struct error_handler_data *) cinfo->err;
 121
 122         /* Create the message */
 123         (* cinfo->err->format_message) (cinfo, buffer);
 124
 125         /* broken check for *error == NULL for robustness against
 126          * crappy JPEG library
 127          */
 128         if (errmgr->error && *errmgr->error == NULL) {
 129                 g_set_error (errmgr->error,
 130                              GDK_PIXBUF_ERROR,
 131                              cinfo->err->msg_code == JERR_OUT_OF_MEMORY
 132                              ? GDK_PIXBUF_ERROR_INSUFFICIENT_MEMORY
 133                              : GDK_PIXBUF_ERROR_CORRUPT_IMAGE,
 134                              _("Error interpreting JPEG image file (%s)"),
 135                              buffer);
 136         }
 137
 138         siglongjmp (errmgr->setjmp_buffer, 1);
 139
 140         g_assert_not_reached ();
 141 }
 142
 143 static void
 144 output_message_handler (j_common_ptr cinfo)
 145 {
 146   /* This method keeps libjpeg from dumping crap to stderr */
 147
 148   /* do nothing */
 149 }
 150
 151 static gboolean image_loader_jpeg_load (gpointer loader, const guchar *buf, gsize count, GError **error)
 152 {
 153         ImageLoaderJpeg *lj = (ImageLoaderJpeg *) loader;
 154         struct jpeg_decompress_struct cinfo;
 155         guchar *dptr;
 156         guint rowstride;
 157
 158         struct error_handler_data jerr;
 159 //      stdio_src_ptr src;
 160         MPOData *mpo = jpeg_get_mpo_data(buf, count);
 161
 162         /* setup error handler */
 163         cinfo.err = jpeg_std_error (&jerr.pub);
 164         jerr.pub.error_exit = fatal_error_handler;
 165         jerr.pub.output_message = output_message_handler;
 166
 167         jerr.error = error;
 168
 169
 170         if (setjmp(jerr.setjmp_buffer))
 171                 {
 172                 /* If we get here, the JPEG code has signaled an error.
 173                  * We need to clean up the JPEG object, close the input file, and return.
 174                 */
 175                 jpeg_destroy_decompress(&cinfo);
 176                 return FALSE;
 177                 }
 178
 179         jpeg_create_decompress(&cinfo);
 180
 181         jpeg_mem_src(&cinfo, (unsigned char *)buf, count);
 182
 183
 184         jpeg_read_header(&cinfo, TRUE);
 185
 186         lj->requested_width = cinfo.image_width;
 187         lj->requested_height = cinfo.image_height;
 188         lj->size_cb(loader, cinfo.image_width, cinfo.image_height, lj->data);
 189
 190         cinfo.scale_num = 1;
 191         for (cinfo.scale_denom = 2; cinfo.scale_denom <= 8; cinfo.scale_denom *= 2) {
 192                 jpeg_calc_output_dimensions(&cinfo);
 193                 if (cinfo.output_width < lj->requested_width || cinfo.output_height < lj->requested_height) {
 194                         cinfo.scale_denom /= 2;
 195                         break;
 196                 }
 197         }
 198         jpeg_calc_output_dimensions(&cinfo);
 199
 200         jpeg_start_decompress(&cinfo);
 201
 202         lj->pixbuf = gdk_pixbuf_new (GDK_COLORSPACE_RGB,
 203                                      cinfo.out_color_components == 4 ? TRUE : FALSE,
 204                                      8, cinfo.output_width, cinfo.output_height);
 205
 206         lj->area_prepared_cb(loader, lj->data);
 207         rowstride = gdk_pixbuf_get_rowstride(lj->pixbuf);
 208         dptr = gdk_pixbuf_get_pixels(lj->pixbuf);
 209
 210         if (!lj->pixbuf)
 211                 {
 212                 jpeg_destroy_decompress (&cinfo);
 213                 return 0;
 214                 }
 215
 216         while (cinfo.output_scanline < cinfo.output_height && !lj->abort)
 217                 {
 218                 guchar *lines[4];
 219                 guchar **lptr;
 220                 gint i;
 221                 guint scanline = cinfo.output_scanline;
 222
 223                 lptr = lines;
 224                 for (i = 0; i < cinfo.rec_outbuf_height; i++)
 225                         {
 226                         *lptr++ = dptr;
 227                         dptr += rowstride;
 228                         }
 229
 230                 jpeg_read_scanlines (&cinfo, lines, cinfo.rec_outbuf_height);
 231
 232                 switch (cinfo.out_color_space)
 233                         {
 234                             case JCS_GRAYSCALE:
 235                               explode_gray_into_buf (&cinfo, lines);
 236                               break;
 237                             case JCS_RGB:
 238                               /* do nothing */
 239                               break;
 240                             case JCS_CMYK:
 241                               convert_cmyk_to_rgb (&cinfo, lines);
 242                               break;
 243                             default:
 244                               break;
 245                         }
 246                 lj->area_updated_cb(loader, 0, scanline, cinfo.output_width, cinfo.rec_outbuf_height, lj->data);
 247                 }
 248
 249         jpeg_finish_decompress(&cinfo);
 250         jpeg_destroy_decompress(&cinfo);
 251         return TRUE;
 252 }
 253
 254 static void image_loader_jpeg_set_size(gpointer loader, int width, int height)
 255 {
 256         ImageLoaderJpeg *lj = (ImageLoaderJpeg *) loader;
 257         lj->requested_width = width;
 258         lj->requested_height = height;
 259 }
 260
 261 static GdkPixbuf* image_loader_jpeg_get_pixbuf(gpointer loader)
 262 {
 263         ImageLoaderJpeg *lj = (ImageLoaderJpeg *) loader;
 264         return lj->pixbuf;
 265 }
 266
 267 static gchar* image_loader_jpeg_get_format_name(gpointer loader)
 268 {
 269         return g_strdup("jpeg");
 270 }
 271 static gchar** image_loader_jpeg_get_format_mime_types(gpointer loader)
 272 {
 273         static gchar *mime[] = {"image/jpeg", NULL};
 274         return g_strdupv(mime);
 275 }
 276
 277 static gboolean image_loader_jpeg_close(gpointer loader, GError **error)
 278 {
 279         return TRUE;
 280 }
 281
 282 static void image_loader_jpeg_abort(gpointer loader)
 283 {
 284         ImageLoaderJpeg *lj = (ImageLoaderJpeg *) loader;
 285         lj->abort = TRUE;
 286 }
 287
 288 static void image_loader_jpeg_free(gpointer loader)
 289 {
 290         ImageLoaderJpeg *lj = (ImageLoaderJpeg *) loader;
 291         if (lj->pixbuf) g_object_unref(lj->pixbuf);
 292         g_free(lj);
 293 }
 294
 295
 296 void image_loader_backend_set_jpeg(ImageLoaderBackend *funcs)
 297 {
 298         funcs->loader_new = image_loader_jpeg_new;
 299         funcs->set_size = image_loader_jpeg_set_size;
 300         funcs->load = image_loader_jpeg_load;
 301         funcs->write = NULL;
 302         funcs->get_pixbuf = image_loader_jpeg_get_pixbuf;
 303         funcs->close = image_loader_jpeg_close;
 304         funcs->abort = image_loader_jpeg_abort;
 305         funcs->free = image_loader_jpeg_free;
 306
 307         funcs->get_format_name = image_loader_jpeg_get_format_name;
 308         funcs->get_format_mime_types = image_loader_jpeg_get_format_mime_types;
 309 }
 310
 311
 312