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