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
 192         struct error_handler_data jerr;
 193 //      stdio_src_ptr src;
 194         MPOData *mpo = jpeg_get_mpo_data(buf, count);
 195         lj->stereo = (mpo && mpo->num_images > 1);
 196
 197         /* setup error handler */
 198         cinfo.err = jpeg_std_error (&jerr.pub);
 199         if (lj->stereo) cinfo2.err = jpeg_std_error (&jerr.pub);
 200         jerr.pub.error_exit = fatal_error_handler;
 201         jerr.pub.output_message = output_message_handler;
 202
 203         jerr.error = error;
 204
 205
 206         if (setjmp(jerr.setjmp_buffer))
 207                 {
 208                 /* If we get here, the JPEG code has signaled an error.
 209                  * We need to clean up the JPEG object, close the input file, and return.
 210                 */
 211                 jpeg_destroy_decompress(&cinfo);
 212                 if (lj->stereo) jpeg_destroy_decompress(&cinfo2);
 213                 return FALSE;
 214                 }
 215
 216         jpeg_create_decompress(&cinfo);
 217
 218         jpeg_mem_src(&cinfo, (unsigned char *)buf, count);
 219
 220
 221         jpeg_read_header(&cinfo, TRUE);
 222
 223         if (lj->stereo)
 224                 {
 225                 jpeg_create_decompress(&cinfo2);
 226                 jpeg_mem_src(&cinfo2, (unsigned char *)buf + mpo->images[1].offset, mpo->images[1].length);
 227                 jpeg_read_header(&cinfo2, TRUE);
 228
 229                 if (cinfo.image_width != cinfo2.image_width ||
 230                     cinfo.image_height != cinfo2.image_height)
 231                         {
 232                         DEBUG_1("stereo data with different size");
 233                         jpeg_destroy_decompress(&cinfo2);
 234                         lj->stereo = FALSE;
 235                         }
 236                 }
 237
 238
 239
 240         lj->requested_width = lj->stereo ? cinfo.image_width * 2: cinfo.image_width;
 241         lj->requested_height = cinfo.image_height;
 242         lj->size_cb(loader, lj->requested_width, lj->requested_height, lj->data);
 243
 244         cinfo.scale_num = 1;
 245         for (cinfo.scale_denom = 2; cinfo.scale_denom <= 8; cinfo.scale_denom *= 2) {
 246                 jpeg_calc_output_dimensions(&cinfo);
 247                 if (cinfo.output_width < (lj->stereo ? lj->requested_width / 2 : lj->requested_width) || cinfo.output_height < lj->requested_height) {
 248                         cinfo.scale_denom /= 2;
 249                         break;
 250                 }
 251         }
 252         jpeg_calc_output_dimensions(&cinfo);
 253         if (lj->stereo)
 254                 {
 255                 cinfo2.scale_num = cinfo.scale_num;
 256                 cinfo2.scale_denom = cinfo.scale_denom;
 257                 jpeg_calc_output_dimensions(&cinfo2);
 258                 jpeg_start_decompress(&cinfo2);
 259                 }
 260
 261
 262         jpeg_start_decompress(&cinfo);
 263
 264
 265         if (lj->stereo)
 266                 {
 267                 if (cinfo.output_width != cinfo2.output_width ||
 268                     cinfo.output_height != cinfo2.output_height ||
 269                     cinfo.out_color_components != cinfo2.out_color_components)
 270                         {
 271                         DEBUG_1("stereo data with different output size");
 272                         jpeg_destroy_decompress(&cinfo2);
 273                         lj->stereo = FALSE;
 274                         }
 275                 }
 276
 277
 278         lj->pixbuf = gdk_pixbuf_new (GDK_COLORSPACE_RGB,
 279                                      cinfo.out_color_components == 4 ? TRUE : FALSE,
 280                                      8, lj->stereo ? cinfo.output_width * 2: cinfo.output_width, cinfo.output_height);
 281
 282         if (!lj->pixbuf)
 283                 {
 284                 jpeg_destroy_decompress (&cinfo);
 285                 if (lj->stereo) jpeg_destroy_decompress (&cinfo2);
 286                 return 0;
 287                 }
 288         if (lj->stereo) g_object_set_data(G_OBJECT(lj->pixbuf), "stereo_data", GINT_TO_POINTER(STEREO_PIXBUF_CROSS));
 289         lj->area_prepared_cb(loader, lj->data);
 290
 291         rowstride = gdk_pixbuf_get_rowstride(lj->pixbuf);
 292         dptr = gdk_pixbuf_get_pixels(lj->pixbuf);
 293         dptr2 = gdk_pixbuf_get_pixels(lj->pixbuf) + ((cinfo.out_color_components == 4) ? 4 * cinfo.output_width : 3 * cinfo.output_width);
 294
 295
 296         while (cinfo.output_scanline < cinfo.output_height && !lj->abort)
 297                 {
 298                 guint scanline = cinfo.output_scanline;
 299                 image_loader_jpeg_read_scanline(&cinfo, &dptr, rowstride);
 300                 lj->area_updated_cb(loader, 0, scanline, cinfo.output_width, cinfo.rec_outbuf_height, lj->data);
 301                 if (lj->stereo)
 302                         {
 303                         guint scanline = cinfo2.output_scanline;
 304                         image_loader_jpeg_read_scanline(&cinfo2, &dptr2, rowstride);
 305                         lj->area_updated_cb(loader, cinfo.output_width, scanline, cinfo2.output_width, cinfo2.rec_outbuf_height, lj->data);
 306                         }
 307                 }
 308
 309         jpeg_finish_decompress(&cinfo);
 310         jpeg_destroy_decompress(&cinfo);
 311         if (lj->stereo)
 312                 {
 313                 jpeg_finish_decompress(&cinfo);
 314                 jpeg_destroy_decompress(&cinfo);
 315                 }
 316
 317         return TRUE;
 318 }
 319
 320 static void image_loader_jpeg_set_size(gpointer loader, int width, int height)
 321 {
 322         ImageLoaderJpeg *lj = (ImageLoaderJpeg *) loader;
 323         lj->requested_width = width;
 324         lj->requested_height = height;
 325 }
 326
 327 static GdkPixbuf* image_loader_jpeg_get_pixbuf(gpointer loader)
 328 {
 329         ImageLoaderJpeg *lj = (ImageLoaderJpeg *) loader;
 330         return lj->pixbuf;
 331 }
 332
 333 static gchar* image_loader_jpeg_get_format_name(gpointer loader)
 334 {
 335         return g_strdup("jpeg");
 336 }
 337 static gchar** image_loader_jpeg_get_format_mime_types(gpointer loader)
 338 {
 339         static gchar *mime[] = {"image/jpeg", NULL};
 340         return g_strdupv(mime);
 341 }
 342
 343 static gboolean image_loader_jpeg_close(gpointer loader, GError **error)
 344 {
 345         return TRUE;
 346 }
 347
 348 static void image_loader_jpeg_abort(gpointer loader)
 349 {
 350         ImageLoaderJpeg *lj = (ImageLoaderJpeg *) loader;
 351         lj->abort = TRUE;
 352 }
 353
 354 static void image_loader_jpeg_free(gpointer loader)
 355 {
 356         ImageLoaderJpeg *lj = (ImageLoaderJpeg *) loader;
 357         if (lj->pixbuf) g_object_unref(lj->pixbuf);
 358         g_free(lj);
 359 }
 360
 361
 362 void image_loader_backend_set_jpeg(ImageLoaderBackend *funcs)
 363 {
 364         funcs->loader_new = image_loader_jpeg_new;
 365         funcs->set_size = image_loader_jpeg_set_size;
 366         funcs->load = image_loader_jpeg_load;
 367         funcs->write = NULL;
 368         funcs->get_pixbuf = image_loader_jpeg_get_pixbuf;
 369         funcs->close = image_loader_jpeg_close;
 370         funcs->abort = image_loader_jpeg_abort;
 371         funcs->free = image_loader_jpeg_free;
 372
 373         funcs->get_format_name = image_loader_jpeg_get_format_name;
 374         funcs->get_format_mime_types = image_loader_jpeg_get_format_mime_types;
 375 }
 376
 377
 378