JPEG/imjpeg.c

   1 /*
   2 =head1 NAME
   3
   4 jpeg.c - implement saving and loading JPEG images
   5
   6 =head1 SYNOPSIS
   7
   8   io_glue *ig;
   9   if (!i_writejpeg_wiol(im, ig, quality)) {
  10     .. error ..
  11   }
  12   im = i_readjpeg_wiol(ig, length, iptc_text, itlength);
  13
  14 =head1 DESCRIPTION
  15
  16 Reads and writes JPEG images
  17
  18 =over
  19
  20 =cut
  21 */
  22
  23 #include "imjpeg.h"
  24 #include "imext.h"
  25 #include <stdio.h>
  26 #include <sys/stat.h>
  27 #ifndef _MSC_VER
  28 #include <unistd.h>
  29 #endif
  30 #include <setjmp.h>
  31 #include <string.h>
  32
  33 #include "jpeglib.h"
  34 #include "jerror.h"
  35 #include <errno.h>
  36 #include <stdlib.h>
  37
  38 #define JPEG_APP13       0xED    /* APP13 marker code */
  39 #define JPEG_APP1 (JPEG_APP0 + 1)
  40 #define JPGS 16384
  41
  42 #define JPEG_DIM_MAX JPEG_MAX_DIMENSION
  43
  44 #define _STRINGIFY(x) #x
  45 #define STRINGIFY(x) _STRINGIFY(x)
  46
  47 static unsigned char fake_eoi[]={(JOCTET) 0xFF,(JOCTET) JPEG_EOI};
  48
  49 /* Source and Destination managers */
  50
  51 typedef struct {
  52   struct jpeg_source_mgr pub;   /* public fields */
  53   io_glue *data;
  54   JOCTET *buffer;               /* start of buffer */
  55   int length;                   /* Do I need this? */
  56   boolean start_of_file;        /* have we gotten any data yet? */
  57 } wiol_source_mgr;
  58
  59 typedef struct {
  60   struct jpeg_destination_mgr pub; /* public fields */
  61   io_glue *data;
  62   JOCTET *buffer;               /* start of buffer */
  63   boolean start_of_file;        /* have we gotten any data yet? */
  64 } wiol_destination_mgr;
  65
  66 typedef wiol_source_mgr *wiol_src_ptr;
  67 typedef wiol_destination_mgr *wiol_dest_ptr;
  68
  69 /*
  70  * Methods for io manager objects
  71  *
  72  * Methods for source managers:
  73  *
  74  * init_source         (j_decompress_ptr cinfo);
  75  * skip_input_data     (j_decompress_ptr cinfo, long num_bytes);
  76  * fill_input_buffer   (j_decompress_ptr cinfo);
  77  * term_source         (j_decompress_ptr cinfo);
  78  */
  79
  80
  81
  82 static void
  83 wiol_init_source (j_decompress_ptr cinfo) {
  84   wiol_src_ptr src = (wiol_src_ptr) cinfo->src;
  85
  86   /* We reset the empty-input-file flag for each image, but we don't clear
  87    * the input buffer.   This is correct behavior for reading a series of
  88    * images from one source.
  89    */
  90   src->start_of_file = TRUE;
  91 }
  92
  93
  94
  95 static boolean
  96 wiol_fill_input_buffer(j_decompress_ptr cinfo) {
  97   wiol_src_ptr src = (wiol_src_ptr) cinfo->src;
  98   ssize_t nbytes; /* We assume that reads are "small" */
  99
 100   mm_log((1,"wiol_fill_input_buffer(cinfo %p)\n", cinfo));
 101
 102   nbytes = i_io_read(src->data, src->buffer, JPGS);
 103
 104   if (nbytes <= 0) { /* Insert a fake EOI marker */
 105     src->pub.next_input_byte = fake_eoi;
 106     src->pub.bytes_in_buffer = 2;
 107   } else {
 108     src->pub.next_input_byte = src->buffer;
 109     src->pub.bytes_in_buffer = nbytes;
 110   }
 111   src->start_of_file = FALSE;
 112   return TRUE;
 113 }
 114
 115
 116 static void
 117 wiol_skip_input_data (j_decompress_ptr cinfo, long num_bytes) {
 118   wiol_src_ptr src = (wiol_src_ptr) cinfo->src;
 119
 120   /* Just a dumb implementation for now.  Could use fseek() except
 121    * it doesn't work on pipes.  Not clear that being smart is worth
 122    * any trouble anyway --- large skips are infrequent.
 123    */
 124
 125   if (num_bytes > 0) {
 126     while (num_bytes > (long) src->pub.bytes_in_buffer) {
 127       num_bytes -= (long) src->pub.bytes_in_buffer;
 128       (void) wiol_fill_input_buffer(cinfo);
 129       /* note we assume that fill_input_buffer will never return FALSE,
 130        * so suspension need not be handled.
 131        */
 132     }
 133     src->pub.next_input_byte += (size_t) num_bytes;
 134     src->pub.bytes_in_buffer -= (size_t) num_bytes;
 135   }
 136 }
 137
 138 static void
 139 wiol_term_source (j_decompress_ptr cinfo) {
 140   /* no work necessary here */
 141   wiol_src_ptr src;
 142   if (cinfo->src != NULL) {
 143     src = (wiol_src_ptr) cinfo->src;
 144     myfree(src->buffer);
 145   }
 146 }
 147
 148
 149 /* Source manager Constructor */
 150
 151 static void
 152 jpeg_wiol_src(j_decompress_ptr cinfo, io_glue *ig, int length) {
 153   wiol_src_ptr src;
 154
 155   if (cinfo->src == NULL) {     /* first time for this JPEG object? */
 156     cinfo->src = (struct jpeg_source_mgr *) (*cinfo->mem->alloc_small)
 157       ((j_common_ptr) cinfo, JPOOL_PERMANENT,sizeof(wiol_source_mgr));
 158     src = (wiol_src_ptr) cinfo->src;
 159   }
 160
 161   /* put the request method call in here later */
 162
 163   src         = (wiol_src_ptr) cinfo->src;
 164   src->data   = ig;
 165   src->buffer = mymalloc( JPGS );
 166   src->length = length;
 167
 168   src->pub.init_source       = wiol_init_source;
 169   src->pub.fill_input_buffer = wiol_fill_input_buffer;
 170   src->pub.skip_input_data   = wiol_skip_input_data;
 171   src->pub.resync_to_restart = jpeg_resync_to_restart; /* use default method */
 172   src->pub.term_source       = wiol_term_source;
 173   src->pub.bytes_in_buffer   = 0; /* forces fill_input_buffer on first read */
 174   src->pub.next_input_byte   = NULL; /* until buffer loaded */
 175 }
 176
 177
 178
 179
 180 /*
 181  * Methods for destination managers:
 182  *
 183  * init_destination    (j_compress_ptr cinfo);
 184  * empty_output_buffer (j_compress_ptr cinfo);
 185  * term_destination    (j_compress_ptr cinfo);
 186  *
 187  */
 188
 189 static void
 190 wiol_init_destination (j_compress_ptr cinfo) {
 191   wiol_dest_ptr dest = (wiol_dest_ptr) cinfo->dest;
 192
 193   /* We reset the empty-input-file flag for each image, but we don't clear
 194    * the input buffer.   This is correct behavior for reading a series of
 195    * images from one source.
 196    */
 197   dest->start_of_file = TRUE;
 198 }
 199
 200 static boolean
 201 wiol_empty_output_buffer(j_compress_ptr cinfo) {
 202   wiol_dest_ptr dest = (wiol_dest_ptr) cinfo->dest;
 203   ssize_t rc;
 204   /*
 205     Previously this code was checking free_in_buffer to see how much
 206     needed to be written.  This does not follow the documentation:
 207
 208                        "In typical applications, it should write out the
 209         *entire* buffer (use the saved start address and buffer length;
 210         ignore the current state of next_output_byte and free_in_buffer)."
 211
 212   ssize_t nbytes     = JPGS - dest->pub.free_in_buffer;
 213   */
 214
 215   mm_log((1,"wiol_empty_output_buffer(cinfo %p)\n", cinfo));
 216   rc = i_io_write(dest->data, dest->buffer, JPGS);
 217
 218   if (rc != JPGS) { /* XXX: Should raise some jpeg error */
 219     myfree(dest->buffer);
 220     mm_log((1, "wiol_empty_output_buffer: Error: nbytes = %d != rc = %d\n", JPGS, (int)rc));
 221     ERREXIT(cinfo, JERR_FILE_WRITE);
 222   }
 223   dest->pub.free_in_buffer = JPGS;
 224   dest->pub.next_output_byte = dest->buffer;
 225   return TRUE;
 226 }
 227
 228 static void
 229 wiol_term_destination (j_compress_ptr cinfo) {
 230   wiol_dest_ptr dest = (wiol_dest_ptr) cinfo->dest;
 231   size_t nbytes = JPGS - dest->pub.free_in_buffer;
 232   /* yes, this needs to flush the buffer */
 233   /* needs error handling */
 234
 235   if (i_io_write(dest->data, dest->buffer, nbytes) != nbytes) {
 236     myfree(dest->buffer);
 237     ERREXIT(cinfo, JERR_FILE_WRITE);
 238   }
 239
 240   myfree(dest->buffer);
 241 }
 242
 243
 244 /* Destination manager Constructor */
 245
 246 static void
 247 jpeg_wiol_dest(j_compress_ptr cinfo, io_glue *ig) {
 248   wiol_dest_ptr dest;
 249
 250   if (cinfo->dest == NULL) {    /* first time for this JPEG object? */
 251     cinfo->dest =
 252       (struct jpeg_destination_mgr *)
 253       (*cinfo->mem->alloc_small)
 254       ((j_common_ptr) cinfo, JPOOL_PERMANENT, sizeof(wiol_destination_mgr));
 255   }
 256
 257   dest = (wiol_dest_ptr) cinfo->dest;
 258   dest->data                    = ig;
 259   dest->buffer                  = mymalloc( JPGS );
 260
 261   dest->pub.init_destination    = wiol_init_destination;
 262   dest->pub.empty_output_buffer = wiol_empty_output_buffer;
 263   dest->pub.term_destination    = wiol_term_destination;
 264   dest->pub.free_in_buffer      = JPGS;
 265   dest->pub.next_output_byte    = dest->buffer;
 266 }
 267
 268 METHODDEF(void)
 269 my_output_message (j_common_ptr cinfo) {
 270   char buffer[JMSG_LENGTH_MAX];
 271
 272   /* Create the message */
 273   (*cinfo->err->format_message) (cinfo, buffer);
 274
 275   i_push_error(0, buffer);
 276
 277   /* Send it to stderr, adding a newline */
 278   mm_log((1, "%s\n", buffer));
 279 }
 280
 281 struct my_error_mgr {
 282   struct jpeg_error_mgr pub;    /* "public" fields */
 283   jmp_buf setjmp_buffer;        /* for return to caller */
 284 };
 285
 286 typedef struct my_error_mgr * my_error_ptr;
 287
 288 /* Here's the routine that will replace the standard error_exit method */
 289
 290 METHODDEF(void)
 291 my_error_exit (j_common_ptr cinfo) {
 292   /* cinfo->err really points to a my_error_mgr struct, so coerce pointer */
 293   my_error_ptr myerr = (my_error_ptr) cinfo->err;
 294
 295   /* Always display the message. */
 296   /* We could postpone this until after returning, if we chose. */
 297   (*cinfo->err->output_message) (cinfo);
 298
 299   /* Return control to the setjmp point */
 300   longjmp(myerr->setjmp_buffer, 1);
 301 }
 302
 303 static void
 304 transfer_cmyk_inverted(i_color *out, JSAMPARRAY in, int width) {
 305   JSAMPROW inrow = *in;
 306   while (width--) {
 307     /* extract and convert to real CMYK */
 308     /* horribly enough this is correct given cmyk values are inverted */
 309     int c = *inrow++;
 310     int m = *inrow++;
 311     int y = *inrow++;
 312     int k = *inrow++;
 313     out->rgba.r = (c * k) / MAXJSAMPLE;
 314     out->rgba.g = (m * k) / MAXJSAMPLE;
 315     out->rgba.b = (y * k) / MAXJSAMPLE;
 316     ++out;
 317   }
 318 }
 319
 320 static void
 321 transfer_rgb(i_color *out, JSAMPARRAY in, int width) {
 322   JSAMPROW inrow = *in;
 323   while (width--) {
 324     out->rgba.r = *inrow++;
 325     out->rgba.g = *inrow++;
 326     out->rgba.b = *inrow++;
 327     ++out;
 328   }
 329 }
 330
 331 static void
 332 transfer_gray(i_color *out, JSAMPARRAY in, int width) {
 333   JSAMPROW inrow = *in;
 334   while (width--) {
 335     out->gray.gray_color = *inrow++;
 336     ++out;
 337   }
 338 }
 339
 340 typedef void (*transfer_function_t)(i_color *out, JSAMPARRAY in, int width);
 341
 342 static const char version_string[] =
 343 #ifdef LIBJPEG_TURBO_VERSION
 344   "libjpeg-turbo " STRINGIFY(LIBJPEG_TURBO_VERSION) " api " STRINGIFY(JPEG_LIB_VERSION)
 345 #else
 346   "libjpeg " STRINGIFY(JPEG_LIB_VERSION)
 347 #endif
 348   ;
 349
 350 /*
 351 =item i_libjpeg_version()
 352
 353 =cut
 354 */
 355
 356 const char *
 357 i_libjpeg_version(void) {
 358   return version_string;
 359 }
 360
 361 /*
 362 =item i_readjpeg_wiol(data, length, iptc_itext, itlength)
 363
 364 =cut
 365 */
 366 i_img*
 367 i_readjpeg_wiol(io_glue *data, int length, char** iptc_itext, int *itlength) {
 368   i_img * volatile im = NULL;
 369   int seen_exif = 0;
 370   i_color * volatile line_buffer = NULL;
 371   struct jpeg_decompress_struct cinfo;
 372   struct my_error_mgr jerr;
 373   JSAMPARRAY buffer;            /* Output row buffer */
 374   int row_stride;               /* physical row width in output buffer */
 375   jpeg_saved_marker_ptr markerp;
 376   transfer_function_t transfer_f;
 377   int channels;
 378   volatile int src_set = 0;
 379
 380   mm_log((1,"i_readjpeg_wiol(data %p, length %d,iptc_itext %p)\n", data, length, iptc_itext));
 381
 382   i_clear_error();
 383
 384   *iptc_itext = NULL;
 385   *itlength = 0;
 386
 387   cinfo.err = jpeg_std_error(&jerr.pub);
 388   jerr.pub.error_exit     = my_error_exit;
 389   jerr.pub.output_message = my_output_message;
 390
 391   /* Set error handler */
 392   if (setjmp(jerr.setjmp_buffer)) {
 393     if (src_set)
 394       wiol_term_source(&cinfo);
 395     jpeg_destroy_decompress(&cinfo);
 396     if (line_buffer)
 397       myfree(line_buffer);
 398     if (im)
 399       i_img_destroy(im);
 400     return NULL;
 401   }
 402
 403   jpeg_create_decompress(&cinfo);
 404   jpeg_save_markers(&cinfo, JPEG_APP13, 0xFFFF);
 405   jpeg_save_markers(&cinfo, JPEG_APP1, 0xFFFF);
 406   jpeg_save_markers(&cinfo, JPEG_COM, 0xFFFF);
 407   jpeg_wiol_src(&cinfo, data, length);
 408   src_set = 1;
 409
 410   (void) jpeg_read_header(&cinfo, TRUE);
 411   (void) jpeg_start_decompress(&cinfo);
 412
 413   channels = cinfo.output_components;
 414   switch (cinfo.out_color_space) {
 415   case JCS_GRAYSCALE:
 416     if (cinfo.output_components != 1) {
 417       mm_log((1, "i_readjpeg: grayscale image with %d channels\n", cinfo.output_components));
 418       i_push_errorf(0, "grayscale image with invalid components %d", cinfo.output_components);
 419       wiol_term_source(&cinfo);
 420       jpeg_destroy_decompress(&cinfo);
 421       return NULL;
 422     }
 423     transfer_f = transfer_gray;
 424     break;
 425
 426   case JCS_RGB:
 427     transfer_f = transfer_rgb;
 428     if (cinfo.output_components != 3) {
 429       mm_log((1, "i_readjpeg: RGB image with %d channels\n", cinfo.output_components));
 430       i_push_errorf(0, "RGB image with invalid components %d", cinfo.output_components);
 431       wiol_term_source(&cinfo);
 432       jpeg_destroy_decompress(&cinfo);
 433       return NULL;
 434     }
 435     break;
 436
 437   case JCS_CMYK:
 438     if (cinfo.output_components == 4) {
 439       /* we treat the CMYK values as inverted, because that's what that
 440          buggy photoshop does, and everyone has to follow the gorilla.
 441
 442          Is there any app that still produces correct CMYK JPEGs?
 443       */
 444       transfer_f = transfer_cmyk_inverted;
 445       channels = 3;
 446     }
 447     else {
 448       mm_log((1, "i_readjpeg: cmyk image with %d channels\n", cinfo.output_components));
 449       i_push_errorf(0, "CMYK image with invalid components %d", cinfo.output_components);
 450       wiol_term_source(&cinfo);
 451       jpeg_destroy_decompress(&cinfo);
 452       return NULL;
 453     }
 454     break;
 455
 456   default:
 457     mm_log((1, "i_readjpeg: unknown color space %d\n", cinfo.out_color_space));
 458     i_push_errorf(0, "Unknown color space %d", cinfo.out_color_space);
 459     wiol_term_source(&cinfo);
 460     jpeg_destroy_decompress(&cinfo);
 461     return NULL;
 462   }
 463
 464   if (!i_int_check_image_file_limits(cinfo.output_width, cinfo.output_height,
 465                                      channels, sizeof(i_sample_t))) {
 466     mm_log((1, "i_readjpeg: image size exceeds limits\n"));
 467     wiol_term_source(&cinfo);
 468     jpeg_destroy_decompress(&cinfo);
 469     return NULL;
 470   }
 471
 472   im = i_img_8_new(cinfo.output_width, cinfo.output_height, channels);
 473   if (!im) {
 474     wiol_term_source(&cinfo);
 475     jpeg_destroy_decompress(&cinfo);
 476     return NULL;
 477   }
 478   row_stride = cinfo.output_width * cinfo.output_components;
 479   buffer = (*cinfo.mem->alloc_sarray) ((j_common_ptr) &cinfo, JPOOL_IMAGE, row_stride, 1);
 480   line_buffer = mymalloc(sizeof(i_color) * cinfo.output_width);
 481   while (cinfo.output_scanline < cinfo.output_height) {
 482     (void) jpeg_read_scanlines(&cinfo, buffer, 1);
 483     transfer_f(line_buffer, buffer, cinfo.output_width);
 484     i_plin(im, 0, cinfo.output_width, cinfo.output_scanline-1, line_buffer);
 485   }
 486   myfree(line_buffer);
 487   line_buffer = NULL;
 488
 489   /* check for APP1 marker and save */
 490   markerp = cinfo.marker_list;
 491   while (markerp != NULL) {
 492     if (markerp->marker == JPEG_COM) {
 493       i_tags_set(&im->tags, "jpeg_comment", (const char *)markerp->data,
 494                  markerp->data_length);
 495     }
 496     else if (markerp->marker == JPEG_APP1 && !seen_exif) {
 497       unsigned char *data = markerp->data;
 498       size_t len = markerp->data_length;
 499       if (len >= 6 && memcmp(data, "Exif\0\0", 6) == 0) {
 500         seen_exif = im_decode_exif(im, data+6, len-6);
 501       }
 502     }
 503     else if (markerp->marker == JPEG_APP13) {
 504       *iptc_itext = mymalloc(markerp->data_length);
 505       memcpy(*iptc_itext, markerp->data, markerp->data_length);
 506       *itlength = markerp->data_length;
 507     }
 508
 509     markerp = markerp->next;
 510   }
 511
 512   i_tags_setn(&im->tags, "jpeg_out_color_space", cinfo.out_color_space);
 513   i_tags_setn(&im->tags, "jpeg_color_space", cinfo.jpeg_color_space);
 514
 515   if (cinfo.saw_JFIF_marker) {
 516     double xres = cinfo.X_density;
 517     double yres = cinfo.Y_density;
 518
 519     i_tags_setn(&im->tags, "jpeg_density_unit", cinfo.density_unit);
 520     switch (cinfo.density_unit) {
 521     case 0: /* values are just the aspect ratio */
 522       i_tags_setn(&im->tags, "i_aspect_only", 1);
 523       i_tags_set(&im->tags, "jpeg_density_unit_name", "none", -1);
 524       break;
 525
 526     case 1: /* per inch */
 527       i_tags_set(&im->tags, "jpeg_density_unit_name", "inch", -1);
 528       break;
 529
 530     case 2: /* per cm */
 531       i_tags_set(&im->tags, "jpeg_density_unit_name", "centimeter", -1);
 532       xres *= 2.54;
 533       yres *= 2.54;
 534       break;
 535     }
 536     i_tags_set_float2(&im->tags, "i_xres", 0, xres, 6);
 537     i_tags_set_float2(&im->tags, "i_yres", 0, yres, 6);
 538   }
 539
 540   /* I originally used jpeg_has_multiple_scans() here, but that can
 541    * return true for non-progressive files too.  The progressive_mode
 542    * member is available at least as far back as 6b and does the right
 543    * thing.
 544    */
 545   i_tags_setn(&im->tags, "jpeg_progressive",
 546               cinfo.progressive_mode ? 1 : 0);
 547
 548   (void) jpeg_finish_decompress(&cinfo);
 549   jpeg_destroy_decompress(&cinfo);
 550
 551   i_tags_set(&im->tags, "i_format", "jpeg", 4);
 552
 553   mm_log((1,"i_readjpeg_wiol -> (%p)\n",im));
 554   return im;
 555 }
 556
 557 /*
 558 =item i_writejpeg_wiol(im, ig, qfactor)
 559
 560 =cut
 561 */
 562
 563 undef_int
 564 i_writejpeg_wiol(i_img *im, io_glue *ig, int qfactor) {
 565   JSAMPLE *image_buffer;
 566   int quality;
 567   int got_xres, got_yres, aspect_only, resunit;
 568   double xres, yres;
 569   int comment_entry;
 570   int want_channels = im->channels;
 571   int progressive = 0;
 572   int optimize = 0;
 573
 574   struct jpeg_compress_struct cinfo;
 575   struct my_error_mgr jerr;
 576
 577   JSAMPROW row_pointer[1];      /* pointer to JSAMPLE row[s] */
 578   int row_stride;               /* physical row width in image buffer */
 579   unsigned char * data = NULL;
 580   i_color *line_buf = NULL;
 581
 582   mm_log((1,"i_writejpeg(im %p, ig %p, qfactor %d)\n", im, ig, qfactor));
 583
 584   i_clear_error();
 585
 586   if (im->xsize > JPEG_DIM_MAX || im->ysize > JPEG_DIM_MAX) {
 587     i_push_error(0, "image too large for JPEG");
 588     return 0;
 589   }
 590
 591   if (!(im->channels==1 || im->channels==3)) {
 592     want_channels = im->channels - 1;
 593   }
 594   quality = qfactor;
 595
 596   cinfo.err = jpeg_std_error(&jerr.pub);
 597   jerr.pub.error_exit = my_error_exit;
 598   jerr.pub.output_message = my_output_message;
 599
 600   jpeg_create_compress(&cinfo);
 601
 602   if (setjmp(jerr.setjmp_buffer)) {
 603     jpeg_destroy_compress(&cinfo);
 604     if (data)
 605       myfree(data);
 606     if (line_buf)
 607       myfree(line_buf);
 608     return 0;
 609   }
 610
 611   jpeg_wiol_dest(&cinfo, ig);
 612
 613   cinfo.image_width  = im -> xsize;     /* image width and height, in pixels */
 614   cinfo.image_height = im -> ysize;
 615
 616   if (want_channels==3) {
 617     cinfo.input_components = 3;         /* # of color components per pixel */
 618     cinfo.in_color_space = JCS_RGB;     /* colorspace of input image */
 619   }
 620
 621   if (want_channels==1) {
 622     cinfo.input_components = 1;         /* # of color components per pixel */
 623     cinfo.in_color_space = JCS_GRAYSCALE;       /* colorspace of input image */
 624   }
 625
 626   jpeg_set_defaults(&cinfo);
 627   jpeg_set_quality(&cinfo, quality, TRUE);  /* limit to baseline-JPEG values */
 628
 629   if (!i_tags_get_int(&im->tags, "jpeg_progressive", 0, &progressive))
 630     progressive = 0;
 631   if (progressive) {
 632     jpeg_simple_progression(&cinfo);
 633   }
 634   if (!i_tags_get_int(&im->tags, "jpeg_optimize", 0, &optimize))
 635     optimize = 0;
 636   cinfo.optimize_coding = optimize;
 637
 638   got_xres = i_tags_get_float(&im->tags, "i_xres", 0, &xres);
 639   got_yres = i_tags_get_float(&im->tags, "i_yres", 0, &yres);
 640   if (!i_tags_get_int(&im->tags, "i_aspect_only", 0,&aspect_only))
 641     aspect_only = 0;
 642   if (!i_tags_get_int(&im->tags, "jpeg_density_unit", 0, &resunit))
 643     resunit = 1; /* per inch */
 644   if (resunit < 0 || resunit > 2) /* default to inch if invalid */
 645     resunit = 1;
 646   if (got_xres || got_yres) {
 647     if (!got_xres)
 648       xres = yres;
 649     else if (!got_yres)
 650       yres = xres;
 651     if (aspect_only)
 652       resunit = 0; /* standard tags override format tags */
 653     if (resunit == 2) {
 654       /* convert to per cm */
 655       xres /= 2.54;
 656       yres /= 2.54;
 657     }
 658     cinfo.density_unit = resunit;
 659     cinfo.X_density = (int)(xres + 0.5);
 660     cinfo.Y_density = (int)(yres + 0.5);
 661   }
 662
 663   jpeg_start_compress(&cinfo, TRUE);
 664
 665   if (i_tags_find(&im->tags, "jpeg_comment", 0, &comment_entry)) {
 666     jpeg_write_marker(&cinfo, JPEG_COM,
 667                       (const JOCTET *)im->tags.tags[comment_entry].data,
 668                       im->tags.tags[comment_entry].size);
 669   }
 670
 671   row_stride = im->xsize * im->channels;        /* JSAMPLEs per row in image_buffer */
 672
 673   if (!im->virtual && im->type == i_direct_type && im->bits == i_8_bits
 674       && im->channels == want_channels) {
 675     image_buffer=im->idata;
 676
 677     while (cinfo.next_scanline < cinfo.image_height) {
 678       /* jpeg_write_scanlines expects an array of pointers to scanlines.
 679        * Here the array is only one element long, but you could pass
 680        * more than one scanline at a time if that's more convenient.
 681        */
 682       row_pointer[0] = & image_buffer[cinfo.next_scanline * row_stride];
 683       (void) jpeg_write_scanlines(&cinfo, row_pointer, 1);
 684     }
 685   }
 686   else {
 687     i_color bg;
 688
 689     i_get_file_background(im, &bg);
 690     data = mymalloc(im->xsize * im->channels);
 691     if (data) {
 692       while (cinfo.next_scanline < cinfo.image_height) {
 693         /* jpeg_write_scanlines expects an array of pointers to scanlines.
 694          * Here the array is only one element long, but you could pass
 695          * more than one scanline at a time if that's more convenient.
 696          */
 697         i_gsamp_bg(im, 0, im->xsize, cinfo.next_scanline, data,
 698                    want_channels, &bg);
 699         row_pointer[0] = data;
 700         (void) jpeg_write_scanlines(&cinfo, row_pointer, 1);
 701       }
 702       myfree(data);
 703     }
 704     else {
 705       jpeg_destroy_compress(&cinfo);
 706       i_push_error(0, "out of memory");
 707       return 0; /* out of memory? */
 708     }
 709   }
 710
 711   /* Step 6: Finish compression */
 712
 713   jpeg_finish_compress(&cinfo);
 714
 715   jpeg_destroy_compress(&cinfo);
 716
 717   if (i_io_close(ig))
 718     return 0;
 719
 720   return(1);
 721 }
 722
 723 /*
 724 =back
 725
 726 =head1 AUTHOR
 727
 728 Arnar M. Hrafnkelsson, addi@umich.edu
 729
 730 =head1 SEE ALSO
 731
 732 Imager(3)
 733
 734 =cut
 735 */