]> git.saurik.com Git - wxWidgets.git/blame_incremental - src/tiff/tif_jpeg.c
[ 1509599 ] 'Split pickers page in widgets sample' with more icons and rebaking.
[wxWidgets.git] / src / tiff / tif_jpeg.c
... / ...
CommitLineData
1/* $Header$ */
2
3/*
4 * Copyright (c) 1994-1997 Sam Leffler
5 * Copyright (c) 1994-1997 Silicon Graphics, Inc.
6 *
7 * Permission to use, copy, modify, distribute, and sell this software and
8 * its documentation for any purpose is hereby granted without fee, provided
9 * that (i) the above copyright notices and this permission notice appear in
10 * all copies of the software and related documentation, and (ii) the names of
11 * Sam Leffler and Silicon Graphics may not be used in any advertising or
12 * publicity relating to the software without the specific, prior written
13 * permission of Sam Leffler and Silicon Graphics.
14 *
15 * THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND,
16 * EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY
17 * WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
18 *
19 * IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR
20 * ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND,
21 * OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
22 * WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF
23 * LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
24 * OF THIS SOFTWARE.
25 */
26
27#include "tiffiop.h"
28#ifdef JPEG_SUPPORT
29/*
30 * TIFF Library
31 *
32 * JPEG Compression support per TIFF Technical Note #2
33 * (*not* per the original TIFF 6.0 spec).
34 *
35 * This file is simply an interface to the libjpeg library written by
36 * the Independent JPEG Group. You need release 5 or later of the IJG
37 * code, which you can find on the Internet at ftp.uu.net:/graphics/jpeg/.
38 *
39 * Contributed by Tom Lane <tgl@sss.pgh.pa.us>.
40 */
41#include <assert.h>
42#include <stdio.h>
43#include <setjmp.h>
44
45int TIFFFillStrip(TIFF*, tstrip_t);
46int TIFFFillTile(TIFF*, ttile_t);
47
48/* We undefine FAR to avoid conflict with JPEG definition */
49
50#ifdef FAR
51#undef FAR
52#endif
53
54/*
55 The windows RPCNDR.H file defines boolean, but defines it with the
56 wrong size. So we declare HAVE_BOOLEAN so that the jpeg include file
57 won't try to typedef boolean, but #define it to override the rpcndr.h
58 definition.
59
60 http://bugzilla.remotesensing.org/show_bug.cgi?id=188
61*/
62#if defined(__RPCNDR_H__)
63#define HAVE_BOOLEAN
64#define boolean unsigned int
65#endif
66
67#include "jpeglib.h"
68#include "jerror.h"
69
70/*
71 * On some machines it may be worthwhile to use _setjmp or sigsetjmp
72 * in place of plain setjmp. These macros will make it easier.
73 */
74#define SETJMP(jbuf) setjmp(jbuf)
75#define LONGJMP(jbuf,code) longjmp(jbuf,code)
76#define JMP_BUF jmp_buf
77
78typedef struct jpeg_destination_mgr jpeg_destination_mgr;
79typedef struct jpeg_source_mgr jpeg_source_mgr;
80typedef struct jpeg_error_mgr jpeg_error_mgr;
81
82/*
83 * State block for each open TIFF file using
84 * libjpeg to do JPEG compression/decompression.
85 *
86 * libjpeg's visible state is either a jpeg_compress_struct
87 * or jpeg_decompress_struct depending on which way we
88 * are going. comm can be used to refer to the fields
89 * which are common to both.
90 *
91 * NB: cinfo is required to be the first member of JPEGState,
92 * so we can safely cast JPEGState* -> jpeg_xxx_struct*
93 * and vice versa!
94 */
95typedef struct {
96 union {
97 struct jpeg_compress_struct c;
98 struct jpeg_decompress_struct d;
99 struct jpeg_common_struct comm;
100 } cinfo; /* NB: must be first */
101 int cinfo_initialized;
102
103 jpeg_error_mgr err; /* libjpeg error manager */
104 JMP_BUF exit_jmpbuf; /* for catching libjpeg failures */
105 /*
106 * The following two members could be a union, but
107 * they're small enough that it's not worth the effort.
108 */
109 jpeg_destination_mgr dest; /* data dest for compression */
110 jpeg_source_mgr src; /* data source for decompression */
111 /* private state */
112 TIFF* tif; /* back link needed by some code */
113 uint16 photometric; /* copy of PhotometricInterpretation */
114 uint16 h_sampling; /* luminance sampling factors */
115 uint16 v_sampling;
116 tsize_t bytesperline; /* decompressed bytes per scanline */
117 /* pointers to intermediate buffers when processing downsampled data */
118 JSAMPARRAY ds_buffer[MAX_COMPONENTS];
119 int scancount; /* number of "scanlines" accumulated */
120 int samplesperclump;
121
122 TIFFVGetMethod vgetparent; /* super-class method */
123 TIFFVSetMethod vsetparent; /* super-class method */
124 TIFFStripMethod defsparent; /* super-class method */
125 TIFFTileMethod deftparent; /* super-class method */
126 /* pseudo-tag fields */
127 void* jpegtables; /* JPEGTables tag value, or NULL */
128 uint32 jpegtables_length; /* number of bytes in same */
129 int jpegquality; /* Compression quality level */
130 int jpegcolormode; /* Auto RGB<=>YCbCr convert? */
131 int jpegtablesmode; /* What to put in JPEGTables */
132
133 int ycbcrsampling_fetched;
134} JPEGState;
135
136#define JState(tif) ((JPEGState*)(tif)->tif_data)
137
138static int JPEGDecode(TIFF*, tidata_t, tsize_t, tsample_t);
139static int JPEGDecodeRaw(TIFF*, tidata_t, tsize_t, tsample_t);
140static int JPEGEncode(TIFF*, tidata_t, tsize_t, tsample_t);
141static int JPEGEncodeRaw(TIFF*, tidata_t, tsize_t, tsample_t);
142static int JPEGInitializeLibJPEG( TIFF * tif );
143
144#define FIELD_JPEGTABLES (FIELD_CODEC+0)
145
146static const TIFFFieldInfo jpegFieldInfo[] = {
147 { TIFFTAG_JPEGTABLES, -1,-1, TIFF_UNDEFINED, FIELD_JPEGTABLES,
148 FALSE, TRUE, "JPEGTables" },
149 { TIFFTAG_JPEGQUALITY, 0, 0, TIFF_ANY, FIELD_PSEUDO,
150 TRUE, FALSE, "" },
151 { TIFFTAG_JPEGCOLORMODE, 0, 0, TIFF_ANY, FIELD_PSEUDO,
152 FALSE, FALSE, "" },
153 { TIFFTAG_JPEGTABLESMODE, 0, 0, TIFF_ANY, FIELD_PSEUDO,
154 FALSE, FALSE, "" },
155};
156#define N(a) (sizeof (a) / sizeof (a[0]))
157
158/*
159 * libjpeg interface layer.
160 *
161 * We use setjmp/longjmp to return control to libtiff
162 * when a fatal error is encountered within the JPEG
163 * library. We also direct libjpeg error and warning
164 * messages through the appropriate libtiff handlers.
165 */
166
167/*
168 * Error handling routines (these replace corresponding
169 * IJG routines from jerror.c). These are used for both
170 * compression and decompression.
171 */
172static void
173TIFFjpeg_error_exit(j_common_ptr cinfo)
174{
175 JPEGState *sp = (JPEGState *) cinfo; /* NB: cinfo assumed first */
176 char buffer[JMSG_LENGTH_MAX];
177
178 (*cinfo->err->format_message) (cinfo, buffer);
179 TIFFError("JPEGLib", buffer); /* display the error message */
180 jpeg_abort(cinfo); /* clean up libjpeg state */
181 LONGJMP(sp->exit_jmpbuf, 1); /* return to libtiff caller */
182}
183
184/*
185 * This routine is invoked only for warning messages,
186 * since error_exit does its own thing and trace_level
187 * is never set > 0.
188 */
189static void
190TIFFjpeg_output_message(j_common_ptr cinfo)
191{
192 char buffer[JMSG_LENGTH_MAX];
193
194 (*cinfo->err->format_message) (cinfo, buffer);
195 TIFFWarning("JPEGLib", buffer);
196}
197
198/*
199 * Interface routines. This layer of routines exists
200 * primarily to limit side-effects from using setjmp.
201 * Also, normal/error returns are converted into return
202 * values per libtiff practice.
203 */
204#define CALLJPEG(sp, fail, op) (SETJMP((sp)->exit_jmpbuf) ? (fail) : (op))
205#define CALLVJPEG(sp, op) CALLJPEG(sp, 0, ((op),1))
206
207static int
208TIFFjpeg_create_compress(JPEGState* sp)
209{
210 /* initialize JPEG error handling */
211 sp->cinfo.c.err = jpeg_std_error(&sp->err);
212 sp->err.error_exit = TIFFjpeg_error_exit;
213 sp->err.output_message = TIFFjpeg_output_message;
214
215 return CALLVJPEG(sp, jpeg_create_compress(&sp->cinfo.c));
216}
217
218static int
219TIFFjpeg_create_decompress(JPEGState* sp)
220{
221 /* initialize JPEG error handling */
222 sp->cinfo.d.err = jpeg_std_error(&sp->err);
223 sp->err.error_exit = TIFFjpeg_error_exit;
224 sp->err.output_message = TIFFjpeg_output_message;
225
226 return CALLVJPEG(sp, jpeg_create_decompress(&sp->cinfo.d));
227}
228
229static int
230TIFFjpeg_set_defaults(JPEGState* sp)
231{
232 return CALLVJPEG(sp, jpeg_set_defaults(&sp->cinfo.c));
233}
234
235static int
236TIFFjpeg_set_colorspace(JPEGState* sp, J_COLOR_SPACE colorspace)
237{
238 return CALLVJPEG(sp, jpeg_set_colorspace(&sp->cinfo.c, colorspace));
239}
240
241static int
242TIFFjpeg_set_quality(JPEGState* sp, int quality, boolean force_baseline)
243{
244 return CALLVJPEG(sp,
245 jpeg_set_quality(&sp->cinfo.c, quality, force_baseline));
246}
247
248static int
249TIFFjpeg_suppress_tables(JPEGState* sp, boolean suppress)
250{
251 return CALLVJPEG(sp, jpeg_suppress_tables(&sp->cinfo.c, suppress));
252}
253
254static int
255TIFFjpeg_start_compress(JPEGState* sp, boolean write_all_tables)
256{
257 return CALLVJPEG(sp,
258 jpeg_start_compress(&sp->cinfo.c, write_all_tables));
259}
260
261static int
262TIFFjpeg_write_scanlines(JPEGState* sp, JSAMPARRAY scanlines, int num_lines)
263{
264 return CALLJPEG(sp, -1, (int) jpeg_write_scanlines(&sp->cinfo.c,
265 scanlines, (JDIMENSION) num_lines));
266}
267
268static int
269TIFFjpeg_write_raw_data(JPEGState* sp, JSAMPIMAGE data, int num_lines)
270{
271 return CALLJPEG(sp, -1, (int) jpeg_write_raw_data(&sp->cinfo.c,
272 data, (JDIMENSION) num_lines));
273}
274
275static int
276TIFFjpeg_finish_compress(JPEGState* sp)
277{
278 return CALLVJPEG(sp, jpeg_finish_compress(&sp->cinfo.c));
279}
280
281static int
282TIFFjpeg_write_tables(JPEGState* sp)
283{
284 return CALLVJPEG(sp, jpeg_write_tables(&sp->cinfo.c));
285}
286
287static int
288TIFFjpeg_read_header(JPEGState* sp, boolean require_image)
289{
290 return CALLJPEG(sp, -1, jpeg_read_header(&sp->cinfo.d, require_image));
291}
292
293static int
294TIFFjpeg_start_decompress(JPEGState* sp)
295{
296 return CALLVJPEG(sp, jpeg_start_decompress(&sp->cinfo.d));
297}
298
299static int
300TIFFjpeg_read_scanlines(JPEGState* sp, JSAMPARRAY scanlines, int max_lines)
301{
302 return CALLJPEG(sp, -1, (int) jpeg_read_scanlines(&sp->cinfo.d,
303 scanlines, (JDIMENSION) max_lines));
304}
305
306static int
307TIFFjpeg_read_raw_data(JPEGState* sp, JSAMPIMAGE data, int max_lines)
308{
309 return CALLJPEG(sp, -1, (int) jpeg_read_raw_data(&sp->cinfo.d,
310 data, (JDIMENSION) max_lines));
311}
312
313static int
314TIFFjpeg_finish_decompress(JPEGState* sp)
315{
316 return CALLJPEG(sp, -1, (int) jpeg_finish_decompress(&sp->cinfo.d));
317}
318
319static int
320TIFFjpeg_abort(JPEGState* sp)
321{
322 return CALLVJPEG(sp, jpeg_abort(&sp->cinfo.comm));
323}
324
325static int
326TIFFjpeg_destroy(JPEGState* sp)
327{
328 return CALLVJPEG(sp, jpeg_destroy(&sp->cinfo.comm));
329}
330
331static JSAMPARRAY
332TIFFjpeg_alloc_sarray(JPEGState* sp, int pool_id,
333 JDIMENSION samplesperrow, JDIMENSION numrows)
334{
335 return CALLJPEG(sp, (JSAMPARRAY) NULL,
336 (*sp->cinfo.comm.mem->alloc_sarray)
337 (&sp->cinfo.comm, pool_id, samplesperrow, numrows));
338}
339
340/*
341 * JPEG library destination data manager.
342 * These routines direct compressed data from libjpeg into the
343 * libtiff output buffer.
344 */
345
346static void
347std_init_destination(j_compress_ptr cinfo)
348{
349 JPEGState* sp = (JPEGState*) cinfo;
350 TIFF* tif = sp->tif;
351
352 sp->dest.next_output_byte = (JOCTET*) tif->tif_rawdata;
353 sp->dest.free_in_buffer = (size_t) tif->tif_rawdatasize;
354}
355
356static boolean
357std_empty_output_buffer(j_compress_ptr cinfo)
358{
359 JPEGState* sp = (JPEGState*) cinfo;
360 TIFF* tif = sp->tif;
361
362 /* the entire buffer has been filled */
363 tif->tif_rawcc = tif->tif_rawdatasize;
364 TIFFFlushData1(tif);
365 sp->dest.next_output_byte = (JOCTET*) tif->tif_rawdata;
366 sp->dest.free_in_buffer = (size_t) tif->tif_rawdatasize;
367
368 return (TRUE);
369}
370
371static void
372std_term_destination(j_compress_ptr cinfo)
373{
374 JPEGState* sp = (JPEGState*) cinfo;
375 TIFF* tif = sp->tif;
376
377 tif->tif_rawcp = (tidata_t) sp->dest.next_output_byte;
378 tif->tif_rawcc =
379 tif->tif_rawdatasize - (tsize_t) sp->dest.free_in_buffer;
380 /* NB: libtiff does the final buffer flush */
381}
382
383static void
384TIFFjpeg_data_dest(JPEGState* sp, TIFF* tif)
385{
386 (void) tif;
387 sp->cinfo.c.dest = &sp->dest;
388 sp->dest.init_destination = std_init_destination;
389 sp->dest.empty_output_buffer = std_empty_output_buffer;
390 sp->dest.term_destination = std_term_destination;
391}
392
393/*
394 * Alternate destination manager for outputting to JPEGTables field.
395 */
396
397static void
398tables_init_destination(j_compress_ptr cinfo)
399{
400 JPEGState* sp = (JPEGState*) cinfo;
401
402 /* while building, jpegtables_length is allocated buffer size */
403 sp->dest.next_output_byte = (JOCTET*) sp->jpegtables;
404 sp->dest.free_in_buffer = (size_t) sp->jpegtables_length;
405}
406
407static boolean
408tables_empty_output_buffer(j_compress_ptr cinfo)
409{
410 JPEGState* sp = (JPEGState*) cinfo;
411 void* newbuf;
412
413 /* the entire buffer has been filled; enlarge it by 1000 bytes */
414 newbuf = _TIFFrealloc((tdata_t) sp->jpegtables,
415 (tsize_t) (sp->jpegtables_length + 1000));
416 if (newbuf == NULL)
417 ERREXIT1(cinfo, JERR_OUT_OF_MEMORY, 100);
418 sp->dest.next_output_byte = (JOCTET*) newbuf + sp->jpegtables_length;
419 sp->dest.free_in_buffer = (size_t) 1000;
420 sp->jpegtables = newbuf;
421 sp->jpegtables_length += 1000;
422 return (TRUE);
423}
424
425static void
426tables_term_destination(j_compress_ptr cinfo)
427{
428 JPEGState* sp = (JPEGState*) cinfo;
429
430 /* set tables length to number of bytes actually emitted */
431 sp->jpegtables_length -= sp->dest.free_in_buffer;
432}
433
434static int
435TIFFjpeg_tables_dest(JPEGState* sp, TIFF* tif)
436{
437 (void) tif;
438 /*
439 * Allocate a working buffer for building tables.
440 * Initial size is 1000 bytes, which is usually adequate.
441 */
442 if (sp->jpegtables)
443 _TIFFfree(sp->jpegtables);
444 sp->jpegtables_length = 1000;
445 sp->jpegtables = (void*) _TIFFmalloc((tsize_t) sp->jpegtables_length);
446 if (sp->jpegtables == NULL) {
447 sp->jpegtables_length = 0;
448 TIFFError("TIFFjpeg_tables_dest", "No space for JPEGTables");
449 return (0);
450 }
451 sp->cinfo.c.dest = &sp->dest;
452 sp->dest.init_destination = tables_init_destination;
453 sp->dest.empty_output_buffer = tables_empty_output_buffer;
454 sp->dest.term_destination = tables_term_destination;
455 return (1);
456}
457
458/*
459 * JPEG library source data manager.
460 * These routines supply compressed data to libjpeg.
461 */
462
463static void
464std_init_source(j_decompress_ptr cinfo)
465{
466 JPEGState* sp = (JPEGState*) cinfo;
467 TIFF* tif = sp->tif;
468
469 sp->src.next_input_byte = (const JOCTET*) tif->tif_rawdata;
470 sp->src.bytes_in_buffer = (size_t) tif->tif_rawcc;
471}
472
473static boolean
474std_fill_input_buffer(j_decompress_ptr cinfo)
475{
476 JPEGState* sp = (JPEGState* ) cinfo;
477 static const JOCTET dummy_EOI[2] = { 0xFF, JPEG_EOI };
478
479 /*
480 * Should never get here since entire strip/tile is
481 * read into memory before the decompressor is called,
482 * and thus was supplied by init_source.
483 */
484 WARNMS(cinfo, JWRN_JPEG_EOF);
485 /* insert a fake EOI marker */
486 sp->src.next_input_byte = dummy_EOI;
487 sp->src.bytes_in_buffer = 2;
488 return (TRUE);
489}
490
491static void
492std_skip_input_data(j_decompress_ptr cinfo, long num_bytes)
493{
494 JPEGState* sp = (JPEGState*) cinfo;
495
496 if (num_bytes > 0) {
497 if (num_bytes > (long) sp->src.bytes_in_buffer) {
498 /* oops, buffer overrun */
499 (void) std_fill_input_buffer(cinfo);
500 } else {
501 sp->src.next_input_byte += (size_t) num_bytes;
502 sp->src.bytes_in_buffer -= (size_t) num_bytes;
503 }
504 }
505}
506
507static void
508std_term_source(j_decompress_ptr cinfo)
509{
510 /* No work necessary here */
511 /* Or must we update tif->tif_rawcp, tif->tif_rawcc ??? */
512 /* (if so, need empty tables_term_source!) */
513 (void) cinfo;
514}
515
516static void
517TIFFjpeg_data_src(JPEGState* sp, TIFF* tif)
518{
519 (void) tif;
520 sp->cinfo.d.src = &sp->src;
521 sp->src.init_source = std_init_source;
522 sp->src.fill_input_buffer = std_fill_input_buffer;
523 sp->src.skip_input_data = std_skip_input_data;
524 sp->src.resync_to_restart = jpeg_resync_to_restart;
525 sp->src.term_source = std_term_source;
526 sp->src.bytes_in_buffer = 0; /* for safety */
527 sp->src.next_input_byte = NULL;
528}
529
530/*
531 * Alternate source manager for reading from JPEGTables.
532 * We can share all the code except for the init routine.
533 */
534
535static void
536tables_init_source(j_decompress_ptr cinfo)
537{
538 JPEGState* sp = (JPEGState*) cinfo;
539
540 sp->src.next_input_byte = (const JOCTET*) sp->jpegtables;
541 sp->src.bytes_in_buffer = (size_t) sp->jpegtables_length;
542}
543
544static void
545TIFFjpeg_tables_src(JPEGState* sp, TIFF* tif)
546{
547 TIFFjpeg_data_src(sp, tif);
548 sp->src.init_source = tables_init_source;
549}
550
551/*
552 * Allocate downsampled-data buffers needed for downsampled I/O.
553 * We use values computed in jpeg_start_compress or jpeg_start_decompress.
554 * We use libjpeg's allocator so that buffers will be released automatically
555 * when done with strip/tile.
556 * This is also a handy place to compute samplesperclump, bytesperline.
557 */
558static int
559alloc_downsampled_buffers(TIFF* tif, jpeg_component_info* comp_info,
560 int num_components)
561{
562 JPEGState* sp = JState(tif);
563 int ci;
564 jpeg_component_info* compptr;
565 JSAMPARRAY buf;
566 int samples_per_clump = 0;
567
568 for (ci = 0, compptr = comp_info; ci < num_components;
569 ci++, compptr++) {
570 samples_per_clump += compptr->h_samp_factor *
571 compptr->v_samp_factor;
572 buf = TIFFjpeg_alloc_sarray(sp, JPOOL_IMAGE,
573 compptr->width_in_blocks * DCTSIZE,
574 (JDIMENSION) (compptr->v_samp_factor*DCTSIZE));
575 if (buf == NULL)
576 return (0);
577 sp->ds_buffer[ci] = buf;
578 }
579 sp->samplesperclump = samples_per_clump;
580 return (1);
581}
582
583
584/*
585 * JPEG Decoding.
586 */
587
588static int
589JPEGSetupDecode(TIFF* tif)
590{
591 JPEGState* sp = JState(tif);
592 TIFFDirectory *td = &tif->tif_dir;
593
594 JPEGInitializeLibJPEG( tif );
595
596 assert(sp != NULL);
597 assert(sp->cinfo.comm.is_decompressor);
598
599 /* Read JPEGTables if it is present */
600 if (TIFFFieldSet(tif,FIELD_JPEGTABLES)) {
601 TIFFjpeg_tables_src(sp, tif);
602 if(TIFFjpeg_read_header(sp,FALSE) != JPEG_HEADER_TABLES_ONLY) {
603 TIFFError("JPEGSetupDecode", "Bogus JPEGTables field");
604 return (0);
605 }
606 }
607
608 /* Grab parameters that are same for all strips/tiles */
609 sp->photometric = td->td_photometric;
610 switch (sp->photometric) {
611 case PHOTOMETRIC_YCBCR:
612 sp->h_sampling = td->td_ycbcrsubsampling[0];
613 sp->v_sampling = td->td_ycbcrsubsampling[1];
614 break;
615 default:
616 /* TIFF 6.0 forbids subsampling of all other color spaces */
617 sp->h_sampling = 1;
618 sp->v_sampling = 1;
619 break;
620 }
621
622 /* Set up for reading normal data */
623 TIFFjpeg_data_src(sp, tif);
624 tif->tif_postdecode = _TIFFNoPostDecode; /* override byte swapping */
625 return (1);
626}
627
628/*
629 * Set up for decoding a strip or tile.
630 */
631static int
632JPEGPreDecode(TIFF* tif, tsample_t s)
633{
634 JPEGState *sp = JState(tif);
635 TIFFDirectory *td = &tif->tif_dir;
636 static const char module[] = "JPEGPreDecode";
637 uint32 segment_width, segment_height;
638 int downsampled_output;
639 int ci;
640
641 assert(sp != NULL);
642 assert(sp->cinfo.comm.is_decompressor);
643 /*
644 * Reset decoder state from any previous strip/tile,
645 * in case application didn't read the whole strip.
646 */
647 if (!TIFFjpeg_abort(sp))
648 return (0);
649 /*
650 * Read the header for this strip/tile.
651 */
652 if (TIFFjpeg_read_header(sp, TRUE) != JPEG_HEADER_OK)
653 return (0);
654 /*
655 * Check image parameters and set decompression parameters.
656 */
657 segment_width = td->td_imagewidth;
658 segment_height = td->td_imagelength - tif->tif_row;
659 if (isTiled(tif)) {
660 segment_width = td->td_tilewidth;
661 segment_height = td->td_tilelength;
662 sp->bytesperline = TIFFTileRowSize(tif);
663 } else {
664 if (segment_height > td->td_rowsperstrip)
665 segment_height = td->td_rowsperstrip;
666 sp->bytesperline = TIFFScanlineSize(tif);
667 }
668 if (td->td_planarconfig == PLANARCONFIG_SEPARATE && s > 0) {
669 /*
670 * For PC 2, scale down the expected strip/tile size
671 * to match a downsampled component
672 */
673 segment_width = TIFFhowmany(segment_width, sp->h_sampling);
674 segment_height = TIFFhowmany(segment_height, sp->v_sampling);
675 }
676 if (sp->cinfo.d.image_width != segment_width ||
677 sp->cinfo.d.image_height != segment_height) {
678 TIFFWarning(module,
679 "Improper JPEG strip/tile size, expected %dx%d, got %dx%d",
680 segment_width,
681 segment_height,
682 sp->cinfo.d.image_width,
683 sp->cinfo.d.image_height);
684 }
685 if (sp->cinfo.d.num_components !=
686 (td->td_planarconfig == PLANARCONFIG_CONTIG ?
687 td->td_samplesperpixel : 1)) {
688 TIFFError(module, "Improper JPEG component count");
689 return (0);
690 }
691 if (sp->cinfo.d.data_precision != td->td_bitspersample) {
692 TIFFError(module, "Improper JPEG data precision");
693 return (0);
694 }
695 if (td->td_planarconfig == PLANARCONFIG_CONTIG) {
696 /* Component 0 should have expected sampling factors */
697 if (sp->cinfo.d.comp_info[0].h_samp_factor != sp->h_sampling ||
698 sp->cinfo.d.comp_info[0].v_samp_factor != sp->v_sampling) {
699 TIFFWarning(module,
700 "Improper JPEG sampling factors %d,%d\n"
701 "Apparently should be %d,%d, "
702 "decompressor will try reading with "
703 "sampling %d,%d",
704 sp->cinfo.d.comp_info[0].h_samp_factor,
705 sp->cinfo.d.comp_info[0].v_samp_factor,
706 sp->h_sampling,
707 sp->v_sampling,
708 sp->cinfo.d.comp_info[0].h_samp_factor,
709 sp->cinfo.d.comp_info[0].v_samp_factor );
710
711 sp->h_sampling = (uint16)
712 sp->cinfo.d.comp_info[0].h_samp_factor;
713 sp->v_sampling = (uint16)
714 sp->cinfo.d.comp_info[0].v_samp_factor;
715 }
716 /* Rest should have sampling factors 1,1 */
717 for (ci = 1; ci < sp->cinfo.d.num_components; ci++) {
718 if (sp->cinfo.d.comp_info[ci].h_samp_factor != 1 ||
719 sp->cinfo.d.comp_info[ci].v_samp_factor != 1) {
720 TIFFError(module, "Improper JPEG sampling factors");
721 return (0);
722 }
723 }
724 } else {
725 /* PC 2's single component should have sampling factors 1,1 */
726 if (sp->cinfo.d.comp_info[0].h_samp_factor != 1 ||
727 sp->cinfo.d.comp_info[0].v_samp_factor != 1) {
728 TIFFError(module, "Improper JPEG sampling factors");
729 return (0);
730 }
731 }
732 downsampled_output = FALSE;
733 if (td->td_planarconfig == PLANARCONFIG_CONTIG &&
734 sp->photometric == PHOTOMETRIC_YCBCR &&
735 sp->jpegcolormode == JPEGCOLORMODE_RGB) {
736 /* Convert YCbCr to RGB */
737 sp->cinfo.d.jpeg_color_space = JCS_YCbCr;
738 sp->cinfo.d.out_color_space = JCS_RGB;
739 } else {
740 /* Suppress colorspace handling */
741 sp->cinfo.d.jpeg_color_space = JCS_UNKNOWN;
742 sp->cinfo.d.out_color_space = JCS_UNKNOWN;
743 if (td->td_planarconfig == PLANARCONFIG_CONTIG &&
744 (sp->h_sampling != 1 || sp->v_sampling != 1))
745 downsampled_output = TRUE;
746 /* XXX what about up-sampling? */
747 }
748 if (downsampled_output) {
749 /* Need to use raw-data interface to libjpeg */
750 sp->cinfo.d.raw_data_out = TRUE;
751 tif->tif_decoderow = JPEGDecodeRaw;
752 tif->tif_decodestrip = JPEGDecodeRaw;
753 tif->tif_decodetile = JPEGDecodeRaw;
754 } else {
755 /* Use normal interface to libjpeg */
756 sp->cinfo.d.raw_data_out = FALSE;
757 tif->tif_decoderow = JPEGDecode;
758 tif->tif_decodestrip = JPEGDecode;
759 tif->tif_decodetile = JPEGDecode;
760 }
761 /* Start JPEG decompressor */
762 if (!TIFFjpeg_start_decompress(sp))
763 return (0);
764 /* Allocate downsampled-data buffers if needed */
765 if (downsampled_output) {
766 if (!alloc_downsampled_buffers(tif, sp->cinfo.d.comp_info,
767 sp->cinfo.d.num_components))
768 return (0);
769 sp->scancount = DCTSIZE; /* mark buffer empty */
770 }
771 return (1);
772}
773
774/*
775 * Decode a chunk of pixels.
776 * "Standard" case: returned data is not downsampled.
777 */
778/*ARGSUSED*/ static int
779JPEGDecode(TIFF* tif, tidata_t buf, tsize_t cc, tsample_t s)
780{
781 JPEGState *sp = JState(tif);
782 tsize_t nrows;
783
784 nrows = cc / sp->bytesperline;
785 if (cc % sp->bytesperline)
786 TIFFWarning(tif->tif_name, "fractional scanline not read");
787
788 if( nrows > (int) sp->cinfo.d.image_height )
789 nrows = sp->cinfo.d.image_height;
790
791 /* data is expected to be read in multiples of a scanline */
792 if (nrows)
793 {
794 do {
795 JSAMPROW bufptr = (JSAMPROW)buf;
796
797 if (TIFFjpeg_read_scanlines(sp, &bufptr, 1) != 1)
798 return (0);
799 ++tif->tif_row;
800 buf += sp->bytesperline;
801 cc -= sp->bytesperline;
802 } while (--nrows > 0);
803 }
804 /* Close down the decompressor if we've finished the strip or tile. */
805 return sp->cinfo.d.output_scanline < sp->cinfo.d.output_height
806 || TIFFjpeg_finish_decompress(sp);
807}
808
809/*
810 * Decode a chunk of pixels.
811 * Returned data is downsampled per sampling factors.
812 */
813/*ARGSUSED*/ static int
814JPEGDecodeRaw(TIFF* tif, tidata_t buf, tsize_t cc, tsample_t s)
815{
816 JPEGState *sp = JState(tif);
817 tsize_t nrows;
818
819 /* data is expected to be read in multiples of a scanline */
820 if ( (nrows = sp->cinfo.d.image_height) ) {
821 /* Cb,Cr both have sampling factors 1, so this is correct */
822 JDIMENSION clumps_per_line = sp->cinfo.d.comp_info[1].downsampled_width;
823 int samples_per_clump = sp->samplesperclump;
824
825 do {
826 jpeg_component_info *compptr;
827 int ci, clumpoffset;
828
829 /* Reload downsampled-data buffer if needed */
830 if (sp->scancount >= DCTSIZE) {
831 int n = sp->cinfo.d.max_v_samp_factor * DCTSIZE;
832
833 if (TIFFjpeg_read_raw_data(sp, sp->ds_buffer, n)
834 != n)
835 return (0);
836 sp->scancount = 0;
837 }
838 /*
839 * Fastest way to unseparate data is to make one pass
840 * over the scanline for each row of each component.
841 */
842 clumpoffset = 0; /* first sample in clump */
843 for (ci = 0, compptr = sp->cinfo.d.comp_info;
844 ci < sp->cinfo.d.num_components;
845 ci++, compptr++) {
846 int hsamp = compptr->h_samp_factor;
847 int vsamp = compptr->v_samp_factor;
848 int ypos;
849
850 for (ypos = 0; ypos < vsamp; ypos++) {
851 JSAMPLE *inptr = sp->ds_buffer[ci][sp->scancount*vsamp + ypos];
852 JSAMPLE *outptr = (JSAMPLE*)buf + clumpoffset;
853 JDIMENSION nclump;
854
855 if (hsamp == 1) {
856 /* fast path for at least Cb and Cr */
857 for (nclump = clumps_per_line; nclump-- > 0; ) {
858 outptr[0] = *inptr++;
859 outptr += samples_per_clump;
860 }
861 } else {
862 int xpos;
863
864 /* general case */
865 for (nclump = clumps_per_line; nclump-- > 0; ) {
866 for (xpos = 0; xpos < hsamp; xpos++)
867 outptr[xpos] = *inptr++;
868 outptr += samples_per_clump;
869 }
870 }
871 clumpoffset += hsamp;
872 }
873 }
874 ++sp->scancount;
875 ++tif->tif_row;
876 buf += sp->bytesperline;
877 cc -= sp->bytesperline;
878 } while (--nrows > 0);
879 }
880
881 /* Close down the decompressor if done. */
882 return sp->cinfo.d.output_scanline < sp->cinfo.d.output_height
883 || TIFFjpeg_finish_decompress(sp);
884}
885
886
887/*
888 * JPEG Encoding.
889 */
890
891static void
892unsuppress_quant_table (JPEGState* sp, int tblno)
893{
894 JQUANT_TBL* qtbl;
895
896 if ((qtbl = sp->cinfo.c.quant_tbl_ptrs[tblno]) != NULL)
897 qtbl->sent_table = FALSE;
898}
899
900static void
901unsuppress_huff_table (JPEGState* sp, int tblno)
902{
903 JHUFF_TBL* htbl;
904
905 if ((htbl = sp->cinfo.c.dc_huff_tbl_ptrs[tblno]) != NULL)
906 htbl->sent_table = FALSE;
907 if ((htbl = sp->cinfo.c.ac_huff_tbl_ptrs[tblno]) != NULL)
908 htbl->sent_table = FALSE;
909}
910
911static int
912prepare_JPEGTables(TIFF* tif)
913{
914 JPEGState* sp = JState(tif);
915
916 JPEGInitializeLibJPEG( tif );
917
918 /* Initialize quant tables for current quality setting */
919 if (!TIFFjpeg_set_quality(sp, sp->jpegquality, FALSE))
920 return (0);
921 /* Mark only the tables we want for output */
922 /* NB: chrominance tables are currently used only with YCbCr */
923 if (!TIFFjpeg_suppress_tables(sp, TRUE))
924 return (0);
925 if (sp->jpegtablesmode & JPEGTABLESMODE_QUANT) {
926 unsuppress_quant_table(sp, 0);
927 if (sp->photometric == PHOTOMETRIC_YCBCR)
928 unsuppress_quant_table(sp, 1);
929 }
930 if (sp->jpegtablesmode & JPEGTABLESMODE_HUFF) {
931 unsuppress_huff_table(sp, 0);
932 if (sp->photometric == PHOTOMETRIC_YCBCR)
933 unsuppress_huff_table(sp, 1);
934 }
935 /* Direct libjpeg output into jpegtables */
936 if (!TIFFjpeg_tables_dest(sp, tif))
937 return (0);
938 /* Emit tables-only datastream */
939 if (!TIFFjpeg_write_tables(sp))
940 return (0);
941
942 return (1);
943}
944
945static int
946JPEGSetupEncode(TIFF* tif)
947{
948 JPEGState* sp = JState(tif);
949 TIFFDirectory *td = &tif->tif_dir;
950 static const char module[] = "JPEGSetupEncode";
951
952 JPEGInitializeLibJPEG( tif );
953
954 assert(sp != NULL);
955 assert(!sp->cinfo.comm.is_decompressor);
956
957 /*
958 * Initialize all JPEG parameters to default values.
959 * Note that jpeg_set_defaults needs legal values for
960 * in_color_space and input_components.
961 */
962 sp->cinfo.c.in_color_space = JCS_UNKNOWN;
963 sp->cinfo.c.input_components = 1;
964 if (!TIFFjpeg_set_defaults(sp))
965 return (0);
966 /* Set per-file parameters */
967 sp->photometric = td->td_photometric;
968 switch (sp->photometric) {
969 case PHOTOMETRIC_YCBCR:
970 sp->h_sampling = td->td_ycbcrsubsampling[0];
971 sp->v_sampling = td->td_ycbcrsubsampling[1];
972 /*
973 * A ReferenceBlackWhite field *must* be present since the
974 * default value is inappropriate for YCbCr. Fill in the
975 * proper value if application didn't set it.
976 */
977 if (!TIFFFieldSet(tif, FIELD_REFBLACKWHITE)) {
978 float refbw[6];
979 long top = 1L << td->td_bitspersample;
980 refbw[0] = 0;
981 refbw[1] = (float)(top-1L);
982 refbw[2] = (float)(top>>1);
983 refbw[3] = refbw[1];
984 refbw[4] = refbw[2];
985 refbw[5] = refbw[1];
986 TIFFSetField(tif, TIFFTAG_REFERENCEBLACKWHITE, refbw);
987 }
988 break;
989 case PHOTOMETRIC_PALETTE: /* disallowed by Tech Note */
990 case PHOTOMETRIC_MASK:
991 TIFFError(module,
992 "PhotometricInterpretation %d not allowed for JPEG",
993 (int) sp->photometric);
994 return (0);
995 default:
996 /* TIFF 6.0 forbids subsampling of all other color spaces */
997 sp->h_sampling = 1;
998 sp->v_sampling = 1;
999 break;
1000 }
1001
1002 /* Verify miscellaneous parameters */
1003
1004 /*
1005 * This would need work if libtiff ever supports different
1006 * depths for different components, or if libjpeg ever supports
1007 * run-time selection of depth. Neither is imminent.
1008 */
1009 if (td->td_bitspersample != BITS_IN_JSAMPLE) {
1010 TIFFError(module, "BitsPerSample %d not allowed for JPEG",
1011 (int) td->td_bitspersample);
1012 return (0);
1013 }
1014 sp->cinfo.c.data_precision = td->td_bitspersample;
1015 if (isTiled(tif)) {
1016 if ((td->td_tilelength % (sp->v_sampling * DCTSIZE)) != 0) {
1017 TIFFError(module,
1018 "JPEG tile height must be multiple of %d",
1019 sp->v_sampling * DCTSIZE);
1020 return (0);
1021 }
1022 if ((td->td_tilewidth % (sp->h_sampling * DCTSIZE)) != 0) {
1023 TIFFError(module,
1024 "JPEG tile width must be multiple of %d",
1025 sp->h_sampling * DCTSIZE);
1026 return (0);
1027 }
1028 } else {
1029 if (td->td_rowsperstrip < td->td_imagelength &&
1030 (td->td_rowsperstrip % (sp->v_sampling * DCTSIZE)) != 0) {
1031 TIFFError(module,
1032 "RowsPerStrip must be multiple of %d for JPEG",
1033 sp->v_sampling * DCTSIZE);
1034 return (0);
1035 }
1036 }
1037
1038 /* Create a JPEGTables field if appropriate */
1039 if (sp->jpegtablesmode & (JPEGTABLESMODE_QUANT|JPEGTABLESMODE_HUFF)) {
1040 if (!prepare_JPEGTables(tif))
1041 return (0);
1042 /* Mark the field present */
1043 /* Can't use TIFFSetField since BEENWRITING is already set! */
1044 TIFFSetFieldBit(tif, FIELD_JPEGTABLES);
1045 tif->tif_flags |= TIFF_DIRTYDIRECT;
1046 } else {
1047 /* We do not support application-supplied JPEGTables, */
1048 /* so mark the field not present */
1049 TIFFClrFieldBit(tif, FIELD_JPEGTABLES);
1050 }
1051
1052 /* Direct libjpeg output to libtiff's output buffer */
1053 TIFFjpeg_data_dest(sp, tif);
1054
1055 return (1);
1056}
1057
1058/*
1059 * Set encoding state at the start of a strip or tile.
1060 */
1061static int
1062JPEGPreEncode(TIFF* tif, tsample_t s)
1063{
1064 JPEGState *sp = JState(tif);
1065 TIFFDirectory *td = &tif->tif_dir;
1066 static const char module[] = "JPEGPreEncode";
1067 uint32 segment_width, segment_height;
1068 int downsampled_input;
1069
1070 assert(sp != NULL);
1071 assert(!sp->cinfo.comm.is_decompressor);
1072 /*
1073 * Set encoding parameters for this strip/tile.
1074 */
1075 if (isTiled(tif)) {
1076 segment_width = td->td_tilewidth;
1077 segment_height = td->td_tilelength;
1078 sp->bytesperline = TIFFTileRowSize(tif);
1079 } else {
1080 segment_width = td->td_imagewidth;
1081 segment_height = td->td_imagelength - tif->tif_row;
1082 if (segment_height > td->td_rowsperstrip)
1083 segment_height = td->td_rowsperstrip;
1084 sp->bytesperline = TIFFScanlineSize(tif);
1085 }
1086 if (td->td_planarconfig == PLANARCONFIG_SEPARATE && s > 0) {
1087 /* for PC 2, scale down the strip/tile size
1088 * to match a downsampled component
1089 */
1090 segment_width = TIFFhowmany(segment_width, sp->h_sampling);
1091 segment_height = TIFFhowmany(segment_height, sp->v_sampling);
1092 }
1093 if (segment_width > 65535 || segment_height > 65535) {
1094 TIFFError(module, "Strip/tile too large for JPEG");
1095 return (0);
1096 }
1097 sp->cinfo.c.image_width = segment_width;
1098 sp->cinfo.c.image_height = segment_height;
1099 downsampled_input = FALSE;
1100 if (td->td_planarconfig == PLANARCONFIG_CONTIG) {
1101 sp->cinfo.c.input_components = td->td_samplesperpixel;
1102 if (sp->photometric == PHOTOMETRIC_YCBCR) {
1103 if (sp->jpegcolormode == JPEGCOLORMODE_RGB) {
1104 sp->cinfo.c.in_color_space = JCS_RGB;
1105 } else {
1106 sp->cinfo.c.in_color_space = JCS_YCbCr;
1107 if (sp->h_sampling != 1 || sp->v_sampling != 1)
1108 downsampled_input = TRUE;
1109 }
1110 if (!TIFFjpeg_set_colorspace(sp, JCS_YCbCr))
1111 return (0);
1112 /*
1113 * Set Y sampling factors;
1114 * we assume jpeg_set_colorspace() set the rest to 1
1115 */
1116 sp->cinfo.c.comp_info[0].h_samp_factor = sp->h_sampling;
1117 sp->cinfo.c.comp_info[0].v_samp_factor = sp->v_sampling;
1118 } else {
1119 sp->cinfo.c.in_color_space = JCS_UNKNOWN;
1120 if (!TIFFjpeg_set_colorspace(sp, JCS_UNKNOWN))
1121 return (0);
1122 /* jpeg_set_colorspace set all sampling factors to 1 */
1123 }
1124 } else {
1125 sp->cinfo.c.input_components = 1;
1126 sp->cinfo.c.in_color_space = JCS_UNKNOWN;
1127 if (!TIFFjpeg_set_colorspace(sp, JCS_UNKNOWN))
1128 return (0);
1129 sp->cinfo.c.comp_info[0].component_id = s;
1130 /* jpeg_set_colorspace() set sampling factors to 1 */
1131 if (sp->photometric == PHOTOMETRIC_YCBCR && s > 0) {
1132 sp->cinfo.c.comp_info[0].quant_tbl_no = 1;
1133 sp->cinfo.c.comp_info[0].dc_tbl_no = 1;
1134 sp->cinfo.c.comp_info[0].ac_tbl_no = 1;
1135 }
1136 }
1137 /* ensure libjpeg won't write any extraneous markers */
1138 sp->cinfo.c.write_JFIF_header = FALSE;
1139 sp->cinfo.c.write_Adobe_marker = FALSE;
1140 /* set up table handling correctly */
1141 if (! (sp->jpegtablesmode & JPEGTABLESMODE_QUANT)) {
1142 if (!TIFFjpeg_set_quality(sp, sp->jpegquality, FALSE))
1143 return (0);
1144 unsuppress_quant_table(sp, 0);
1145 unsuppress_quant_table(sp, 1);
1146 }
1147 if (sp->jpegtablesmode & JPEGTABLESMODE_HUFF)
1148 sp->cinfo.c.optimize_coding = FALSE;
1149 else
1150 sp->cinfo.c.optimize_coding = TRUE;
1151 if (downsampled_input) {
1152 /* Need to use raw-data interface to libjpeg */
1153 sp->cinfo.c.raw_data_in = TRUE;
1154 tif->tif_encoderow = JPEGEncodeRaw;
1155 tif->tif_encodestrip = JPEGEncodeRaw;
1156 tif->tif_encodetile = JPEGEncodeRaw;
1157 } else {
1158 /* Use normal interface to libjpeg */
1159 sp->cinfo.c.raw_data_in = FALSE;
1160 tif->tif_encoderow = JPEGEncode;
1161 tif->tif_encodestrip = JPEGEncode;
1162 tif->tif_encodetile = JPEGEncode;
1163 }
1164 /* Start JPEG compressor */
1165 if (!TIFFjpeg_start_compress(sp, FALSE))
1166 return (0);
1167 /* Allocate downsampled-data buffers if needed */
1168 if (downsampled_input) {
1169 if (!alloc_downsampled_buffers(tif, sp->cinfo.c.comp_info,
1170 sp->cinfo.c.num_components))
1171 return (0);
1172 }
1173 sp->scancount = 0;
1174
1175 return (1);
1176}
1177
1178/*
1179 * Encode a chunk of pixels.
1180 * "Standard" case: incoming data is not downsampled.
1181 */
1182static int
1183JPEGEncode(TIFF* tif, tidata_t buf, tsize_t cc, tsample_t s)
1184{
1185 JPEGState *sp = JState(tif);
1186 tsize_t nrows;
1187 JSAMPROW bufptr[1];
1188
1189 (void) s;
1190 assert(sp != NULL);
1191 /* data is expected to be supplied in multiples of a scanline */
1192 nrows = cc / sp->bytesperline;
1193 if (cc % sp->bytesperline)
1194 TIFFWarning(tif->tif_name, "fractional scanline discarded");
1195
1196 while (nrows-- > 0) {
1197 bufptr[0] = (JSAMPROW) buf;
1198 if (TIFFjpeg_write_scanlines(sp, bufptr, 1) != 1)
1199 return (0);
1200 if (nrows > 0)
1201 tif->tif_row++;
1202 buf += sp->bytesperline;
1203 }
1204 return (1);
1205}
1206
1207/*
1208 * Encode a chunk of pixels.
1209 * Incoming data is expected to be downsampled per sampling factors.
1210 */
1211static int
1212JPEGEncodeRaw(TIFF* tif, tidata_t buf, tsize_t cc, tsample_t s)
1213{
1214 JPEGState *sp = JState(tif);
1215 JSAMPLE* inptr;
1216 JSAMPLE* outptr;
1217 tsize_t nrows;
1218 JDIMENSION clumps_per_line, nclump;
1219 int clumpoffset, ci, xpos, ypos;
1220 jpeg_component_info* compptr;
1221 int samples_per_clump = sp->samplesperclump;
1222
1223 (void) s;
1224 assert(sp != NULL);
1225 /* data is expected to be supplied in multiples of a scanline */
1226 nrows = cc / sp->bytesperline;
1227 if (cc % sp->bytesperline)
1228 TIFFWarning(tif->tif_name, "fractional scanline discarded");
1229
1230 /* Cb,Cr both have sampling factors 1, so this is correct */
1231 clumps_per_line = sp->cinfo.c.comp_info[1].downsampled_width;
1232
1233 while (nrows-- > 0) {
1234 /*
1235 * Fastest way to separate the data is to make one pass
1236 * over the scanline for each row of each component.
1237 */
1238 clumpoffset = 0; /* first sample in clump */
1239 for (ci = 0, compptr = sp->cinfo.c.comp_info;
1240 ci < sp->cinfo.c.num_components;
1241 ci++, compptr++) {
1242 int hsamp = compptr->h_samp_factor;
1243 int vsamp = compptr->v_samp_factor;
1244 int padding = (int) (compptr->width_in_blocks * DCTSIZE -
1245 clumps_per_line * hsamp);
1246 for (ypos = 0; ypos < vsamp; ypos++) {
1247 inptr = ((JSAMPLE*) buf) + clumpoffset;
1248 outptr = sp->ds_buffer[ci][sp->scancount*vsamp + ypos];
1249 if (hsamp == 1) {
1250 /* fast path for at least Cb and Cr */
1251 for (nclump = clumps_per_line; nclump-- > 0; ) {
1252 *outptr++ = inptr[0];
1253 inptr += samples_per_clump;
1254 }
1255 } else {
1256 /* general case */
1257 for (nclump = clumps_per_line; nclump-- > 0; ) {
1258 for (xpos = 0; xpos < hsamp; xpos++)
1259 *outptr++ = inptr[xpos];
1260 inptr += samples_per_clump;
1261 }
1262 }
1263 /* pad each scanline as needed */
1264 for (xpos = 0; xpos < padding; xpos++) {
1265 *outptr = outptr[-1];
1266 outptr++;
1267 }
1268 clumpoffset += hsamp;
1269 }
1270 }
1271 sp->scancount++;
1272 if (sp->scancount >= DCTSIZE) {
1273 int n = sp->cinfo.c.max_v_samp_factor * DCTSIZE;
1274 if (TIFFjpeg_write_raw_data(sp, sp->ds_buffer, n) != n)
1275 return (0);
1276 sp->scancount = 0;
1277 }
1278 if (nrows > 0)
1279 tif->tif_row++;
1280 buf += sp->bytesperline;
1281 }
1282 return (1);
1283}
1284
1285/*
1286 * Finish up at the end of a strip or tile.
1287 */
1288static int
1289JPEGPostEncode(TIFF* tif)
1290{
1291 JPEGState *sp = JState(tif);
1292
1293 if (sp->scancount > 0) {
1294 /*
1295 * Need to emit a partial bufferload of downsampled data.
1296 * Pad the data vertically.
1297 */
1298 int ci, ypos, n;
1299 jpeg_component_info* compptr;
1300
1301 for (ci = 0, compptr = sp->cinfo.c.comp_info;
1302 ci < sp->cinfo.c.num_components;
1303 ci++, compptr++) {
1304 int vsamp = compptr->v_samp_factor;
1305 tsize_t row_width = compptr->width_in_blocks * DCTSIZE
1306 * sizeof(JSAMPLE);
1307 for (ypos = sp->scancount * vsamp;
1308 ypos < DCTSIZE * vsamp; ypos++) {
1309 _TIFFmemcpy((tdata_t)sp->ds_buffer[ci][ypos],
1310 (tdata_t)sp->ds_buffer[ci][ypos-1],
1311 row_width);
1312
1313 }
1314 }
1315 n = sp->cinfo.c.max_v_samp_factor * DCTSIZE;
1316 if (TIFFjpeg_write_raw_data(sp, sp->ds_buffer, n) != n)
1317 return (0);
1318 }
1319
1320 return (TIFFjpeg_finish_compress(JState(tif)));
1321}
1322
1323static void
1324JPEGCleanup(TIFF* tif)
1325{
1326 if (tif->tif_data) {
1327 JPEGState *sp = JState(tif);
1328 if( sp->cinfo_initialized )
1329 TIFFjpeg_destroy(sp); /* release libjpeg resources */
1330 if (sp->jpegtables) /* tag value */
1331 _TIFFfree(sp->jpegtables);
1332 _TIFFfree(tif->tif_data); /* release local state */
1333 tif->tif_data = NULL;
1334 }
1335}
1336
1337static int
1338JPEGVSetField(TIFF* tif, ttag_t tag, va_list ap)
1339{
1340 JPEGState* sp = JState(tif);
1341 TIFFDirectory* td = &tif->tif_dir;
1342 uint32 v32;
1343
1344 switch (tag) {
1345 case TIFFTAG_JPEGTABLES:
1346 v32 = va_arg(ap, uint32);
1347 if (v32 == 0) {
1348 /* XXX */
1349 return (0);
1350 }
1351 _TIFFsetByteArray(&sp->jpegtables, va_arg(ap, void*),
1352 (long) v32);
1353 sp->jpegtables_length = v32;
1354 TIFFSetFieldBit(tif, FIELD_JPEGTABLES);
1355 break;
1356 case TIFFTAG_JPEGQUALITY:
1357 sp->jpegquality = va_arg(ap, int);
1358 return (1); /* pseudo tag */
1359 case TIFFTAG_JPEGCOLORMODE:
1360 sp->jpegcolormode = va_arg(ap, int);
1361 /*
1362 * Mark whether returned data is up-sampled or not
1363 * so TIFFStripSize and TIFFTileSize return values
1364 * that reflect the true amount of data.
1365 */
1366 tif->tif_flags &= ~TIFF_UPSAMPLED;
1367 if (td->td_planarconfig == PLANARCONFIG_CONTIG) {
1368 if (td->td_photometric == PHOTOMETRIC_YCBCR &&
1369 sp->jpegcolormode == JPEGCOLORMODE_RGB) {
1370 tif->tif_flags |= TIFF_UPSAMPLED;
1371 } else {
1372 if (td->td_ycbcrsubsampling[0] != 1 ||
1373 td->td_ycbcrsubsampling[1] != 1)
1374 ; /* XXX what about up-sampling? */
1375 }
1376 }
1377 /*
1378 * Must recalculate cached tile size
1379 * in case sampling state changed.
1380 */
1381 tif->tif_tilesize = TIFFTileSize(tif);
1382 return (1); /* pseudo tag */
1383 case TIFFTAG_JPEGTABLESMODE:
1384 sp->jpegtablesmode = va_arg(ap, int);
1385 return (1); /* pseudo tag */
1386 case TIFFTAG_YCBCRSUBSAMPLING:
1387 /* mark the fact that we have a real ycbcrsubsampling! */
1388 sp->ycbcrsampling_fetched = 1;
1389 return (*sp->vsetparent)(tif, tag, ap);
1390 default:
1391 return (*sp->vsetparent)(tif, tag, ap);
1392 }
1393 tif->tif_flags |= TIFF_DIRTYDIRECT;
1394 return (1);
1395}
1396
1397/*
1398 * Some JPEG-in-TIFF produces do not emit the YCBCRSUBSAMPLING values in
1399 * the TIFF tags, but still use non-default (2,2) values within the jpeg
1400 * data stream itself. In order for TIFF applications to work properly
1401 * - for instance to get the strip buffer size right - it is imperative
1402 * that the subsampling be available before we start reading the image
1403 * data normally. This function will attempt to load the first strip in
1404 * order to get the sampling values from the jpeg data stream. Various
1405 * hacks are various places are done to ensure this function gets called
1406 * before the td_ycbcrsubsampling values are used from the directory structure,
1407 * including calling TIFFGetField() for the YCBCRSUBSAMPLING field from
1408 * TIFFStripSize(), and the printing code in tif_print.c.
1409 *
1410 * Note that JPEGPreDeocode() will produce a fairly loud warning when the
1411 * discovered sampling does not match the default sampling (2,2) or whatever
1412 * was actually in the tiff tags.
1413 *
1414 * Problems:
1415 * o This code will cause one whole strip/tile of compressed data to be
1416 * loaded just to get the tags right, even if the imagery is never read.
1417 * It would be more efficient to just load a bit of the header, and
1418 * initialize things from that.
1419 *
1420 * See the bug in bugzilla for details:
1421 *
1422 * http://bugzilla.remotesensing.org/show_bug.cgi?id=168
1423 *
1424 * Frank Warmerdam, July 2002
1425 */
1426
1427static void
1428JPEGFixupTestSubsampling( TIFF * tif )
1429{
1430#if CHECK_JPEG_YCBCR_SUBSAMPLING == 1
1431 JPEGState *sp = JState(tif);
1432 TIFFDirectory *td = &tif->tif_dir;
1433
1434 JPEGInitializeLibJPEG( tif );
1435
1436 /*
1437 * Some JPEG-in-TIFF files don't provide the ycbcrsampling tags,
1438 * and use a sampling schema other than the default 2,2. To handle
1439 * this we actually have to scan the header of a strip or tile of
1440 * jpeg data to get the sampling.
1441 */
1442 if( !sp->cinfo.comm.is_decompressor
1443 || sp->ycbcrsampling_fetched
1444 || td->td_photometric != PHOTOMETRIC_YCBCR )
1445 return;
1446
1447 sp->ycbcrsampling_fetched = 1;
1448 if( TIFFIsTiled( tif ) )
1449 {
1450 if( !TIFFFillTile( tif, 0 ) )
1451 return;
1452 }
1453 else
1454 {
1455 if( !TIFFFillStrip( tif, 0 ) )
1456 return;
1457 }
1458
1459 TIFFSetField( tif, TIFFTAG_YCBCRSUBSAMPLING,
1460 (uint16) sp->h_sampling, (uint16) sp->v_sampling );
1461#endif /* CHECK_JPEG_YCBCR_SUBSAMPLING == 1 */
1462}
1463
1464static int
1465JPEGVGetField(TIFF* tif, ttag_t tag, va_list ap)
1466{
1467 JPEGState* sp = JState(tif);
1468
1469 switch (tag) {
1470 case TIFFTAG_JPEGTABLES:
1471 /* u_short is bogus --- should be uint32 ??? */
1472 /* TIFFWriteNormalTag needs fixed XXX */
1473 *va_arg(ap, u_short*) = (u_short) sp->jpegtables_length;
1474 *va_arg(ap, void**) = sp->jpegtables;
1475 break;
1476 case TIFFTAG_JPEGQUALITY:
1477 *va_arg(ap, int*) = sp->jpegquality;
1478 break;
1479 case TIFFTAG_JPEGCOLORMODE:
1480 *va_arg(ap, int*) = sp->jpegcolormode;
1481 break;
1482 case TIFFTAG_JPEGTABLESMODE:
1483 *va_arg(ap, int*) = sp->jpegtablesmode;
1484 break;
1485 case TIFFTAG_YCBCRSUBSAMPLING:
1486 JPEGFixupTestSubsampling( tif );
1487 return (*sp->vgetparent)(tif, tag, ap);
1488 break;
1489 default:
1490 return (*sp->vgetparent)(tif, tag, ap);
1491 }
1492 return (1);
1493}
1494
1495static void
1496JPEGPrintDir(TIFF* tif, FILE* fd, long flags)
1497{
1498 JPEGState* sp = JState(tif);
1499
1500 (void) flags;
1501 if (TIFFFieldSet(tif,FIELD_JPEGTABLES))
1502 fprintf(fd, " JPEG Tables: (%lu bytes)\n",
1503 (u_long) sp->jpegtables_length);
1504}
1505
1506static uint32
1507JPEGDefaultStripSize(TIFF* tif, uint32 s)
1508{
1509 JPEGState* sp = JState(tif);
1510 TIFFDirectory *td = &tif->tif_dir;
1511
1512 s = (*sp->defsparent)(tif, s);
1513 if (s < td->td_imagelength)
1514 s = TIFFroundup(s, td->td_ycbcrsubsampling[1] * DCTSIZE);
1515 return (s);
1516}
1517
1518static void
1519JPEGDefaultTileSize(TIFF* tif, uint32* tw, uint32* th)
1520{
1521 JPEGState* sp = JState(tif);
1522 TIFFDirectory *td = &tif->tif_dir;
1523
1524 (*sp->deftparent)(tif, tw, th);
1525 *tw = TIFFroundup(*tw, td->td_ycbcrsubsampling[0] * DCTSIZE);
1526 *th = TIFFroundup(*th, td->td_ycbcrsubsampling[1] * DCTSIZE);
1527}
1528
1529/*
1530 * The JPEG library initialized used to be done in TIFFInitJPEG(), but
1531 * now that we allow a TIFF file to be opened in update mode it is necessary
1532 * to have some way of deciding whether compression or decompression is
1533 * desired other than looking at tif->tif_mode. We accomplish this by
1534 * examining {TILE/STRIP}BYTECOUNTS to see if there is a non-zero entry.
1535 * If so, we assume decompression is desired.
1536 *
1537 * This is tricky, because TIFFInitJPEG() is called while the directory is
1538 * being read, and generally speaking the BYTECOUNTS tag won't have been read
1539 * at that point. So we try to defer jpeg library initialization till we
1540 * do have that tag ... basically any access that might require the compressor
1541 * or decompressor that occurs after the reading of the directory.
1542 *
1543 * In an ideal world compressors or decompressors would be setup
1544 * at the point where a single tile or strip was accessed (for read or write)
1545 * so that stuff like update of missing tiles, or replacement of tiles could
1546 * be done. However, we aren't trying to crack that nut just yet ...
1547 *
1548 * NFW, Feb 3rd, 2003.
1549 */
1550
1551static int JPEGInitializeLibJPEG( TIFF * tif )
1552{
1553 JPEGState* sp = JState(tif);
1554 uint32 *byte_counts = NULL;
1555 int data_is_empty = TRUE;
1556
1557 if( sp->cinfo_initialized )
1558 return 1;
1559
1560 /*
1561 * Do we have tile data already? Make sure we initialize the
1562 * the state in decompressor mode if we have tile data, even if we
1563 * are not in read-only file access mode.
1564 */
1565 if( TIFFIsTiled( tif )
1566 && TIFFGetField( tif, TIFFTAG_TILEBYTECOUNTS, &byte_counts )
1567 && byte_counts != NULL )
1568 {
1569 data_is_empty = byte_counts[0] == 0;
1570 }
1571 if( !TIFFIsTiled( tif )
1572 && TIFFGetField( tif, TIFFTAG_STRIPBYTECOUNTS, &byte_counts)
1573 && byte_counts != NULL )
1574 {
1575 data_is_empty = byte_counts[0] == 0;
1576 }
1577
1578 /*
1579 * Initialize libjpeg.
1580 */
1581 if (tif->tif_mode == O_RDONLY || !data_is_empty ) {
1582 if (!TIFFjpeg_create_decompress(sp))
1583 return (0);
1584
1585 } else {
1586 if (!TIFFjpeg_create_compress(sp))
1587 return (0);
1588 }
1589
1590 sp->cinfo_initialized = TRUE;
1591
1592 return 1;
1593}
1594
1595int
1596TIFFInitJPEG(TIFF* tif, int scheme)
1597{
1598 JPEGState* sp;
1599
1600 assert(scheme == COMPRESSION_JPEG);
1601
1602 /*
1603 * Allocate state block so tag methods have storage to record values.
1604 */
1605 tif->tif_data = (tidata_t) _TIFFmalloc(sizeof (JPEGState));
1606
1607 if (tif->tif_data == NULL) {
1608 TIFFError("TIFFInitJPEG", "No space for JPEG state block");
1609 return (0);
1610 }
1611 memset( tif->tif_data, 0, sizeof(JPEGState));
1612
1613 sp = JState(tif);
1614 sp->tif = tif; /* back link */
1615
1616 /*
1617 * Merge codec-specific tag information and
1618 * override parent get/set field methods.
1619 */
1620 _TIFFMergeFieldInfo(tif, jpegFieldInfo, N(jpegFieldInfo));
1621 sp->vgetparent = tif->tif_tagmethods.vgetfield;
1622 tif->tif_tagmethods.vgetfield = JPEGVGetField; /* hook for codec tags */
1623 sp->vsetparent = tif->tif_tagmethods.vsetfield;
1624 tif->tif_tagmethods.vsetfield = JPEGVSetField; /* hook for codec tags */
1625 tif->tif_tagmethods.printdir = JPEGPrintDir; /* hook for codec tags */
1626
1627 /* Default values for codec-specific fields */
1628 sp->jpegtables = NULL;
1629 sp->jpegtables_length = 0;
1630 sp->jpegquality = 75; /* Default IJG quality */
1631 sp->jpegcolormode = JPEGCOLORMODE_RAW;
1632 sp->jpegtablesmode = JPEGTABLESMODE_QUANT | JPEGTABLESMODE_HUFF;
1633
1634 sp->ycbcrsampling_fetched = 0;
1635
1636 /*
1637 * Install codec methods.
1638 */
1639 tif->tif_setupdecode = JPEGSetupDecode;
1640 tif->tif_predecode = JPEGPreDecode;
1641 tif->tif_decoderow = JPEGDecode;
1642 tif->tif_decodestrip = JPEGDecode;
1643 tif->tif_decodetile = JPEGDecode;
1644 tif->tif_setupencode = JPEGSetupEncode;
1645 tif->tif_preencode = JPEGPreEncode;
1646 tif->tif_postencode = JPEGPostEncode;
1647 tif->tif_encoderow = JPEGEncode;
1648 tif->tif_encodestrip = JPEGEncode;
1649 tif->tif_encodetile = JPEGEncode;
1650 tif->tif_cleanup = JPEGCleanup;
1651 sp->defsparent = tif->tif_defstripsize;
1652 tif->tif_defstripsize = JPEGDefaultStripSize;
1653 sp->deftparent = tif->tif_deftilesize;
1654 tif->tif_deftilesize = JPEGDefaultTileSize;
1655 tif->tif_flags |= TIFF_NOBITREV; /* no bit reversal, please */
1656
1657 sp->cinfo_initialized = FALSE;
1658
1659 /*
1660 * Mark the TIFFTAG_YCBCRSAMPLES as present even if it is not
1661 * see: JPEGFixupTestSubsampling().
1662 */
1663 TIFFSetFieldBit( tif, FIELD_YCBCRSUBSAMPLING );
1664
1665 return (1);
1666}
1667#endif /* JPEG_SUPPORT */