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 */ 2631