]>
Commit | Line | Data |
---|---|---|
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 | */ |