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