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
 152 void image_loader_jpeg_read_scanline(struct jpeg_decompress_struct *cinfo, guchar **dptr, guint rowstride)
 153 {
 154         guchar *lines[4];
 155         guchar **lptr;
 156         gint i;
 157
 158         lptr = lines;
 159         for (i = 0; i < cinfo->rec_outbuf_height; i++)
 160                 {
 161                 *lptr++ = *dptr;
 162                 *dptr += rowstride;
 163                 }
 164
 165         jpeg_read_scanlines (cinfo, lines, cinfo->rec_outbuf_height);
 166
 167         switch (cinfo->out_color_space)
 168                 {
 169                     case JCS_GRAYSCALE:
 170                       explode_gray_into_buf (cinfo, lines);
 171                       break;
 172                     case JCS_RGB:
 173                       /* do nothing */
 174                       break;
 175                     case JCS_CMYK:
 176                       convert_cmyk_to_rgb (cinfo, lines);
 177                       break;
 178                     default:
 179                       break;
 180                 }
 181 }
 182
 183 static gboolean image_loader_jpeg_load (gpointer loader, const guchar *buf, gsize count, GError **error)
 184 {
 185         ImageLoaderJpeg *lj = (ImageLoaderJpeg *) loader;
 186         struct jpeg_decompress_struct cinfo;
 187         struct jpeg_decompress_struct cinfo2;
 188         guchar *dptr, *dptr2;
 189         guint rowstride;
 190
 191         struct error_handler_data jerr;
 192 //      stdio_src_ptr src;
 193         MPOData *mpo = jpeg_get_mpo_data(buf, count);
 194         gboolean stereo = (mpo && mpo->num_images > 1);
 195
 196         /* setup error handler */
 197         cinfo.err = jpeg_std_error (&jerr.pub);
 198         if (stereo) cinfo2.err = jpeg_std_error (&jerr.pub);
 199         jerr.pub.error_exit = fatal_error_handler;
 200         jerr.pub.output_message = output_message_handler;
 201
 202         jerr.error = error;
 203
 204
 205         if (setjmp(jerr.setjmp_buffer))
 206                 {
 207                 /* If we get here, the JPEG code has signaled an error.
 208                  * We need to clean up the JPEG object, close the input file, and return.
 209                 */
 210                 jpeg_destroy_decompress(&cinfo);
 211                 if (stereo) jpeg_destroy_decompress(&cinfo2);
 212                 return FALSE;
 213                 }
 214
 215         jpeg_create_decompress(&cinfo);
 216
 217         jpeg_mem_src(&cinfo, (unsigned char *)buf, count);
 218
 219
 220         jpeg_read_header(&cinfo, TRUE);
 221
 222         if (stereo)
 223                 {
 224                 printf("decoding stereo");
 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                         stereo = FALSE;
 235                         }
 236                 }
 237
 238
 239
 240         lj->requested_width = 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 < (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 (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 (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                         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, stereo ? cinfo.output_width * 2: cinfo.output_width, cinfo.output_height);
 281
 282         if (!lj->pixbuf)
 283                 {
 284                 jpeg_destroy_decompress (&cinfo);
 285                 if (stereo) jpeg_destroy_decompress (&cinfo2);
 286                 return 0;
 287                 }
 288         if (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 (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 (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