]> git.saurik.com Git - wxWidgets.git/blame - src/tiff/tif_ojpeg.c
projects / wxWidgets.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
removed hard tabs
[wxWidgets.git] / src / tiff / tif_ojpeg.c
CommitLineData
7da02538
VZ		 1#include "tiffiop.h"
2#ifdef OJPEG_SUPPORT
3
4/* JPEG Compression support, as per the original TIFF 6.0 specification.
5
6 WARNING: KLUDGE ALERT! The type of JPEG encapsulation defined by the TIFF
7 Version 6.0 specification is now totally obsolete and
8 deprecated for new applications and images. This file is an unsupported hack
9 that was created solely in order to read (but NOT write!) a few old,
10 unconverted images still present on some users' computer systems. The code
11 isn't pretty or robust, and it won't read every "old format" JPEG-in-TIFF
12 file (see Samuel Leffler's draft "TIFF Technical Note No. 2" for a long and
13 incomplete list of known problems), but it seems to work well enough in the
14 few cases of practical interest to the author; so, "caveat emptor"! This
15 file should NEVER be enhanced to write new images using anything other than
16 the latest approved JPEG-in-TIFF encapsulation method, implemented by the
17 "tif_jpeg.c" file elsewhere in this library.
18
19 This file interfaces with Release 6B of the JPEG Library written by theu
20 Independent JPEG Group, which you can find on the Internet at:
21 ftp://ftp.uu.net:/graphics/jpeg/.
22
23 The "C" Preprocessor macros, "[CD]_LOSSLESS_SUPPORTED", are defined by your
24 JPEG Library Version 6B only if you have applied a (massive!) patch by Ken
25 Murchison of Oceana Matrix Ltd. <ken@oceana.com> to support lossless Huffman
26 encoding (TIFF "JPEGProc" tag value = 14). This patch can be found on the
27 Internet at: ftp://ftp.oceana.com/pub/ljpeg-6b.tar.gz.
28
29 Some old files produced by the Wang Imaging application for Microsoft Windows
30 apparently can be decoded only with a special patch to the JPEG Library,
31 which defines a subroutine named "jpeg_reset_huff_decode()" in its "jdhuff.c"
32 module (the "jdshuff.c" module, if Ken Murchison's patch has been applied).
33 Unfortunately the patch differs slightly in each case, and some TIFF Library
34 have reported problems finding the code, so both versions appear below; you
35 should carefully extract and apply only the version that applies to your JPEG
36 Library!
37
38 Contributed by Scott Marovich <marovich@hpl.hp.com> with considerable help
39 from Charles Auer <Bumble731@msn.com> to unravel the mysteries of image files
40 created by the Wang Imaging application for Microsoft Windows.
41*/
42#if 0 /* Patch for JPEG Library WITHOUT lossless Huffman coding */
43*** jdhuff.c.orig Mon Oct 20 17:51:10 1997
44--- jdhuff.c Sun Nov 11 17:33:58 2001
45***************
46*** 648,651 ****
47--- 648,683 ----
48 for (i = 0; i < NUM_HUFF_TBLS; i++) {
49 entropy->dc_derived_tbls[i] = entropy->ac_derived_tbls[i] = NULL;
50 }
51 }
52+
53+ /*
54+ * BEWARE OF KLUDGE: This subroutine is a hack for decoding illegal JPEG-in-
55+ * TIFF encapsulations produced by Microsoft's Wang Imaging
56+ * for Windows application with the public-domain TIFF Library. Based upon an
57+ * examination of selected output files, this program apparently divides a JPEG
58+ * bit-stream into consecutive horizontal TIFF "strips", such that the JPEG
59+ * encoder's/decoder's DC coefficients for each image component are reset before
60+ * each "strip". Moreover, a "strip" is not necessarily encoded in a multiple
61+ * of 8 bits, so one must sometimes discard 1-7 bits at the end of each "strip"
62+ * for alignment to the next input-Byte storage boundary. IJG JPEG Library
63+ * decoder state is not normally exposed to client applications, so this sub-
64+ * routine provides the TIFF Library with a "hook" to make these corrections.
65+ * It should be called after "jpeg_start_decompress()" and before
66+ * "jpeg_finish_decompress()", just before decoding each "strip" using
67+ * "jpeg_read_raw_data()" or "jpeg_read_scanlines()".
68+ *
69+ * This kludge is not sanctioned or supported by the Independent JPEG Group, and
70+ * future changes to the IJG JPEG Library might invalidate it. Do not send bug
71+ * reports about this code to IJG developers. Instead, contact the author for
72+ * advice: Scott B. Marovich <marovich@hpl.hp.com>, Hewlett-Packard Labs, 6/01.
73+ */
74+ GLOBAL(void)
75+ jpeg_reset_huff_decode (register j_decompress_ptr cinfo)
76+ { register huff_entropy_ptr entropy = (huff_entropy_ptr)cinfo->entropy;
77+ register int ci = 0;
78+
79+ /* Discard encoded input bits, up to the next Byte boundary */
80+ entropy->bitstate.bits_left &= ~7;
81+ /* Re-initialize DC predictions to 0 */
82+ do entropy->saved.last_dc_val[ci] = 0; while (++ci < cinfo->comps_in_scan);
83+ }
84#endif /* Patch for JPEG Library WITHOUT lossless Huffman coding */
85#if 0 /* Patch for JPEG Library WITH lossless Huffman coding */
86*** jdshuff.c.orig Mon Mar 11 16:44:54 2002
87--- jdshuff.c Mon Mar 11 16:44:54 2002
88***************
89*** 357,360 ****
90--- 357,393 ----
91 for (i = 0; i < NUM_HUFF_TBLS; i++) {
92 entropy->dc_derived_tbls[i] = entropy->ac_derived_tbls[i] = NULL;
93 }
94 }
95+
96+ /*
97+ * BEWARE OF KLUDGE: This subroutine is a hack for decoding illegal JPEG-in-
98+ * TIFF encapsulations produced by Microsoft's Wang Imaging
99+ * for Windows application with the public-domain TIFF Library. Based upon an
100+ * examination of selected output files, this program apparently divides a JPEG
101+ * bit-stream into consecutive horizontal TIFF "strips", such that the JPEG
102+ * encoder's/decoder's DC coefficients for each image component are reset before
103+ * each "strip". Moreover, a "strip" is not necessarily encoded in a multiple
104+ * of 8 bits, so one must sometimes discard 1-7 bits at the end of each "strip"
105+ * for alignment to the next input-Byte storage boundary. IJG JPEG Library
106+ * decoder state is not normally exposed to client applications, so this sub-
107+ * routine provides the TIFF Library with a "hook" to make these corrections.
108+ * It should be called after "jpeg_start_decompress()" and before
109+ * "jpeg_finish_decompress()", just before decoding each "strip" using
110+ * "jpeg_read_raw_data()" or "jpeg_read_scanlines()".
111+ *
112+ * This kludge is not sanctioned or supported by the Independent JPEG Group, and
113+ * future changes to the IJG JPEG Library might invalidate it. Do not send bug
114+ * reports about this code to IJG developers. Instead, contact the author for
115+ * advice: Scott B. Marovich <marovich@hpl.hp.com>, Hewlett-Packard Labs, 6/01.
116+ */
117+ GLOBAL(void)
118+ jpeg_reset_huff_decode (register j_decompress_ptr cinfo)
119+ { register shuff_entropy_ptr entropy = (shuff_entropy_ptr)
120+ ((j_lossy_d_ptr)cinfo->codec)->entropy_private;
121+ register int ci = 0;
122+
123+ /* Discard encoded input bits, up to the next Byte boundary */
124+ entropy->bitstate.bits_left &= ~7;
125+ /* Re-initialize DC predictions to 0 */
126+ do entropy->saved.last_dc_val[ci] = 0; while (++ci < cinfo->comps_in_scan);
127+ }
128#endif /* Patch for JPEG Library WITH lossless Huffman coding */
129#include <setjmp.h>
130#include <stdio.h>
131#ifdef FAR
132#undef FAR /* Undefine FAR to avoid conflict with JPEG definition */
133#endif
134#define JPEG_INTERNALS /* Include "jpegint.h" for "DSTATE_*" symbols */
135#define JPEG_CJPEG_DJPEG /* Include all Version 6B+ "jconfig.h" options */
136#undef INLINE
137#include "jpeglib.h"
138#undef JPEG_CJPEG_DJPEG
139#undef JPEG_INTERNALS
140
141/* Hack for files produced by Wang Imaging application on Microsoft Windows */
142extern void jpeg_reset_huff_decode(j_decompress_ptr);
143
144/* On some machines, it may be worthwhile to use "_setjmp()" or "sigsetjmp()"
145 instead of "setjmp()". These macros make it easier:
146*/
147#define SETJMP(jbuf)setjmp(jbuf)
148#define LONGJMP(jbuf,code)longjmp(jbuf,code)
149#define JMP_BUF jmp_buf
150
151#define TIFFTAG_WANG_PAGECONTROL 32934
152
153/* Bit-vector offsets for keeping track of TIFF records that we've parsed. */
154
155#define FIELD_JPEGPROC FIELD_CODEC
156#define FIELD_JPEGIFOFFSET (FIELD_CODEC+1)
157#define FIELD_JPEGIFBYTECOUNT (FIELD_CODEC+2)
158#define FIELD_JPEGRESTARTINTERVAL (FIELD_CODEC+3)
159#define FIELD_JPEGTABLES (FIELD_CODEC+4) /* New, post-6.0 JPEG-in-TIFF tag! */
160#define FIELD_JPEGLOSSLESSPREDICTORS (FIELD_CODEC+5)
161#define FIELD_JPEGPOINTTRANSFORM (FIELD_CODEC+6)
162#define FIELD_JPEGQTABLES (FIELD_CODEC+7)
163#define FIELD_JPEGDCTABLES (FIELD_CODEC+8)
164#define FIELD_JPEGACTABLES (FIELD_CODEC+9)
165#define FIELD_WANG_PAGECONTROL (FIELD_CODEC+10)
166#define FIELD_JPEGCOLORMODE (FIELD_CODEC+11)
167
168typedef struct jpeg_destination_mgr jpeg_destination_mgr;
169typedef struct jpeg_source_mgr jpeg_source_mgr;
170typedef struct jpeg_error_mgr jpeg_error_mgr;
171
172/* State variable for each open TIFF file that uses "libjpeg" for JPEG
173 decompression. (Note: This file should NEVER perform JPEG compression
174 except in the manner implemented by the "tif_jpeg.c" file, elsewhere in this
175 library; see comments above.) JPEG Library internal state is recorded in a
176 "jpeg_{de}compress_struct", while a "jpeg_common_struct" records a few items
177 common to both compression and expansion. The "cinfo" field containing JPEG
178 Library state MUST be the 1st member of our own state variable, so that we
179 can safely "cast" pointers back and forth.
180*/
181typedef struct /* This module's private, per-image state variable */
182 {
183 union /* JPEG Library state variable; this MUST be our 1st field! */
184 {
185 struct jpeg_compress_struct c;
186 struct jpeg_decompress_struct d;
187 struct jpeg_common_struct comm;
188 } cinfo;
189 jpeg_error_mgr err; /* JPEG Library error manager */
190 JMP_BUF exit_jmpbuf; /* ...for catching JPEG Library failures */
191# ifdef never
192
193 /* (The following two fields could be a "union", but they're small enough that
194 it's not worth the effort.)
195 */
196 jpeg_destination_mgr dest; /* Destination for compressed data */
197# endif
198 jpeg_source_mgr src; /* Source of expanded data */
199 JSAMPARRAY ds_buffer[MAX_COMPONENTS]; /* ->Temporary downsampling buffers */
200 TIFF *tif; /* Reverse pointer, needed by some code */
201 TIFFVGetMethod vgetparent; /* "Super class" methods... */
202 TIFFVSetMethod vsetparent;
203 TIFFStripMethod defsparent;
204 TIFFTileMethod deftparent;
205 void *jpegtables; /* ->"New" JPEG tables, if we synthesized any */
206 uint32 is_WANG, /* <=> Wang Imaging for Microsoft Windows output file? */
207 jpegtables_length; /* Length of "new" JPEG tables, if they exist */
208 tsize_t bytesperline; /* No. of decompressed Bytes per scan line */
209 int jpegquality, /* Compression quality level */
210 jpegtablesmode, /* What to put in JPEGTables */
211 samplesperclump,
212 scancount; /* No. of scan lines accumulated */
213 J_COLOR_SPACE photometric; /* IJG JPEG Library's photometry code */
214 u_char h_sampling, /* Luminance sampling factors */
215 v_sampling,
216 jpegcolormode; /* Who performs RGB <-> YCbCr conversion? */
217 /* JPEGCOLORMODE_RAW <=> TIFF Library or its client */
218 /* JPEGCOLORMODE_RGB <=> JPEG Library */
219 /* These fields are added to support TIFFGetField */
220 uint16 jpegproc;
221 uint32 jpegifoffset;
222 uint32 jpegifbytecount;
223 uint32 jpegrestartinterval;
224 void* jpeglosslesspredictors;
225 uint16 jpeglosslesspredictors_length;
226 void* jpegpointtransform;
227 uint32 jpegpointtransform_length;
228 void* jpegqtables;
229 uint32 jpegqtables_length;
230 void* jpegdctables;
231 uint32 jpegdctables_length;
232 void* jpegactables;
233 uint32 jpegactables_length;
234
235 } OJPEGState;
236#define OJState(tif)((OJPEGState*)(tif)->tif_data)
237
238static const TIFFFieldInfo ojpegFieldInfo[]=/* JPEG-specific TIFF-record tags */
239 {
240
241 /* This is the current JPEG-in-TIFF metadata-encapsulation tag, and its
242 treatment in this file is idiosyncratic. It should never appear in a
243 "source" image conforming to the TIFF Version 6.0 specification, so we
244 arrange to report an error if it appears. But in order to support possible
245 future conversion of "old" JPEG-in-TIFF encapsulations to "new" ones, we
246 might wish to synthesize an equivalent value to be returned by the TIFF
247 Library's "getfield" method. So, this table tells the TIFF Library to pass
248 these records to us in order to filter them below.
249 */
250 {
251 TIFFTAG_JPEGTABLES ,TIFF_VARIABLE,TIFF_VARIABLE,
252 TIFF_UNDEFINED,FIELD_JPEGTABLES ,FALSE,TRUE ,"JPEGTables"
253 },
254
255 /* These tags are defined by the TIFF Version 6.0 specification and are now
256 obsolete. This module reads them from an old "source" image, but it never
257 writes them to a new "destination" image.
258 */
259 {
260 TIFFTAG_JPEGPROC ,1 ,1 ,
261 TIFF_SHORT ,FIELD_JPEGPROC ,FALSE,FALSE,"JPEGProc"
262 },
263 {
264 TIFFTAG_JPEGIFOFFSET ,1 ,1 ,
265 TIFF_LONG ,FIELD_JPEGIFOFFSET ,FALSE,FALSE,"JPEGInterchangeFormat"
266 },
267 {
268 TIFFTAG_JPEGIFBYTECOUNT ,1 ,1 ,
269 TIFF_LONG ,FIELD_JPEGIFBYTECOUNT ,FALSE,FALSE,"JPEGInterchangeFormatLength"
270 },
271 {
272 TIFFTAG_JPEGRESTARTINTERVAL ,1 ,1 ,
273 TIFF_SHORT ,FIELD_JPEGRESTARTINTERVAL ,FALSE,FALSE,"JPEGRestartInterval"
274 },
275 {
276 TIFFTAG_JPEGLOSSLESSPREDICTORS,TIFF_VARIABLE,TIFF_VARIABLE,
277 TIFF_SHORT ,FIELD_JPEGLOSSLESSPREDICTORS,FALSE,TRUE ,"JPEGLosslessPredictors"
278 },
279 {
280 TIFFTAG_JPEGPOINTTRANSFORM ,TIFF_VARIABLE,TIFF_VARIABLE,
281 TIFF_SHORT ,FIELD_JPEGPOINTTRANSFORM ,FALSE,TRUE ,"JPEGPointTransforms"
282 },
283 {
284 TIFFTAG_JPEGQTABLES ,TIFF_VARIABLE,TIFF_VARIABLE,
285 TIFF_LONG ,FIELD_JPEGQTABLES ,FALSE,TRUE ,"JPEGQTables"
286 },
287 {
288 TIFFTAG_JPEGDCTABLES ,TIFF_VARIABLE,TIFF_VARIABLE,
289 TIFF_LONG ,FIELD_JPEGDCTABLES ,FALSE,TRUE ,"JPEGDCTables"
290 },
291 {
292 TIFFTAG_JPEGACTABLES ,TIFF_VARIABLE,TIFF_VARIABLE,
293 TIFF_LONG ,FIELD_JPEGACTABLES ,FALSE,TRUE ,"JPEGACTables"
294 },
295 {
296 TIFFTAG_WANG_PAGECONTROL ,TIFF_VARIABLE,1 ,
297 TIFF_LONG ,FIELD_WANG_PAGECONTROL ,FALSE,FALSE,"WANG PageControl"
298 },
299
300 /* This is a pseudo tag intended for internal use only by the TIFF Library and
301 its clients, which should never appear in an input/output image file. It
302 specifies whether the TIFF Library (or its client) should do YCbCr <-> RGB
303 color-space conversion (JPEGCOLORMODE_RAW <=> 0) or whether we should ask
304 the JPEG Library to do it (JPEGCOLORMODE_RGB <=> 1).
305 */
306 {
307 TIFFTAG_JPEGCOLORMODE ,0 ,0 ,
308 TIFF_ANY ,FIELD_PSEUDO ,FALSE,FALSE,"JPEGColorMode"
309 }
310 };
311static const char JPEGLib_name[]={"JPEG Library"},
312 bad_bps[]={"%u BitsPerSample not allowed for JPEG"},
313 bad_photometry[]={"PhotometricInterpretation %u not allowed for JPEG"},
314 bad_subsampling[]={"invalid YCbCr subsampling factor(s)"},
315# ifdef never
316 no_write_frac[]={"fractional scan line discarded"},
317# endif
318 no_read_frac[]={"fractional scan line not read"},
319 no_jtable_space[]={"No space for JPEGTables"};
320
321/* The following diagnostic subroutines interface with and replace default
322 subroutines in the JPEG Library. Our basic strategy is to use "setjmp()"/
323 "longjmp()" in order to return control to the TIFF Library when the JPEG
324 library detects an error, and to use TIFF Library subroutines for displaying
325 diagnostic messages to a client application.
326*/
327static void
328TIFFojpeg_error_exit(register j_common_ptr cinfo)
329 { char buffer[JMSG_LENGTH_MAX];
330
331 (*cinfo->err->format_message)(cinfo,buffer);
332 TIFFError(JPEGLib_name,buffer); /* Display error message */
333 jpeg_abort(cinfo); /* Clean up JPEG Library state */
334 LONGJMP(((OJPEGState *)cinfo)->exit_jmpbuf,1); /* Return to TIFF client */
335 }
336
337static void
338TIFFojpeg_output_message(register j_common_ptr cinfo)
339 { char buffer[JMSG_LENGTH_MAX];
340
341 /* This subroutine is invoked only for warning messages, since the JPEG
342 Library's "error_exit" method does its own thing and "trace_level" is never
343 set > 0.
344 */
345 (*cinfo->err->format_message)(cinfo,buffer);
346 TIFFWarning(JPEGLib_name,buffer);
347 }
348
349/* The following subroutines, which also interface with the JPEG Library, exist
350 mainly in limit the side effects of "setjmp()" and convert JPEG normal/error
351 conditions into TIFF Library return codes.
352*/
353#define CALLJPEG(sp,fail,op)(SETJMP((sp)->exit_jmpbuf)?(fail):(op))
354#define CALLVJPEG(sp,op)CALLJPEG(sp,0,((op),1))
355#ifdef never
356
357static int
358TIFFojpeg_create_compress(register OJPEGState *sp)
359 {
360 sp->cinfo.c.err = jpeg_std_error(&sp->err); /* Initialize error handling */
361 sp->err.error_exit = TIFFojpeg_error_exit;
362 sp->err.output_message = TIFFojpeg_output_message;
363 return CALLVJPEG(sp,jpeg_create_compress(&sp->cinfo.c));
364 }
365
366/* The following subroutines comprise a JPEG Library "destination" data manager
367 by directing compressed data from the JPEG Library to a TIFF Library output
368 buffer.
369*/
370static void
371std_init_destination(register j_compress_ptr cinfo){} /* "Dummy" stub */
372
373static boolean
374std_empty_output_buffer(register j_compress_ptr cinfo)
375 {
376# define sp ((OJPEGState *)cinfo)
377 register TIFF *tif = sp->tif;
378
379 tif->tif_rawcc = tif->tif_rawdatasize; /* Entire buffer has been filled */
380 TIFFFlushData1(tif);
381 sp->dest.next_output_byte = (JOCTET *)tif->tif_rawdata;
382 sp->dest.free_in_buffer = (size_t)tif->tif_rawdatasize;
383 return TRUE;
384# undef sp
385 }
386
387static void
388std_term_destination(register j_compress_ptr cinfo)
389 {
390# define sp ((OJPEGState *)cinfo)
391 register TIFF *tif = sp->tif;
392
393 /* NB: The TIFF Library does the final buffer flush. */
394 tif->tif_rawcp = (tidata_t)sp->dest.next_output_byte;
395 tif->tif_rawcc = tif->tif_rawdatasize - (tsize_t)sp->dest.free_in_buffer;
396# undef sp
397 }
398
399/* Alternate destination manager to output JPEGTables field: */
400
401static void
402tables_init_destination(register j_compress_ptr cinfo)
403 {
404# define sp ((OJPEGState *)cinfo)
405 /* The "jpegtables_length" field is the allocated buffer size while building */
406 sp->dest.next_output_byte = (JOCTET *)sp->jpegtables;
407 sp->dest.free_in_buffer = (size_t)sp->jpegtables_length;
408# undef sp
409 }
410
411static boolean
412tables_empty_output_buffer(register j_compress_ptr cinfo)
413 { void *newbuf;
414# define sp ((OJPEGState *)cinfo)
415
416 /* The entire buffer has been filled, so enlarge it by 1000 bytes. */
417 if (!( newbuf = _TIFFrealloc( (tdata_t)sp->jpegtables
418 , (tsize_t)(sp->jpegtables_length + 1000)
419 )
420 )
421 ) ERREXIT1(cinfo,JERR_OUT_OF_MEMORY,100);
422 sp->dest.next_output_byte = (JOCTET *)newbuf + sp->jpegtables_length;
423 sp->dest.free_in_buffer = (size_t)1000;
424 sp->jpegtables = newbuf;
425 sp->jpegtables_length += 1000;
426 return TRUE;
427# undef sp
428 }
429
430static void
431tables_term_destination(register j_compress_ptr cinfo)
432 {
433# define sp ((OJPEGState *)cinfo)
434 /* Set tables length to no. of Bytes actually emitted. */
435 sp->jpegtables_length -= sp->dest.free_in_buffer;
436# undef sp
437 }
438
439/*ARGSUSED*/ static int
440TIFFojpeg_tables_dest(register OJPEGState *sp, TIFF *tif)
441 {
442
443 /* Allocate a working buffer for building tables. The initial size is 1000
444 Bytes, which is usually adequate.
445 */
446 if (sp->jpegtables) _TIFFfree(sp->jpegtables);
447 if (!(sp->jpegtables = (void*)
448 _TIFFmalloc((tsize_t)(sp->jpegtables_length = 1000))
449 )
450 )
451 {
452 sp->jpegtables_length = 0;
453 TIFFError("TIFFojpeg_tables_dest",no_jtable_space);
454 return 0;
455 };
456 sp->cinfo.c.dest = &sp->dest;
457 sp->dest.init_destination = tables_init_destination;
458 sp->dest.empty_output_buffer = tables_empty_output_buffer;
459 sp->dest.term_destination = tables_term_destination;
460 return 1;
461 }
462#else /* well, hardly ever */
463
464static int
465_notSupported(register TIFF *tif)
466 { const TIFFCodec *c = TIFFFindCODEC(tif->tif_dir.td_compression);
467
468 TIFFError(tif->tif_name,"%s compression not supported",c->name);
469 return 0;
470 }
471#endif /* never */
472
473/* The following subroutines comprise a JPEG Library "source" data manager by
474 by directing compressed data to the JPEG Library from a TIFF Library input
475 buffer.
476*/
477static void
478std_init_source(register j_decompress_ptr cinfo)
479 {
480# define sp ((OJPEGState *)cinfo)
481 register TIFF *tif = sp->tif;
482
483 if (sp->src.bytes_in_buffer == 0)
484 {
485 sp->src.next_input_byte = (const JOCTET *)tif->tif_rawdata;
486 sp->src.bytes_in_buffer = (size_t)tif->tif_rawcc;
487 };
488# undef sp
489 }
490
491static boolean
492std_fill_input_buffer(register j_decompress_ptr cinfo)
493 { static const JOCTET dummy_EOI[2]={0xFF,JPEG_EOI};
494# define sp ((OJPEGState *)cinfo)
495
496 /* Control should never get here, since an entire strip/tile is read into
497 memory before the decompressor is called; thus, data should have been
498 supplied by the "init_source" method. ...But, sometimes things fail.
499 */
500 WARNMS(cinfo,JWRN_JPEG_EOF);
501 sp->src.next_input_byte = dummy_EOI; /* Insert a fake EOI marker */
502 sp->src.bytes_in_buffer = sizeof dummy_EOI;
503 return TRUE;
504# undef sp
505 }
506
507static void
508std_skip_input_data(register j_decompress_ptr cinfo, long num_bytes)
509 {
510# define sp ((OJPEGState *)cinfo)
511
512 if (num_bytes > 0)
513 {
514 if (num_bytes > (long)sp->src.bytes_in_buffer) /* oops: buffer overrun */
515 (void)std_fill_input_buffer(cinfo);
516 else
517 {
518 sp->src.next_input_byte += (size_t)num_bytes;
519 sp->src.bytes_in_buffer -= (size_t)num_bytes;
520 }
521 }
522# undef sp
523 }
524
525/*ARGSUSED*/ static void
526std_term_source(register j_decompress_ptr cinfo){} /* "Dummy" stub */
527
528/* Allocate temporary I/O buffers for downsampled data, using values computed in
529 "jpeg_start_{de}compress()". We use the JPEG Library's allocator so that
530 buffers will be released automatically when done with a strip/tile. This is
531 also a handy place to compute samplesperclump, bytesperline, etc.
532*/
533static int
534alloc_downsampled_buffers(TIFF *tif,jpeg_component_info *comp_info,
535 int num_components)
536 { register OJPEGState *sp = OJState(tif);
537
538 sp->samplesperclump = 0;
539 if (num_components > 0)
540 { tsize_t size = sp->cinfo.comm.is_decompressor
541# ifdef D_LOSSLESS_SUPPORTED
542 ? sp->cinfo.d.min_codec_data_unit
543# else
544 ? DCTSIZE
545# endif
546# ifdef C_LOSSLESS_SUPPORTED
547 : sp->cinfo.c.data_unit;
548# else
549 : DCTSIZE;
550# endif
551 int ci = 0;
552 register jpeg_component_info *compptr = comp_info;
553
554 do
555 { JSAMPARRAY buf;
556
557 sp->samplesperclump +=
558 compptr->h_samp_factor * compptr->v_samp_factor;
559# if defined(C_LOSSLESS_SUPPORTED) || defined(D_LOSSLESS_SUPPORTED)
560 if (!(buf = CALLJPEG(sp,0,(*sp->cinfo.comm.mem->alloc_sarray)(&sp->cinfo.comm,JPOOL_IMAGE,compptr->width_in_data_units*size,compptr->v_samp_factor*size))))
561# else
562 if (!(buf = CALLJPEG(sp,0,(*sp->cinfo.comm.mem->alloc_sarray)(&sp->cinfo.comm,JPOOL_IMAGE,compptr->width_in_blocks*size,compptr->v_samp_factor*size))))
563# endif
564 return 0;
565 sp->ds_buffer[ci] = buf;
566 }
567 while (++compptr,++ci < num_components);
568 };
569 return 1;
570 }
571#ifdef never
572
573/* JPEG Encoding begins here. */
574
575/*ARGSUSED*/ static int
576OJPEGEncode(register TIFF *tif,tidata_t buf,tsize_t cc,tsample_t s)
577 { tsize_t rows; /* No. of unprocessed rows in file */
578 register OJPEGState *sp = OJState(tif);
579
580 /* Encode a chunk of pixels, where returned data is NOT down-sampled (the
581 standard case). The data is expected to be written in scan-line multiples.
582 */
583 if (cc % sp->bytesperline) TIFFWarning(tif->tif_name,no_write_frac);
584 if ( (cc /= bytesperline) /* No. of complete rows in caller's buffer */
585 > (rows = sp->cinfo.c.image_height - sp->cinfo.c.next_scanline)
586 ) cc = rows;
587 while (--cc >= 0)
588 {
589 if ( CALLJPEG(sp,-1,jpeg_write_scanlines(&sp->cinfo.c,(JSAMPARRAY)&buf,1))
590 != 1
591 ) return 0;
592 ++tif->tif_row;
593 buf += sp->bytesperline;
594 };
595 return 1;
596 }
597
598/*ARGSUSED*/ static int
599OJPEGEncodeRaw(register TIFF *tif,tidata_t buf,tsize_t cc,tsample_t s)
600 { tsize_t rows; /* No. of unprocessed rows in file */
601 JDIMENSION lines_per_MCU, size;
602 register OJPEGState *sp = OJState(tif);
603
604 /* Encode a chunk of pixels, where returned data is down-sampled as per the
605 sampling factors. The data is expected to be written in scan-line
606 multiples.
607 */
608 cc /= sp->bytesperline;
609 if (cc % sp->bytesperline) TIFFWarning(tif->tif_name,no_write_frac);
610 if ( (cc /= bytesperline) /* No. of complete rows in caller's buffer */
611 > (rows = sp->cinfo.c.image_height - sp->cinfo.c.next_scanline)
612 ) cc = rows;
613# ifdef C_LOSSLESS_SUPPORTED
614 lines_per_MCU = sp->cinfo.c.max_samp_factor*(size = sp->cinfo.d.data_unit);
615# else
616 lines_per_MCU = sp->cinfo.c.max_samp_factor*(size = DCTSIZE);
617# endif
618 while (--cc >= 0)
619 { int ci = 0, clumpoffset = 0;
620 register jpeg_component_info *compptr = sp->cinfo.c.comp_info;
621
622 /* The fastest way to separate the data is to make 1 pass over the scan
623 line for each row of each component.
624 */
625 do
626 { int ypos = 0;
627
628 do
629 { int padding;
630 register JSAMPLE *inptr = (JSAMPLE*)buf + clumpoffset,
631 *outptr =
632 sp->ds_buffer[ci][sp->scancount*compptr->v_samp_factor+ypos];
633 /* Cb,Cr both have sampling factors 1, so this is correct */
634 register int clumps_per_line =
635 sp->cinfo.c.comp_info[1].downsampled_width,
636 xpos;
637
638 padding = (int)
639# ifdef C_LOSSLESS_SUPPORTED
640 ( compptr->width_in_data_units * size
641# else
642 ( compptr->width_in_blocks * size
643# endif
644 - clumps_per_line * compptr->h_samp_factor
645 );
646 if (compptr->h_samp_factor == 1) /* Cb & Cr fast path */
647 do *outptr++ = *inptr;
648 while ((inptr += sp->samplesperclump),--clumps_per_line > 0);
649 else /* general case */
650 do
651 {
652 xpos = 0;
653 do *outptr++ = inptr[xpos];
654 while (++xpos < compptr->h_samp_factor);
655 }
656 while ((inptr += sp->samplesperclump),--clumps_per_line > 0);
657 xpos = 0; /* Pad each scan line as needed */
658 do outptr[0] = outptr[-1]; while (++outptr,++xpos < padding);
659 clumpoffset += compptr->h_samp_factor;
660 }
661 while (++ypos < compptr->v_samp_factor);
662 }
663 while (++compptr,++ci < sp->cinfo.c.num_components);
664 if (++sp->scancount >= size)
665 {
666 if ( CALLJPEG(sp,-1,jpeg_write_raw_data(&sp->cinfo.c,sp->ds_buffer,lines_per_MCU))
667 != lines_per_MCU
668 ) return 0;
669 sp->scancount = 0;
670 };
671 ++tif->tif_row++
672 buf += sp->bytesperline;
673 };
674 return 1;
675 }
676
677static int
678OJPEGSetupEncode(register TIFF *tif)
679 { static const char module[]={"OJPEGSetupEncode"};
680 uint32 segment_height, segment_width;
681 int status = 1; /* Assume success by default */
682 register OJPEGState *sp = OJState(tif);
683# define td (&tif->tif_dir)
684
685 /* Verify miscellaneous parameters. This will need work if the TIFF Library
686 ever supports different depths for different components, or if the JPEG
687 Library ever supports run-time depth selection. Neither seems imminent.
688 */
689 if (td->td_bitspersample != 8)
690 {
691 TIFFError(module,bad_bps,td->td_bitspersample);
692 status = 0;
693 };
694
695 /* The TIFF Version 6.0 specification and IJG JPEG Library accept different
696 sets of color spaces, so verify that our image belongs to the common subset
697 and map its photometry code, then initialize to handle subsampling and
698 optional JPEG Library YCbCr <-> RGB color-space conversion.
699 */
700 switch (td->td_photometric)
701 {
702 case PHOTOMETRIC_YCBCR :
703
704 /* ISO IS 10918-1 requires that JPEG subsampling factors be 1-4, but
705 TIFF Version 6.0 is more restrictive: only 1, 2, and 4 are allowed.
706 */
707 if ( ( td->td_ycbcrsubsampling[0] == 1
708 || td->td_ycbcrsubsampling[0] == 2
709 || td->td_ycbcrsubsampling[0] == 4
710 )
711 && ( td->td_ycbcrsubsampling[1] == 1
712 || td->td_ycbcrsubsampling[1] == 2
713 || td->td_ycbcrsubsampling[1] == 4
714 )
715 )
716 sp->cinfo.c.raw_data_in =
717 ( (sp->h_sampling = td->td_ycbcrsubsampling[0]) << 3
718 | (sp->v_sampling = td->td_ycbcrsubsampling[1])
719 ) != 011;
720 else
721 {
722 TIFFError(module,bad_subsampling);
723 status = 0;
724 };
725
726 /* A ReferenceBlackWhite field MUST be present, since the default value
727 is inapproriate for YCbCr. Fill in the proper value if the
728 application didn't set it.
729 */
730 if (!TIFFFieldSet(tif,FIELD_REFBLACKWHITE))
731 { float refbw[6];
732 long top = 1L << td->td_bitspersample;
733
734 refbw[0] = 0;
735 refbw[1] = (float)(top-1L);
736 refbw[2] = (float)(top>>1);
737 refbw[3] = refbw[1];
738 refbw[4] = refbw[2];
739 refbw[5] = refbw[1];
740 TIFFSetField(tif,TIFFTAG_REFERENCEBLACKWHITE,refbw);
741 };
742 sp->cinfo.c.jpeg_color_space = JCS_YCbCr;
743 if (sp->jpegcolormode == JPEGCOLORMODE_RGB)
744 {
745 sp->cinfo.c.raw_data_in = FALSE;
746 sp->in_color_space = JCS_RGB;
747 break;
748 };
749 goto L2;
750 case PHOTOMETRIC_MINISBLACK:
751 sp->cinfo.c.jpeg_color_space = JCS_GRAYSCALE;
752 goto L1;
753 case PHOTOMETRIC_RGB :
754 sp->cinfo.c.jpeg_color_space = JCS_RGB;
755 goto L1;
756 case PHOTOMETRIC_SEPARATED :
757 sp->cinfo.c.jpeg_color_space = JCS_CMYK;
758 L1: sp->jpegcolormode = JPEGCOLORMODE_RAW; /* No JPEG Lib. conversion */
759 L2: sp->cinfo.d.in_color_space = sp->cinfo.d.jpeg_color-space;
760 break;
761 default :
762 TIFFError(module,bad_photometry,td->td_photometric);
763 status = 0;
764 };
765 tif->tif_encoderow = tif->tif_encodestrip = tif->tif_encodetile =
766 sp->cinfo.c.raw_data_in ? OJPEGEncodeRaw : OJPEGEncode;
767 if (isTiled(tif))
768 { tsize_t size;
769
770# ifdef C_LOSSLESS_SUPPORTED
771 if ((size = sp->v_sampling*sp->cinfo.c.data_unit) < 16) size = 16;
772# else
773 if ((size = sp->v_sampling*DCTSIZE) < 16) size = 16;
774# endif
775 if ((segment_height = td->td_tilelength) % size)
776 {
777 TIFFError(module,"JPEG tile height must be multiple of %d",size);
778 status = 0;
779 };
780# ifdef C_LOSSLESS_SUPPORTED
781 if ((size = sp->h_sampling*sp->cinfo.c.data_unit) < 16) size = 16;
782# else
783 if ((size = sp->h_sampling*DCTSIZE) < 16) size = 16;
784# endif
785 if ((segment_width = td->td_tilewidth) % size)
786 {
787 TIFFError(module,"JPEG tile width must be multiple of %d",size);
788 status = 0;
789 };
790 sp->bytesperline = TIFFTileRowSize(tif);
791 }
792 else
793 { tsize_t size;
794
795# ifdef C_LOSSLESS_SUPPORTED
796 if ((size = sp->v_sampling*sp->cinfo.c.data_unit) < 16) size = 16;
797# else
798 if ((size = sp->v_sampling*DCTSIZE) < 16) size = 16;
799# endif
800 if (td->td_rowsperstrip < (segment_height = td->td_imagelength))
801 {
802 if (td->td_rowsperstrip % size)
803 {
804 TIFFError(module,"JPEG RowsPerStrip must be multiple of %d",size);
805 status = 0;
806 };
807 segment_height = td->td_rowsperstrip;
808 };
809 segment_width = td->td_imagewidth;
810 sp->bytesperline = tif->tif_scanlinesize;
811 };
812 if (segment_width > 65535 || segment_height > 65535)
813 {
814 TIFFError(module,"Strip/tile too large for JPEG");
815 status = 0;
816 };
817
818 /* Initialize all JPEG parameters to default values. Note that the JPEG
819 Library's "jpeg_set_defaults()" method needs legal values for the
820 "in_color_space" and "input_components" fields.
821 */
822 sp->cinfo.c.input_components = 1; /* Default for JCS_UNKNOWN */
823 if (!CALLVJPEG(sp,jpeg_set_defaults(&sp->cinfo.c))) status = 0;
824 switch (sp->jpegtablesmode & (JPEGTABLESMODE_HUFF|JPEGTABLESMODE_QUANT))
825 { register JHUFF_TBL *htbl;
826 register JQUANT_TBL *qtbl;
827
828 case 0 :
829 sp->cinfo.c.optimize_coding = TRUE;
830 case JPEGTABLESMODE_HUFF :
831 if (!CALLVJPEG(sp,jpeg_set_quality(&sp->cinfo.c,sp->jpegquality,FALSE)))
832 return 0;
833 if (qtbl = sp->cinfo.c.quant_tbl_ptrs[0]) qtbl->sent_table = FALSE;
834 if (qtbl = sp->cinfo.c.quant_tbl_ptrs[1]) qtbl->sent_table = FALSE;
835 goto L3;
836 case JPEGTABLESMODE_QUANT :
837 sp->cinfo.c.optimize_coding = TRUE;
838
839 /* We do not support application-supplied JPEG tables, so mark the field
840 "not present".
841 */
842 L3: TIFFClrFieldBit(tif,FIELD_JPEGTABLES);
843 break;
844 case JPEGTABLESMODE_HUFF|JPEGTABLESMODE_QUANT:
845 if ( !CALLVJPEG(sp,jpeg_set_quality(&sp->cinfo.c,sp->jpegquality,FALSE))
846 || !CALLVJPEG(sp,jpeg_suppress_tables(&sp->cinfo.c,TRUE))
847 )
848 {
849 status = 0;
850 break;
851 };
852 if (qtbl = sp->cinfo.c.quant_tbl_ptrs[0]) qtbl->sent_table = FALSE;
853 if (htbl = sp->cinfo.c.dc_huff_tbl_ptrs[0]) htbl->sent_table = FALSE;
854 if (htbl = sp->cinfo.c.ac_huff_tbl_ptrs[0]) htbl->sent_table = FALSE;
855 if (sp->cinfo.c.jpeg_color_space == JCS_YCbCr)
856 {
857 if (qtbl = sp->cinfo.c.quant_tbl_ptrs[1])
858 qtbl->sent_table = FALSE;
859 if (htbl = sp->cinfo.c.dc_huff_tbl_ptrs[1])
860 htbl->sent_table = FALSE;
861 if (htbl = sp->cinfo.c.ac_huff_tbl_ptrs[1])
862 htbl->sent_table = FALSE;
863 };
864 if ( TIFFojpeg_tables_dest(sp,tif)
865 && CALLVJPEG(sp,jpeg_write_tables(&sp->cinfo.c))
866 )
867 {
868
869 /* Mark the field "present". We can't use "TIFFSetField()" because
870 "BEENWRITING" is already set!
871 */
872 TIFFSetFieldBit(tif,FIELD_JPEGTABLES);
873 tif->tif_flags |= TIFF_DIRTYDIRECT;
874 }
875 else status = 0;
876 };
877 if ( sp->cinfo.c.raw_data_in
878 && !alloc_downsampled_buffers(tif,sp->cinfo.c.comp_info,
879 sp->cinfo.c.num_components)
880 ) status = 0;
881 if (status == 0) return 0; /* If TIFF errors, don't bother to continue */
882 /* Grab parameters that are same for all strips/tiles. */
883
884 sp->dest.init_destination = std_init_destination;
885 sp->dest.empty_output_buffer = std_empty_output_buffer;
886 sp->dest.term_destination = std_term_destination;
887 sp->cinfo.c.dest = &sp->dest;
888 sp->cinfo.c.data_precision = td->td_bitspersample;
889 sp->cinfo.c.write_JFIF_header = /* Don't write extraneous markers */
890 sp->cinfo.c.write_Adobe_marker = FALSE;
891 sp->cinfo.c.image_width = segment_width;
892 sp->cinfo.c.image_height = segment_height;
893 sp->cinfo.c.comp_info[0].h_samp_factor =
894 sp->cinfo.c.comp_info[0].v_samp_factor = 1;
895 return CALLVJPEG(sp,jpeg_start_compress(&sp->cinfo.c,FALSE));
896# undef td
897 }
898
899static int
900OJPEGPreEncode(register TIFF *tif,tsample_t s)
901 { register OJPEGState *sp = OJState(tif);
902# define td (&tif->tif_dir)
903
904 /* If we are about to write the first row of an image plane, which should
905 coincide with a JPEG "scan", reset the JPEG Library's compressor. Otherwise
906 let the compressor run "as is" and return a "success" status without further
907 ado.
908 */
909 if ( (isTiled(tif) ? tif->tif_curtile : tif->tif_curstrip)
910 % td->td_stripsperimage
911 == 0
912 )
913 {
914 if ( (sp->cinfo.c.comp_info[0].component_id = s) == 1)
915 && sp->cinfo.c.jpeg_color_space == JCS_YCbCr
916 )
917 {
918 sp->cinfo.c.comp_info[0].quant_tbl_no =
919 sp->cinfo.c.comp_info[0].dc_tbl_no =
920 sp->cinfo.c.comp_info[0].ac_tbl_no = 1;
921 sp->cinfo.c.comp_info[0].h_samp_factor = sp->h_sampling;
922 sp->cinfo.c.comp_info[0].v_samp_factor = sp->v_sampling;
923
924 /* Scale expected strip/tile size to match a downsampled component. */
925
926 sp->cinfo.c.image_width = TIFFhowmany(segment_width,sp->h_sampling);
927 sp->cinfo.c.image_height=TIFFhowmany(segment_height,sp->v_sampling);
928 };
929 sp->scancount = 0; /* Mark subsampling buffer(s) empty */
930 };
931 return 1;
932# undef td
933 }
934
935static int
936OJPEGPostEncode(register TIFF *tif)
937 { register OJPEGState *sp = OJState(tif);
938
939 /* Finish up at the end of a strip or tile. */
940
941 if (sp->scancount > 0) /* emit partial buffer of down-sampled data */
942 { JDIMENSION n;
943
944# ifdef C_LOSSLESS_SUPPORTED
945 if ( sp->scancount < sp->cinfo.c.data_unit
946 && sp->cinfo.c.num_components > 0
947 )
948# else
949 if (sp->scancount < DCTSIZE && sp->cinfo.c.num_components > 0)
950# endif
951 { int ci = 0, /* Pad the data vertically */
952# ifdef C_LOSSLESS_SUPPORTED
953 size = sp->cinfo.c.data_unit;
954# else
955 size = DCTSIZE;
956# endif
957 register jpeg_component_info *compptr = sp->cinfo.c.comp_info;
958
959 do
960# ifdef C_LOSSLESS_SUPPORTED
961 { tsize_t row_width = compptr->width_in_data_units
962# else
963 tsize_t row_width = compptr->width_in_blocks
964# endif
965 *size*sizeof(JSAMPLE);
966 int ypos = sp->scancount*compptr->v_samp_factor;
967
968 do _TIFFmemcpy( (tdata_t)sp->ds_buffer[ci][ypos]
969 , (tdata_t)sp->ds_buffer[ci][ypos-1]
970 , row_width
971 );
972 while (++ypos < compptr->v_samp_factor*size);
973 }
974 while (++compptr,++ci < sp->cinfo.c.num_components);
975 };
976 n = sp->cinfo.c.max_v_samp_factor*size;
977 if (CALLJPEG(sp,-1,jpeg_write_raw_data(&sp->cinfo.c,sp->ds_buffer,n)) != n)
978 return 0;
979 };
980 return CALLVJPEG(sp,jpeg_finish_compress(&sp->cinfo.c));
981 }
982#endif /* never */
983
984/* JPEG Decoding begins here. */
985
986/*ARGSUSED*/ static int
987OJPEGDecode(register TIFF *tif,tidata_t buf,tsize_t cc,tsample_t s)
988 { tsize_t bytesperline = isTiled(tif)
989 ? TIFFTileRowSize(tif)
990 : tif->tif_scanlinesize,
991 rows; /* No. of unprocessed rows in file */
992 register OJPEGState *sp = OJState(tif);
993
994 /* Decode a chunk of pixels, where the input data has not NOT been down-
995 sampled, or else the TIFF Library's client has used the "JPEGColorMode" TIFF
996 pseudo-tag to request that the JPEG Library do color-space conversion; this
997 is the normal case. The data is expected to be read in scan-line multiples,
998 and this subroutine is called for both pixel-interleaved and separate color
999 planes.
1000
1001 WARNING: Unlike "OJPEGDecodeRawContig()", below, the no. of Bytes in each
1002 decoded row is calculated here as "bytesperline" instead of
1003 using "sp->bytesperline", which might be a little smaller. This can
1004 occur for an old tiled image whose width isn't a multiple of 8 pixels.
1005 That's illegal according to the TIFF Version 6 specification, but some
1006 test files, like "zackthecat.tif", were built that way. In those cases,
1007 we want to embed the image's true width in our caller's buffer (which is
1008 presumably allocated according to the expected tile width) by
1009 effectively "padding" it with unused Bytes at the end of each row.
1010 */
1011 if ( (cc /= bytesperline) /* No. of complete rows in caller's buffer */
1012 > (rows = sp->cinfo.d.output_height - sp->cinfo.d.output_scanline)
1013 ) cc = rows;
1014 while (--cc >= 0)
1015 {
1016 if ( CALLJPEG(sp,-1,jpeg_read_scanlines(&sp->cinfo.d,(JSAMPARRAY)&buf,1))
1017 != 1
1018 ) return 0;
1019 buf += bytesperline;
1020 ++tif->tif_row;
1021 };
1022
1023 /* BEWARE OF KLUDGE: If our input file was produced by Microsoft's Wang
1024 Imaging for Windows application, the DC coefficients of
1025 each JPEG image component (Y,Cb,Cr) must be reset at the end of each TIFF
1026 "strip", and any JPEG data bits remaining in the current Byte of the
1027 decoder's input buffer must be discarded. To do so, we create an "ad hoc"
1028 interface in the "jdhuff.c" module of IJG JPEG Library Version 6 (module
1029 "jdshuff.c", if Ken Murchison's lossless-Huffman patch is applied), and we
1030 invoke that interface here after decoding each "strip".
1031 */
1032 if (sp->is_WANG) jpeg_reset_huff_decode(&sp->cinfo.d);
1033 return 1;
1034 }
1035
1036/*ARGSUSED*/ static int
1037OJPEGDecodeRawContig(register TIFF *tif,tidata_t buf,tsize_t cc,tsample_t s)
1038 { tsize_t rows; /* No. of unprocessed rows in file */
1039 JDIMENSION lines_per_MCU, size;
1040 register OJPEGState *sp = OJState(tif);
1041
1042 /* Decode a chunk of pixels, where the input data has pixel-interleaved color
1043 planes, some of which have been down-sampled, but the TIFF Library's client
1044 has NOT used the "JPEGColorMode" TIFF pseudo-tag to request that the JPEG
1045 Library do color-space conversion. In other words, we must up-sample/
1046 expand/duplicate image components according to the image's sampling factors,
1047 without changing its color space. The data is expected to be read in scan-
1048 line multiples.
1049 */
1050 if ( (cc /= sp->bytesperline) /* No. of complete rows in caller's buffer */
1051 > (rows = sp->cinfo.d.output_height - sp->cinfo.d.output_scanline)
1052 ) cc = rows;
1053 lines_per_MCU = sp->cinfo.d.max_v_samp_factor
1054# ifdef D_LOSSLESS_SUPPORTED
1055 * (size = sp->cinfo.d.min_codec_data_unit);
1056# else
1057 * (size = DCTSIZE);
1058# endif
1059 while (--cc >= 0)
1060 { int clumpoffset, ci;
1061 register jpeg_component_info *compptr;
1062
1063 if (sp->scancount >= size) /* reload downsampled-data buffers */
1064 {
1065 if ( CALLJPEG(sp,-1,jpeg_read_raw_data(&sp->cinfo.d,sp->ds_buffer,lines_per_MCU))
1066 != lines_per_MCU
1067 ) return 0;
1068 sp->scancount = 0;
1069 };
1070
1071 /* The fastest way to separate the data is: make 1 pass over the scan
1072 line for each row of each component.
1073 */
1074 clumpoffset = ci = 0;
1075 compptr = sp->cinfo.d.comp_info;
1076 do
1077 { int ypos = 0;
1078
1079 if (compptr->h_samp_factor == 1) /* fast path */
1080 do
1081 { register JSAMPLE *inptr =
1082 sp->ds_buffer[ci][sp->scancount*compptr->v_samp_factor+ypos],
1083 *outptr = (JSAMPLE *)buf + clumpoffset;
1084 register int clumps_per_line = compptr->downsampled_width;
1085
1086 do *outptr = *inptr++;
1087 while ((outptr += sp->samplesperclump),--clumps_per_line > 0);
1088 }
1089 while ( (clumpoffset += compptr->h_samp_factor)
1090 , ++ypos < compptr->v_samp_factor
1091 );
1092 else /* general case */
1093 do
1094 { register JSAMPLE *inptr =
1095 sp->ds_buffer[ci][sp->scancount*compptr->v_samp_factor+ypos],
1096 *outptr = (JSAMPLE *)buf + clumpoffset;
1097 register int clumps_per_line = compptr->downsampled_width;
1098
1099 do
1100 { register int xpos = 0;
1101
1102 do outptr[xpos] = *inptr++;
1103 while (++xpos < compptr->h_samp_factor);
1104 }
1105 while ((outptr += sp->samplesperclump),--clumps_per_line > 0);
1106 }
1107 while ( (clumpoffset += compptr->h_samp_factor)
1108 , ++ypos < compptr->v_samp_factor
1109 );
1110 }
1111 while (++compptr,++ci < sp->cinfo.d.num_components);
1112 ++sp->scancount;
1113 buf += sp->bytesperline;
1114 ++tif->tif_row;
1115 };
1116
1117 /* BEWARE OF KLUDGE: If our input file was produced by Microsoft's Wang
1118 Imaging for Windows application, the DC coefficients of
1119 each JPEG image component (Y,Cb,Cr) must be reset at the end of each TIFF
1120 "strip", and any JPEG data bits remaining in the current Byte of the
1121 decoder's input buffer must be discarded. To do so, we create an "ad hoc"
1122 interface in the "jdhuff.c" module of IJG JPEG Library Version 6 (module
1123 "jdshuff.c", if Ken Murchison's lossless-Huffman patch is applied), and we
1124 invoke that interface here after decoding each "strip".
1125 */
1126 if (sp->is_WANG) jpeg_reset_huff_decode(&sp->cinfo.d);
1127 return 1;
1128 }
1129
1130/*ARGSUSED*/ static int
1131OJPEGDecodeRawSeparate(TIFF *tif,register tidata_t buf,tsize_t cc,tsample_t s)
1132 { tsize_t rows; /* No. of unprocessed rows in file */
1133 JDIMENSION lines_per_MCU,
1134 size, /* ...of MCU */
1135 v; /* Component's vertical up-sampling ratio */
1136 register OJPEGState *sp = OJState(tif);
1137 register jpeg_component_info *compptr = sp->cinfo.d.comp_info + s;
1138
1139 /* Decode a chunk of pixels, where the input data has separate color planes,
1140 some of which have been down-sampled, but the TIFF Library's client has NOT
1141 used the "JPEGColorMode" TIFF pseudo-tag to request that the JPEG Library
1142 do color-space conversion. The data is expected to be read in scan-line
1143 multiples.
1144 */
1145 v = sp->cinfo.d.max_v_samp_factor/compptr->v_samp_factor;
1146 if ( (cc /= compptr->downsampled_width) /* No. of rows in caller's buffer */
1147 > (rows = (sp->cinfo.d.output_height-sp->cinfo.d.output_scanline+v-1)/v)
1148 ) cc = rows; /* No. of rows of "clumps" to read */
1149 lines_per_MCU = sp->cinfo.d.max_v_samp_factor
1150# ifdef D_LOSSLESS_SUPPORTED
1151 * (size = sp->cinfo.d.min_codec_data_unit);
1152# else
1153 * (size = DCTSIZE);
1154# endif
1155 L: if (sp->scancount >= size) /* reload downsampled-data buffers */
1156 {
1157 if ( CALLJPEG(sp,-1,jpeg_read_raw_data(&sp->cinfo.d,sp->ds_buffer,lines_per_MCU))
1158 != lines_per_MCU
1159 ) return 0;
1160 sp->scancount = 0;
1161 };
1162 rows = 0;
1163 do
1164 { register JSAMPLE *inptr =
1165 sp->ds_buffer[s][sp->scancount*compptr->v_samp_factor + rows];
1166 register int clumps_per_line = compptr->downsampled_width;
1167
1168 do *buf++ = *inptr++; while (--clumps_per_line > 0); /* Copy scanline */
1169 tif->tif_row += v;
1170 if (--cc <= 0) return 1; /* End of caller's buffer? */
1171 }
1172 while (++rows < compptr->v_samp_factor);
1173 ++sp->scancount;
1174 goto L;
1175 }
1176
1177/* "OJPEGSetupDecode()" temporarily forces the JPEG Library to use the following
1178 subroutine as a "dummy" input reader in order to fool the library into
1179 thinking that it has read the image's first "Start of Scan" (SOS) marker, so
1180 that it initializes accordingly.
1181*/
1182/*ARGSUSED*/ METHODDEF(int)
1183fake_SOS_marker(j_decompress_ptr cinfo){return JPEG_REACHED_SOS;}
1184
1185/*ARGSUSED*/ METHODDEF(int)
1186suspend(j_decompress_ptr cinfo){return JPEG_SUSPENDED;}
1187
1188/* The JPEG Library's "null" color-space converter actually re-packs separate
1189 color planes (it's native image representation) into a pixel-interleaved,
1190 contiguous plane. But if our TIFF Library client is tryng to process a
1191 PLANARCONFIG_SEPARATE image, we don't want that; so here are modifications of
1192 code in the JPEG Library's "jdcolor.c" file, which simply copy Bytes to a
1193 color plane specified by the current JPEG "scan".
1194*/
1195METHODDEF(void)
1196ycc_rgb_convert(register j_decompress_ptr cinfo,JSAMPIMAGE in,JDIMENSION row,
1197 register JSAMPARRAY out,register int nrows)
1198 { typedef struct /* "jdcolor.c" color-space conversion state */
1199 {
1200
1201 /* WARNING: This declaration is ugly and dangerous! It's supposed to be
1202 private to the JPEG Library's "jdcolor.c" module, but we also
1203 need it here. Since the library's copy might change without notice, be
1204 sure to keep this one synchronized or the following code will break!
1205 */
1206 struct jpeg_color_deconverter pub; /* Public fields */
1207 /* Private state for YCC->RGB conversion */
1208 int *Cr_r_tab, /* ->Cr to R conversion table */
1209 *Cb_b_tab; /* ->Cb to B conversion table */
1210 INT32 *Cr_g_tab, /* ->Cr to G conversion table */
1211 *Cb_g_tab; /* ->Cb to G conversion table */
1212 } *my_cconvert_ptr;
1213 my_cconvert_ptr cconvert = (my_cconvert_ptr)cinfo->cconvert;
1214 JSAMPARRAY irow0p = in[0] + row;
1215 register JSAMPLE *range_limit = cinfo->sample_range_limit;
1216 register JSAMPROW outp, Y;
1217
1218 switch (cinfo->output_scan_number - 1)
1219 { JSAMPARRAY irow1p, irow2p;
1220 register INT32 *table0, *table1;
1221 SHIFT_TEMPS
1222
1223 case RGB_RED : irow2p = in[2] + row;
1224 table0 = (INT32 *)cconvert->Cr_r_tab;
1225 while (--nrows >= 0)
1226 { register JSAMPROW Cr = *irow2p++;
1227 register int i = cinfo->output_width;
1228
1229 Y = *irow0p++;
1230 outp = *out++;
1231 while (--i >= 0)
1232 *outp++ = range_limit[*Y++ + table0[*Cr++]];
1233 };
1234 return;
1235 case RGB_GREEN: irow1p = in[1] + row;
1236 irow2p = in[2] + row;
1237 table0 = cconvert->Cb_g_tab;
1238 table1 = cconvert->Cr_g_tab;
1239 while (--nrows >= 0)
1240 { register JSAMPROW Cb = *irow1p++,
1241 Cr = *irow2p++;
1242 register int i = cinfo->output_width;
1243
1244 Y = *irow0p++;
1245 outp = *out++;
1246 while (--i >= 0)
1247 *outp++ =
1248 range_limit[ *Y++
1249 + RIGHT_SHIFT(table0[*Cb++]+table1[*Cr++],16)
1250 ];
1251 };
1252 return;
1253 case RGB_BLUE : irow1p = in[1] + row;
1254 table0 = (INT32 *)cconvert->Cb_b_tab;
1255 while (--nrows >= 0)
1256 { register JSAMPROW Cb = *irow1p++;
1257 register int i = cinfo->output_width;
1258
1259 Y = *irow0p++;
1260 outp = *out++;
1261 while (--i >= 0)
1262 *outp++ = range_limit[*Y++ + table0[*Cb++]];
1263 }
1264 }
1265 }
1266
1267METHODDEF(void)
1268null_convert(register j_decompress_ptr cinfo,JSAMPIMAGE in,JDIMENSION row,
1269 register JSAMPARRAY out,register int nrows)
1270 { register JSAMPARRAY irowp = in[cinfo->output_scan_number - 1] + row;
1271
1272 while (--nrows >= 0) _TIFFmemcpy(*out++,*irowp++,cinfo->output_width);
1273 }
1274
1275static int
1276OJPEGSetupDecode(register TIFF *tif)
1277 { static char module[]={"OJPEGSetupDecode"};
1278 J_COLOR_SPACE jpeg_color_space, /* Color space of JPEG-compressed image */
1279 out_color_space; /* Color space of decompressed image */
1280 uint32 segment_width;
1281 int status = 1; /* Assume success by default */
1282 boolean downsampled_output=FALSE, /* <=> Want JPEG Library's "raw" image? */
1283 is_JFIF; /* <=> JFIF image? */
1284 register OJPEGState *sp = OJState(tif);
1285# define td (&tif->tif_dir)
1286
1287 /* Verify miscellaneous parameters. This will need work if the TIFF Library
1288 ever supports different depths for different components, or if the JPEG
1289 Library ever supports run-time depth selection. Neither seems imminent.
1290 */
1291 if (td->td_bitspersample != sp->cinfo.d.data_precision)
1292 {
1293 TIFFError(module,bad_bps,td->td_bitspersample);
1294 status = 0;
1295 };
1296
1297 /* The TIFF Version 6.0 specification and IJG JPEG Library accept different
1298 sets of color spaces, so verify that our image belongs to the common subset
1299 and map its photometry code, then initialize to handle subsampling and
1300 optional JPEG Library YCbCr <-> RGB color-space conversion.
1301 */
1302 switch (td->td_photometric)
1303 {
1304 case PHOTOMETRIC_YCBCR :
1305
1306 /* ISO IS 10918-1 requires that JPEG subsampling factors be 1-4, but
1307 TIFF Version 6.0 is more restrictive: only 1, 2, and 4 are allowed.
1308 */
1309 if ( ( td->td_ycbcrsubsampling[0] == 1
1310 || td->td_ycbcrsubsampling[0] == 2
1311 || td->td_ycbcrsubsampling[0] == 4
1312 )
1313 && ( td->td_ycbcrsubsampling[1] == 1
1314 || td->td_ycbcrsubsampling[1] == 2
1315 || td->td_ycbcrsubsampling[1] == 4
1316 )
1317 )
1318 downsampled_output =
1319 (
1320 (sp->h_sampling = td->td_ycbcrsubsampling[0]) << 3
1321 | (sp->v_sampling = td->td_ycbcrsubsampling[1])
1322 ) != 011;
1323 else
1324 {
1325 TIFFError(module,bad_subsampling);
1326 status = 0;
1327 };
1328 jpeg_color_space = JCS_YCbCr;
1329 if (sp->jpegcolormode == JPEGCOLORMODE_RGB)
1330 {
1331 downsampled_output = FALSE;
1332 out_color_space = JCS_RGB;
1333 break;
1334 };
1335 goto L2;
1336 case PHOTOMETRIC_MINISBLACK:
1337 jpeg_color_space = JCS_GRAYSCALE;
1338 goto L1;
1339 case PHOTOMETRIC_RGB :
1340 jpeg_color_space = JCS_RGB;
1341 goto L1;
1342 case PHOTOMETRIC_SEPARATED :
1343 jpeg_color_space = JCS_CMYK;
1344 L1: sp->jpegcolormode = JPEGCOLORMODE_RAW; /* No JPEG Lib. conversion */
1345 L2: out_color_space = jpeg_color_space;
1346 break;
1347 default :
1348 TIFFError(module,bad_photometry,td->td_photometric);
1349 status = 0;
1350 };
1351 if (status == 0) return 0; /* If TIFF errors, don't bother to continue */
1352
1353 /* Set parameters that are same for all strips/tiles. */
1354
1355 sp->cinfo.d.src = &sp->src;
1356 sp->src.init_source = std_init_source;
1357 sp->src.fill_input_buffer = std_fill_input_buffer;
1358 sp->src.skip_input_data = std_skip_input_data;
1359 sp->src.resync_to_restart = jpeg_resync_to_restart;
1360 sp->src.term_source = std_term_source;
1361
1362 /* BOGOSITY ALERT! The Wang Imaging application for Microsoft Windows produces
1363 images containing "JPEGInterchangeFormat[Length]" TIFF
1364 records that resemble JFIF-in-TIFF encapsulations but, in fact, violate the
1365 TIFF Version 6 specification in several ways; nevertheless, we try to handle
1366 them gracefully because there are apparently a lot of them around. The
1367 purported "JFIF" data stream in one of these files vaguely resembles a JPEG
1368 "tables only" data stream, except that there's no trailing EOI marker. The
1369 rest of the JPEG data stream lies in a discontiguous file region, identified
1370 by the 0th Strip offset (which is *also* illegal!), where it begins with an
1371 SOS marker and apparently continues to the end of the file. There is no
1372 trailing EOI marker here, either.
1373 */
1374 is_JFIF = !sp->is_WANG && TIFFFieldSet(tif,FIELD_JPEGIFOFFSET);
1375
1376 /* Initialize decompression parameters that won't be overridden by JPEG Library
1377 defaults set during the "jpeg_read_header()" call, below.
1378 */
1379 segment_width = td->td_imagewidth;
1380 if (isTiled(tif))
1381 {
1382 if (sp->is_WANG) /* we don't know how to handle it */
1383 {
1384 TIFFError(module,"Tiled Wang image not supported");
1385 return 0;
1386 };
1387
1388 /* BOGOSITY ALERT! "TIFFTileRowSize()" seems to work fine for modern JPEG-
1389 in-TIFF encapsulations where the image width--like the
1390 tile width--is a multiple of 8 or 16 pixels. But image widths and
1391 heights are aren't restricted to 8- or 16-bit multiples, and we need
1392 the exact Byte count of decompressed scan lines when we call the JPEG
1393 Library. At least one old file ("zackthecat.tif") in the TIFF Library
1394 test suite has widths and heights slightly less than the tile sizes, and
1395 it apparently used the bogus computation below to determine the number
1396 of Bytes per scan line (was this due to an old, broken version of
1397 "TIFFhowmany()"?). Before we get here, "OJPEGSetupDecode()" verified
1398 that our image uses 8-bit samples, so the following check appears to
1399 return the correct answer in all known cases tested to date.
1400 */
1401 if (is_JFIF || (segment_width & 7) == 0)
1402 sp->bytesperline = TIFFTileRowSize(tif); /* Normal case */
1403 else
1404 {
1405 /* Was the file-encoder's segment-width calculation bogus? */
1406 segment_width = (segment_width/sp->h_sampling + 1) * sp->h_sampling;
1407 sp->bytesperline = segment_width * td->td_samplesperpixel;
1408 }
1409 }
1410 else sp->bytesperline = TIFFVStripSize(tif,1);
1411
1412 /* BEWARE OF KLUDGE: If we have JPEG Interchange File Format (JFIF) image,
1413 then we want to read "metadata" in the bit-stream's
1414 header and validate it against corresponding information in TIFF records.
1415 But if we have a *really old* JPEG file that's not JFIF, then we simply
1416 assign TIFF-record values to JPEG Library variables without checking.
1417 */
1418 if (is_JFIF) /* JFIF image */
1419 { unsigned char *end_of_data;
1420 int subsampling_factors;
1421 register unsigned char *p;
1422 register int i;
1423
1424 /* WARNING: Although the image file contains a JFIF bit stream, it might
1425 also contain some old TIFF records causing "OJPEGVSetField()"
1426 to have allocated quantization or Huffman decoding tables. But when the
1427 JPEG Library reads and parses the JFIF header below, it reallocate these
1428 tables anew without checking for "dangling" pointers, thereby causing a
1429 memory "leak". We have enough information to potentially deallocate the
1430 old tables here, but unfortunately JPEG Library Version 6B uses a "pool"
1431 allocator for small objects, with no deallocation procedure; instead, it
1432 reclaims a whole pool when an image is closed/destroyed, so well-behaved
1433 TIFF client applications (i.e., those which close their JPEG images as
1434 soon as they're no longer needed) will waste memory for a short time but
1435 recover it eventually. But ill-behaved TIFF clients (i.e., those which
1436 keep many JPEG images open gratuitously) can exhaust memory prematurely.
1437 If the JPEG Library ever implements a deallocation procedure, insert
1438 this clean-up code:
1439 */
1440# ifdef someday
1441 if (sp->jpegtablesmode & JPEGTABLESMODE_QUANT) /* free quant. tables */
1442 { register int i = 0;
1443
1444 do
1445 { register JQUANT_TBL *q;
1446
1447 if (q = sp->cinfo.d.quant_tbl_ptrs[i])
1448 {
1449 jpeg_free_small(&sp->cinfo.comm,q,sizeof *q);
1450 sp->cinfo.d.quant_tbl_ptrs[i] = 0;
1451 }
1452 }
1453 while (++i < NUM_QUANT_TBLS);
1454 };
1455 if (sp->jpegtablesmode & JPEGTABLESMODE_HUFF) /* free Huffman tables */
1456 { register int i = 0;
1457
1458 do
1459 { register JHUFF_TBL *h;
1460
1461 if (h = sp->cinfo.d.dc_huff_tbl_ptrs[i])
1462 {
1463 jpeg_free_small(&sp->cinfo.comm,h,sizeof *h);
1464 sp->cinfo.d.dc_huff_tbl_ptrs[i] = 0;
1465 };
1466 if (h = sp->cinfo.d.ac_huff_tbl_ptrs[i])
1467 {
1468 jpeg_free_small(&sp->cinfo.comm,h,sizeof *h);
1469 sp->cinfo.d.ac_huff_tbl_ptrs[i] = 0;
1470 }
1471 }
1472 while (++i < NUM_HUFF_TBLS);
1473 };
1474# endif /* someday */
1475
1476 /* Since we might someday wish to try rewriting "old format" JPEG-in-TIFF
1477 encapsulations in "new format" files, try to synthesize the value of a
1478 modern "JPEGTables" TIFF record by scanning the JPEG data from just past
1479 the "Start of Information" (SOI) marker until something other than a
1480 legitimate "table" marker is found, as defined in ISO IS 10918-1
1481 Appending B.2.4; namely:
1482
1483 -- Define Quantization Table (DQT)
1484 -- Define Huffman Table (DHT)
1485 -- Define Arithmetic Coding table (DAC)
1486 -- Define Restart Interval (DRI)
1487 -- Comment (COM)
1488 -- Application data (APPn)
1489
1490 For convenience, we also accept "Expansion" (EXP) markers, although they
1491 are apparently not a part of normal "table" data.
1492 */
1493 sp->jpegtables = p = (unsigned char *)sp->src.next_input_byte;
1494 end_of_data = p + sp->src.bytes_in_buffer;
1495 p += 2;
1496 while (p < end_of_data && p[0] == 0xFF)
1497 switch (p[1])
1498 {
1499 default : goto L;
1500 case 0xC0: /* SOF0 */
1501 case 0xC1: /* SOF1 */
1502 case 0xC2: /* SOF2 */
1503 case 0xC3: /* SOF3 */
1504 case 0xC4: /* DHT */
1505 case 0xC5: /* SOF5 */
1506 case 0xC6: /* SOF6 */
1507 case 0xC7: /* SOF7 */
1508 case 0xC9: /* SOF9 */
1509 case 0xCA: /* SOF10 */
1510 case 0xCB: /* SOF11 */
1511 case 0xCC: /* DAC */
1512 case 0xCD: /* SOF13 */
1513 case 0xCE: /* SOF14 */
1514 case 0xCF: /* SOF15 */
1515 case 0xDB: /* DQT */
1516 case 0xDD: /* DRI */
1517 case 0xDF: /* EXP */
1518 case 0xE0: /* APP0 */
1519 case 0xE1: /* APP1 */
1520 case 0xE2: /* APP2 */
1521 case 0xE3: /* APP3 */
1522 case 0xE4: /* APP4 */
1523 case 0xE5: /* APP5 */
1524 case 0xE6: /* APP6 */
1525 case 0xE7: /* APP7 */
1526 case 0xE8: /* APP8 */
1527 case 0xE9: /* APP9 */
1528 case 0xEA: /* APP10 */
1529 case 0xEB: /* APP11 */
1530 case 0xEC: /* APP12 */
1531 case 0xED: /* APP13 */
1532 case 0xEE: /* APP14 */
1533 case 0xEF: /* APP15 */
1534 case 0xFE: /* COM */
1535 p += (p[2] << 8 | p[3]) + 2;
1536 };
1537 L: if (p - (unsigned char *)sp->jpegtables > 2) /* fake "JPEGTables" */
1538 {
1539
1540 /* In case our client application asks, pretend that this image file
1541 contains a modern "JPEGTables" TIFF record by copying to a buffer
1542 the initial part of the JFIF bit-stream that we just scanned, from
1543 the SOI marker through the "metadata" tables, then append an EOI
1544 marker and flag the "JPEGTables" TIFF record as "present".
1545 */
1546 sp->jpegtables_length = p - (unsigned char*)sp->jpegtables + 2;
1547 p = sp->jpegtables;
1548 if (!(sp->jpegtables = _TIFFmalloc(sp->jpegtables_length)))
1549 {
1550 TIFFError(module,no_jtable_space);
1551 return 0;
1552 };
1553 _TIFFmemcpy(sp->jpegtables,p,sp->jpegtables_length-2);
1554 p = (unsigned char *)sp->jpegtables + sp->jpegtables_length;
1555 p[-2] = 0xFF; p[-1] = JPEG_EOI; /* Append EOI marker */
1556 TIFFSetFieldBit(tif,FIELD_JPEGTABLES);
1557 tif->tif_flags |= TIFF_DIRTYDIRECT;
1558 }
1559 else sp->jpegtables = 0; /* Don't simulate "JPEGTables" */
1560 if ( CALLJPEG(sp,-1,jpeg_read_header(&sp->cinfo.d,TRUE))
1561 != JPEG_HEADER_OK
1562 ) return 0;
1563 if ( sp->cinfo.d.image_width != segment_width
1564 || sp->cinfo.d.image_height != td->td_imagelength
1565 )
1566 {
1567 TIFFError(module,"Improper JPEG strip/tile size");
1568 return 0;
1569 };
1570 if (sp->cinfo.d.num_components != td->td_samplesperpixel)
1571 {
1572 TIFFError(module,"Improper JPEG component count");
1573 return 0;
1574 };
1575 if (sp->cinfo.d.data_precision != td->td_bitspersample)
1576 {
1577 TIFFError(module,"Improper JPEG data precision");
1578 return 0;
1579 };
1580
1581 /* Check that JPEG image components all have the same subsampling factors
1582 declared (or defaulted) in the TIFF file, since TIFF Version 6.0 is more
1583 restrictive than JPEG: Only the 0th component may have horizontal and
1584 vertical subsampling factors other than <1,1>.
1585 */
1586 subsampling_factors = sp->h_sampling << 3 | sp->v_sampling;
1587 i = 0;
1588 do
1589 {
1590 if ( ( sp->cinfo.d.comp_info[i].h_samp_factor << 3
1591 | sp->cinfo.d.comp_info[i].v_samp_factor
1592 )
1593 != subsampling_factors
1594 )
1595 {
1596 TIFFError(module,"Improper JPEG subsampling factors");
1597 return 0;
1598 };
1599 subsampling_factors = 011; /* Required for image components > 0 */
1600 }
1601 while (++i < sp->cinfo.d.num_components);
1602 }
1603 else /* not JFIF image */
1604 { int (*save)(j_decompress_ptr cinfo) = sp->cinfo.d.marker->read_markers;
1605 register int i;
1606
1607 /* We're not assuming that this file's JPEG bit stream has any header
1608 "metadata", so fool the JPEG Library into thinking that we read a
1609 "Start of Input" (SOI) marker and a "Start of Frame" (SOFx) marker, then
1610 force it to read a simulated "Start of Scan" (SOS) marker when we call
1611 "jpeg_read_header()" below. This should cause the JPEG Library to
1612 establish reasonable defaults.
1613 */
1614 sp->cinfo.d.marker->saw_SOI = /* Pretend we saw SOI marker */
1615 sp->cinfo.d.marker->saw_SOF = TRUE; /* Pretend we saw SOF marker */
1616 sp->cinfo.d.marker->read_markers =
1617 sp->is_WANG ? suspend : fake_SOS_marker;
1618 sp->cinfo.d.global_state = DSTATE_INHEADER;
1619 sp->cinfo.d.Se = DCTSIZE2-1; /* Suppress JPEG Library warning */
1620 sp->cinfo.d.image_width = segment_width;
1621 sp->cinfo.d.image_height = td->td_imagelength;
1622
1623 /* The following color-space initialization, including the complicated
1624 "switch"-statement below, essentially duplicates the logic used by the
1625 JPEG Library's "jpeg_init_colorspace()" subroutine during compression.
1626 */
1627 sp->cinfo.d.num_components = td->td_samplesperpixel;
1628 sp->cinfo.d.comp_info = (jpeg_component_info *)
1629 (*sp->cinfo.d.mem->alloc_small)
1630 ( &sp->cinfo.comm
1631 , JPOOL_IMAGE
1632 , sp->cinfo.d.num_components * sizeof *sp->cinfo.d.comp_info
1633 );
1634 i = 0;
1635 do
1636 {
1637 sp->cinfo.d.comp_info[i].component_index = i;
1638 sp->cinfo.d.comp_info[i].component_needed = TRUE;
1639 sp->cinfo.d.cur_comp_info[i] = &sp->cinfo.d.comp_info[i];
1640 }
1641 while (++i < sp->cinfo.d.num_components);
1642 switch (jpeg_color_space)
1643 {
1644 case JCS_UNKNOWN :
1645 i = 0;
1646 do
1647 {
1648 sp->cinfo.d.comp_info[i].component_id = i;
1649 sp->cinfo.d.comp_info[i].h_samp_factor =
1650 sp->cinfo.d.comp_info[i].v_samp_factor = 1;
1651 }
1652 while (++i < sp->cinfo.d.num_components);
1653 break;
1654 case JCS_GRAYSCALE:
1655 sp->cinfo.d.comp_info[0].component_id =
1656 sp->cinfo.d.comp_info[0].h_samp_factor =
1657 sp->cinfo.d.comp_info[0].v_samp_factor = 1;
1658 break;
1659 case JCS_RGB :
1660 sp->cinfo.d.comp_info[0].component_id = 'R';
1661 sp->cinfo.d.comp_info[1].component_id = 'G';
1662 sp->cinfo.d.comp_info[2].component_id = 'B';
1663 i = 0;
1664 do sp->cinfo.d.comp_info[i].h_samp_factor =
1665 sp->cinfo.d.comp_info[i].v_samp_factor = 1;
1666 while (++i < sp->cinfo.d.num_components);
1667 break;
1668 case JCS_CMYK :
1669 sp->cinfo.d.comp_info[0].component_id = 'C';
1670 sp->cinfo.d.comp_info[1].component_id = 'M';
1671 sp->cinfo.d.comp_info[2].component_id = 'Y';
1672 sp->cinfo.d.comp_info[3].component_id = 'K';
1673 i = 0;
1674 do sp->cinfo.d.comp_info[i].h_samp_factor =
1675 sp->cinfo.d.comp_info[i].v_samp_factor = 1;
1676 while (++i < sp->cinfo.d.num_components);
1677 break;
1678 case JCS_YCbCr :
1679 i = 0;
1680 do
1681 {
1682 sp->cinfo.d.comp_info[i].component_id = i+1;
1683 sp->cinfo.d.comp_info[i].h_samp_factor =
1684 sp->cinfo.d.comp_info[i].v_samp_factor = 1;
1685 sp->cinfo.d.comp_info[i].quant_tbl_no =
1686 sp->cinfo.d.comp_info[i].dc_tbl_no =
1687 sp->cinfo.d.comp_info[i].ac_tbl_no = i > 0;
1688 }
1689 while (++i < sp->cinfo.d.num_components);
1690 sp->cinfo.d.comp_info[0].h_samp_factor = sp->h_sampling;
1691 sp->cinfo.d.comp_info[0].v_samp_factor = sp->v_sampling;
1692 };
1693 sp->cinfo.d.comps_in_scan = td->td_planarconfig == PLANARCONFIG_CONTIG
1694 ? sp->cinfo.d.num_components
1695 : 1;
1696 i = CALLJPEG(sp,-1,jpeg_read_header(&sp->cinfo.d,!sp->is_WANG));
1697 sp->cinfo.d.marker->read_markers = save; /* Restore input method */
1698 if (sp->is_WANG) /* produced by Wang Imaging on Microsoft Windows */
1699 {
1700 if (i != JPEG_SUSPENDED) return 0;
1701
1702 /* BOGOSITY ALERT! Files prooduced by the Wang Imaging application for
1703 Microsoft Windows are a special--and, technically
1704 illegal--case. A JPEG SOS marker and rest of the data stream should
1705 be located at the end of the file, in a position identified by the
1706 0th Strip offset.
1707 */
1708 i = td->td_nstrips - 1;
1709 sp->src.next_input_byte = tif->tif_base + td->td_stripoffset[0];
1710 sp->src.bytes_in_buffer = td->td_stripoffset[i] -
1711 td->td_stripoffset[0] + td->td_stripbytecount[i];
1712 i = CALLJPEG(sp,-1,jpeg_read_header(&sp->cinfo.d,TRUE));
1713 };
1714 if (i != JPEG_HEADER_OK) return 0;
1715 };
1716
1717 /* Some of our initialization must wait until the JPEG Library is initialized
1718 above, in order to override its defaults.
1719 */
1720 if ( (sp->cinfo.d.raw_data_out = downsampled_output)
1721 && !alloc_downsampled_buffers(tif,sp->cinfo.d.comp_info,
1722 sp->cinfo.d.num_components)
1723 ) return 0;
1724 sp->cinfo.d.jpeg_color_space = jpeg_color_space;
1725 sp->cinfo.d.out_color_space = out_color_space;
1726 sp->cinfo.d.dither_mode = JDITHER_NONE; /* Reduce image "noise" */
1727 sp->cinfo.d.two_pass_quantize = FALSE;
1728
1729 /* If the image consists of separate, discontiguous TIFF "samples" (= color
1730 planes, hopefully = JPEG "scans"), then we must use the JPEG Library's
1731 "buffered image" mode to decompress the entire image into temporary buffers,
1732 because the JPEG Library must parse the entire JPEG bit-stream in order to
1733 be satsified that it has a complete set of color components for each pixel,
1734 but the TIFF Library must allow our client to extract 1 component at a time.
1735 Initializing the JPEG Library's "buffered image" mode is tricky: First, we
1736 start its decompressor, then we tell the decompressor to "consume" (i.e.,
1737 buffer) the entire bit-stream.
1738
1739 WARNING: Disabling "fancy" up-sampling seems to slightly reduce "noise" for
1740 certain old Wang Imaging files, but it absolutely *must* be
1741 enabled if the image has separate color planes, since in that case, the JPEG
1742 Library doesn't use an "sp->cinfo.d.cconvert" structure (so de-referencing
1743 this pointer below will cause a fatal crash) but writing our own code to up-
1744 sample separate color planes is too much work for right now. Maybe someday?
1745 */
1746 sp->cinfo.d.do_fancy_upsampling = /* Always let this default (to TRUE)? */
1747 sp->cinfo.d.buffered_image = td->td_planarconfig == PLANARCONFIG_SEPARATE;
1748 if (!CALLJPEG(sp,0,jpeg_start_decompress(&sp->cinfo.d))) return 0;
1749 if (sp->cinfo.d.buffered_image) /* separate color planes */
1750 {
1751 if (sp->cinfo.d.raw_data_out)
1752 tif->tif_decoderow = tif->tif_decodestrip = tif->tif_decodetile =
1753 OJPEGDecodeRawSeparate;
1754 else
1755 {
1756 tif->tif_decoderow = tif->tif_decodestrip = tif->tif_decodetile =
1757 OJPEGDecode;
1758
1759 /* In JPEG Library Version 6B, color-space conversion isn't implemented
1760 for separate color planes, so we must do it ourself if our TIFF
1761 client doesn't want to:
1762 */
1763 sp->cinfo.d.cconvert->color_convert =
1764 sp->cinfo.d.jpeg_color_space == sp->cinfo.d.out_color_space
1765 ? null_convert : ycc_rgb_convert;
1766 };
1767 L3: switch (CALLJPEG(sp,0,jpeg_consume_input(&sp->cinfo.d)))
1768 {
1769 default : goto L3;
1770
1771 /* If no JPEG "End of Information" (EOI) marker is found when bit-
1772 stream parsing ends, check whether we have enough data to proceed
1773 before reporting an error.
1774 */
1775 case JPEG_SUSPENDED : if ( sp->cinfo.d.input_scan_number
1776 *sp->cinfo.d.image_height
1777 + sp->cinfo.d.input_iMCU_row
1778 *sp->cinfo.d.max_v_samp_factor
1779# ifdef D_LOSSLESS_SUPPORTED
1780 *sp->cinfo.d.data_units_in_MCU
1781 *sp->cinfo.d.min_codec_data_unit
1782# else
1783 *sp->cinfo.d.blocks_in_MCU
1784 *DCTSIZE
1785# endif
1786 < td->td_samplesperpixel
1787 *sp->cinfo.d.image_height
1788 )
1789 {
1790 TIFFError(tif->tif_name,
1791 "Premature end of JPEG bit-stream");
1792 return 0;
1793 }
1794 case JPEG_REACHED_EOI: ;
1795 }
1796 }
1797 else /* pixel-interleaved color planes */
1798 tif->tif_decoderow = tif->tif_decodestrip = tif->tif_decodetile =
1799 downsampled_output ? OJPEGDecodeRawContig : OJPEGDecode;
1800 return 1;
1801# undef td
1802 }
1803
1804static int
1805OJPEGPreDecode(register TIFF *tif,tsample_t s)
1806 { register OJPEGState *sp = OJState(tif);
1807# define td (&tif->tif_dir)
1808
1809 /* If we are about to read the first row of an image plane (hopefully, these
1810 are coincident with JPEG "scans"!), reset the JPEG Library's decompressor
1811 appropriately. Otherwise, let the decompressor run "as is" and return a
1812 "success" status without further ado.
1813 */
1814 if ( (isTiled(tif) ? tif->tif_curtile : tif->tif_curstrip)
1815 % td->td_stripsperimage
1816 == 0
1817 )
1818 {
1819 if ( sp->cinfo.d.buffered_image
1820 && !CALLJPEG(sp,0,jpeg_start_output(&sp->cinfo.d,s+1))
1821 ) return 0;
1822 sp->cinfo.d.output_scanline = 0;
1823
1824 /* Mark subsampling buffers "empty". */
1825
1826# ifdef D_LOSSLESS_SUPPORTED
1827 sp->scancount = sp->cinfo.d.min_codec_data_unit;
1828# else
1829 sp->scancount = DCTSIZE;
1830# endif
1831 };
1832 return 1;
1833# undef td
1834 }
1835
1836/*ARGSUSED*/ static void
1837OJPEGPostDecode(register TIFF *tif,tidata_t buf,tsize_t cc)
1838 { register OJPEGState *sp = OJState(tif);
1839# define td (&tif->tif_dir)
1840
1841 /* The JPEG Library decompressor has reached the end of a strip/tile. If this
1842 is the end of a TIFF image "sample" (= JPEG "scan") in a file with separate
1843 components (color planes), then end the "scan". If it ends the image's last
1844 sample/scan, then also stop the JPEG Library's decompressor.
1845 */
1846 if (sp->cinfo.d.output_scanline >= sp->cinfo.d.output_height)
1847 {
1848 if (sp->cinfo.d.buffered_image)
1849 CALLJPEG(sp,-1,jpeg_finish_output(&sp->cinfo.d)); /* End JPEG scan */
1850 if ( (isTiled(tif) ? tif->tif_curtile : tif->tif_curstrip)
1851 >= td->td_nstrips-1
1852 ) CALLJPEG(sp,0,jpeg_finish_decompress(&sp->cinfo.d));
1853 }
1854# undef td
1855 }
1856
1857static int
1858OJPEGVSetField(register TIFF *tif,ttag_t tag,va_list ap)
1859{
1860 uint32 v32;
1861 register OJPEGState *sp = OJState(tif);
1862# define td (&tif->tif_dir)
1863 toff_t tiffoff=0;
1864 uint32 bufoff=0;
1865 uint32 code_count=0;
1866 int i2=0;
1867 int k2=0;
1868
1869 switch (tag)
1870 {
1871
1872 /* If a "ReferenceBlackWhite" TIFF tag appears in the file explicitly, undo
1873 any modified default definition that we might have installed below, then
1874 install the real one.
1875 */
1876 case TIFFTAG_REFERENCEBLACKWHITE : if (td->td_refblackwhite)
1877 {
1878 _TIFFfree(td->td_refblackwhite);
1879 td->td_refblackwhite = 0;
1880 };
1881 default : return
1882 (*sp->vsetparent)(tif,tag,ap);
1883
1884 /* BEWARE OF KLUDGE: Some old-format JPEG-in-TIFF files, including those
1885 produced by the Wang Imaging application for Micro-
1886 soft Windows, illegally omit a "ReferenceBlackWhite" TIFF tag, even
1887 though the TIFF specification's default is intended for the RGB color
1888 space and is inappropriate for the YCbCr color space ordinarily used for
1889 JPEG images. Since many TIFF client applications request the value of
1890 this tag immediately after a TIFF image directory is parsed, and before
1891 any other code in this module receives control, we are forced to fix
1892 this problem very early in image-file processing. Fortunately, legal
1893 TIFF files are supposed to store their tags in numeric order, so a
1894 mandatory "PhotometricInterpretation" tag should always appear before
1895 an optional "ReferenceBlackWhite" tag. Hence, we slyly peek ahead when
1896 we discover the desired photometry, by installing modified black and
1897 white reference levels.
1898 */
1899 case TIFFTAG_PHOTOMETRIC :
1900 if ( (v32 = (*sp->vsetparent)(tif,tag,ap))
1901 && td->td_photometric == PHOTOMETRIC_YCBCR
1902 )
1903 {
1904 if ( (td->td_refblackwhite = _TIFFmalloc(6*sizeof(float))) )
1905 { register long top = 1 << td->td_bitspersample;
1906
1907 td->td_refblackwhite[0] = 0;
1908 td->td_refblackwhite[1] = td->td_refblackwhite[3] =
1909 td->td_refblackwhite[5] = top - 1;
1910 td->td_refblackwhite[2] = td->td_refblackwhite[4] = top >> 1;
1911 }
1912 else
1913 {
1914 TIFFError(tif->tif_name,
1915 "Cannot set default reference black and white levels");
1916 v32 = 0;
1917 };
1918 }
1919 return v32;
1920
1921 /* BEWARE OF KLUDGE: According to Charles Auer <Bumble731@msn.com>, if our
1922 input is a multi-image (multi-directory) JPEG-in-TIFF
1923 file is produced by the Wang Imaging application on Microsoft Windows,
1924 for some reason the first directory excludes the vendor-specific "WANG
1925 PageControl" tag (32934) that we check below, so the only other way to
1926 identify these directories is apparently to look for a software-
1927 identification tag with the substring, "Wang Labs". Single-image files
1928 can apparently pass both tests, which causes no harm here, but what a
1929 mess this is!
1930 */
1931 case TIFFTAG_SOFTWARE :
1932 {
1933 char *software;
1934
1935 v32 = (*sp->vsetparent)(tif,tag,ap);
1936 if( TIFFGetField( tif, TIFFTAG_SOFTWARE, &software )
1937 && strstr( software, "Wang Labs" ) )
1938 sp->is_WANG = 1;
1939 return v32;
1940 }
1941
1942 case TIFFTAG_JPEGPROC :
1943 case TIFFTAG_JPEGIFOFFSET :
1944 case TIFFTAG_JPEGIFBYTECOUNT :
1945 case TIFFTAG_JPEGRESTARTINTERVAL :
1946 case TIFFTAG_JPEGLOSSLESSPREDICTORS:
1947 case TIFFTAG_JPEGPOINTTRANSFORM :
1948 case TIFFTAG_JPEGQTABLES :
1949 case TIFFTAG_JPEGDCTABLES :
1950 case TIFFTAG_JPEGACTABLES :
1951 case TIFFTAG_WANG_PAGECONTROL :
1952 case TIFFTAG_JPEGCOLORMODE : ;
1953 };
1954 v32 = va_arg(ap,uint32); /* No. of values in this TIFF record */
1955
1956 /* This switch statement is added for OJPEGVSetField */
1957 if(v32 !=0){
1958 switch(tag){
1959 case TIFFTAG_JPEGPROC:
1960 sp->jpegproc=v32;
1961 break;
1962 case TIFFTAG_JPEGIFOFFSET:
1963 sp->jpegifoffset=v32;
1964 break;
1965 case TIFFTAG_JPEGIFBYTECOUNT:
1966 sp->jpegifbytecount=v32;
1967 break;
1968 case TIFFTAG_JPEGRESTARTINTERVAL:
1969 sp->jpegrestartinterval=v32;
1970 break;
1971 case TIFFTAG_JPEGLOSSLESSPREDICTORS:
1972 sp->jpeglosslesspredictors_length=v32;
1973 break;
1974 case TIFFTAG_JPEGPOINTTRANSFORM:
1975 sp->jpegpointtransform_length=v32;
1976 break;
1977 case TIFFTAG_JPEGQTABLES:
1978 sp->jpegqtables_length=v32;
1979 break;
1980 case TIFFTAG_JPEGACTABLES:
1981 sp->jpegactables_length=v32;
1982 break;
1983 case TIFFTAG_JPEGDCTABLES:
1984 sp->jpegdctables_length=v32;
1985 break;
1986 default:
1987 break;
1988 }
1989 }
1990
1991 /* BEWARE: The following actions apply only if we are reading a "source" TIFF
1992 image to be decompressed for a client application program. If we
1993 ever enhance this file's CODEC to write "destination" JPEG-in-TIFF images,
1994 we'll need an "if"- and another "switch"-statement below, because we'll
1995 probably want to store these records' values in some different places. Most
1996 of these need not be parsed here in order to decode JPEG bit stream, so we
1997 set boolean flags to note that they have been seen, but we otherwise ignore
1998 them.
1999 */
2000 switch (tag)
2001 { JHUFF_TBL **h;
2002
2003 /* Validate the JPEG-process code. */
2004
2005 case TIFFTAG_JPEGPROC :
2006 switch (v32)
2007 {
2008 default : TIFFError(tif->tif_name,
2009 "Unknown JPEG process");
2010 return 0;
2011# ifdef C_LOSSLESS_SUPPORTED
2012
2013 /* Image uses (lossy) baseline sequential coding. */
2014
2015 case JPEGPROC_BASELINE: sp->cinfo.d.process = JPROC_SEQUENTIAL;
2016 sp->cinfo.d.data_unit = DCTSIZE;
2017 break;
2018
2019 /* Image uses (lossless) Huffman coding. */
2020
2021 case JPEGPROC_LOSSLESS: sp->cinfo.d.process = JPROC_LOSSLESS;
2022 sp->cinfo.d.data_unit = 1;
2023# else /* not C_LOSSLESS_SUPPORTED */
2024 case JPEGPROC_LOSSLESS: TIFFError(JPEGLib_name,
2025 "Does not support lossless Huffman coding");
2026 return 0;
2027 case JPEGPROC_BASELINE: ;
2028# endif /* C_LOSSLESS_SUPPORTED */
2029 };
2030 break;
2031
2032 /* The TIFF Version 6.0 specification says that if the value of a TIFF
2033 "JPEGInterchangeFormat" record is 0, then we are to behave as if this
2034 record were absent; i.e., the data does *not* represent a JPEG Inter-
2035 change Format File (JFIF), so don't even set the boolean "I've been
2036 here" flag below. Otherwise, the field's value represents the file
2037 offset of the JPEG SOI marker.
2038 */
2039 case TIFFTAG_JPEGIFOFFSET :
2040 if (v32)
2041 {
2042 sp->src.next_input_byte = tif->tif_base + v32;
2043 break;
2044 };
2045 return 1;
2046 case TIFFTAG_JPEGIFBYTECOUNT :
2047 sp->src.bytes_in_buffer = v32;
2048 break;
2049
2050 /* The TIFF Version 6.0 specification says that if the JPEG "Restart"
2051 marker interval is 0, then the data has no "Restart" markers; i.e., we
2052 must behave as if this TIFF record were absent. So, don't even set the
2053 boolean "I've been here" flag below.
2054 */
2055 /*
2056 * Instead, set the field bit so TIFFGetField can get whether or not
2057 * it was set.
2058 */
2059 case TIFFTAG_JPEGRESTARTINTERVAL :
2060 if (v32)
2061 sp->cinfo.d.restart_interval = v32;
2062 break;
2063 /* The TIFF Version 6.0 specification says that this tag is supposed to be
2064 a vector containing a value for each image component, but for lossless
2065 Huffman coding (the only JPEG process defined by the specification for
2066 which this tag should be needed), ISO IS 10918-1 uses only a single
2067 value, equivalent to the "Ss" field in a JPEG bit-stream's "Start of
2068 Scan" (SOS) marker. So, we extract the first vector element and ignore
2069 the rest. (I hope this is correct!)
2070 */
2071 case TIFFTAG_JPEGLOSSLESSPREDICTORS:
2072 if (v32)
2073 {
2074 sp->cinfo.d.Ss = *va_arg(ap,uint16 *);
2075 sp->jpeglosslesspredictors =
2076 _TIFFmalloc(sp->jpeglosslesspredictors_length
2077 * sizeof(uint16));
2078 if(sp->jpeglosslesspredictors==NULL){return(0);}
2079 for(i2=0;i2<sp->jpeglosslesspredictors_length;i2++){
2080 ((uint16*)sp->jpeglosslesspredictors)[i2] =
2081 ((uint16*)sp->cinfo.d.Ss)[i2];
2082 }
2083 sp->jpeglosslesspredictors_length*=sizeof(uint16);
2084 break;
2085 };
2086 return v32;
2087
2088 /* The TIFF Version 6.0 specification says that this tag is supposed to be
2089 a vector containing a value for each image component, but for lossless
2090 Huffman coding (the only JPEG process defined by the specification for
2091 which this tag should be needed), ISO IS 10918-1 uses only a single
2092 value, equivalent to the "Al" field in a JPEG bit-stream's "Start of
2093 Scan" (SOS) marker. So, we extract the first vector element and ignore
2094 the rest. (I hope this is correct!)
2095 */
2096 case TIFFTAG_JPEGPOINTTRANSFORM :
2097 if (v32)
2098 {
2099 sp->cinfo.d.Al = *va_arg(ap,uint16 *);
2100 sp->jpegpointtransform =
2101 _TIFFmalloc(sp->jpegpointtransform_length*sizeof(uint16));
2102 if(sp->jpegpointtransform==NULL){return(0);}
2103 for(i2=0;i2<sp->jpegpointtransform_length;i2++) {
2104 ((uint16*)sp->jpegpointtransform)[i2] =
2105 ((uint16*)sp->cinfo.d.Al)[i2];
2106 }
2107 sp->jpegpointtransform_length*=sizeof(uint16);
2108 break;
2109 }
2110 return v32;
2111
2112 /* We have a vector of offsets to quantization tables, so load 'em! */
2113
2114 case TIFFTAG_JPEGQTABLES :
2115 if (v32)
2116 { uint32 *v;
2117 int i;
2118 if (v32 > NUM_QUANT_TBLS)
2119 {
2120 TIFFError(tif->tif_name,"Too many quantization tables");
2121 return 0;
2122 };
2123 i = 0;
2124 v = va_arg(ap,uint32 *);
2125 sp->jpegqtables=_TIFFmalloc(64*sp->jpegqtables_length);
2126 if(sp->jpegqtables==NULL){return(0);}
2127 tiffoff = TIFFSeekFile(tif, 0, SEEK_CUR);
2128 bufoff=0;
2129 for(i2=0;i2<sp->jpegqtables_length;i2++){
2130 TIFFSeekFile(tif, v[i2], SEEK_SET);
2131 TIFFReadFile(tif, &(((u_char*)(sp->jpegqtables))[bufoff]),
2132 64);
2133 bufoff+=64;
2134 }
2135 sp->jpegqtables_length=bufoff;
2136 TIFFSeekFile(tif, tiffoff, SEEK_SET);
2137
2138 do /* read quantization table */
2139 { register UINT8 *from = tif->tif_base + *v++;
2140 register UINT16 *to;
2141 register int j = DCTSIZE2;
2142
2143 if (!( sp->cinfo.d.quant_tbl_ptrs[i]
2144 = CALLJPEG(sp,0,jpeg_alloc_quant_table(&sp->cinfo.comm))
2145 )
2146 )
2147 {
2148 TIFFError(JPEGLib_name,"No space for quantization table");
2149 return 0;
2150 };
2151 to = sp->cinfo.d.quant_tbl_ptrs[i]->quantval;
2152 do *to++ = *from++; while (--j > 0);
2153 }
2154 while (++i < v32);
2155 sp->jpegtablesmode |= JPEGTABLESMODE_QUANT;
2156 };
2157 break;
2158
2159 /* We have a vector of offsets to DC Huffman tables, so load 'em! */
2160
2161 case TIFFTAG_JPEGDCTABLES :
2162 h = sp->cinfo.d.dc_huff_tbl_ptrs;
2163 goto L;
2164
2165 /* We have a vector of offsets to AC Huffman tables, so load 'em! */
2166
2167 case TIFFTAG_JPEGACTABLES :
2168 h = sp->cinfo.d.ac_huff_tbl_ptrs;
2169 L: if (v32)
2170 { uint32 *v;
2171 int i;
2172 if (v32 > NUM_HUFF_TBLS)
2173 {
2174 TIFFError(tif->tif_name,"Too many Huffman tables");
2175 return 0;
2176 };
2177 v = va_arg(ap,uint32 *);
2178 if(tag == TIFFTAG_JPEGDCTABLES) {
2179 sp->jpegdctables=_TIFFmalloc(272*sp->jpegdctables_length);
2180 if(sp->jpegdctables==NULL){return(0);}
2181 tiffoff = TIFFSeekFile(tif, 0, SEEK_CUR);
2182 bufoff=0;
2183 code_count=0;
2184 for(i2=0;i2<sp->jpegdctables_length;i2++){
2185 TIFFSeekFile(tif, v[i2], SEEK_SET);
2186 TIFFReadFile(tif,
2187 &(((u_char*)(sp->jpegdctables))[bufoff]),
2188 16);
2189 code_count=0;
2190 for(k2=0;k2<16;k2++){
2191 code_count+=((u_char*)(sp->jpegdctables))[k2+bufoff];
2192 }
2193 TIFFReadFile(tif,
2194 &(((u_char*)(sp->jpegdctables))[bufoff+16]),
2195 code_count);
2196 bufoff+=16;
2197 bufoff+=code_count;
2198 }
2199 sp->jpegdctables_length=bufoff;
2200 TIFFSeekFile(tif, tiffoff, SEEK_SET);
2201 }
2202 if(tag==TIFFTAG_JPEGACTABLES){
2203 sp->jpegactables=_TIFFmalloc(272*sp->jpegactables_length);
2204 if(sp->jpegactables==NULL){return(0);}
2205 tiffoff = TIFFSeekFile(tif, 0, SEEK_CUR);
2206 bufoff=0;
2207 code_count=0;
2208 for(i2=0;i2<sp->jpegactables_length;i2++){
2209 TIFFSeekFile(tif, v[i2], SEEK_SET);
2210 TIFFReadFile(tif, &(((unsigned char*)(sp->jpegactables))[bufoff]), 16);
2211 code_count=0;
2212 for(k2=0;k2<16;k2++){
2213 code_count+=((unsigned char*)(sp->jpegactables))[k2+bufoff];
2214 }
2215 TIFFReadFile(tif, &(((unsigned char*)(sp->jpegactables))[bufoff+16]), code_count);
2216 bufoff+=16;
2217 bufoff+=code_count;
2218 }
2219 sp->jpegactables_length=bufoff;
2220 TIFFSeekFile(tif, tiffoff, SEEK_SET);
2221 }
2222 i = 0;
2223 do /* copy each Huffman table */
2224 { int size = 0;
2225 register UINT8 *from = tif->tif_base + *v++, *to;
2226 register int j = sizeof (*h)->bits;
2227
2228 /* WARNING: This code relies on the fact that an image file not
2229 "memory mapped" was read entirely into a single
2230 buffer by "TIFFInitOJPEG()", so we can do a fast memory-to-
2231 memory copy here. Each table consists of 16 Bytes, which are
2232 suffixed to a 0 Byte when copied, followed by a variable
2233 number of Bytes whose length is the sum of the first 16.
2234 */
2235 if (!( *h
2236 = CALLJPEG(sp,0,jpeg_alloc_huff_table(&sp->cinfo.comm))
2237 )
2238 )
2239 {
2240 TIFFError(JPEGLib_name,"No space for Huffman table");
2241 return 0;
2242 };
2243 to = (*h++)->bits;
2244 *to++ = 0;
2245 while (--j > 0) size += *to++ = *from++; /* Copy 16 Bytes */
2246 if (size > sizeof (*h)->huffval/sizeof *(*h)->huffval)
2247 {
2248 TIFFError(tif->tif_name,"Huffman table too big");
2249 return 0;
2250 };
2251 if ((j = size) > 0) do *to++ = *from++; while (--j > 0);
2252 while (++size <= sizeof (*h)->huffval/sizeof *(*h)->huffval)
2253 *to++ = 0; /* Zero the rest of the table for cleanliness */
2254 }
2255 while (++i < v32);
2256 sp->jpegtablesmode |= JPEGTABLESMODE_HUFF;
2257 };
2258 break;
2259
2260 /* The following vendor-specific TIFF tag occurs in (highly illegal) files
2261 produced by the Wang Imaging application for Microsoft Windows. These
2262 can apparently have several "pages", in which case this tag specifies
2263 the offset of a "page control" structure, which we don't currently know
2264 how to handle. 0 indicates a 1-page image with no "page control", which
2265 we make a feeble effort to handle.
2266 */
2267 case TIFFTAG_WANG_PAGECONTROL :
2268 if (v32 == 0) v32 = -1;
2269 sp->is_WANG = v32;
2270 tag = TIFFTAG_JPEGPROC+FIELD_WANG_PAGECONTROL-FIELD_JPEGPROC;
2271 break;
2272
2273 /* This pseudo tag indicates whether our caller is expected to do YCbCr <->
2274 RGB color-space conversion (JPEGCOLORMODE_RAW <=> 0) or whether we must
2275 ask the JPEG Library to do it (JPEGCOLORMODE_RGB <=> 1).
2276 */
2277 case TIFFTAG_JPEGCOLORMODE :
2278 sp->jpegcolormode = v32;
2279
2280 /* Mark the image to indicate whether returned data is up-sampled, so
2281 that "TIFF{Strip,Tile}Size()" reflect the true amount of data present.
2282 */
2283 v32 = tif->tif_flags; /* Save flags temporarily */
2284 tif->tif_flags &= ~TIFF_UPSAMPLED;
2285 if ( td->td_photometric == PHOTOMETRIC_YCBCR
2286 && (td->td_ycbcrsubsampling[0]<<3 | td->td_ycbcrsubsampling[1])
2287 != 011
2288 && sp->jpegcolormode == JPEGCOLORMODE_RGB
2289 ) tif->tif_flags |= TIFF_UPSAMPLED;
2290
2291 /* If the up-sampling state changed, re-calculate tile size. */
2292
2293 if ((tif->tif_flags ^ v32) & TIFF_UPSAMPLED)
2294 {
2295 tif->tif_tilesize = TIFFTileSize(tif);
2296 tif->tif_flags |= TIFF_DIRTYDIRECT;
2297 };
2298 return 1;
2299 };
2300 TIFFSetFieldBit(tif,tag-TIFFTAG_JPEGPROC+FIELD_JPEGPROC);
2301 return 1;
2302# undef td
2303 }
2304
2305static int
2306OJPEGVGetField(register TIFF *tif,ttag_t tag,va_list ap)
2307 { register OJPEGState *sp = OJState(tif);
2308
2309 switch (tag)
2310 {
2311
2312 /* If this file has managed to synthesize a set of consolidated "metadata"
2313 tables for the current (post-TIFF Version 6.0 specification) JPEG-in-
2314 TIFF encapsulation strategy, then tell our caller about them; otherwise,
2315 keep mum.
2316 */
2317 case TIFFTAG_JPEGTABLES :
2318 if (sp->jpegtables_length) /* we have "new"-style JPEG tables */
2319 {
2320 *va_arg(ap,uint32 *) = sp->jpegtables_length;
2321 *va_arg(ap,char **) = sp->jpegtables;
2322 return 1;
2323 };
2324
2325 /* This pseudo tag indicates whether our caller is expected to do YCbCr <->
2326 RGB color-space conversion (JPEGCOLORMODE_RAW <=> 0) or whether we must
2327 ask the JPEG Library to do it (JPEGCOLORMODE_RGB <=> 1).
2328 */
2329 case TIFFTAG_JPEGCOLORMODE :
2330 *va_arg(ap,uint32 *) = sp->jpegcolormode;
2331 return 1;
2332
2333 /* The following tags are defined by the TIFF Version 6.0 specification
2334 and are obsolete. If our caller asks for information about them, do not
2335 return anything, even if we parsed them in an old-format "source" image.
2336 */
2337 case TIFFTAG_JPEGPROC :
2338 *va_arg(ap, uint16*)=sp->jpegproc;
2339 return(1);
2340 break;
2341 case TIFFTAG_JPEGIFOFFSET :
2342 *va_arg(ap, uint32*)=sp->jpegifoffset;
2343 return(1);
2344 break;
2345 case TIFFTAG_JPEGIFBYTECOUNT :
2346 *va_arg(ap, uint32*)=sp->jpegifbytecount;
2347 return(1);
2348 break;
2349 case TIFFTAG_JPEGRESTARTINTERVAL :
2350 *va_arg(ap, uint32*)=sp->jpegrestartinterval;
2351 return(1);
2352 break;
2353 case TIFFTAG_JPEGLOSSLESSPREDICTORS:
2354 *va_arg(ap, uint32*)=sp->jpeglosslesspredictors_length;
2355 *va_arg(ap, void**)=sp->jpeglosslesspredictors;
2356 return(1);
2357 break;
2358 case TIFFTAG_JPEGPOINTTRANSFORM :
2359 *va_arg(ap, uint32*)=sp->jpegpointtransform_length;
2360 *va_arg(ap, void**)=sp->jpegpointtransform;
2361 return(1);
2362 break;
2363 case TIFFTAG_JPEGQTABLES :
2364 *va_arg(ap, uint32*)=sp->jpegqtables_length;
2365 *va_arg(ap, void**)=sp->jpegqtables;
2366 return(1);
2367 break;
2368 case TIFFTAG_JPEGDCTABLES :
2369 *va_arg(ap, uint32*)=sp->jpegdctables_length;
2370 *va_arg(ap, void**)=sp->jpegdctables;
2371 return(1);
2372 break;
2373 case TIFFTAG_JPEGACTABLES :
2374 *va_arg(ap, uint32*)=sp->jpegactables_length;
2375 *va_arg(ap, void**)=sp->jpegactables;
2376 return(1);
2377 break;
2378 };
2379 return (*sp->vgetparent)(tif,tag,ap);
2380 }
2381
2382static void
2383OJPEGPrintDir(register TIFF *tif,FILE *fd,long flags)
2384 { register OJPEGState *sp = OJState(tif);
2385
2386 if ( ( flags
2387 & (TIFFPRINT_JPEGQTABLES|TIFFPRINT_JPEGDCTABLES|TIFFPRINT_JPEGACTABLES)
2388 )
2389 && sp->jpegtables_length
2390 )
2391 fprintf(fd," JPEG Table Data: <present>, %lu bytes\n",
2392 sp->jpegtables_length);
2393 }
2394
2395static uint32
2396OJPEGDefaultStripSize(register TIFF *tif,register uint32 s)
2397 { register OJPEGState *sp = OJState(tif);
2398# define td (&tif->tif_dir)
2399
2400 if ((s = (*sp->defsparent)(tif,s)) < td->td_imagelength)
2401 { register tsize_t size = sp->cinfo.comm.is_decompressor
2402# ifdef D_LOSSLESS_SUPPORTED
2403 ? sp->cinfo.d.min_codec_data_unit
2404# else
2405 ? DCTSIZE
2406# endif
2407# ifdef C_LOSSLESS_SUPPORTED
2408 : sp->cinfo.c.data_unit;
2409# else
2410 : DCTSIZE;
2411# endif
2412
2413 size = TIFFroundup(size,16);
2414 s = TIFFroundup(s,td->td_ycbcrsubsampling[1]*size);
2415 };
2416 return s;
2417# undef td
2418 }
2419
2420static void
2421OJPEGDefaultTileSize(register TIFF *tif,register uint32 *tw,register uint32 *th)
2422 { register OJPEGState *sp = OJState(tif);
2423 register tsize_t size;
2424# define td (&tif->tif_dir)
2425
2426 size = sp->cinfo.comm.is_decompressor
2427# ifdef D_LOSSLESS_SUPPORTED
2428 ? sp->cinfo.d.min_codec_data_unit
2429# else
2430 ? DCTSIZE
2431# endif
2432# ifdef C_LOSSLESS_SUPPORTED
2433 : sp->cinfo.c.data_unit;
2434# else
2435 : DCTSIZE;
2436# endif
2437 size = TIFFroundup(size,16);
2438 (*sp->deftparent)(tif,tw,th);
2439 *tw = TIFFroundup(*tw,td->td_ycbcrsubsampling[0]*size);
2440 *th = TIFFroundup(*th,td->td_ycbcrsubsampling[1]*size);
2441# undef td
2442 }
2443
2444static void
2445OJPEGCleanUp(register TIFF *tif)
2446 { register OJPEGState *sp;
2447
2448 if ( (sp = OJState(tif)) )
2449 {
2450 CALLVJPEG(sp,jpeg_destroy(&sp->cinfo.comm)); /* Free JPEG Lib. vars. */
2451 if (sp->jpegtables) {_TIFFfree(sp->jpegtables);sp->jpegtables=0;}
2452 if (sp->jpeglosslesspredictors) {
2453 _TIFFfree(sp->jpeglosslesspredictors);
2454 sp->jpeglosslesspredictors = 0;
2455 }
2456 if (sp->jpegpointtransform) {
2457 _TIFFfree(sp->jpegpointtransform);
2458 sp->jpegpointtransform=0;
2459 }
2460 if (sp->jpegqtables) {_TIFFfree(sp->jpegqtables);sp->jpegqtables=0;}
2461 if (sp->jpegactables) {_TIFFfree(sp->jpegactables);sp->jpegactables=0;}
2462 if (sp->jpegdctables) {_TIFFfree(sp->jpegdctables);sp->jpegdctables=0;}
2463 /* If the image file isn't "memory mapped" and we read it all into a
2464 single, large memory buffer, free the buffer now.
2465 */
2466 if (!isMapped(tif) && tif->tif_base) /* free whole-file buffer */
2467 {
2468 _TIFFfree(tif->tif_base);
2469 tif->tif_base = 0;
2470 tif->tif_size = 0;
2471 };
2472 _TIFFfree(sp); /* Release local variables */
2473 tif->tif_data = 0;
2474 }
2475 }
2476
2477int
2478TIFFInitOJPEG(register TIFF *tif,int scheme)
2479 { register OJPEGState *sp;
2480# define td (&tif->tif_dir)
2481# ifndef never
2482
2483 /* This module supports a decompression-only CODEC, which is intended strictly
2484 for viewing old image files using the obsolete JPEG-in-TIFF encapsulation
2485 specified by the TIFF Version 6.0 specification. It does not, and never
2486 should, support compression for new images. If a client application asks us
2487 to, refuse and complain loudly!
2488 */
2489 if (tif->tif_mode != O_RDONLY) return _notSupported(tif);
2490# endif /* never */
2491 if (!isMapped(tif))
2492 {
2493
2494 /* BEWARE OF KLUDGE: If our host operating-system doesn't let an image
2495 file be "memory mapped", then we want to read the
2496 entire file into a single (possibly large) memory buffer as if it had
2497 been "memory mapped". Although this is likely to waste space, because
2498 analysis of the file's content might cause parts of it to be read into
2499 smaller buffers duplicatively, it appears to be the lesser of several
2500 evils. Very old JPEG-in-TIFF encapsulations aren't guaranteed to be
2501 JFIF bit streams, or to have a TIFF "JPEGTables" record or much other
2502 "metadata" to help us locate the decoding tables and entropy-coded data,
2503 so we're likely do a lot of random-access grokking around, and we must
2504 ultimately tell the JPEG Library to sequentially scan much of the file
2505 anyway. This is all likely to be easier if we use "brute force" to
2506 read the entire file, once, and don't use incremental disc I/O. If our
2507 client application tries to process a file so big that we can't buffer
2508 it entirely, then tough shit: we'll give up and exit!
2509 */
2510 if (!(tif->tif_base = _TIFFmalloc(tif->tif_size=TIFFGetFileSize(tif))))
2511 {
2512 TIFFError(tif->tif_name,"Cannot allocate file buffer");
2513 return 0;
2514 };
2515 if (!SeekOK(tif,0) || !ReadOK(tif,tif->tif_base,tif->tif_size))
2516 {
2517 TIFFError(tif->tif_name,"Cannot read file");
2518 return 0;
2519 }
2520 };
2521
2522 /* Allocate storage for this module's per-file variables. */
2523
2524 if (!(tif->tif_data = (tidata_t)_TIFFmalloc(sizeof *sp)))
2525 {
2526 TIFFError("TIFFInitOJPEG","No space for JPEG state block");
2527 return 0;
2528 };
2529 (sp = OJState(tif))->tif = tif; /* Initialize reverse pointer */
2530 sp->cinfo.d.err = jpeg_std_error(&sp->err); /* Initialize error handling */
2531 sp->err.error_exit = TIFFojpeg_error_exit;
2532 sp->err.output_message = TIFFojpeg_output_message;
2533 if (!CALLVJPEG(sp,jpeg_create_decompress(&sp->cinfo.d))) return 0;
2534
2535 /* Install CODEC-specific tag information and override default TIFF Library
2536 "method" subroutines with our own, CODEC-specific methods. Like all good
2537 members of an object-class, we save some of these subroutine pointers for
2538 "fall back" in case our own methods fail.
2539 */
2540 _TIFFMergeFieldInfo(tif,ojpegFieldInfo,
2541 sizeof ojpegFieldInfo/sizeof *ojpegFieldInfo);
2542 sp->defsparent = tif->tif_defstripsize;
2543 sp->deftparent = tif->tif_deftilesize;
2544 sp->vgetparent = tif->tif_tagmethods.vgetfield;
2545 sp->vsetparent = tif->tif_tagmethods.vsetfield;
2546 tif->tif_defstripsize = OJPEGDefaultStripSize;
2547 tif->tif_deftilesize = OJPEGDefaultTileSize;
2548 tif->tif_tagmethods.vgetfield = OJPEGVGetField;
2549 tif->tif_tagmethods.vsetfield = OJPEGVSetField;
2550 tif->tif_tagmethods.printdir = OJPEGPrintDir;
2551# ifdef never
2552 tif->tif_setupencode = OJPEGSetupEncode;
2553 tif->tif_preencode = OJPEGPreEncode;
2554 tif->tif_postencode = OJPEGPostEncode;
2555# else /* well, hardly ever */
2556 tif->tif_setupencode = tif->tif_postencode = _notSupported;
2557 tif->tif_preencode = (TIFFPreMethod)_notSupported;
2558# endif /* never */
2559 tif->tif_setupdecode = OJPEGSetupDecode;
2560 tif->tif_predecode = OJPEGPreDecode;
2561 tif->tif_postdecode = OJPEGPostDecode;
2562 tif->tif_cleanup = OJPEGCleanUp;
2563
2564 /* If the image file doesn't have "JPEGInterchangeFormat[Length]" TIFF records
2565 to guide us, we have few clues about where its encapsulated JPEG bit stream
2566 is located, so establish intelligent defaults: If the Image File Directory
2567 doesn't immediately follow the TIFF header, assume that the JPEG data lies
2568 in between; otherwise, assume that it follows the Image File Directory.
2569 */
2570 if (tif->tif_header.tiff_diroff > sizeof tif->tif_header)
2571 {
2572 sp->src.next_input_byte = tif->tif_base + sizeof tif->tif_header;
2573 sp->src.bytes_in_buffer = tif->tif_header.tiff_diroff
2574 - sizeof tif->tif_header;
2575 }
2576 else /* this case is ugly! */
2577 { uint32 maxoffset = tif->tif_size;
2578 uint16 dircount;
2579
2580 /* Calculate the offset to the next Image File Directory, if there is one,
2581 or to the end of the file, if not. Then arrange to read the file from
2582 the end of the Image File Directory to that offset.
2583 */
2584 if (tif->tif_nextdiroff) maxoffset = tif->tif_nextdiroff; /* Not EOF */
2585 _TIFFmemcpy(&dircount,(const tdata_t)
2586 (sp->src.next_input_byte = tif->tif_base+tif->tif_header.tiff_diroff),
2587 sizeof dircount);
2588 if (tif->tif_flags & TIFF_SWAB) TIFFSwabShort(&dircount);
2589 sp->src.next_input_byte += dircount*sizeof(TIFFDirEntry)
2590 + sizeof maxoffset + sizeof dircount;
2591 sp->src.bytes_in_buffer = tif->tif_base - sp->src.next_input_byte
2592 + maxoffset;
2593 };
2594
2595 /* IJG JPEG Library Version 6B can be configured for either 8- or 12-bit sample
2596 precision, but we assume that "old JPEG" TIFF clients only need 8 bits.
2597 */
2598 sp->cinfo.d.data_precision = 8;
2599# ifdef C_LOSSLESS_SUPPORTED
2600
2601 /* If the "JPEGProc" TIFF tag is missing from the Image File Dictionary, the
2602 JPEG Library will use its (lossy) baseline sequential process by default.
2603 */
2604 sp->cinfo.d.data_unit = DCTSIZE;
2605# endif /* C_LOSSLESS_SUPPORTED */
2606
2607 /* Initialize other CODEC-specific variables requiring default values. */
2608
2609 tif->tif_flags |= TIFF_NOBITREV; /* No bit-reversal within data bytes */
2610 sp->h_sampling = sp->v_sampling = 1; /* No subsampling by default */
2611 sp->is_WANG = 0; /* Assume not a MS Windows Wang Imaging file by default */
2612 sp->jpegtables = 0; /* No "new"-style JPEG tables synthesized yet */
2613 sp->jpegtables_length = 0;
2614 sp->jpegquality = 75; /* Default IJG quality */
2615 sp->jpegcolormode = JPEGCOLORMODE_RAW;
2616 sp->jpegtablesmode = 0; /* No tables found yet */
2617 sp->jpeglosslesspredictors=0;
2618 sp->jpeglosslesspredictors_length=0;
2619 sp->jpegpointtransform=0;
2620 sp->jpegpointtransform_length=0;
2621 sp->jpegqtables=0;
2622 sp->jpegqtables_length=0;
2623 sp->jpegdctables=0;
2624 sp->jpegdctables_length=0;
2625 sp->jpegactables=0;
2626 sp->jpegactables_length=0;
2627 return 1;
2628# undef td
2629 }
2630#endif /* OJPEG_SUPPORT */
wxWidgets (Impactor)