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