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