- added experimental EXIF decoding when reading JPEG files.
[imager.git] / jpeg.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 <stdio.h>
24 #include <sys/stat.h>
25 #ifndef _MSC_VER
26 #include <unistd.h>
27 #endif
28 #include <setjmp.h>
29
30 #include "iolayer.h"
31 #include "imagei.h"
32 #include "jpeglib.h"
33 #include "jerror.h"
34 #include <errno.h>
35 #ifdef IMEXIF_ENABLE
36 #include "imexif.h"
37 #endif
38
39 #define JPEG_APP13       0xED    /* APP13 marker code */
40 #define JPEG_APP1 (JPEG_APP0 + 1)
41 #define JPGS 16384
42
43 static unsigned char fake_eoi[]={(JOCTET) 0xFF,(JOCTET) JPEG_EOI};
44
45 /* Bad design right here */
46
47 static int tlength=0;
48 static char **iptc_text=NULL;
49
50
51 /* Source and Destination managers */
52
53
54 typedef struct {
55   struct jpeg_source_mgr pub;   /* public fields */
56   io_glue *data;
57   JOCTET *buffer;               /* start of buffer */
58   int length;                   /* Do I need this? */
59   boolean start_of_file;        /* have we gotten any data yet? */
60 } wiol_source_mgr;
61
62 typedef struct {
63   struct jpeg_destination_mgr pub; /* public fields */
64   io_glue *data;
65   JOCTET *buffer;               /* start of buffer */
66   boolean start_of_file;        /* have we gotten any data yet? */
67 } wiol_destination_mgr;
68
69 typedef wiol_source_mgr *wiol_src_ptr;
70 typedef wiol_destination_mgr *wiol_dest_ptr;
71
72
73 /*
74  * Methods for io manager objects 
75  * 
76  * Methods for source managers: 
77  *
78  * init_source         (j_decompress_ptr cinfo);
79  * skip_input_data     (j_decompress_ptr cinfo, long num_bytes);
80  * fill_input_buffer   (j_decompress_ptr cinfo);
81  * term_source         (j_decompress_ptr cinfo);
82  */
83
84
85
86 static void
87 wiol_init_source (j_decompress_ptr cinfo) {
88   wiol_src_ptr src = (wiol_src_ptr) cinfo->src;
89   
90   /* We reset the empty-input-file flag for each image, but we don't clear
91    * the input buffer.   This is correct behavior for reading a series of
92    * images from one source.
93    */
94   src->start_of_file = TRUE;
95 }
96
97
98
99 static boolean
100 wiol_fill_input_buffer(j_decompress_ptr cinfo) {
101   wiol_src_ptr src = (wiol_src_ptr) cinfo->src;
102   ssize_t nbytes; /* We assume that reads are "small" */
103   
104   mm_log((1,"wiol_fill_input_buffer(cinfo 0x%p)\n"));
105   
106   nbytes = src->data->readcb(src->data, src->buffer, JPGS);
107   
108   if (nbytes <= 0) { /* Insert a fake EOI marker */
109     src->pub.next_input_byte = fake_eoi;
110     src->pub.bytes_in_buffer = 2;
111   } else {
112     src->pub.next_input_byte = src->buffer;
113     src->pub.bytes_in_buffer = nbytes;
114   }
115   src->start_of_file = FALSE;
116   return TRUE;
117 }
118
119
120 static void
121 wiol_skip_input_data (j_decompress_ptr cinfo, long num_bytes) {
122   wiol_src_ptr src = (wiol_src_ptr) cinfo->src;
123   
124   /* Just a dumb implementation for now.  Could use fseek() except
125    * it doesn't work on pipes.  Not clear that being smart is worth
126    * any trouble anyway --- large skips are infrequent.
127    */
128   
129   if (num_bytes > 0) {
130     while (num_bytes > (long) src->pub.bytes_in_buffer) {
131       num_bytes -= (long) src->pub.bytes_in_buffer;
132       (void) wiol_fill_input_buffer(cinfo);
133       /* note we assume that fill_input_buffer will never return FALSE,
134        * so suspension need not be handled.
135        */
136     }
137     src->pub.next_input_byte += (size_t) num_bytes;
138     src->pub.bytes_in_buffer -= (size_t) num_bytes;
139   }
140 }
141
142 static void
143 wiol_term_source (j_decompress_ptr cinfo) {
144   /* no work necessary here */ 
145   wiol_src_ptr src;
146   if (cinfo->src != NULL) {
147     src = (wiol_src_ptr) cinfo->src;
148     myfree(src->buffer);
149   }
150 }
151
152
153 /* Source manager Constructor */
154
155 static void
156 jpeg_wiol_src(j_decompress_ptr cinfo, io_glue *ig, int length) {
157   wiol_src_ptr src;
158   
159   if (cinfo->src == NULL) {     /* first time for this JPEG object? */
160     cinfo->src = (struct jpeg_source_mgr *) (*cinfo->mem->alloc_small) 
161       ((j_common_ptr) cinfo, JPOOL_PERMANENT,sizeof(wiol_source_mgr));
162     src = (wiol_src_ptr) cinfo->src;
163   }
164
165   /* put the request method call in here later */
166   io_glue_commit_types(ig);
167   
168   src         = (wiol_src_ptr) cinfo->src;
169   src->data   = ig;
170   src->buffer = mymalloc( JPGS );
171   src->length = length;
172
173   src->pub.init_source       = wiol_init_source;
174   src->pub.fill_input_buffer = wiol_fill_input_buffer;
175   src->pub.skip_input_data   = wiol_skip_input_data;
176   src->pub.resync_to_restart = jpeg_resync_to_restart; /* use default method */
177   src->pub.term_source       = wiol_term_source;
178   src->pub.bytes_in_buffer   = 0; /* forces fill_input_buffer on first read */
179   src->pub.next_input_byte   = NULL; /* until buffer loaded */
180 }
181
182
183
184
185 /*
186  * Methods for destination managers:
187  *
188  * init_destination    (j_compress_ptr cinfo);
189  * empty_output_buffer (j_compress_ptr cinfo);
190  * term_destination    (j_compress_ptr cinfo);
191  *
192  */
193
194 static void
195 wiol_init_destination (j_compress_ptr cinfo) {
196   wiol_dest_ptr dest = (wiol_dest_ptr) cinfo->dest;
197   
198   /* We reset the empty-input-file flag for each image, but we don't clear
199    * the input buffer.   This is correct behavior for reading a series of
200    * images from one source.
201    */
202   dest->start_of_file = TRUE;
203 }
204
205 static boolean
206 wiol_empty_output_buffer(j_compress_ptr cinfo) {
207   wiol_dest_ptr dest = (wiol_dest_ptr) cinfo->dest;
208   ssize_t rc;
209   /*
210     Previously this code was checking free_in_buffer to see how much 
211     needed to be written.  This does not follow the documentation:
212
213                        "In typical applications, it should write out the
214         *entire* buffer (use the saved start address and buffer length;
215         ignore the current state of next_output_byte and free_in_buffer)."
216
217   ssize_t nbytes     = JPGS - dest->pub.free_in_buffer;
218   */
219
220   mm_log((1,"wiol_empty_output_buffer(cinfo 0x%p)\n"));
221   rc = dest->data->writecb(dest->data, dest->buffer, JPGS);
222
223   if (rc != JPGS) { /* XXX: Should raise some jpeg error */
224     myfree(dest->buffer);
225     mm_log((1, "wiol_empty_output_buffer: Error: nbytes = %d != rc = %d\n", JPGS, rc));
226     ERREXIT(cinfo, JERR_FILE_WRITE);
227   }
228   dest->pub.free_in_buffer = JPGS;
229   dest->pub.next_output_byte = dest->buffer;
230   return TRUE;
231 }
232
233 static void
234 wiol_term_destination (j_compress_ptr cinfo) {
235   wiol_dest_ptr dest = (wiol_dest_ptr) cinfo->dest;
236   size_t nbytes = JPGS - dest->pub.free_in_buffer;
237   /* yes, this needs to flush the buffer */
238   /* needs error handling */
239
240   if (dest->data->writecb(dest->data, dest->buffer, nbytes) != nbytes) {
241     myfree(dest->buffer);
242     ERREXIT(cinfo, JERR_FILE_WRITE);
243   }
244   
245   if (dest != NULL) myfree(dest->buffer);
246 }
247
248
249 /* Destination manager Constructor */
250
251 static void
252 jpeg_wiol_dest(j_compress_ptr cinfo, io_glue *ig) {
253   wiol_dest_ptr dest;
254   
255   if (cinfo->dest == NULL) {    /* first time for this JPEG object? */
256     cinfo->dest = 
257       (struct jpeg_destination_mgr *)
258       (*cinfo->mem->alloc_small) 
259       ((j_common_ptr) cinfo, JPOOL_PERMANENT, sizeof(wiol_destination_mgr));
260   }
261   
262   dest = (wiol_dest_ptr) cinfo->dest;
263   dest->data                    = ig;
264   dest->buffer                  = mymalloc( JPGS );
265
266   dest->pub.init_destination    = wiol_init_destination;
267   dest->pub.empty_output_buffer = wiol_empty_output_buffer;
268   dest->pub.term_destination    = wiol_term_destination;
269   dest->pub.free_in_buffer      = JPGS;
270   dest->pub.next_output_byte    = dest->buffer;
271 }
272
273 LOCAL(unsigned int)
274 jpeg_getc (j_decompress_ptr cinfo)
275 /* Read next byte */
276 {
277   struct jpeg_source_mgr * datasrc = cinfo->src;
278
279   if (datasrc->bytes_in_buffer == 0) {
280     if (! (*datasrc->fill_input_buffer) (cinfo))
281       { fprintf(stderr,"Jpeglib: cant suspend.\n"); exit(3); }
282       /*      ERREXIT(cinfo, JERR_CANT_SUSPEND);*/
283   }
284   datasrc->bytes_in_buffer--;
285   return GETJOCTET(*datasrc->next_input_byte++);
286 }
287
288 METHODDEF(boolean)
289 APP13_handler (j_decompress_ptr cinfo) {
290   INT32 length;
291   unsigned int cnt=0;
292   
293   length = jpeg_getc(cinfo) << 8;
294   length += jpeg_getc(cinfo);
295   length -= 2;  /* discount the length word itself */
296   
297   tlength=length;
298
299   if ( ((*iptc_text)=mymalloc(length)) == NULL ) return FALSE;
300   while (--length >= 0) (*iptc_text)[cnt++] = jpeg_getc(cinfo); 
301  
302   return TRUE;
303 }
304
305 METHODDEF(void)
306 my_output_message (j_common_ptr cinfo) {
307   char buffer[JMSG_LENGTH_MAX];
308
309   /* Create the message */
310   (*cinfo->err->format_message) (cinfo, buffer);
311
312   i_push_error(0, buffer);
313
314   /* Send it to stderr, adding a newline */
315   mm_log((1, "%s\n", buffer));
316 }
317
318 struct my_error_mgr {
319   struct jpeg_error_mgr pub;    /* "public" fields */
320   jmp_buf setjmp_buffer;        /* for return to caller */
321 };
322
323 typedef struct my_error_mgr * my_error_ptr;
324
325 /* Here's the routine that will replace the standard error_exit method */
326
327 METHODDEF(void)
328 my_error_exit (j_common_ptr cinfo) {
329   /* cinfo->err really points to a my_error_mgr struct, so coerce pointer */
330   my_error_ptr myerr = (my_error_ptr) cinfo->err;
331   
332   /* Always display the message. */
333   /* We could postpone this until after returning, if we chose. */
334   (*cinfo->err->output_message) (cinfo);
335
336   /* Return control to the setjmp point */
337   longjmp(myerr->setjmp_buffer, 1);
338 }
339
340 /*
341 =item i_readjpeg_wiol(data, length, iptc_itext, itlength)
342
343 =cut
344 */
345 i_img*
346 i_readjpeg_wiol(io_glue *data, int length, char** iptc_itext, int *itlength) {
347   i_img *im;
348 #ifdef IMEXIF_ENABLE
349   int seen_exif = 0;
350 #endif
351
352   struct jpeg_decompress_struct cinfo;
353   struct my_error_mgr jerr;
354   JSAMPARRAY buffer;            /* Output row buffer */
355   int row_stride;               /* physical row width in output buffer */
356   jpeg_saved_marker_ptr markerp;
357
358   mm_log((1,"i_readjpeg_wiol(data 0x%p, length %d,iptc_itext 0x%p)\n", data, iptc_itext));
359
360   i_clear_error();
361
362   iptc_text = iptc_itext;
363   cinfo.err = jpeg_std_error(&jerr.pub);
364   jerr.pub.error_exit     = my_error_exit;
365   jerr.pub.output_message = my_output_message;
366
367   /* Set error handler */
368   if (setjmp(jerr.setjmp_buffer)) {
369     jpeg_destroy_decompress(&cinfo); 
370     *iptc_itext=NULL;
371     *itlength=0;
372     return NULL;
373   }
374   
375   jpeg_create_decompress(&cinfo);
376   jpeg_set_marker_processor(&cinfo, JPEG_APP13, APP13_handler);
377   jpeg_save_markers(&cinfo, JPEG_APP1, 0xFFFF);
378   jpeg_save_markers(&cinfo, JPEG_COM, 0xFFFF);
379   jpeg_wiol_src(&cinfo, data, length);
380
381   (void) jpeg_read_header(&cinfo, TRUE);
382   (void) jpeg_start_decompress(&cinfo);
383   if (!i_int_check_image_file_limits(cinfo.output_width, cinfo.output_height,
384                                      cinfo.output_components, sizeof(i_sample_t))) {
385     mm_log((1, "i_readjpeg: image size exceeds limits\n"));
386
387     jpeg_destroy_decompress(&cinfo);
388     return NULL;
389   }
390   im=i_img_empty_ch(NULL,cinfo.output_width,cinfo.output_height,cinfo.output_components);
391   if (!im) {
392     jpeg_destroy_decompress(&cinfo);
393     return NULL;
394   }
395   row_stride = cinfo.output_width * cinfo.output_components;
396   buffer = (*cinfo.mem->alloc_sarray) ((j_common_ptr) &cinfo, JPOOL_IMAGE, row_stride, 1);
397   while (cinfo.output_scanline < cinfo.output_height) {
398     (void) jpeg_read_scanlines(&cinfo, buffer, 1);
399     memcpy(im->idata+im->channels*im->xsize*(cinfo.output_scanline-1),buffer[0],row_stride);
400   }
401
402   /* check for APP1 marker and save */
403   markerp = cinfo.marker_list;
404   while (markerp != NULL) {
405     if (markerp->marker == JPEG_COM) {
406       i_tags_add(&im->tags, "jpeg_comment", 0, markerp->data,
407                  markerp->data_length, 0);
408     }
409 #ifdef IMEXIF_ENABLE
410     else if (markerp->marker == JPEG_APP1 && !seen_exif) {
411       seen_exif = i_int_decode_exif(im, markerp->data, markerp->data_length);
412     }
413 #endif      
414
415     markerp = markerp->next;
416   }
417
418   (void) jpeg_finish_decompress(&cinfo);
419   jpeg_destroy_decompress(&cinfo);
420   *itlength=tlength;
421
422   i_tags_add(&im->tags, "i_format", 0, "jpeg", 4, 0);
423
424   mm_log((1,"i_readjpeg_wiol -> (0x%x)\n",im));
425   return im;
426 }
427
428 /*
429 =item i_writejpeg_wiol(im, ig, qfactor)
430
431 =cut
432 */
433
434 undef_int
435 i_writejpeg_wiol(i_img *im, io_glue *ig, int qfactor) {
436   JSAMPLE *image_buffer;
437   int quality;
438
439   struct jpeg_compress_struct cinfo;
440   struct my_error_mgr jerr;
441
442   JSAMPROW row_pointer[1];      /* pointer to JSAMPLE row[s] */
443   int row_stride;               /* physical row width in image buffer */
444   unsigned char * data = NULL;
445
446   mm_log((1,"i_writejpeg(im %p, ig %p, qfactor %d)\n", im, ig, qfactor));
447   
448   i_clear_error();
449
450   if (!(im->channels==1 || im->channels==3)) { 
451     i_push_error(0, "only 1 or 3 channels images can be saved as JPEG");
452     return 0;
453   }
454   quality = qfactor;
455
456   cinfo.err = jpeg_std_error(&jerr.pub);
457   jerr.pub.error_exit = my_error_exit;
458   jerr.pub.output_message = my_output_message;
459   
460   jpeg_create_compress(&cinfo);
461
462   if (setjmp(jerr.setjmp_buffer)) {
463     jpeg_destroy_compress(&cinfo);
464     if (data)
465       myfree(data);
466     return 0;
467   }
468
469   io_glue_commit_types(ig);
470   jpeg_wiol_dest(&cinfo, ig);
471
472   cinfo.image_width  = im -> xsize;     /* image width and height, in pixels */
473   cinfo.image_height = im -> ysize;
474
475   if (im->channels==3) {
476     cinfo.input_components = 3;         /* # of color components per pixel */
477     cinfo.in_color_space = JCS_RGB;     /* colorspace of input image */
478   }
479
480   if (im->channels==1) {
481     cinfo.input_components = 1;         /* # of color components per pixel */
482     cinfo.in_color_space = JCS_GRAYSCALE;       /* colorspace of input image */
483   }
484
485   jpeg_set_defaults(&cinfo);
486   jpeg_set_quality(&cinfo, quality, TRUE);  /* limit to baseline-JPEG values */
487
488   jpeg_start_compress(&cinfo, TRUE);
489
490   row_stride = im->xsize * im->channels;        /* JSAMPLEs per row in image_buffer */
491
492   if (!im->virtual && im->type == i_direct_type && im->bits == i_8_bits) {
493     image_buffer=im->idata;
494
495     while (cinfo.next_scanline < cinfo.image_height) {
496       /* jpeg_write_scanlines expects an array of pointers to scanlines.
497        * Here the array is only one element long, but you could pass
498        * more than one scanline at a time if that's more convenient.
499        */
500       row_pointer[0] = & image_buffer[cinfo.next_scanline * row_stride];
501       (void) jpeg_write_scanlines(&cinfo, row_pointer, 1);
502     }
503   }
504   else {
505     data = mymalloc(im->xsize * im->channels);
506     if (data) {
507       while (cinfo.next_scanline < cinfo.image_height) {
508         /* jpeg_write_scanlines expects an array of pointers to scanlines.
509          * Here the array is only one element long, but you could pass
510          * more than one scanline at a time if that's more convenient.
511          */
512         i_gsamp(im, 0, im->xsize, cinfo.next_scanline, data, 
513                 NULL, im->channels);
514         row_pointer[0] = data;
515         (void) jpeg_write_scanlines(&cinfo, row_pointer, 1);
516       }
517     }
518     else {
519       jpeg_destroy_compress(&cinfo);
520       i_push_error(0, "out of memory");
521       return 0; /* out of memory? */
522     }
523   }
524
525   /* Step 6: Finish compression */
526
527   jpeg_finish_compress(&cinfo);
528
529   jpeg_destroy_compress(&cinfo);
530
531   ig->closecb(ig);
532
533   return(1);
534 }
535
536 /*
537 =back
538
539 =head1 AUTHOR
540
541 Arnar M. Hrafnkelsson, addi@umich.edu
542
543 =head1 SEE ALSO
544
545 Imager(3)
546
547 =cut
548 */