projects / reactos.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
[MINGW]
[reactos.git] / reactos / dll / 3rdparty / libtiff / tif_jpeg.c
1 /* $Id: tif_jpeg.c,v 1.50.2.9 2010-06-14 02:47:16 fwarmerdam Exp $ */
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 #define WIN32_LEAN_AND_MEAN
28 #define VC_EXTRALEAN
29
30 #include "tiffiop.h"
31 #ifdef JPEG_SUPPORT
32
33 /*
34 * TIFF Library
35 *
36 * JPEG Compression support per TIFF Technical Note #2
37 * (*not* per the original TIFF 6.0 spec).
38 *
39 * This file is simply an interface to the libjpeg library written by
40 * the Independent JPEG Group. You need release 5 or later of the IJG
41 * code, which you can find on the Internet at ftp.uu.net:/graphics/jpeg/.
42 *
43 * Contributed by Tom Lane <tgl@sss.pgh.pa.us>.
44 */
45 #include <setjmp.h>
46
47 int TIFFFillStrip(TIFF*, tstrip_t);
48 int TIFFFillTile(TIFF*, ttile_t);
49
50 /* We undefine FAR to avoid conflict with JPEG definition */
51
52 #ifdef FAR
53 #undef FAR
54 #endif
55
56 /*
57 Libjpeg's jmorecfg.h defines INT16 and INT32, but only if XMD_H is
58 not defined. Unfortunately, the MinGW and Borland compilers include
59 a typedef for INT32, which causes a conflict. MSVC does not include
60 a conficting typedef given the headers which are included.
61 */
62 #if defined(__BORLANDC__) || defined(__MINGW32__)
63 # define XMD_H 1
64 #endif
65
66 /*
67 The windows RPCNDR.H file defines boolean, but defines it with the
68 unsigned char size. You should compile JPEG library using appropriate
69 definitions in jconfig.h header, but many users compile library in wrong
70 way. That causes errors of the following type:
71
72 "JPEGLib: JPEG parameter struct mismatch: library thinks size is 432,
73 caller expects 464"
74
75 For such users we wil fix the problem here. See install.doc file from
76 the JPEG library distribution for details.
77 */
78
79 /* Define "boolean" as unsigned char, not int, per Windows custom. */
80 #if defined(WIN32) && !defined(__MINGW32__)
81 # ifndef __RPCNDR_H__ /* don't conflict if rpcndr.h already read */
82 typedef unsigned char boolean;
83 # endif
84 # define HAVE_BOOLEAN /* prevent jmorecfg.h from redefining it */
85 #endif
86
87 #include "jpeglib.h"
88 #include "jerror.h"
89
90 /*
91 * We are using width_in_blocks which is supposed to be private to
92 * libjpeg. Unfortunately, the libjpeg delivered with Cygwin has
93 * renamed this member to width_in_data_units. Since the header has
94 * also renamed a define, use that unique define name in order to
95 * detect the problem header and adjust to suit.
96 */
97 #if defined(D_MAX_DATA_UNITS_IN_MCU)
98 #define width_in_blocks width_in_data_units
99 #endif
100
101 /*
102 * On some machines it may be worthwhile to use _setjmp or sigsetjmp
103 * in place of plain setjmp. These macros will make it easier.
104 */
105 #define SETJMP(jbuf) setjmp(jbuf)
106 #define LONGJMP(jbuf,code) longjmp(jbuf,code)
107 #define JMP_BUF jmp_buf
108
109 typedef struct jpeg_destination_mgr jpeg_destination_mgr;
110 typedef struct jpeg_source_mgr jpeg_source_mgr;
111 typedef struct jpeg_error_mgr jpeg_error_mgr;
112
113 /*
114 * State block for each open TIFF file using
115 * libjpeg to do JPEG compression/decompression.
116 *
117 * libjpeg's visible state is either a jpeg_compress_struct
118 * or jpeg_decompress_struct depending on which way we
119 * are going. comm can be used to refer to the fields
120 * which are common to both.
121 *
122 * NB: cinfo is required to be the first member of JPEGState,
123 * so we can safely cast JPEGState* -> jpeg_xxx_struct*
124 * and vice versa!
125 */
126 typedef struct {
127 union {
128 struct jpeg_compress_struct c;
129 struct jpeg_decompress_struct d;
130 struct jpeg_common_struct comm;
131 } cinfo; /* NB: must be first */
132 int cinfo_initialized;
133
134 jpeg_error_mgr err; /* libjpeg error manager */
135 JMP_BUF exit_jmpbuf; /* for catching libjpeg failures */
136 /*
137 * The following two members could be a union, but
138 * they're small enough that it's not worth the effort.
139 */
140 jpeg_destination_mgr dest; /* data dest for compression */
141 jpeg_source_mgr src; /* data source for decompression */
142 /* private state */
143 TIFF* tif; /* back link needed by some code */
144 uint16 photometric; /* copy of PhotometricInterpretation */
145 uint16 h_sampling; /* luminance sampling factors */
146 uint16 v_sampling;
147 tsize_t bytesperline; /* decompressed bytes per scanline */
148 /* pointers to intermediate buffers when processing downsampled data */
149 JSAMPARRAY ds_buffer[MAX_COMPONENTS];
150 int scancount; /* number of "scanlines" accumulated */
151 int samplesperclump;
152
153 TIFFVGetMethod vgetparent; /* super-class method */
154 TIFFVSetMethod vsetparent; /* super-class method */
155 TIFFPrintMethod printdir; /* super-class method */
156 TIFFStripMethod defsparent; /* super-class method */
157 TIFFTileMethod deftparent; /* super-class method */
158 /* pseudo-tag fields */
159 void* jpegtables; /* JPEGTables tag value, or NULL */
160 uint32 jpegtables_length; /* number of bytes in same */
161 int jpegquality; /* Compression quality level */
162 int jpegcolormode; /* Auto RGB<=>YCbCr convert? */
163 int jpegtablesmode; /* What to put in JPEGTables */
164
165 int ycbcrsampling_fetched;
166 uint32 recvparams; /* encoded Class 2 session params */
167 char* subaddress; /* subaddress string */
168 uint32 recvtime; /* time spent receiving (secs) */
169 char* faxdcs; /* encoded fax parameters (DCS, Table 2/T.30) */
170 } JPEGState;
171
172 #define JState(tif) ((JPEGState*)(tif)->tif_data)
173
174 static int JPEGDecode(TIFF*, tidata_t, tsize_t, tsample_t);
175 static int JPEGDecodeRaw(TIFF*, tidata_t, tsize_t, tsample_t);
176 static int JPEGEncode(TIFF*, tidata_t, tsize_t, tsample_t);
177 static int JPEGEncodeRaw(TIFF*, tidata_t, tsize_t, tsample_t);
178 static int JPEGInitializeLibJPEG( TIFF * tif,
179 int force_encode, int force_decode );
180
181 #define FIELD_JPEGTABLES (FIELD_CODEC+0)
182 #define FIELD_RECVPARAMS (FIELD_CODEC+1)
183 #define FIELD_SUBADDRESS (FIELD_CODEC+2)
184 #define FIELD_RECVTIME (FIELD_CODEC+3)
185 #define FIELD_FAXDCS (FIELD_CODEC+4)
186
187 static const TIFFFieldInfo jpegFieldInfo[] = {
188 { TIFFTAG_JPEGTABLES, -3,-3, TIFF_UNDEFINED, FIELD_JPEGTABLES,
189 FALSE, TRUE, "JPEGTables" },
190 { TIFFTAG_JPEGQUALITY, 0, 0, TIFF_ANY, FIELD_PSEUDO,
191 TRUE, FALSE, "" },
192 { TIFFTAG_JPEGCOLORMODE, 0, 0, TIFF_ANY, FIELD_PSEUDO,
193 FALSE, FALSE, "" },
194 { TIFFTAG_JPEGTABLESMODE, 0, 0, TIFF_ANY, FIELD_PSEUDO,
195 FALSE, FALSE, "" },
196 /* Specific for JPEG in faxes */
197 { TIFFTAG_FAXRECVPARAMS, 1, 1, TIFF_LONG, FIELD_RECVPARAMS,
198 TRUE, FALSE, "FaxRecvParams" },
199 { TIFFTAG_FAXSUBADDRESS, -1,-1, TIFF_ASCII, FIELD_SUBADDRESS,
200 TRUE, FALSE, "FaxSubAddress" },
201 { TIFFTAG_FAXRECVTIME, 1, 1, TIFF_LONG, FIELD_RECVTIME,
202 TRUE, FALSE, "FaxRecvTime" },
203 { TIFFTAG_FAXDCS, -1, -1, TIFF_ASCII, FIELD_FAXDCS,
204 TRUE, FALSE, "FaxDcs" },
205 };
206 #define N(a) (sizeof (a) / sizeof (a[0]))
207
208 /*
209 * libjpeg interface layer.
210 *
211 * We use setjmp/longjmp to return control to libtiff
212 * when a fatal error is encountered within the JPEG
213 * library. We also direct libjpeg error and warning
214 * messages through the appropriate libtiff handlers.
215 */
216
217 /*
218 * Error handling routines (these replace corresponding
219 * IJG routines from jerror.c). These are used for both
220 * compression and decompression.
221 */
222 static void
223 TIFFjpeg_error_exit(j_common_ptr cinfo)
224 {
225 JPEGState *sp = (JPEGState *) cinfo; /* NB: cinfo assumed first */
226 char buffer[JMSG_LENGTH_MAX];
227
228 (*cinfo->err->format_message) (cinfo, buffer);
229 TIFFErrorExt(sp->tif->tif_clientdata, "JPEGLib", "%s", buffer); /* display the error message */
230 jpeg_abort(cinfo); /* clean up libjpeg state */
231 LONGJMP(sp->exit_jmpbuf, 1); /* return to libtiff caller */
232 }
233
234 /*
235 * This routine is invoked only for warning messages,
236 * since error_exit does its own thing and trace_level
237 * is never set > 0.
238 */
239 static void
240 TIFFjpeg_output_message(j_common_ptr cinfo)
241 {
242 char buffer[JMSG_LENGTH_MAX];
243
244 (*cinfo->err->format_message) (cinfo, buffer);
245 TIFFWarningExt(((JPEGState *) cinfo)->tif->tif_clientdata, "JPEGLib", "%s", buffer);
246 }
247
248 /*
249 * Interface routines. This layer of routines exists
250 * primarily to limit side-effects from using setjmp.
251 * Also, normal/error returns are converted into return
252 * values per libtiff practice.
253 */
254 #define CALLJPEG(sp, fail, op) (SETJMP((sp)->exit_jmpbuf) ? (fail) : (op))
255 #define CALLVJPEG(sp, op) CALLJPEG(sp, 0, ((op),1))
256
257 static int
258 TIFFjpeg_create_compress(JPEGState* sp)
259 {
260 /* initialize JPEG error handling */
261 sp->cinfo.c.err = jpeg_std_error(&sp->err);
262 sp->err.error_exit = TIFFjpeg_error_exit;
263 sp->err.output_message = TIFFjpeg_output_message;
264
265 return CALLVJPEG(sp, jpeg_create_compress(&sp->cinfo.c));
266 }
267
268 static int
269 TIFFjpeg_create_decompress(JPEGState* sp)
270 {
271 /* initialize JPEG error handling */
272 sp->cinfo.d.err = jpeg_std_error(&sp->err);
273 sp->err.error_exit = TIFFjpeg_error_exit;
274 sp->err.output_message = TIFFjpeg_output_message;
275
276 return CALLVJPEG(sp, jpeg_create_decompress(&sp->cinfo.d));
277 }
278
279 static int
280 TIFFjpeg_set_defaults(JPEGState* sp)
281 {
282 return CALLVJPEG(sp, jpeg_set_defaults(&sp->cinfo.c));
283 }
284
285 static int
286 TIFFjpeg_set_colorspace(JPEGState* sp, J_COLOR_SPACE colorspace)
287 {
288 return CALLVJPEG(sp, jpeg_set_colorspace(&sp->cinfo.c, colorspace));
289 }
290
291 static int
292 TIFFjpeg_set_quality(JPEGState* sp, int quality, boolean force_baseline)
293 {
294 return CALLVJPEG(sp,
295 jpeg_set_quality(&sp->cinfo.c, quality, force_baseline));
296 }
297
298 static int
299 TIFFjpeg_suppress_tables(JPEGState* sp, boolean suppress)
300 {
301 return CALLVJPEG(sp, jpeg_suppress_tables(&sp->cinfo.c, suppress));
302 }
303
304 static int
305 TIFFjpeg_start_compress(JPEGState* sp, boolean write_all_tables)
306 {
307 return CALLVJPEG(sp,
308 jpeg_start_compress(&sp->cinfo.c, write_all_tables));
309 }
310
311 static int
312 TIFFjpeg_write_scanlines(JPEGState* sp, JSAMPARRAY scanlines, int num_lines)
313 {
314 return CALLJPEG(sp, -1, (int) jpeg_write_scanlines(&sp->cinfo.c,
315 scanlines, (JDIMENSION) num_lines));
316 }
317
318 static int
319 TIFFjpeg_write_raw_data(JPEGState* sp, JSAMPIMAGE data, int num_lines)
320 {
321 return CALLJPEG(sp, -1, (int) jpeg_write_raw_data(&sp->cinfo.c,
322 data, (JDIMENSION) num_lines));
323 }
324
325 static int
326 TIFFjpeg_finish_compress(JPEGState* sp)
327 {
328 return CALLVJPEG(sp, jpeg_finish_compress(&sp->cinfo.c));
329 }
330
331 static int
332 TIFFjpeg_write_tables(JPEGState* sp)
333 {
334 return CALLVJPEG(sp, jpeg_write_tables(&sp->cinfo.c));
335 }
336
337 static int
338 TIFFjpeg_read_header(JPEGState* sp, boolean require_image)
339 {
340 return CALLJPEG(sp, -1, jpeg_read_header(&sp->cinfo.d, require_image));
341 }
342
343 static int
344 TIFFjpeg_start_decompress(JPEGState* sp)
345 {
346 return CALLVJPEG(sp, jpeg_start_decompress(&sp->cinfo.d));
347 }
348
349 static int
350 TIFFjpeg_read_scanlines(JPEGState* sp, JSAMPARRAY scanlines, int max_lines)
351 {
352 return CALLJPEG(sp, -1, (int) jpeg_read_scanlines(&sp->cinfo.d,
353 scanlines, (JDIMENSION) max_lines));
354 }
355
356 static int
357 TIFFjpeg_read_raw_data(JPEGState* sp, JSAMPIMAGE data, int max_lines)
358 {
359 return CALLJPEG(sp, -1, (int) jpeg_read_raw_data(&sp->cinfo.d,
360 data, (JDIMENSION) max_lines));
361 }
362
363 static int
364 TIFFjpeg_finish_decompress(JPEGState* sp)
365 {
366 return CALLJPEG(sp, -1, (int) jpeg_finish_decompress(&sp->cinfo.d));
367 }
368
369 static int
370 TIFFjpeg_abort(JPEGState* sp)
371 {
372 return CALLVJPEG(sp, jpeg_abort(&sp->cinfo.comm));
373 }
374
375 static int
376 TIFFjpeg_destroy(JPEGState* sp)
377 {
378 return CALLVJPEG(sp, jpeg_destroy(&sp->cinfo.comm));
379 }
380
381 static JSAMPARRAY
382 TIFFjpeg_alloc_sarray(JPEGState* sp, int pool_id,
383 JDIMENSION samplesperrow, JDIMENSION numrows)
384 {
385 return CALLJPEG(sp, (JSAMPARRAY) NULL,
386 (*sp->cinfo.comm.mem->alloc_sarray)
387 (&sp->cinfo.comm, pool_id, samplesperrow, numrows));
388 }
389
390 /*
391 * JPEG library destination data manager.
392 * These routines direct compressed data from libjpeg into the
393 * libtiff output buffer.
394 */
395
396 static void
397 std_init_destination(j_compress_ptr cinfo)
398 {
399 JPEGState* sp = (JPEGState*) cinfo;
400 TIFF* tif = sp->tif;
401
402 sp->dest.next_output_byte = (JOCTET*) tif->tif_rawdata;
403 sp->dest.free_in_buffer = (size_t) tif->tif_rawdatasize;
404 }
405
406 static boolean
407 std_empty_output_buffer(j_compress_ptr cinfo)
408 {
409 JPEGState* sp = (JPEGState*) cinfo;
410 TIFF* tif = sp->tif;
411
412 /* the entire buffer has been filled */
413 tif->tif_rawcc = tif->tif_rawdatasize;
414 TIFFFlushData1(tif);
415 sp->dest.next_output_byte = (JOCTET*) tif->tif_rawdata;
416 sp->dest.free_in_buffer = (size_t) tif->tif_rawdatasize;
417
418 return (TRUE);
419 }
420
421 static void
422 std_term_destination(j_compress_ptr cinfo)
423 {
424 JPEGState* sp = (JPEGState*) cinfo;
425 TIFF* tif = sp->tif;
426
427 tif->tif_rawcp = (tidata_t) sp->dest.next_output_byte;
428 tif->tif_rawcc =
429 tif->tif_rawdatasize - (tsize_t) sp->dest.free_in_buffer;
430 /* NB: libtiff does the final buffer flush */
431 }
432
433 static void
434 TIFFjpeg_data_dest(JPEGState* sp, TIFF* tif)
435 {
436 (void) tif;
437 sp->cinfo.c.dest = &sp->dest;
438 sp->dest.init_destination = std_init_destination;
439 sp->dest.empty_output_buffer = std_empty_output_buffer;
440 sp->dest.term_destination = std_term_destination;
441 }
442
443 /*
444 * Alternate destination manager for outputting to JPEGTables field.
445 */
446
447 static void
448 tables_init_destination(j_compress_ptr cinfo)
449 {
450 JPEGState* sp = (JPEGState*) cinfo;
451
452 /* while building, jpegtables_length is allocated buffer size */
453 sp->dest.next_output_byte = (JOCTET*) sp->jpegtables;
454 sp->dest.free_in_buffer = (size_t) sp->jpegtables_length;
455 }
456
457 static boolean
458 tables_empty_output_buffer(j_compress_ptr cinfo)
459 {
460 JPEGState* sp = (JPEGState*) cinfo;
461 void* newbuf;
462
463 /* the entire buffer has been filled; enlarge it by 1000 bytes */
464 newbuf = _TIFFrealloc((tdata_t) sp->jpegtables,
465 (tsize_t) (sp->jpegtables_length + 1000));
466 if (newbuf == NULL)
467 ERREXIT1(cinfo, JERR_OUT_OF_MEMORY, 100);
468 sp->dest.next_output_byte = (JOCTET*) newbuf + sp->jpegtables_length;
469 sp->dest.free_in_buffer = (size_t) 1000;
470 sp->jpegtables = newbuf;
471 sp->jpegtables_length += 1000;
472 return (TRUE);
473 }
474
475 static void
476 tables_term_destination(j_compress_ptr cinfo)
477 {
478 JPEGState* sp = (JPEGState*) cinfo;
479
480 /* set tables length to number of bytes actually emitted */
481 sp->jpegtables_length -= sp->dest.free_in_buffer;
482 }
483
484 static int
485 TIFFjpeg_tables_dest(JPEGState* sp, TIFF* tif)
486 {
487 (void) tif;
488 /*
489 * Allocate a working buffer for building tables.
490 * Initial size is 1000 bytes, which is usually adequate.
491 */
492 if (sp->jpegtables)
493 _TIFFfree(sp->jpegtables);
494 sp->jpegtables_length = 1000;
495 sp->jpegtables = (void*) _TIFFmalloc((tsize_t) sp->jpegtables_length);
496 if (sp->jpegtables == NULL) {
497 sp->jpegtables_length = 0;
498 TIFFErrorExt(sp->tif->tif_clientdata, "TIFFjpeg_tables_dest", "No space for JPEGTables");
499 return (0);
500 }
501 sp->cinfo.c.dest = &sp->dest;
502 sp->dest.init_destination = tables_init_destination;
503 sp->dest.empty_output_buffer = tables_empty_output_buffer;
504 sp->dest.term_destination = tables_term_destination;
505 return (1);
506 }
507
508 /*
509 * JPEG library source data manager.
510 * These routines supply compressed data to libjpeg.
511 */
512
513 static void
514 std_init_source(j_decompress_ptr cinfo)
515 {
516 JPEGState* sp = (JPEGState*) cinfo;
517 TIFF* tif = sp->tif;
518
519 sp->src.next_input_byte = (const JOCTET*) tif->tif_rawdata;
520 sp->src.bytes_in_buffer = (size_t) tif->tif_rawcc;
521 }
522
523 static boolean
524 std_fill_input_buffer(j_decompress_ptr cinfo)
525 {
526 JPEGState* sp = (JPEGState* ) cinfo;
527 static const JOCTET dummy_EOI[2] = { 0xFF, JPEG_EOI };
528
529 /*
530 * Should never get here since entire strip/tile is
531 * read into memory before the decompressor is called,
532 * and thus was supplied by init_source.
533 */
534 WARNMS(cinfo, JWRN_JPEG_EOF);
535 /* insert a fake EOI marker */
536 sp->src.next_input_byte = dummy_EOI;
537 sp->src.bytes_in_buffer = 2;
538 return (TRUE);
539 }
540
541 static void
542 std_skip_input_data(j_decompress_ptr cinfo, long num_bytes)
543 {
544 JPEGState* sp = (JPEGState*) cinfo;
545
546 if (num_bytes > 0) {
547 if (num_bytes > (long) sp->src.bytes_in_buffer) {
548 /* oops, buffer overrun */
549 (void) std_fill_input_buffer(cinfo);
550 } else {
551 sp->src.next_input_byte += (size_t) num_bytes;
552 sp->src.bytes_in_buffer -= (size_t) num_bytes;
553 }
554 }
555 }
556
557 static void
558 std_term_source(j_decompress_ptr cinfo)
559 {
560 /* No work necessary here */
561 /* Or must we update tif->tif_rawcp, tif->tif_rawcc ??? */
562 /* (if so, need empty tables_term_source!) */
563 (void) cinfo;
564 }
565
566 static void
567 TIFFjpeg_data_src(JPEGState* sp, TIFF* tif)
568 {
569 (void) tif;
570 sp->cinfo.d.src = &sp->src;
571 sp->src.init_source = std_init_source;
572 sp->src.fill_input_buffer = std_fill_input_buffer;
573 sp->src.skip_input_data = std_skip_input_data;
574 sp->src.resync_to_restart = jpeg_resync_to_restart;
575 sp->src.term_source = std_term_source;
576 sp->src.bytes_in_buffer = 0; /* for safety */
577 sp->src.next_input_byte = NULL;
578 }
579
580 /*
581 * Alternate source manager for reading from JPEGTables.
582 * We can share all the code except for the init routine.
583 */
584
585 static void
586 tables_init_source(j_decompress_ptr cinfo)
587 {
588 JPEGState* sp = (JPEGState*) cinfo;
589
590 sp->src.next_input_byte = (const JOCTET*) sp->jpegtables;
591 sp->src.bytes_in_buffer = (size_t) sp->jpegtables_length;
592 }
593
594 static void
595 TIFFjpeg_tables_src(JPEGState* sp, TIFF* tif)
596 {
597 TIFFjpeg_data_src(sp, tif);
598 sp->src.init_source = tables_init_source;
599 }
600
601 /*
602 * Allocate downsampled-data buffers needed for downsampled I/O.
603 * We use values computed in jpeg_start_compress or jpeg_start_decompress.
604 * We use libjpeg's allocator so that buffers will be released automatically
605 * when done with strip/tile.
606 * This is also a handy place to compute samplesperclump, bytesperline.
607 */
608 static int
609 alloc_downsampled_buffers(TIFF* tif, jpeg_component_info* comp_info,
610 int num_components)
611 {
612 JPEGState* sp = JState(tif);
613 int ci;
614 jpeg_component_info* compptr;
615 JSAMPARRAY buf;
616 int samples_per_clump = 0;
617
618 for (ci = 0, compptr = comp_info; ci < num_components;
619 ci++, compptr++) {
620 samples_per_clump += compptr->h_samp_factor *
621 compptr->v_samp_factor;
622 buf = TIFFjpeg_alloc_sarray(sp, JPOOL_IMAGE,
623 compptr->width_in_blocks * DCTSIZE,
624 (JDIMENSION) (compptr->v_samp_factor*DCTSIZE));
625 if (buf == NULL)
626 return (0);
627 sp->ds_buffer[ci] = buf;
628 }
629 sp->samplesperclump = samples_per_clump;
630 return (1);
631 }
632
633
634 /*
635 * JPEG Decoding.
636 */
637
638 static int
639 JPEGSetupDecode(TIFF* tif)
640 {
641 JPEGState* sp = JState(tif);
642 TIFFDirectory *td = &tif->tif_dir;
643
644 JPEGInitializeLibJPEG( tif, 0, 1 );
645
646 assert(sp != NULL);
647 assert(sp->cinfo.comm.is_decompressor);
648
649 /* Read JPEGTables if it is present */
650 if (TIFFFieldSet(tif,FIELD_JPEGTABLES)) {
651 TIFFjpeg_tables_src(sp, tif);
652 if(TIFFjpeg_read_header(sp,FALSE) != JPEG_HEADER_TABLES_ONLY) {
653 TIFFErrorExt(tif->tif_clientdata, "JPEGSetupDecode", "Bogus JPEGTables field");
654 return (0);
655 }
656 }
657
658 /* Grab parameters that are same for all strips/tiles */
659 sp->photometric = td->td_photometric;
660 switch (sp->photometric) {
661 case PHOTOMETRIC_YCBCR:
662 sp->h_sampling = td->td_ycbcrsubsampling[0];
663 sp->v_sampling = td->td_ycbcrsubsampling[1];
664 break;
665 default:
666 /* TIFF 6.0 forbids subsampling of all other color spaces */
667 sp->h_sampling = 1;
668 sp->v_sampling = 1;
669 break;
670 }
671
672 /* Set up for reading normal data */
673 TIFFjpeg_data_src(sp, tif);
674 tif->tif_postdecode = _TIFFNoPostDecode; /* override byte swapping */
675 return (1);
676 }
677
678 /*
679 * Set up for decoding a strip or tile.
680 */
681 static int
682 JPEGPreDecode(TIFF* tif, tsample_t s)
683 {
684 JPEGState *sp = JState(tif);
685 TIFFDirectory *td = &tif->tif_dir;
686 static const char module[] = "JPEGPreDecode";
687 uint32 segment_width, segment_height;
688 int downsampled_output;
689 int ci;
690
691 assert(sp != NULL);
692 assert(sp->cinfo.comm.is_decompressor);
693 /*
694 * Reset decoder state from any previous strip/tile,
695 * in case application didn't read the whole strip.
696 */
697 if (!TIFFjpeg_abort(sp))
698 return (0);
699 /*
700 * Read the header for this strip/tile.
701 */
702 if (TIFFjpeg_read_header(sp, TRUE) != JPEG_HEADER_OK)
703 return (0);
704 /*
705 * Check image parameters and set decompression parameters.
706 */
707 segment_width = td->td_imagewidth;
708 segment_height = td->td_imagelength - tif->tif_row;
709 if (isTiled(tif)) {
710 segment_width = td->td_tilewidth;
711 segment_height = td->td_tilelength;
712 sp->bytesperline = TIFFTileRowSize(tif);
713 } else {
714 if (segment_height > td->td_rowsperstrip)
715 segment_height = td->td_rowsperstrip;
716 sp->bytesperline = TIFFOldScanlineSize(tif);
717 }
718 if (td->td_planarconfig == PLANARCONFIG_SEPARATE && s > 0) {
719 /*
720 * For PC 2, scale down the expected strip/tile size
721 * to match a downsampled component
722 */
723 segment_width = TIFFhowmany(segment_width, sp->h_sampling);
724 segment_height = TIFFhowmany(segment_height, sp->v_sampling);
725 }
726 if (sp->cinfo.d.image_width < segment_width ||
727 sp->cinfo.d.image_height < segment_height) {
728 TIFFWarningExt(tif->tif_clientdata, module,
729 "Improper JPEG strip/tile size, "
730 "expected %dx%d, got %dx%d",
731 segment_width, segment_height,
732 sp->cinfo.d.image_width,
733 sp->cinfo.d.image_height);
734 }
735 if (sp->cinfo.d.image_width > segment_width ||
736 sp->cinfo.d.image_height > segment_height) {
737 /*
738 * This case could be dangerous, if the strip or tile size has
739 * been reported as less than the amount of data jpeg will
740 * return, some potential security issues arise. Catch this
741 * case and error out.
742 */
743 TIFFErrorExt(tif->tif_clientdata, module,
744 "JPEG strip/tile size exceeds expected dimensions,"
745 " expected %dx%d, got %dx%d",
746 segment_width, segment_height,
747 sp->cinfo.d.image_width, sp->cinfo.d.image_height);
748 return (0);
749 }
750 if (sp->cinfo.d.num_components !=
751 (td->td_planarconfig == PLANARCONFIG_CONTIG ?
752 td->td_samplesperpixel : 1)) {
753 TIFFErrorExt(tif->tif_clientdata, module, "Improper JPEG component count");
754 return (0);
755 }
756 #ifdef JPEG_LIB_MK1
757 if (12 != td->td_bitspersample && 8 != td->td_bitspersample) {
758 TIFFErrorExt(tif->tif_clientdata, module, "Improper JPEG data precision");
759 return (0);
760 }
761 sp->cinfo.d.data_precision = td->td_bitspersample;
762 sp->cinfo.d.bits_in_jsample = td->td_bitspersample;
763 #else
764 if (sp->cinfo.d.data_precision != td->td_bitspersample) {
765 TIFFErrorExt(tif->tif_clientdata, module, "Improper JPEG data precision");
766 return (0);
767 }
768 #endif
769 if (td->td_planarconfig == PLANARCONFIG_CONTIG) {
770 /* Component 0 should have expected sampling factors */
771 if (sp->cinfo.d.comp_info[0].h_samp_factor != sp->h_sampling ||
772 sp->cinfo.d.comp_info[0].v_samp_factor != sp->v_sampling) {
773 TIFFWarningExt(tif->tif_clientdata, module,
774 "Improper JPEG sampling factors %d,%d\n"
775 "Apparently should be %d,%d.",
776 sp->cinfo.d.comp_info[0].h_samp_factor,
777 sp->cinfo.d.comp_info[0].v_samp_factor,
778 sp->h_sampling, sp->v_sampling);
779
780 /*
781 * There are potential security issues here
782 * for decoders that have already allocated
783 * buffers based on the expected sampling
784 * factors. Lets check the sampling factors
785 * dont exceed what we were expecting.
786 */
787 if (sp->cinfo.d.comp_info[0].h_samp_factor
788 > sp->h_sampling
789 || sp->cinfo.d.comp_info[0].v_samp_factor
790 > sp->v_sampling) {
791 TIFFErrorExt(tif->tif_clientdata,
792 module,
793 "Cannot honour JPEG sampling factors"
794 " that exceed those specified.");
795 return (0);
796 }
797
798 /*
799 * XXX: Files written by the Intergraph software
800 * has different sampling factors stored in the
801 * TIFF tags and in the JPEG structures. We will
802 * try to deduce Intergraph files by the presense
803 * of the tag 33918.
804 */
805 if (!_TIFFFindFieldInfo(tif, 33918, TIFF_ANY)) {
806 TIFFWarningExt(tif->tif_clientdata, module,
807 "Decompressor will try reading with "
808 "sampling %d,%d.",
809 sp->cinfo.d.comp_info[0].h_samp_factor,
810 sp->cinfo.d.comp_info[0].v_samp_factor);
811
812 sp->h_sampling = (uint16)
813 sp->cinfo.d.comp_info[0].h_samp_factor;
814 sp->v_sampling = (uint16)
815 sp->cinfo.d.comp_info[0].v_samp_factor;
816 }
817 }
818 /* Rest should have sampling factors 1,1 */
819 for (ci = 1; ci < sp->cinfo.d.num_components; ci++) {
820 if (sp->cinfo.d.comp_info[ci].h_samp_factor != 1 ||
821 sp->cinfo.d.comp_info[ci].v_samp_factor != 1) {
822 TIFFErrorExt(tif->tif_clientdata, module, "Improper JPEG sampling factors");
823 return (0);
824 }
825 }
826 } else {
827 /* PC 2's single component should have sampling factors 1,1 */
828 if (sp->cinfo.d.comp_info[0].h_samp_factor != 1 ||
829 sp->cinfo.d.comp_info[0].v_samp_factor != 1) {
830 TIFFErrorExt(tif->tif_clientdata, module, "Improper JPEG sampling factors");
831 return (0);
832 }
833 }
834 downsampled_output = FALSE;
835 if (td->td_planarconfig == PLANARCONFIG_CONTIG &&
836 sp->photometric == PHOTOMETRIC_YCBCR &&
837 sp->jpegcolormode == JPEGCOLORMODE_RGB) {
838 /* Convert YCbCr to RGB */
839 sp->cinfo.d.jpeg_color_space = JCS_YCbCr;
840 sp->cinfo.d.out_color_space = JCS_RGB;
841 } else {
842 /* Suppress colorspace handling */
843 sp->cinfo.d.jpeg_color_space = JCS_UNKNOWN;
844 sp->cinfo.d.out_color_space = JCS_UNKNOWN;
845 if (td->td_planarconfig == PLANARCONFIG_CONTIG &&
846 (sp->h_sampling != 1 || sp->v_sampling != 1))
847 downsampled_output = TRUE;
848 /* XXX what about up-sampling? */
849 }
850 if (downsampled_output) {
851 /* Need to use raw-data interface to libjpeg */
852 sp->cinfo.d.raw_data_out = TRUE;
853 tif->tif_decoderow = JPEGDecodeRaw;
854 tif->tif_decodestrip = JPEGDecodeRaw;
855 tif->tif_decodetile = JPEGDecodeRaw;
856 } else {
857 /* Use normal interface to libjpeg */
858 sp->cinfo.d.raw_data_out = FALSE;
859 tif->tif_decoderow = JPEGDecode;
860 tif->tif_decodestrip = JPEGDecode;
861 tif->tif_decodetile = JPEGDecode;
862 }
863 /* Start JPEG decompressor */
864 if (!TIFFjpeg_start_decompress(sp))
865 return (0);
866 /* Allocate downsampled-data buffers if needed */
867 if (downsampled_output) {
868 if (!alloc_downsampled_buffers(tif, sp->cinfo.d.comp_info,
869 sp->cinfo.d.num_components))
870 return (0);
871 sp->scancount = DCTSIZE; /* mark buffer empty */
872 }
873 return (1);
874 }
875
876 /*
877 * Decode a chunk of pixels.
878 * "Standard" case: returned data is not downsampled.
879 */
880 /*ARGSUSED*/ static int
881 JPEGDecode(TIFF* tif, tidata_t buf, tsize_t cc, tsample_t s)
882 {
883 JPEGState *sp = JState(tif);
884 tsize_t nrows;
885 (void) s;
886
887 nrows = cc / sp->bytesperline;
888 if (cc % sp->bytesperline)
889 TIFFWarningExt(tif->tif_clientdata, tif->tif_name, "fractional scanline not read");
890
891 if( nrows > (int) sp->cinfo.d.image_height )
892 nrows = sp->cinfo.d.image_height;
893
894 /* data is expected to be read in multiples of a scanline */
895 if (nrows)
896 {
897 JSAMPROW line_work_buf = NULL;
898
899 /*
900 ** For 6B, only use temporary buffer for 12 bit imagery.
901 ** For Mk1 always use it.
902 */
903 #if !defined(JPEG_LIB_MK1)
904 if( sp->cinfo.d.data_precision == 12 )
905 #endif
906 {
907 line_work_buf = (JSAMPROW)
908 _TIFFmalloc(sizeof(short) * sp->cinfo.d.output_width
909 * sp->cinfo.d.num_components );
910 }
911
912 do {
913 if( line_work_buf != NULL )
914 {
915 /*
916 ** In the MK1 case, we aways read into a 16bit buffer, and then
917 ** pack down to 12bit or 8bit. In 6B case we only read into 16
918 ** bit buffer for 12bit data, which we need to repack.
919 */
920 if (TIFFjpeg_read_scanlines(sp, &line_work_buf, 1) != 1)
921 return (0);
922
923 if( sp->cinfo.d.data_precision == 12 )
924 {
925 int value_pairs = (sp->cinfo.d.output_width
926 * sp->cinfo.d.num_components) / 2;
927 int iPair;
928
929 for( iPair = 0; iPair < value_pairs; iPair++ )
930 {
931 unsigned char *out_ptr =
932 ((unsigned char *) buf) + iPair * 3;
933 JSAMPLE *in_ptr = line_work_buf + iPair * 2;
934
935 out_ptr[0] = (in_ptr[0] & 0xff0) >> 4;
936 out_ptr[1] = ((in_ptr[0] & 0xf) << 4)
937 | ((in_ptr[1] & 0xf00) >> 8);
938 out_ptr[2] = ((in_ptr[1] & 0xff) >> 0);
939 }
940 }
941 else if( sp->cinfo.d.data_precision == 8 )
942 {
943 int value_count = (sp->cinfo.d.output_width
944 * sp->cinfo.d.num_components);
945 int iValue;
946
947 for( iValue = 0; iValue < value_count; iValue++ )
948 {
949 ((unsigned char *) buf)[iValue] =
950 line_work_buf[iValue] & 0xff;
951 }
952 }
953 }
954 else
955 {
956 /*
957 ** In the libjpeg6b 8bit case. We read directly into the
958 ** TIFF buffer.
959 */
960 JSAMPROW bufptr = (JSAMPROW)buf;
961
962 if (TIFFjpeg_read_scanlines(sp, &bufptr, 1) != 1)
963 return (0);
964 }
965
966 ++tif->tif_row;
967 buf += sp->bytesperline;
968 cc -= sp->bytesperline;
969 } while (--nrows > 0);
970
971 if( line_work_buf != NULL )
972 _TIFFfree( line_work_buf );
973 }
974
975 /* Close down the decompressor if we've finished the strip or tile. */
976 return sp->cinfo.d.output_scanline < sp->cinfo.d.output_height
977 || TIFFjpeg_finish_decompress(sp);
978 }
979
980 /*
981 * Decode a chunk of pixels.
982 * Returned data is downsampled per sampling factors.
983 */
984 /*ARGSUSED*/ static int
985 JPEGDecodeRaw(TIFF* tif, tidata_t buf, tsize_t cc, tsample_t s)
986 {
987 JPEGState *sp = JState(tif);
988 tsize_t nrows;
989 (void) s;
990
991 /* data is expected to be read in multiples of a scanline */
992 if ( (nrows = sp->cinfo.d.image_height) ) {
993 /* Cb,Cr both have sampling factors 1, so this is correct */
994 JDIMENSION clumps_per_line = sp->cinfo.d.comp_info[1].downsampled_width;
995 int samples_per_clump = sp->samplesperclump;
996
997 #ifdef JPEG_LIB_MK1
998 unsigned short* tmpbuf = _TIFFmalloc(sizeof(unsigned short) *
999 sp->cinfo.d.output_width *
1000 sp->cinfo.d.num_components);
1001 #endif
1002
1003 do {
1004 jpeg_component_info *compptr;
1005 int ci, clumpoffset;
1006
1007 /* Reload downsampled-data buffer if needed */
1008 if (sp->scancount >= DCTSIZE) {
1009 int n = sp->cinfo.d.max_v_samp_factor * DCTSIZE;
1010 if (TIFFjpeg_read_raw_data(sp, sp->ds_buffer, n) != n)
1011 return (0);
1012 sp->scancount = 0;
1013 }
1014 /*
1015 * Fastest way to unseparate data is to make one pass
1016 * over the scanline for each row of each component.
1017 */
1018 clumpoffset = 0; /* first sample in clump */
1019 for (ci = 0, compptr = sp->cinfo.d.comp_info;
1020 ci < sp->cinfo.d.num_components;
1021 ci++, compptr++) {
1022 int hsamp = compptr->h_samp_factor;
1023 int vsamp = compptr->v_samp_factor;
1024 int ypos;
1025
1026 for (ypos = 0; ypos < vsamp; ypos++) {
1027 JSAMPLE *inptr = sp->ds_buffer[ci][sp->scancount*vsamp + ypos];
1028 #ifdef JPEG_LIB_MK1
1029 JSAMPLE *outptr = (JSAMPLE*)tmpbuf + clumpoffset;
1030 #else
1031 JSAMPLE *outptr = (JSAMPLE*)buf + clumpoffset;
1032 #endif
1033 JDIMENSION nclump;
1034
1035 if (hsamp == 1) {
1036 /* fast path for at least Cb and Cr */
1037 for (nclump = clumps_per_line; nclump-- > 0; ) {
1038 outptr[0] = *inptr++;
1039 outptr += samples_per_clump;
1040 }
1041 } else {
1042 int xpos;
1043
1044 /* general case */
1045 for (nclump = clumps_per_line; nclump-- > 0; ) {
1046 for (xpos = 0; xpos < hsamp; xpos++)
1047 outptr[xpos] = *inptr++;
1048 outptr += samples_per_clump;
1049 }
1050 }
1051 clumpoffset += hsamp;
1052 }
1053 }
1054
1055 #ifdef JPEG_LIB_MK1
1056 {
1057 if (sp->cinfo.d.data_precision == 8)
1058 {
1059 int i=0;
1060 int len = sp->cinfo.d.output_width * sp->cinfo.d.num_components;
1061 for (i=0; i<len; i++)
1062 {
1063 ((unsigned char*)buf)[i] = tmpbuf[i] & 0xff;
1064 }
1065 }
1066 else
1067 { // 12-bit
1068 int value_pairs = (sp->cinfo.d.output_width
1069 * sp->cinfo.d.num_components) / 2;
1070 int iPair;
1071 for( iPair = 0; iPair < value_pairs; iPair++ )
1072 {
1073 unsigned char *out_ptr = ((unsigned char *) buf) + iPair * 3;
1074 JSAMPLE *in_ptr = tmpbuf + iPair * 2;
1075 out_ptr[0] = (in_ptr[0] & 0xff0) >> 4;
1076 out_ptr[1] = ((in_ptr[0] & 0xf) << 4)
1077 | ((in_ptr[1] & 0xf00) >> 8);
1078 out_ptr[2] = ((in_ptr[1] & 0xff) >> 0);
1079 }
1080 }
1081 }
1082 #endif
1083
1084 sp->scancount ++;
1085 tif->tif_row += sp->v_sampling;
1086 /* increment/decrement of buf and cc is still incorrect, but should not matter
1087 * TODO: resolve this */
1088 buf += sp->bytesperline;
1089 cc -= sp->bytesperline;
1090 nrows -= sp->v_sampling;
1091 } while (nrows > 0);
1092
1093 #ifdef JPEG_LIB_MK1
1094 _TIFFfree(tmpbuf);
1095 #endif
1096
1097 }
1098
1099 /* Close down the decompressor if done. */
1100 return sp->cinfo.d.output_scanline < sp->cinfo.d.output_height
1101 || TIFFjpeg_finish_decompress(sp);
1102 }
1103
1104
1105 /*
1106 * JPEG Encoding.
1107 */
1108
1109 static void
1110 unsuppress_quant_table (JPEGState* sp, int tblno)
1111 {
1112 JQUANT_TBL* qtbl;
1113
1114 if ((qtbl = sp->cinfo.c.quant_tbl_ptrs[tblno]) != NULL)
1115 qtbl->sent_table = FALSE;
1116 }
1117
1118 static void
1119 unsuppress_huff_table (JPEGState* sp, int tblno)
1120 {
1121 JHUFF_TBL* htbl;
1122
1123 if ((htbl = sp->cinfo.c.dc_huff_tbl_ptrs[tblno]) != NULL)
1124 htbl->sent_table = FALSE;
1125 if ((htbl = sp->cinfo.c.ac_huff_tbl_ptrs[tblno]) != NULL)
1126 htbl->sent_table = FALSE;
1127 }
1128
1129 static int
1130 prepare_JPEGTables(TIFF* tif)
1131 {
1132 JPEGState* sp = JState(tif);
1133
1134 JPEGInitializeLibJPEG( tif, 0, 0 );
1135
1136 /* Initialize quant tables for current quality setting */
1137 if (!TIFFjpeg_set_quality(sp, sp->jpegquality, FALSE))
1138 return (0);
1139 /* Mark only the tables we want for output */
1140 /* NB: chrominance tables are currently used only with YCbCr */
1141 if (!TIFFjpeg_suppress_tables(sp, TRUE))
1142 return (0);
1143 if (sp->jpegtablesmode & JPEGTABLESMODE_QUANT) {
1144 unsuppress_quant_table(sp, 0);
1145 if (sp->photometric == PHOTOMETRIC_YCBCR)
1146 unsuppress_quant_table(sp, 1);
1147 }
1148 if (sp->jpegtablesmode & JPEGTABLESMODE_HUFF) {
1149 unsuppress_huff_table(sp, 0);
1150 if (sp->photometric == PHOTOMETRIC_YCBCR)
1151 unsuppress_huff_table(sp, 1);
1152 }
1153 /* Direct libjpeg output into jpegtables */
1154 if (!TIFFjpeg_tables_dest(sp, tif))
1155 return (0);
1156 /* Emit tables-only datastream */
1157 if (!TIFFjpeg_write_tables(sp))
1158 return (0);
1159
1160 return (1);
1161 }
1162
1163 static int
1164 JPEGSetupEncode(TIFF* tif)
1165 {
1166 JPEGState* sp = JState(tif);
1167 TIFFDirectory *td = &tif->tif_dir;
1168 static const char module[] = "JPEGSetupEncode";
1169
1170 JPEGInitializeLibJPEG( tif, 1, 0 );
1171
1172 assert(sp != NULL);
1173 assert(!sp->cinfo.comm.is_decompressor);
1174
1175 /*
1176 * Initialize all JPEG parameters to default values.
1177 * Note that jpeg_set_defaults needs legal values for
1178 * in_color_space and input_components.
1179 */
1180 sp->cinfo.c.in_color_space = JCS_UNKNOWN;
1181 sp->cinfo.c.input_components = 1;
1182 if (!TIFFjpeg_set_defaults(sp))
1183 return (0);
1184 /* Set per-file parameters */
1185 sp->photometric = td->td_photometric;
1186 switch (sp->photometric) {
1187 case PHOTOMETRIC_YCBCR:
1188 sp->h_sampling = td->td_ycbcrsubsampling[0];
1189 sp->v_sampling = td->td_ycbcrsubsampling[1];
1190 /*
1191 * A ReferenceBlackWhite field *must* be present since the
1192 * default value is inappropriate for YCbCr. Fill in the
1193 * proper value if application didn't set it.
1194 */
1195 {
1196 float *ref;
1197 if (!TIFFGetField(tif, TIFFTAG_REFERENCEBLACKWHITE,
1198 &ref)) {
1199 float refbw[6];
1200 long top = 1L << td->td_bitspersample;
1201 refbw[0] = 0;
1202 refbw[1] = (float)(top-1L);
1203 refbw[2] = (float)(top>>1);
1204 refbw[3] = refbw[1];
1205 refbw[4] = refbw[2];
1206 refbw[5] = refbw[1];
1207 TIFFSetField(tif, TIFFTAG_REFERENCEBLACKWHITE,
1208 refbw);
1209 }
1210 }
1211 break;
1212 case PHOTOMETRIC_PALETTE: /* disallowed by Tech Note */
1213 case PHOTOMETRIC_MASK:
1214 TIFFErrorExt(tif->tif_clientdata, module,
1215 "PhotometricInterpretation %d not allowed for JPEG",
1216 (int) sp->photometric);
1217 return (0);
1218 default:
1219 /* TIFF 6.0 forbids subsampling of all other color spaces */
1220 sp->h_sampling = 1;
1221 sp->v_sampling = 1;
1222 break;
1223 }
1224
1225 /* Verify miscellaneous parameters */
1226
1227 /*
1228 * This would need work if libtiff ever supports different
1229 * depths for different components, or if libjpeg ever supports
1230 * run-time selection of depth. Neither is imminent.
1231 */
1232 #ifdef JPEG_LIB_MK1
1233 /* BITS_IN_JSAMPLE now permits 8 and 12 --- dgilbert */
1234 if (td->td_bitspersample != 8 && td->td_bitspersample != 12)
1235 #else
1236 if (td->td_bitspersample != BITS_IN_JSAMPLE )
1237 #endif
1238 {
1239 TIFFErrorExt(tif->tif_clientdata, module, "BitsPerSample %d not allowed for JPEG",
1240 (int) td->td_bitspersample);
1241 return (0);
1242 }
1243 sp->cinfo.c.data_precision = td->td_bitspersample;
1244 #ifdef JPEG_LIB_MK1
1245 sp->cinfo.c.bits_in_jsample = td->td_bitspersample;
1246 #endif
1247 if (isTiled(tif)) {
1248 if ((td->td_tilelength % (sp->v_sampling * DCTSIZE)) != 0) {
1249 TIFFErrorExt(tif->tif_clientdata, module,
1250 "JPEG tile height must be multiple of %d",
1251 sp->v_sampling * DCTSIZE);
1252 return (0);
1253 }
1254 if ((td->td_tilewidth % (sp->h_sampling * DCTSIZE)) != 0) {
1255 TIFFErrorExt(tif->tif_clientdata, module,
1256 "JPEG tile width must be multiple of %d",
1257 sp->h_sampling * DCTSIZE);
1258 return (0);
1259 }
1260 } else {
1261 if (td->td_rowsperstrip < td->td_imagelength &&
1262 (td->td_rowsperstrip % (sp->v_sampling * DCTSIZE)) != 0) {
1263 TIFFErrorExt(tif->tif_clientdata, module,
1264 "RowsPerStrip must be multiple of %d for JPEG",
1265 sp->v_sampling * DCTSIZE);
1266 return (0);
1267 }
1268 }
1269
1270 /* Create a JPEGTables field if appropriate */
1271 if (sp->jpegtablesmode & (JPEGTABLESMODE_QUANT|JPEGTABLESMODE_HUFF)) {
1272 if( sp->jpegtables == NULL
1273 || memcmp(sp->jpegtables,"\0\0\0\0\0\0\0\0\0",8) == 0 )
1274 {
1275 if (!prepare_JPEGTables(tif))
1276 return (0);
1277 /* Mark the field present */
1278 /* Can't use TIFFSetField since BEENWRITING is already set! */
1279 tif->tif_flags |= TIFF_DIRTYDIRECT;
1280 TIFFSetFieldBit(tif, FIELD_JPEGTABLES);
1281 }
1282 } else {
1283 /* We do not support application-supplied JPEGTables, */
1284 /* so mark the field not present */
1285 TIFFClrFieldBit(tif, FIELD_JPEGTABLES);
1286 }
1287
1288 /* Direct libjpeg output to libtiff's output buffer */
1289 TIFFjpeg_data_dest(sp, tif);
1290
1291 return (1);
1292 }
1293
1294 /*
1295 * Set encoding state at the start of a strip or tile.
1296 */
1297 static int
1298 JPEGPreEncode(TIFF* tif, tsample_t s)
1299 {
1300 JPEGState *sp = JState(tif);
1301 TIFFDirectory *td = &tif->tif_dir;
1302 static const char module[] = "JPEGPreEncode";
1303 uint32 segment_width, segment_height;
1304 int downsampled_input;
1305
1306 assert(sp != NULL);
1307 assert(!sp->cinfo.comm.is_decompressor);
1308 /*
1309 * Set encoding parameters for this strip/tile.
1310 */
1311 if (isTiled(tif)) {
1312 segment_width = td->td_tilewidth;
1313 segment_height = td->td_tilelength;
1314 sp->bytesperline = TIFFTileRowSize(tif);
1315 } else {
1316 segment_width = td->td_imagewidth;
1317 segment_height = td->td_imagelength - tif->tif_row;
1318 if (segment_height > td->td_rowsperstrip)
1319 segment_height = td->td_rowsperstrip;
1320 sp->bytesperline = TIFFOldScanlineSize(tif);
1321 }
1322 if (td->td_planarconfig == PLANARCONFIG_SEPARATE && s > 0) {
1323 /* for PC 2, scale down the strip/tile size
1324 * to match a downsampled component
1325 */
1326 segment_width = TIFFhowmany(segment_width, sp->h_sampling);
1327 segment_height = TIFFhowmany(segment_height, sp->v_sampling);
1328 }
1329 if (segment_width > 65535 || segment_height > 65535) {
1330 TIFFErrorExt(tif->tif_clientdata, module, "Strip/tile too large for JPEG");
1331 return (0);
1332 }
1333 sp->cinfo.c.image_width = segment_width;
1334 sp->cinfo.c.image_height = segment_height;
1335 downsampled_input = FALSE;
1336 if (td->td_planarconfig == PLANARCONFIG_CONTIG) {
1337 sp->cinfo.c.input_components = td->td_samplesperpixel;
1338 if (sp->photometric == PHOTOMETRIC_YCBCR) {
1339 if (sp->jpegcolormode == JPEGCOLORMODE_RGB) {
1340 sp->cinfo.c.in_color_space = JCS_RGB;
1341 } else {
1342 sp->cinfo.c.in_color_space = JCS_YCbCr;
1343 if (sp->h_sampling != 1 || sp->v_sampling != 1)
1344 downsampled_input = TRUE;
1345 }
1346 if (!TIFFjpeg_set_colorspace(sp, JCS_YCbCr))
1347 return (0);
1348 /*
1349 * Set Y sampling factors;
1350 * we assume jpeg_set_colorspace() set the rest to 1
1351 */
1352 sp->cinfo.c.comp_info[0].h_samp_factor = sp->h_sampling;
1353 sp->cinfo.c.comp_info[0].v_samp_factor = sp->v_sampling;
1354 } else {
1355 sp->cinfo.c.in_color_space = JCS_UNKNOWN;
1356 if (!TIFFjpeg_set_colorspace(sp, JCS_UNKNOWN))
1357 return (0);
1358 /* jpeg_set_colorspace set all sampling factors to 1 */
1359 }
1360 } else {
1361 sp->cinfo.c.input_components = 1;
1362 sp->cinfo.c.in_color_space = JCS_UNKNOWN;
1363 if (!TIFFjpeg_set_colorspace(sp, JCS_UNKNOWN))
1364 return (0);
1365 sp->cinfo.c.comp_info[0].component_id = s;
1366 /* jpeg_set_colorspace() set sampling factors to 1 */
1367 if (sp->photometric == PHOTOMETRIC_YCBCR && s > 0) {
1368 sp->cinfo.c.comp_info[0].quant_tbl_no = 1;
1369 sp->cinfo.c.comp_info[0].dc_tbl_no = 1;
1370 sp->cinfo.c.comp_info[0].ac_tbl_no = 1;
1371 }
1372 }
1373 /* ensure libjpeg won't write any extraneous markers */
1374 sp->cinfo.c.write_JFIF_header = FALSE;
1375 sp->cinfo.c.write_Adobe_marker = FALSE;
1376 /* set up table handling correctly */
1377 if (!TIFFjpeg_set_quality(sp, sp->jpegquality, FALSE))
1378 return (0);
1379 if (! (sp->jpegtablesmode & JPEGTABLESMODE_QUANT)) {
1380 unsuppress_quant_table(sp, 0);
1381 unsuppress_quant_table(sp, 1);
1382 }
1383 if (sp->jpegtablesmode & JPEGTABLESMODE_HUFF)
1384 sp->cinfo.c.optimize_coding = FALSE;
1385 else
1386 sp->cinfo.c.optimize_coding = TRUE;
1387 if (downsampled_input) {
1388 /* Need to use raw-data interface to libjpeg */
1389 sp->cinfo.c.raw_data_in = TRUE;
1390 tif->tif_encoderow = JPEGEncodeRaw;
1391 tif->tif_encodestrip = JPEGEncodeRaw;
1392 tif->tif_encodetile = JPEGEncodeRaw;
1393 } else {
1394 /* Use normal interface to libjpeg */
1395 sp->cinfo.c.raw_data_in = FALSE;
1396 tif->tif_encoderow = JPEGEncode;
1397 tif->tif_encodestrip = JPEGEncode;
1398 tif->tif_encodetile = JPEGEncode;
1399 }
1400 /* Start JPEG compressor */
1401 if (!TIFFjpeg_start_compress(sp, FALSE))
1402 return (0);
1403 /* Allocate downsampled-data buffers if needed */
1404 if (downsampled_input) {
1405 if (!alloc_downsampled_buffers(tif, sp->cinfo.c.comp_info,
1406 sp->cinfo.c.num_components))
1407 return (0);
1408 }
1409 sp->scancount = 0;
1410
1411 return (1);
1412 }
1413
1414 /*
1415 * Encode a chunk of pixels.
1416 * "Standard" case: incoming data is not downsampled.
1417 */
1418 static int
1419 JPEGEncode(TIFF* tif, tidata_t buf, tsize_t cc, tsample_t s)
1420 {
1421 JPEGState *sp = JState(tif);
1422 tsize_t nrows;
1423 JSAMPROW bufptr[1];
1424
1425 (void) s;
1426 assert(sp != NULL);
1427 /* data is expected to be supplied in multiples of a scanline */
1428 nrows = cc / sp->bytesperline;
1429 if (cc % sp->bytesperline)
1430 TIFFWarningExt(tif->tif_clientdata, tif->tif_name, "fractional scanline discarded");
1431
1432 /* The last strip will be limited to image size */
1433 if( !isTiled(tif) && tif->tif_row+nrows > tif->tif_dir.td_imagelength )
1434 nrows = tif->tif_dir.td_imagelength - tif->tif_row;
1435
1436 while (nrows-- > 0) {
1437 bufptr[0] = (JSAMPROW) buf;
1438 if (TIFFjpeg_write_scanlines(sp, bufptr, 1) != 1)
1439 return (0);
1440 if (nrows > 0)
1441 tif->tif_row++;
1442 buf += sp->bytesperline;
1443 }
1444 return (1);
1445 }
1446
1447 /*
1448 * Encode a chunk of pixels.
1449 * Incoming data is expected to be downsampled per sampling factors.
1450 */
1451 static int
1452 JPEGEncodeRaw(TIFF* tif, tidata_t buf, tsize_t cc, tsample_t s)
1453 {
1454 JPEGState *sp = JState(tif);
1455 JSAMPLE* inptr;
1456 JSAMPLE* outptr;
1457 tsize_t nrows;
1458 JDIMENSION clumps_per_line, nclump;
1459 int clumpoffset, ci, xpos, ypos;
1460 jpeg_component_info* compptr;
1461 int samples_per_clump = sp->samplesperclump;
1462 tsize_t bytesperclumpline;
1463
1464 (void) s;
1465 assert(sp != NULL);
1466 /* data is expected to be supplied in multiples of a clumpline */
1467 /* a clumpline is equivalent to v_sampling desubsampled scanlines */
1468 /* TODO: the following calculation of bytesperclumpline, should substitute calculation of sp->bytesperline, except that it is per v_sampling lines */
1469 bytesperclumpline = (((sp->cinfo.c.image_width+sp->h_sampling-1)/sp->h_sampling)
1470 *(sp->h_sampling*sp->v_sampling+2)*sp->cinfo.c.data_precision+7)
1471 /8;
1472
1473 nrows = ( cc / bytesperclumpline ) * sp->v_sampling;
1474 if (cc % bytesperclumpline)
1475 TIFFWarningExt(tif->tif_clientdata, tif->tif_name, "fractional scanline discarded");
1476
1477 /* Cb,Cr both have sampling factors 1, so this is correct */
1478 clumps_per_line = sp->cinfo.c.comp_info[1].downsampled_width;
1479
1480 while (nrows > 0) {
1481 /*
1482 * Fastest way to separate the data is to make one pass
1483 * over the scanline for each row of each component.
1484 */
1485 clumpoffset = 0; /* first sample in clump */
1486 for (ci = 0, compptr = sp->cinfo.c.comp_info;
1487 ci < sp->cinfo.c.num_components;
1488 ci++, compptr++) {
1489 int hsamp = compptr->h_samp_factor;
1490 int vsamp = compptr->v_samp_factor;
1491 int padding = (int) (compptr->width_in_blocks * DCTSIZE -
1492 clumps_per_line * hsamp);
1493 for (ypos = 0; ypos < vsamp; ypos++) {
1494 inptr = ((JSAMPLE*) buf) + clumpoffset;
1495 outptr = sp->ds_buffer[ci][sp->scancount*vsamp + ypos];
1496 if (hsamp == 1) {
1497 /* fast path for at least Cb and Cr */
1498 for (nclump = clumps_per_line; nclump-- > 0; ) {
1499 *outptr++ = inptr[0];
1500 inptr += samples_per_clump;
1501 }
1502 } else {
1503 /* general case */
1504 for (nclump = clumps_per_line; nclump-- > 0; ) {
1505 for (xpos = 0; xpos < hsamp; xpos++)
1506 *outptr++ = inptr[xpos];
1507 inptr += samples_per_clump;
1508 }
1509 }
1510 /* pad each scanline as needed */
1511 for (xpos = 0; xpos < padding; xpos++) {
1512 *outptr = outptr[-1];
1513 outptr++;
1514 }
1515 clumpoffset += hsamp;
1516 }
1517 }
1518 sp->scancount++;
1519 if (sp->scancount >= DCTSIZE) {
1520 int n = sp->cinfo.c.max_v_samp_factor * DCTSIZE;
1521 if (TIFFjpeg_write_raw_data(sp, sp->ds_buffer, n) != n)
1522 return (0);
1523 sp->scancount = 0;
1524 }
1525 tif->tif_row += sp->v_sampling;
1526 buf += sp->bytesperline;
1527 nrows -= sp->v_sampling;
1528 }
1529 return (1);
1530 }
1531
1532 /*
1533 * Finish up at the end of a strip or tile.
1534 */
1535 static int
1536 JPEGPostEncode(TIFF* tif)
1537 {
1538 JPEGState *sp = JState(tif);
1539
1540 if (sp->scancount > 0) {
1541 /*
1542 * Need to emit a partial bufferload of downsampled data.
1543 * Pad the data vertically.
1544 */
1545 int ci, ypos, n;
1546 jpeg_component_info* compptr;
1547
1548 for (ci = 0, compptr = sp->cinfo.c.comp_info;
1549 ci < sp->cinfo.c.num_components;
1550 ci++, compptr++) {
1551 int vsamp = compptr->v_samp_factor;
1552 tsize_t row_width = compptr->width_in_blocks * DCTSIZE
1553 * sizeof(JSAMPLE);
1554 for (ypos = sp->scancount * vsamp;
1555 ypos < DCTSIZE * vsamp; ypos++) {
1556 _TIFFmemcpy((tdata_t)sp->ds_buffer[ci][ypos],
1557 (tdata_t)sp->ds_buffer[ci][ypos-1],
1558 row_width);
1559
1560 }
1561 }
1562 n = sp->cinfo.c.max_v_samp_factor * DCTSIZE;
1563 if (TIFFjpeg_write_raw_data(sp, sp->ds_buffer, n) != n)
1564 return (0);
1565 }
1566
1567 return (TIFFjpeg_finish_compress(JState(tif)));
1568 }
1569
1570 static void
1571 JPEGCleanup(TIFF* tif)
1572 {
1573 JPEGState *sp = JState(tif);
1574
1575 assert(sp != 0);
1576
1577 tif->tif_tagmethods.vgetfield = sp->vgetparent;
1578 tif->tif_tagmethods.vsetfield = sp->vsetparent;
1579 tif->tif_tagmethods.printdir = sp->printdir;
1580
1581 if( sp->cinfo_initialized )
1582 TIFFjpeg_destroy(sp); /* release libjpeg resources */
1583 if (sp->jpegtables) /* tag value */
1584 _TIFFfree(sp->jpegtables);
1585 _TIFFfree(tif->tif_data); /* release local state */
1586 tif->tif_data = NULL;
1587
1588 _TIFFSetDefaultCompressionState(tif);
1589 }
1590
1591 static void
1592 JPEGResetUpsampled( TIFF* tif )
1593 {
1594 JPEGState* sp = JState(tif);
1595 TIFFDirectory* td = &tif->tif_dir;
1596
1597 /*
1598 * Mark whether returned data is up-sampled or not so TIFFStripSize
1599 * and TIFFTileSize return values that reflect the true amount of
1600 * data.
1601 */
1602 tif->tif_flags &= ~TIFF_UPSAMPLED;
1603 if (td->td_planarconfig == PLANARCONFIG_CONTIG) {
1604 if (td->td_photometric == PHOTOMETRIC_YCBCR &&
1605 sp->jpegcolormode == JPEGCOLORMODE_RGB) {
1606 tif->tif_flags |= TIFF_UPSAMPLED;
1607 } else {
1608 #ifdef notdef
1609 if (td->td_ycbcrsubsampling[0] != 1 ||
1610 td->td_ycbcrsubsampling[1] != 1)
1611 ; /* XXX what about up-sampling? */
1612 #endif
1613 }
1614 }
1615
1616 /*
1617 * Must recalculate cached tile size in case sampling state changed.
1618 * Should we really be doing this now if image size isn't set?
1619 */
1620 if( tif->tif_tilesize > 0 )
1621 tif->tif_tilesize = isTiled(tif) ? TIFFTileSize(tif) : (tsize_t) -1;
1622
1623 if(tif->tif_scanlinesize > 0 )
1624 tif->tif_scanlinesize = TIFFScanlineSize(tif);
1625 }
1626
1627 static int
1628 JPEGVSetField(TIFF* tif, ttag_t tag, va_list ap)
1629 {
1630 JPEGState* sp = JState(tif);
1631 const TIFFFieldInfo* fip;
1632 uint32 v32;
1633
1634 assert(sp != NULL);
1635
1636 switch (tag) {
1637 case TIFFTAG_JPEGTABLES:
1638 v32 = va_arg(ap, uint32);
1639 if (v32 == 0) {
1640 /* XXX */
1641 return (0);
1642 }
1643 _TIFFsetByteArray(&sp->jpegtables, va_arg(ap, void*),
1644 (long) v32);
1645 sp->jpegtables_length = v32;
1646 TIFFSetFieldBit(tif, FIELD_JPEGTABLES);
1647 break;
1648 case TIFFTAG_JPEGQUALITY:
1649 sp->jpegquality = va_arg(ap, int);
1650 return (1); /* pseudo tag */
1651 case TIFFTAG_JPEGCOLORMODE:
1652 sp->jpegcolormode = va_arg(ap, int);
1653 JPEGResetUpsampled( tif );
1654 return (1); /* pseudo tag */
1655 case TIFFTAG_PHOTOMETRIC:
1656 {
1657 int ret_value = (*sp->vsetparent)(tif, tag, ap);
1658 JPEGResetUpsampled( tif );
1659 return ret_value;
1660 }
1661 case TIFFTAG_JPEGTABLESMODE:
1662 sp->jpegtablesmode = va_arg(ap, int);
1663 return (1); /* pseudo tag */
1664 case TIFFTAG_YCBCRSUBSAMPLING:
1665 /* mark the fact that we have a real ycbcrsubsampling! */
1666 sp->ycbcrsampling_fetched = 1;
1667 /* should we be recomputing upsampling info here? */
1668 return (*sp->vsetparent)(tif, tag, ap);
1669 case TIFFTAG_FAXRECVPARAMS:
1670 sp->recvparams = va_arg(ap, uint32);
1671 break;
1672 case TIFFTAG_FAXSUBADDRESS:
1673 _TIFFsetString(&sp->subaddress, va_arg(ap, char*));
1674 break;
1675 case TIFFTAG_FAXRECVTIME:
1676 sp->recvtime = va_arg(ap, uint32);
1677 break;
1678 case TIFFTAG_FAXDCS:
1679 _TIFFsetString(&sp->faxdcs, va_arg(ap, char*));
1680 break;
1681 default:
1682 return (*sp->vsetparent)(tif, tag, ap);
1683 }
1684
1685 if ((fip = _TIFFFieldWithTag(tif, tag))) {
1686 TIFFSetFieldBit(tif, fip->field_bit);
1687 } else {
1688 return (0);
1689 }
1690
1691 tif->tif_flags |= TIFF_DIRTYDIRECT;
1692 return (1);
1693 }
1694
1695 /*
1696 * Some JPEG-in-TIFF produces do not emit the YCBCRSUBSAMPLING values in
1697 * the TIFF tags, but still use non-default (2,2) values within the jpeg
1698 * data stream itself. In order for TIFF applications to work properly
1699 * - for instance to get the strip buffer size right - it is imperative
1700 * that the subsampling be available before we start reading the image
1701 * data normally. This function will attempt to load the first strip in
1702 * order to get the sampling values from the jpeg data stream. Various
1703 * hacks are various places are done to ensure this function gets called
1704 * before the td_ycbcrsubsampling values are used from the directory structure,
1705 * including calling TIFFGetField() for the YCBCRSUBSAMPLING field from
1706 * TIFFStripSize(), and the printing code in tif_print.c.
1707 *
1708 * Note that JPEGPreDeocode() will produce a fairly loud warning when the
1709 * discovered sampling does not match the default sampling (2,2) or whatever
1710 * was actually in the tiff tags.
1711 *
1712 * Problems:
1713 * o This code will cause one whole strip/tile of compressed data to be
1714 * loaded just to get the tags right, even if the imagery is never read.
1715 * It would be more efficient to just load a bit of the header, and
1716 * initialize things from that.
1717 *
1718 * See the bug in bugzilla for details:
1719 *
1720 * http://bugzilla.remotesensing.org/show_bug.cgi?id=168
1721 *
1722 * Frank Warmerdam, July 2002
1723 */
1724
1725 static void
1726 JPEGFixupTestSubsampling( TIFF * tif )
1727 {
1728 #ifdef CHECK_JPEG_YCBCR_SUBSAMPLING
1729 JPEGState *sp = JState(tif);
1730 TIFFDirectory *td = &tif->tif_dir;
1731
1732 JPEGInitializeLibJPEG( tif, 0, 0 );
1733
1734 /*
1735 * Some JPEG-in-TIFF files don't provide the ycbcrsampling tags,
1736 * and use a sampling schema other than the default 2,2. To handle
1737 * this we actually have to scan the header of a strip or tile of
1738 * jpeg data to get the sampling.
1739 */
1740 if( !sp->cinfo.comm.is_decompressor
1741 || sp->ycbcrsampling_fetched
1742 || td->td_photometric != PHOTOMETRIC_YCBCR )
1743 return;
1744
1745 sp->ycbcrsampling_fetched = 1;
1746 if( TIFFIsTiled( tif ) )
1747 {
1748 if( !TIFFFillTile( tif, 0 ) )
1749 return;
1750 }
1751 else
1752 {
1753 if( !TIFFFillStrip( tif, 0 ) )
1754 return;
1755 }
1756
1757 TIFFSetField( tif, TIFFTAG_YCBCRSUBSAMPLING,
1758 (uint16) sp->h_sampling, (uint16) sp->v_sampling );
1759
1760 /*
1761 ** We want to clear the loaded strip so the application has time
1762 ** to set JPEGCOLORMODE or other behavior modifiers. This essentially
1763 ** undoes the JPEGPreDecode triggers by TIFFFileStrip(). (#1936)
1764 */
1765 tif->tif_curstrip = -1;
1766
1767 #endif /* CHECK_JPEG_YCBCR_SUBSAMPLING */
1768 }
1769
1770 static int
1771 JPEGVGetField(TIFF* tif, ttag_t tag, va_list ap)
1772 {
1773 JPEGState* sp = JState(tif);
1774
1775 assert(sp != NULL);
1776
1777 switch (tag) {
1778 case TIFFTAG_JPEGTABLES:
1779 *va_arg(ap, uint32*) = sp->jpegtables_length;
1780 *va_arg(ap, void**) = sp->jpegtables;
1781 break;
1782 case TIFFTAG_JPEGQUALITY:
1783 *va_arg(ap, int*) = sp->jpegquality;
1784 break;
1785 case TIFFTAG_JPEGCOLORMODE:
1786 *va_arg(ap, int*) = sp->jpegcolormode;
1787 break;
1788 case TIFFTAG_JPEGTABLESMODE:
1789 *va_arg(ap, int*) = sp->jpegtablesmode;
1790 break;
1791 case TIFFTAG_YCBCRSUBSAMPLING:
1792 JPEGFixupTestSubsampling( tif );
1793 return (*sp->vgetparent)(tif, tag, ap);
1794 case TIFFTAG_FAXRECVPARAMS:
1795 *va_arg(ap, uint32*) = sp->recvparams;
1796 break;
1797 case TIFFTAG_FAXSUBADDRESS:
1798 *va_arg(ap, char**) = sp->subaddress;
1799 break;
1800 case TIFFTAG_FAXRECVTIME:
1801 *va_arg(ap, uint32*) = sp->recvtime;
1802 break;
1803 case TIFFTAG_FAXDCS:
1804 *va_arg(ap, char**) = sp->faxdcs;
1805 break;
1806 default:
1807 return (*sp->vgetparent)(tif, tag, ap);
1808 }
1809 return (1);
1810 }
1811
1812 static void
1813 JPEGPrintDir(TIFF* tif, FILE* fd, long flags)
1814 {
1815 JPEGState* sp = JState(tif);
1816
1817 assert(sp != NULL);
1818
1819 (void) flags;
1820 if (TIFFFieldSet(tif,FIELD_JPEGTABLES))
1821 fprintf(fd, " JPEG Tables: (%lu bytes)\n",
1822 (unsigned long) sp->jpegtables_length);
1823 if (TIFFFieldSet(tif,FIELD_RECVPARAMS))
1824 fprintf(fd, " Fax Receive Parameters: %08lx\n",
1825 (unsigned long) sp->recvparams);
1826 if (TIFFFieldSet(tif,FIELD_SUBADDRESS))
1827 fprintf(fd, " Fax SubAddress: %s\n", sp->subaddress);
1828 if (TIFFFieldSet(tif,FIELD_RECVTIME))
1829 fprintf(fd, " Fax Receive Time: %lu secs\n",
1830 (unsigned long) sp->recvtime);
1831 if (TIFFFieldSet(tif,FIELD_FAXDCS))
1832 fprintf(fd, " Fax DCS: %s\n", sp->faxdcs);
1833 }
1834
1835 static uint32
1836 JPEGDefaultStripSize(TIFF* tif, uint32 s)
1837 {
1838 JPEGState* sp = JState(tif);
1839 TIFFDirectory *td = &tif->tif_dir;
1840
1841 s = (*sp->defsparent)(tif, s);
1842 if (s < td->td_imagelength)
1843 s = TIFFroundup(s, td->td_ycbcrsubsampling[1] * DCTSIZE);
1844 return (s);
1845 }
1846
1847 static void
1848 JPEGDefaultTileSize(TIFF* tif, uint32* tw, uint32* th)
1849 {
1850 JPEGState* sp = JState(tif);
1851 TIFFDirectory *td = &tif->tif_dir;
1852
1853 (*sp->deftparent)(tif, tw, th);
1854 *tw = TIFFroundup(*tw, td->td_ycbcrsubsampling[0] * DCTSIZE);
1855 *th = TIFFroundup(*th, td->td_ycbcrsubsampling[1] * DCTSIZE);
1856 }
1857
1858 /*
1859 * The JPEG library initialized used to be done in TIFFInitJPEG(), but
1860 * now that we allow a TIFF file to be opened in update mode it is necessary
1861 * to have some way of deciding whether compression or decompression is
1862 * desired other than looking at tif->tif_mode. We accomplish this by
1863 * examining {TILE/STRIP}BYTECOUNTS to see if there is a non-zero entry.
1864 * If so, we assume decompression is desired.
1865 *
1866 * This is tricky, because TIFFInitJPEG() is called while the directory is
1867 * being read, and generally speaking the BYTECOUNTS tag won't have been read
1868 * at that point. So we try to defer jpeg library initialization till we
1869 * do have that tag ... basically any access that might require the compressor
1870 * or decompressor that occurs after the reading of the directory.
1871 *
1872 * In an ideal world compressors or decompressors would be setup
1873 * at the point where a single tile or strip was accessed (for read or write)
1874 * so that stuff like update of missing tiles, or replacement of tiles could
1875 * be done. However, we aren't trying to crack that nut just yet ...
1876 *
1877 * NFW, Feb 3rd, 2003.
1878 */
1879
1880 static int JPEGInitializeLibJPEG( TIFF * tif, int force_encode, int force_decode )
1881 {
1882 JPEGState* sp = JState(tif);
1883 uint32 *byte_counts = NULL;
1884 int data_is_empty = TRUE;
1885 int decompress;
1886
1887
1888 if(sp->cinfo_initialized)
1889 {
1890 if( force_encode && sp->cinfo.comm.is_decompressor )
1891 TIFFjpeg_destroy( sp );
1892 else if( force_decode && !sp->cinfo.comm.is_decompressor )
1893 TIFFjpeg_destroy( sp );
1894 else
1895 return 1;
1896
1897 sp->cinfo_initialized = 0;
1898 }
1899
1900 /*
1901 * Do we have tile data already? Make sure we initialize the
1902 * the state in decompressor mode if we have tile data, even if we
1903 * are not in read-only file access mode.
1904 */
1905 if( TIFFIsTiled( tif )
1906 && TIFFGetField( tif, TIFFTAG_TILEBYTECOUNTS, &byte_counts )
1907 && byte_counts != NULL )
1908 {
1909 data_is_empty = byte_counts[0] == 0;
1910 }
1911 if( !TIFFIsTiled( tif )
1912 && TIFFGetField( tif, TIFFTAG_STRIPBYTECOUNTS, &byte_counts)
1913 && byte_counts != NULL )
1914 {
1915 data_is_empty = byte_counts[0] == 0;
1916 }
1917
1918 if( force_decode )
1919 decompress = 1;
1920 else if( force_encode )
1921 decompress = 0;
1922 else if( tif->tif_mode == O_RDONLY )
1923 decompress = 1;
1924 else if( data_is_empty )
1925 decompress = 0;
1926 else
1927 decompress = 1;
1928
1929 /*
1930 * Initialize libjpeg.
1931 */
1932 if ( decompress ) {
1933 if (!TIFFjpeg_create_decompress(sp))
1934 return (0);
1935
1936 } else {
1937 if (!TIFFjpeg_create_compress(sp))
1938 return (0);
1939 }
1940
1941 sp->cinfo_initialized = TRUE;
1942
1943 return 1;
1944 }
1945
1946 int
1947 TIFFInitJPEG(TIFF* tif, int scheme)
1948 {
1949 JPEGState* sp;
1950
1951 assert(scheme == COMPRESSION_JPEG);
1952
1953 /*
1954 * Merge codec-specific tag information.
1955 */
1956 if (!_TIFFMergeFieldInfo(tif, jpegFieldInfo, N(jpegFieldInfo))) {
1957 TIFFErrorExt(tif->tif_clientdata,
1958 "TIFFInitJPEG",
1959 "Merging JPEG codec-specific tags failed");
1960 return 0;
1961 }
1962
1963 /*
1964 * Allocate state block so tag methods have storage to record values.
1965 */
1966 tif->tif_data = (tidata_t) _TIFFmalloc(sizeof (JPEGState));
1967
1968 if (tif->tif_data == NULL) {
1969 TIFFErrorExt(tif->tif_clientdata,
1970 "TIFFInitJPEG", "No space for JPEG state block");
1971 return 0;
1972 }
1973 _TIFFmemset(tif->tif_data, 0, sizeof(JPEGState));
1974
1975 sp = JState(tif);
1976 sp->tif = tif; /* back link */
1977
1978 /*
1979 * Override parent get/set field methods.
1980 */
1981 sp->vgetparent = tif->tif_tagmethods.vgetfield;
1982 tif->tif_tagmethods.vgetfield = JPEGVGetField; /* hook for codec tags */
1983 sp->vsetparent = tif->tif_tagmethods.vsetfield;
1984 tif->tif_tagmethods.vsetfield = JPEGVSetField; /* hook for codec tags */
1985 sp->printdir = tif->tif_tagmethods.printdir;
1986 tif->tif_tagmethods.printdir = JPEGPrintDir; /* hook for codec tags */
1987
1988 /* Default values for codec-specific fields */
1989 sp->jpegtables = NULL;
1990 sp->jpegtables_length = 0;
1991 sp->jpegquality = 75; /* Default IJG quality */
1992 sp->jpegcolormode = JPEGCOLORMODE_RAW;
1993 sp->jpegtablesmode = JPEGTABLESMODE_QUANT | JPEGTABLESMODE_HUFF;
1994
1995 sp->recvparams = 0;
1996 sp->subaddress = NULL;
1997 sp->faxdcs = NULL;
1998
1999 sp->ycbcrsampling_fetched = 0;
2000
2001 /*
2002 * Install codec methods.
2003 */
2004 tif->tif_setupdecode = JPEGSetupDecode;
2005 tif->tif_predecode = JPEGPreDecode;
2006 tif->tif_decoderow = JPEGDecode;
2007 tif->tif_decodestrip = JPEGDecode;
2008 tif->tif_decodetile = JPEGDecode;
2009 tif->tif_setupencode = JPEGSetupEncode;
2010 tif->tif_preencode = JPEGPreEncode;
2011 tif->tif_postencode = JPEGPostEncode;
2012 tif->tif_encoderow = JPEGEncode;
2013 tif->tif_encodestrip = JPEGEncode;
2014 tif->tif_encodetile = JPEGEncode;
2015 tif->tif_cleanup = JPEGCleanup;
2016 sp->defsparent = tif->tif_defstripsize;
2017 tif->tif_defstripsize = JPEGDefaultStripSize;
2018 sp->deftparent = tif->tif_deftilesize;
2019 tif->tif_deftilesize = JPEGDefaultTileSize;
2020 tif->tif_flags |= TIFF_NOBITREV; /* no bit reversal, please */
2021
2022 sp->cinfo_initialized = FALSE;
2023
2024 /*
2025 ** Create a JPEGTables field if no directory has yet been created.
2026 ** We do this just to ensure that sufficient space is reserved for
2027 ** the JPEGTables field. It will be properly created the right
2028 ** size later.
2029 */
2030 if( tif->tif_diroff == 0 )
2031 {
2032 #define SIZE_OF_JPEGTABLES 2000
2033 /*
2034 The following line assumes incorrectly that all JPEG-in-TIFF files will have
2035 a JPEGTABLES tag generated and causes null-filled JPEGTABLES tags to be written
2036 when the JPEG data is placed with TIFFWriteRawStrip. The field bit should be
2037 set, anyway, later when actual JPEGTABLES header is generated, so removing it
2038 here hopefully is harmless.
2039 TIFFSetFieldBit(tif, FIELD_JPEGTABLES);
2040 */
2041 sp->jpegtables_length = SIZE_OF_JPEGTABLES;
2042 sp->jpegtables = (void *) _TIFFmalloc(sp->jpegtables_length);
2043 _TIFFmemset(sp->jpegtables, 0, SIZE_OF_JPEGTABLES);
2044 #undef SIZE_OF_JPEGTABLES
2045 }
2046
2047 /*
2048 * Mark the TIFFTAG_YCBCRSAMPLES as present even if it is not
2049 * see: JPEGFixupTestSubsampling().
2050 */
2051 TIFFSetFieldBit( tif, FIELD_YCBCRSUBSAMPLING );
2052
2053 return 1;
2054 }
2055 #endif /* JPEG_SUPPORT */
2056
2057 /* vim: set ts=8 sts=8 sw=8 noet: */
2058
2059 /*
2060 * Local Variables:
2061 * mode: c
2062 * c-basic-offset: 8
2063 * fill-column: 78
2064 * End:
2065 */
A free Windows-compatible Operating System