#include "tiffiop.h" #ifdef OJPEG_SUPPORT /* JPEG Compression support, as per the original TIFF 6.0 specification. WARNING: KLUDGE ALERT! The type of JPEG encapsulation defined by the TIFF Version 6.0 specification is now totally obsolete and deprecated for new applications and images. This file is an unsupported hack that was created solely in order to read (but NOT write!) a few old, unconverted images still present on some users' computer systems. The code isn't pretty or robust, and it won't read every "old format" JPEG-in-TIFF file (see Samuel Leffler's draft "TIFF Technical Note No. 2" for a long and incomplete list of known problems), but it seems to work well enough in the few cases of practical interest to the author; so, "caveat emptor"! This file should NEVER be enhanced to write new images using anything other than the latest approved JPEG-in-TIFF encapsulation method, implemented by the "tif_jpeg.c" file elsewhere in this library. This file interfaces with Release 6B of the JPEG Library written by theu Independent JPEG Group, which you can find on the Internet at: ftp://ftp.uu.net:/graphics/jpeg/. The "C" Preprocessor macros, "[CD]_LOSSLESS_SUPPORTED", are defined by your JPEG Library Version 6B only if you have applied a (massive!) patch by Ken Murchison of Oceana Matrix Ltd. to support lossless Huffman encoding (TIFF "JPEGProc" tag value = 14). This patch can be found on the Internet at: ftp://ftp.oceana.com/pub/ljpeg-6b.tar.gz. Some old files produced by the Wang Imaging application for Microsoft Windows apparently can be decoded only with a special patch to the JPEG Library, which defines a subroutine named "jpeg_reset_huff_decode()" in its "jdhuff.c" module (the "jdshuff.c" module, if Ken Murchison's patch has been applied). Unfortunately the patch differs slightly in each case, and some TIFF Library have reported problems finding the code, so both versions appear below; you should carefully extract and apply only the version that applies to your JPEG Library! Contributed by Scott Marovich with considerable help from Charles Auer to unravel the mysteries of image files created by the Wang Imaging application for Microsoft Windows. */ #if 0 /* Patch for JPEG Library WITHOUT lossless Huffman coding */ *** jdhuff.c.orig Mon Oct 20 17:51:10 1997 --- jdhuff.c Sun Nov 11 17:33:58 2001 *************** *** 648,651 **** --- 648,683 ---- for (i = 0; i < NUM_HUFF_TBLS; i++) { entropy->dc_derived_tbls[i] = entropy->ac_derived_tbls[i] = NULL; } } + + /* + * BEWARE OF KLUDGE: This subroutine is a hack for decoding illegal JPEG-in- + * TIFF encapsulations produced by Microsoft's Wang Imaging + * for Windows application with the public-domain TIFF Library. Based upon an + * examination of selected output files, this program apparently divides a JPEG + * bit-stream into consecutive horizontal TIFF "strips", such that the JPEG + * encoder's/decoder's DC coefficients for each image component are reset before + * each "strip". Moreover, a "strip" is not necessarily encoded in a multiple + * of 8 bits, so one must sometimes discard 1-7 bits at the end of each "strip" + * for alignment to the next input-Byte storage boundary. IJG JPEG Library + * decoder state is not normally exposed to client applications, so this sub- + * routine provides the TIFF Library with a "hook" to make these corrections. + * It should be called after "jpeg_start_decompress()" and before + * "jpeg_finish_decompress()", just before decoding each "strip" using + * "jpeg_read_raw_data()" or "jpeg_read_scanlines()". + * + * This kludge is not sanctioned or supported by the Independent JPEG Group, and + * future changes to the IJG JPEG Library might invalidate it. Do not send bug + * reports about this code to IJG developers. Instead, contact the author for + * advice: Scott B. Marovich , Hewlett-Packard Labs, 6/01. + */ + GLOBAL(void) + jpeg_reset_huff_decode (register j_decompress_ptr cinfo) + { register huff_entropy_ptr entropy = (huff_entropy_ptr)cinfo->entropy; + register int ci = 0; + + /* Discard encoded input bits, up to the next Byte boundary */ + entropy->bitstate.bits_left &= ~7; + /* Re-initialize DC predictions to 0 */ + do entropy->saved.last_dc_val[ci] = 0; while (++ci < cinfo->comps_in_scan); + } #endif /* Patch for JPEG Library WITHOUT lossless Huffman coding */ #if 0 /* Patch for JPEG Library WITH lossless Huffman coding */ *** jdshuff.c.orig Mon Mar 11 16:44:54 2002 --- jdshuff.c Mon Mar 11 16:44:54 2002 *************** *** 357,360 **** --- 357,393 ---- for (i = 0; i < NUM_HUFF_TBLS; i++) { entropy->dc_derived_tbls[i] = entropy->ac_derived_tbls[i] = NULL; } } + + /* + * BEWARE OF KLUDGE: This subroutine is a hack for decoding illegal JPEG-in- + * TIFF encapsulations produced by Microsoft's Wang Imaging + * for Windows application with the public-domain TIFF Library. Based upon an + * examination of selected output files, this program apparently divides a JPEG + * bit-stream into consecutive horizontal TIFF "strips", such that the JPEG + * encoder's/decoder's DC coefficients for each image component are reset before + * each "strip". Moreover, a "strip" is not necessarily encoded in a multiple + * of 8 bits, so one must sometimes discard 1-7 bits at the end of each "strip" + * for alignment to the next input-Byte storage boundary. IJG JPEG Library + * decoder state is not normally exposed to client applications, so this sub- + * routine provides the TIFF Library with a "hook" to make these corrections. + * It should be called after "jpeg_start_decompress()" and before + * "jpeg_finish_decompress()", just before decoding each "strip" using + * "jpeg_read_raw_data()" or "jpeg_read_scanlines()". + * + * This kludge is not sanctioned or supported by the Independent JPEG Group, and + * future changes to the IJG JPEG Library might invalidate it. Do not send bug + * reports about this code to IJG developers. Instead, contact the author for + * advice: Scott B. Marovich , Hewlett-Packard Labs, 6/01. + */ + GLOBAL(void) + jpeg_reset_huff_decode (register j_decompress_ptr cinfo) + { register shuff_entropy_ptr entropy = (shuff_entropy_ptr) + ((j_lossy_d_ptr)cinfo->codec)->entropy_private; + register int ci = 0; + + /* Discard encoded input bits, up to the next Byte boundary */ + entropy->bitstate.bits_left &= ~7; + /* Re-initialize DC predictions to 0 */ + do entropy->saved.last_dc_val[ci] = 0; while (++ci < cinfo->comps_in_scan); + } #endif /* Patch for JPEG Library WITH lossless Huffman coding */ #include #include #ifdef FAR #undef FAR /* Undefine FAR to avoid conflict with JPEG definition */ #endif #define JPEG_INTERNALS /* Include "jpegint.h" for "DSTATE_*" symbols */ #define JPEG_CJPEG_DJPEG /* Include all Version 6B+ "jconfig.h" options */ #undef INLINE #include "jpeglib.h" #undef JPEG_CJPEG_DJPEG #undef JPEG_INTERNALS /* Hack for files produced by Wang Imaging application on Microsoft Windows */ extern void jpeg_reset_huff_decode(j_decompress_ptr); /* On some machines, it may be worthwhile to use "_setjmp()" or "sigsetjmp()" instead of "setjmp()". These macros make it easier: */ #define SETJMP(jbuf)setjmp(jbuf) #define LONGJMP(jbuf,code)longjmp(jbuf,code) #define JMP_BUF jmp_buf #define TIFFTAG_WANG_PAGECONTROL 32934 /* Bit-vector offsets for keeping track of TIFF records that we've parsed. */ #define FIELD_JPEGPROC FIELD_CODEC #define FIELD_JPEGIFOFFSET (FIELD_CODEC+1) #define FIELD_JPEGIFBYTECOUNT (FIELD_CODEC+2) #define FIELD_JPEGRESTARTINTERVAL (FIELD_CODEC+3) #define FIELD_JPEGTABLES (FIELD_CODEC+4) /* New, post-6.0 JPEG-in-TIFF tag! */ #define FIELD_JPEGLOSSLESSPREDICTORS (FIELD_CODEC+5) #define FIELD_JPEGPOINTTRANSFORM (FIELD_CODEC+6) #define FIELD_JPEGQTABLES (FIELD_CODEC+7) #define FIELD_JPEGDCTABLES (FIELD_CODEC+8) #define FIELD_JPEGACTABLES (FIELD_CODEC+9) #define FIELD_WANG_PAGECONTROL (FIELD_CODEC+10) #define FIELD_JPEGCOLORMODE (FIELD_CODEC+11) typedef struct jpeg_destination_mgr jpeg_destination_mgr; typedef struct jpeg_source_mgr jpeg_source_mgr; typedef struct jpeg_error_mgr jpeg_error_mgr; /* State variable for each open TIFF file that uses "libjpeg" for JPEG decompression. (Note: This file should NEVER perform JPEG compression except in the manner implemented by the "tif_jpeg.c" file, elsewhere in this library; see comments above.) JPEG Library internal state is recorded in a "jpeg_{de}compress_struct", while a "jpeg_common_struct" records a few items common to both compression and expansion. The "cinfo" field containing JPEG Library state MUST be the 1st member of our own state variable, so that we can safely "cast" pointers back and forth. */ typedef struct /* This module's private, per-image state variable */ { union /* JPEG Library state variable; this MUST be our 1st field! */ { struct jpeg_compress_struct c; struct jpeg_decompress_struct d; struct jpeg_common_struct comm; } cinfo; jpeg_error_mgr err; /* JPEG Library error manager */ JMP_BUF exit_jmpbuf; /* ...for catching JPEG Library failures */ # ifdef never /* (The following two fields could be a "union", but they're small enough that it's not worth the effort.) */ jpeg_destination_mgr dest; /* Destination for compressed data */ # endif jpeg_source_mgr src; /* Source of expanded data */ JSAMPARRAY ds_buffer[MAX_COMPONENTS]; /* ->Temporary downsampling buffers */ TIFF *tif; /* Reverse pointer, needed by some code */ TIFFVGetMethod vgetparent; /* "Super class" methods... */ TIFFVSetMethod vsetparent; TIFFStripMethod defsparent; TIFFTileMethod deftparent; void *jpegtables; /* ->"New" JPEG tables, if we synthesized any */ uint32 is_WANG, /* <=> Wang Imaging for Microsoft Windows output file? */ jpegtables_length; /* Length of "new" JPEG tables, if they exist */ tsize_t bytesperline; /* No. of decompressed Bytes per scan line */ int jpegquality, /* Compression quality level */ jpegtablesmode, /* What to put in JPEGTables */ samplesperclump, scancount; /* No. of scan lines accumulated */ J_COLOR_SPACE photometric; /* IJG JPEG Library's photometry code */ u_char h_sampling, /* Luminance sampling factors */ v_sampling, jpegcolormode; /* Who performs RGB <-> YCbCr conversion? */ /* JPEGCOLORMODE_RAW <=> TIFF Library or its client */ /* JPEGCOLORMODE_RGB <=> JPEG Library */ /* These fields are added to support TIFFGetField */ uint16 jpegproc; uint32 jpegifoffset; uint32 jpegifbytecount; uint32 jpegrestartinterval; void* jpeglosslesspredictors; uint16 jpeglosslesspredictors_length; void* jpegpointtransform; uint32 jpegpointtransform_length; void* jpegqtables; uint32 jpegqtables_length; void* jpegdctables; uint32 jpegdctables_length; void* jpegactables; uint32 jpegactables_length; } OJPEGState; #define OJState(tif)((OJPEGState*)(tif)->tif_data) static const TIFFFieldInfo ojpegFieldInfo[]=/* JPEG-specific TIFF-record tags */ { /* This is the current JPEG-in-TIFF metadata-encapsulation tag, and its treatment in this file is idiosyncratic. It should never appear in a "source" image conforming to the TIFF Version 6.0 specification, so we arrange to report an error if it appears. But in order to support possible future conversion of "old" JPEG-in-TIFF encapsulations to "new" ones, we might wish to synthesize an equivalent value to be returned by the TIFF Library's "getfield" method. So, this table tells the TIFF Library to pass these records to us in order to filter them below. */ { TIFFTAG_JPEGTABLES ,TIFF_VARIABLE,TIFF_VARIABLE, TIFF_UNDEFINED,FIELD_JPEGTABLES ,FALSE,TRUE ,"JPEGTables" }, /* These tags are defined by the TIFF Version 6.0 specification and are now obsolete. This module reads them from an old "source" image, but it never writes them to a new "destination" image. */ { TIFFTAG_JPEGPROC ,1 ,1 , TIFF_SHORT ,FIELD_JPEGPROC ,FALSE,FALSE,"JPEGProc" }, { TIFFTAG_JPEGIFOFFSET ,1 ,1 , TIFF_LONG ,FIELD_JPEGIFOFFSET ,FALSE,FALSE,"JPEGInterchangeFormat" }, { TIFFTAG_JPEGIFBYTECOUNT ,1 ,1 , TIFF_LONG ,FIELD_JPEGIFBYTECOUNT ,FALSE,FALSE,"JPEGInterchangeFormatLength" }, { TIFFTAG_JPEGRESTARTINTERVAL ,1 ,1 , TIFF_SHORT ,FIELD_JPEGRESTARTINTERVAL ,FALSE,FALSE,"JPEGRestartInterval" }, { TIFFTAG_JPEGLOSSLESSPREDICTORS,TIFF_VARIABLE,TIFF_VARIABLE, TIFF_SHORT ,FIELD_JPEGLOSSLESSPREDICTORS,FALSE,TRUE ,"JPEGLosslessPredictors" }, { TIFFTAG_JPEGPOINTTRANSFORM ,TIFF_VARIABLE,TIFF_VARIABLE, TIFF_SHORT ,FIELD_JPEGPOINTTRANSFORM ,FALSE,TRUE ,"JPEGPointTransforms" }, { TIFFTAG_JPEGQTABLES ,TIFF_VARIABLE,TIFF_VARIABLE, TIFF_LONG ,FIELD_JPEGQTABLES ,FALSE,TRUE ,"JPEGQTables" }, { TIFFTAG_JPEGDCTABLES ,TIFF_VARIABLE,TIFF_VARIABLE, TIFF_LONG ,FIELD_JPEGDCTABLES ,FALSE,TRUE ,"JPEGDCTables" }, { TIFFTAG_JPEGACTABLES ,TIFF_VARIABLE,TIFF_VARIABLE, TIFF_LONG ,FIELD_JPEGACTABLES ,FALSE,TRUE ,"JPEGACTables" }, { TIFFTAG_WANG_PAGECONTROL ,TIFF_VARIABLE,1 , TIFF_LONG ,FIELD_WANG_PAGECONTROL ,FALSE,FALSE,"WANG PageControl" }, /* This is a pseudo tag intended for internal use only by the TIFF Library and its clients, which should never appear in an input/output image file. It specifies whether the TIFF Library (or its client) should do YCbCr <-> RGB color-space conversion (JPEGCOLORMODE_RAW <=> 0) or whether we should ask the JPEG Library to do it (JPEGCOLORMODE_RGB <=> 1). */ { TIFFTAG_JPEGCOLORMODE ,0 ,0 , TIFF_ANY ,FIELD_PSEUDO ,FALSE,FALSE,"JPEGColorMode" } }; static const char JPEGLib_name[]={"JPEG Library"}, bad_bps[]={"%u BitsPerSample not allowed for JPEG"}, bad_photometry[]={"PhotometricInterpretation %u not allowed for JPEG"}, bad_subsampling[]={"invalid YCbCr subsampling factor(s)"}, # ifdef never no_write_frac[]={"fractional scan line discarded"}, # endif no_read_frac[]={"fractional scan line not read"}, no_jtable_space[]={"No space for JPEGTables"}; /* The following diagnostic subroutines interface with and replace default subroutines in the JPEG Library. Our basic strategy is to use "setjmp()"/ "longjmp()" in order to return control to the TIFF Library when the JPEG library detects an error, and to use TIFF Library subroutines for displaying diagnostic messages to a client application. */ static void TIFFojpeg_error_exit(register j_common_ptr cinfo) { char buffer[JMSG_LENGTH_MAX]; (*cinfo->err->format_message)(cinfo,buffer); TIFFError(JPEGLib_name,buffer); /* Display error message */ jpeg_abort(cinfo); /* Clean up JPEG Library state */ LONGJMP(((OJPEGState *)cinfo)->exit_jmpbuf,1); /* Return to TIFF client */ } static void TIFFojpeg_output_message(register j_common_ptr cinfo) { char buffer[JMSG_LENGTH_MAX]; /* This subroutine is invoked only for warning messages, since the JPEG Library's "error_exit" method does its own thing and "trace_level" is never set > 0. */ (*cinfo->err->format_message)(cinfo,buffer); TIFFWarning(JPEGLib_name,buffer); } /* The following subroutines, which also interface with the JPEG Library, exist mainly in limit the side effects of "setjmp()" and convert JPEG normal/error conditions into TIFF Library return codes. */ #define CALLJPEG(sp,fail,op)(SETJMP((sp)->exit_jmpbuf)?(fail):(op)) #define CALLVJPEG(sp,op)CALLJPEG(sp,0,((op),1)) #ifdef never static int TIFFojpeg_create_compress(register OJPEGState *sp) { sp->cinfo.c.err = jpeg_std_error(&sp->err); /* Initialize error handling */ sp->err.error_exit = TIFFojpeg_error_exit; sp->err.output_message = TIFFojpeg_output_message; return CALLVJPEG(sp,jpeg_create_compress(&sp->cinfo.c)); } /* The following subroutines comprise a JPEG Library "destination" data manager by directing compressed data from the JPEG Library to a TIFF Library output buffer. */ static void std_init_destination(register j_compress_ptr cinfo){} /* "Dummy" stub */ static boolean std_empty_output_buffer(register j_compress_ptr cinfo) { # define sp ((OJPEGState *)cinfo) register TIFF *tif = sp->tif; tif->tif_rawcc = tif->tif_rawdatasize; /* Entire buffer has been filled */ TIFFFlushData1(tif); sp->dest.next_output_byte = (JOCTET *)tif->tif_rawdata; sp->dest.free_in_buffer = (size_t)tif->tif_rawdatasize; return TRUE; # undef sp } static void std_term_destination(register j_compress_ptr cinfo) { # define sp ((OJPEGState *)cinfo) register TIFF *tif = sp->tif; /* NB: The TIFF Library does the final buffer flush. */ tif->tif_rawcp = (tidata_t)sp->dest.next_output_byte; tif->tif_rawcc = tif->tif_rawdatasize - (tsize_t)sp->dest.free_in_buffer; # undef sp } /* Alternate destination manager to output JPEGTables field: */ static void tables_init_destination(register j_compress_ptr cinfo) { # define sp ((OJPEGState *)cinfo) /* The "jpegtables_length" field is the allocated buffer size while building */ sp->dest.next_output_byte = (JOCTET *)sp->jpegtables; sp->dest.free_in_buffer = (size_t)sp->jpegtables_length; # undef sp } static boolean tables_empty_output_buffer(register j_compress_ptr cinfo) { void *newbuf; # define sp ((OJPEGState *)cinfo) /* The entire buffer has been filled, so enlarge it by 1000 bytes. */ if (!( newbuf = _TIFFrealloc( (tdata_t)sp->jpegtables , (tsize_t)(sp->jpegtables_length + 1000) ) ) ) ERREXIT1(cinfo,JERR_OUT_OF_MEMORY,100); sp->dest.next_output_byte = (JOCTET *)newbuf + sp->jpegtables_length; sp->dest.free_in_buffer = (size_t)1000; sp->jpegtables = newbuf; sp->jpegtables_length += 1000; return TRUE; # undef sp } static void tables_term_destination(register j_compress_ptr cinfo) { # define sp ((OJPEGState *)cinfo) /* Set tables length to no. of Bytes actually emitted. */ sp->jpegtables_length -= sp->dest.free_in_buffer; # undef sp } /*ARGSUSED*/ static int TIFFojpeg_tables_dest(register OJPEGState *sp, TIFF *tif) { /* Allocate a working buffer for building tables. The initial size is 1000 Bytes, which is usually adequate. */ if (sp->jpegtables) _TIFFfree(sp->jpegtables); if (!(sp->jpegtables = (void*) _TIFFmalloc((tsize_t)(sp->jpegtables_length = 1000)) ) ) { sp->jpegtables_length = 0; TIFFError("TIFFojpeg_tables_dest",no_jtable_space); return 0; }; sp->cinfo.c.dest = &sp->dest; sp->dest.init_destination = tables_init_destination; sp->dest.empty_output_buffer = tables_empty_output_buffer; sp->dest.term_destination = tables_term_destination; return 1; } #else /* well, hardly ever */ static int _notSupported(register TIFF *tif) { const TIFFCodec *c = TIFFFindCODEC(tif->tif_dir.td_compression); TIFFError(tif->tif_name,"%s compression not supported",c->name); return 0; } #endif /* never */ /* The following subroutines comprise a JPEG Library "source" data manager by by directing compressed data to the JPEG Library from a TIFF Library input buffer. */ static void std_init_source(register j_decompress_ptr cinfo) { # define sp ((OJPEGState *)cinfo) register TIFF *tif = sp->tif; if (sp->src.bytes_in_buffer == 0) { sp->src.next_input_byte = (const JOCTET *)tif->tif_rawdata; sp->src.bytes_in_buffer = (size_t)tif->tif_rawcc; }; # undef sp } static boolean std_fill_input_buffer(register j_decompress_ptr cinfo) { static const JOCTET dummy_EOI[2]={0xFF,JPEG_EOI}; # define sp ((OJPEGState *)cinfo) /* Control should never get here, since an entire strip/tile is read into memory before the decompressor is called; thus, data should have been supplied by the "init_source" method. ...But, sometimes things fail. */ WARNMS(cinfo,JWRN_JPEG_EOF); sp->src.next_input_byte = dummy_EOI; /* Insert a fake EOI marker */ sp->src.bytes_in_buffer = sizeof dummy_EOI; return TRUE; # undef sp } static void std_skip_input_data(register j_decompress_ptr cinfo, long num_bytes) { # define sp ((OJPEGState *)cinfo) if (num_bytes > 0) { if (num_bytes > (long)sp->src.bytes_in_buffer) /* oops: buffer overrun */ (void)std_fill_input_buffer(cinfo); else { sp->src.next_input_byte += (size_t)num_bytes; sp->src.bytes_in_buffer -= (size_t)num_bytes; } } # undef sp } /*ARGSUSED*/ static void std_term_source(register j_decompress_ptr cinfo){} /* "Dummy" stub */ /* Allocate temporary I/O buffers for downsampled data, using values computed in "jpeg_start_{de}compress()". We use the JPEG Library's allocator so that buffers will be released automatically when done with a strip/tile. This is also a handy place to compute samplesperclump, bytesperline, etc. */ static int alloc_downsampled_buffers(TIFF *tif,jpeg_component_info *comp_info, int num_components) { register OJPEGState *sp = OJState(tif); sp->samplesperclump = 0; if (num_components > 0) { tsize_t size = sp->cinfo.comm.is_decompressor # ifdef D_LOSSLESS_SUPPORTED ? sp->cinfo.d.min_codec_data_unit # else ? DCTSIZE # endif # ifdef C_LOSSLESS_SUPPORTED : sp->cinfo.c.data_unit; # else : DCTSIZE; # endif int ci = 0; register jpeg_component_info *compptr = comp_info; do { JSAMPARRAY buf; sp->samplesperclump += compptr->h_samp_factor * compptr->v_samp_factor; # if defined(C_LOSSLESS_SUPPORTED) || defined(D_LOSSLESS_SUPPORTED) 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)))) # else 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)))) # endif return 0; sp->ds_buffer[ci] = buf; } while (++compptr,++ci < num_components); }; return 1; } #ifdef never /* JPEG Encoding begins here. */ /*ARGSUSED*/ static int OJPEGEncode(register TIFF *tif,tidata_t buf,tsize_t cc,tsample_t s) { tsize_t rows; /* No. of unprocessed rows in file */ register OJPEGState *sp = OJState(tif); /* Encode a chunk of pixels, where returned data is NOT down-sampled (the standard case). The data is expected to be written in scan-line multiples. */ if (cc % sp->bytesperline) TIFFWarning(tif->tif_name,no_write_frac); if ( (cc /= bytesperline) /* No. of complete rows in caller's buffer */ > (rows = sp->cinfo.c.image_height - sp->cinfo.c.next_scanline) ) cc = rows; while (--cc >= 0) { if ( CALLJPEG(sp,-1,jpeg_write_scanlines(&sp->cinfo.c,(JSAMPARRAY)&buf,1)) != 1 ) return 0; ++tif->tif_row; buf += sp->bytesperline; }; return 1; } /*ARGSUSED*/ static int OJPEGEncodeRaw(register TIFF *tif,tidata_t buf,tsize_t cc,tsample_t s) { tsize_t rows; /* No. of unprocessed rows in file */ JDIMENSION lines_per_MCU, size; register OJPEGState *sp = OJState(tif); /* Encode a chunk of pixels, where returned data is down-sampled as per the sampling factors. The data is expected to be written in scan-line multiples. */ cc /= sp->bytesperline; if (cc % sp->bytesperline) TIFFWarning(tif->tif_name,no_write_frac); if ( (cc /= bytesperline) /* No. of complete rows in caller's buffer */ > (rows = sp->cinfo.c.image_height - sp->cinfo.c.next_scanline) ) cc = rows; # ifdef C_LOSSLESS_SUPPORTED lines_per_MCU = sp->cinfo.c.max_samp_factor*(size = sp->cinfo.d.data_unit); # else lines_per_MCU = sp->cinfo.c.max_samp_factor*(size = DCTSIZE); # endif while (--cc >= 0) { int ci = 0, clumpoffset = 0; register jpeg_component_info *compptr = sp->cinfo.c.comp_info; /* The fastest way to separate the data is to make 1 pass over the scan line for each row of each component. */ do { int ypos = 0; do { int padding; register JSAMPLE *inptr = (JSAMPLE*)buf + clumpoffset, *outptr = sp->ds_buffer[ci][sp->scancount*compptr->v_samp_factor+ypos]; /* Cb,Cr both have sampling factors 1, so this is correct */ register int clumps_per_line = sp->cinfo.c.comp_info[1].downsampled_width, xpos; padding = (int) # ifdef C_LOSSLESS_SUPPORTED ( compptr->width_in_data_units * size # else ( compptr->width_in_blocks * size # endif - clumps_per_line * compptr->h_samp_factor ); if (compptr->h_samp_factor == 1) /* Cb & Cr fast path */ do *outptr++ = *inptr; while ((inptr += sp->samplesperclump),--clumps_per_line > 0); else /* general case */ do { xpos = 0; do *outptr++ = inptr[xpos]; while (++xpos < compptr->h_samp_factor); } while ((inptr += sp->samplesperclump),--clumps_per_line > 0); xpos = 0; /* Pad each scan line as needed */ do outptr[0] = outptr[-1]; while (++outptr,++xpos < padding); clumpoffset += compptr->h_samp_factor; } while (++ypos < compptr->v_samp_factor); } while (++compptr,++ci < sp->cinfo.c.num_components); if (++sp->scancount >= size) { if ( CALLJPEG(sp,-1,jpeg_write_raw_data(&sp->cinfo.c,sp->ds_buffer,lines_per_MCU)) != lines_per_MCU ) return 0; sp->scancount = 0; }; ++tif->tif_row++ buf += sp->bytesperline; }; return 1; } static int OJPEGSetupEncode(register TIFF *tif) { static const char module[]={"OJPEGSetupEncode"}; uint32 segment_height, segment_width; int status = 1; /* Assume success by default */ register OJPEGState *sp = OJState(tif); # define td (&tif->tif_dir) /* Verify miscellaneous parameters. This will need work if the TIFF Library ever supports different depths for different components, or if the JPEG Library ever supports run-time depth selection. Neither seems imminent. */ if (td->td_bitspersample != 8) { TIFFError(module,bad_bps,td->td_bitspersample); status = 0; }; /* The TIFF Version 6.0 specification and IJG JPEG Library accept different sets of color spaces, so verify that our image belongs to the common subset and map its photometry code, then initialize to handle subsampling and optional JPEG Library YCbCr <-> RGB color-space conversion. */ switch (td->td_photometric) { case PHOTOMETRIC_YCBCR : /* ISO IS 10918-1 requires that JPEG subsampling factors be 1-4, but TIFF Version 6.0 is more restrictive: only 1, 2, and 4 are allowed. */ if ( ( td->td_ycbcrsubsampling[0] == 1 || td->td_ycbcrsubsampling[0] == 2 || td->td_ycbcrsubsampling[0] == 4 ) && ( td->td_ycbcrsubsampling[1] == 1 || td->td_ycbcrsubsampling[1] == 2 || td->td_ycbcrsubsampling[1] == 4 ) ) sp->cinfo.c.raw_data_in = ( (sp->h_sampling = td->td_ycbcrsubsampling[0]) << 3 | (sp->v_sampling = td->td_ycbcrsubsampling[1]) ) != 011; else { TIFFError(module,bad_subsampling); status = 0; }; /* A ReferenceBlackWhite field MUST be present, since the default value is inapproriate for YCbCr. Fill in the proper value if the application didn't set it. */ if (!TIFFFieldSet(tif,FIELD_REFBLACKWHITE)) { float refbw[6]; long top = 1L << td->td_bitspersample; refbw[0] = 0; refbw[1] = (float)(top-1L); refbw[2] = (float)(top>>1); refbw[3] = refbw[1]; refbw[4] = refbw[2]; refbw[5] = refbw[1]; TIFFSetField(tif,TIFFTAG_REFERENCEBLACKWHITE,refbw); }; sp->cinfo.c.jpeg_color_space = JCS_YCbCr; if (sp->jpegcolormode == JPEGCOLORMODE_RGB) { sp->cinfo.c.raw_data_in = FALSE; sp->in_color_space = JCS_RGB; break; }; goto L2; case PHOTOMETRIC_MINISBLACK: sp->cinfo.c.jpeg_color_space = JCS_GRAYSCALE; goto L1; case PHOTOMETRIC_RGB : sp->cinfo.c.jpeg_color_space = JCS_RGB; goto L1; case PHOTOMETRIC_SEPARATED : sp->cinfo.c.jpeg_color_space = JCS_CMYK; L1: sp->jpegcolormode = JPEGCOLORMODE_RAW; /* No JPEG Lib. conversion */ L2: sp->cinfo.d.in_color_space = sp->cinfo.d.jpeg_color-space; break; default : TIFFError(module,bad_photometry,td->td_photometric); status = 0; }; tif->tif_encoderow = tif->tif_encodestrip = tif->tif_encodetile = sp->cinfo.c.raw_data_in ? OJPEGEncodeRaw : OJPEGEncode; if (isTiled(tif)) { tsize_t size; # ifdef C_LOSSLESS_SUPPORTED if ((size = sp->v_sampling*sp->cinfo.c.data_unit) < 16) size = 16; # else if ((size = sp->v_sampling*DCTSIZE) < 16) size = 16; # endif if ((segment_height = td->td_tilelength) % size) { TIFFError(module,"JPEG tile height must be multiple of %d",size); status = 0; }; # ifdef C_LOSSLESS_SUPPORTED if ((size = sp->h_sampling*sp->cinfo.c.data_unit) < 16) size = 16; # else if ((size = sp->h_sampling*DCTSIZE) < 16) size = 16; # endif if ((segment_width = td->td_tilewidth) % size) { TIFFError(module,"JPEG tile width must be multiple of %d",size); status = 0; }; sp->bytesperline = TIFFTileRowSize(tif); } else { tsize_t size; # ifdef C_LOSSLESS_SUPPORTED if ((size = sp->v_sampling*sp->cinfo.c.data_unit) < 16) size = 16; # else if ((size = sp->v_sampling*DCTSIZE) < 16) size = 16; # endif if (td->td_rowsperstrip < (segment_height = td->td_imagelength)) { if (td->td_rowsperstrip % size) { TIFFError(module,"JPEG RowsPerStrip must be multiple of %d",size); status = 0; }; segment_height = td->td_rowsperstrip; }; segment_width = td->td_imagewidth; sp->bytesperline = tif->tif_scanlinesize; }; if (segment_width > 65535 || segment_height > 65535) { TIFFError(module,"Strip/tile too large for JPEG"); status = 0; }; /* Initialize all JPEG parameters to default values. Note that the JPEG Library's "jpeg_set_defaults()" method needs legal values for the "in_color_space" and "input_components" fields. */ sp->cinfo.c.input_components = 1; /* Default for JCS_UNKNOWN */ if (!CALLVJPEG(sp,jpeg_set_defaults(&sp->cinfo.c))) status = 0; switch (sp->jpegtablesmode & (JPEGTABLESMODE_HUFF|JPEGTABLESMODE_QUANT)) { register JHUFF_TBL *htbl; register JQUANT_TBL *qtbl; case 0 : sp->cinfo.c.optimize_coding = TRUE; case JPEGTABLESMODE_HUFF : if (!CALLVJPEG(sp,jpeg_set_quality(&sp->cinfo.c,sp->jpegquality,FALSE))) return 0; if (qtbl = sp->cinfo.c.quant_tbl_ptrs[0]) qtbl->sent_table = FALSE; if (qtbl = sp->cinfo.c.quant_tbl_ptrs[1]) qtbl->sent_table = FALSE; goto L3; case JPEGTABLESMODE_QUANT : sp->cinfo.c.optimize_coding = TRUE; /* We do not support application-supplied JPEG tables, so mark the field "not present". */ L3: TIFFClrFieldBit(tif,FIELD_JPEGTABLES); break; case JPEGTABLESMODE_HUFF|JPEGTABLESMODE_QUANT: if ( !CALLVJPEG(sp,jpeg_set_quality(&sp->cinfo.c,sp->jpegquality,FALSE)) || !CALLVJPEG(sp,jpeg_suppress_tables(&sp->cinfo.c,TRUE)) ) { status = 0; break; }; if (qtbl = sp->cinfo.c.quant_tbl_ptrs[0]) qtbl->sent_table = FALSE; if (htbl = sp->cinfo.c.dc_huff_tbl_ptrs[0]) htbl->sent_table = FALSE; if (htbl = sp->cinfo.c.ac_huff_tbl_ptrs[0]) htbl->sent_table = FALSE; if (sp->cinfo.c.jpeg_color_space == JCS_YCbCr) { if (qtbl = sp->cinfo.c.quant_tbl_ptrs[1]) qtbl->sent_table = FALSE; if (htbl = sp->cinfo.c.dc_huff_tbl_ptrs[1]) htbl->sent_table = FALSE; if (htbl = sp->cinfo.c.ac_huff_tbl_ptrs[1]) htbl->sent_table = FALSE; }; if ( TIFFojpeg_tables_dest(sp,tif) && CALLVJPEG(sp,jpeg_write_tables(&sp->cinfo.c)) ) { /* Mark the field "present". We can't use "TIFFSetField()" because "BEENWRITING" is already set! */ TIFFSetFieldBit(tif,FIELD_JPEGTABLES); tif->tif_flags |= TIFF_DIRTYDIRECT; } else status = 0; }; if ( sp->cinfo.c.raw_data_in && !alloc_downsampled_buffers(tif,sp->cinfo.c.comp_info, sp->cinfo.c.num_components) ) status = 0; if (status == 0) return 0; /* If TIFF errors, don't bother to continue */ /* Grab parameters that are same for all strips/tiles. */ sp->dest.init_destination = std_init_destination; sp->dest.empty_output_buffer = std_empty_output_buffer; sp->dest.term_destination = std_term_destination; sp->cinfo.c.dest = &sp->dest; sp->cinfo.c.data_precision = td->td_bitspersample; sp->cinfo.c.write_JFIF_header = /* Don't write extraneous markers */ sp->cinfo.c.write_Adobe_marker = FALSE; sp->cinfo.c.image_width = segment_width; sp->cinfo.c.image_height = segment_height; sp->cinfo.c.comp_info[0].h_samp_factor = sp->cinfo.c.comp_info[0].v_samp_factor = 1; return CALLVJPEG(sp,jpeg_start_compress(&sp->cinfo.c,FALSE)); # undef td } static int OJPEGPreEncode(register TIFF *tif,tsample_t s) { register OJPEGState *sp = OJState(tif); # define td (&tif->tif_dir) /* If we are about to write the first row of an image plane, which should coincide with a JPEG "scan", reset the JPEG Library's compressor. Otherwise let the compressor run "as is" and return a "success" status without further ado. */ if ( (isTiled(tif) ? tif->tif_curtile : tif->tif_curstrip) % td->td_stripsperimage == 0 ) { if ( (sp->cinfo.c.comp_info[0].component_id = s) == 1) && sp->cinfo.c.jpeg_color_space == JCS_YCbCr ) { sp->cinfo.c.comp_info[0].quant_tbl_no = sp->cinfo.c.comp_info[0].dc_tbl_no = sp->cinfo.c.comp_info[0].ac_tbl_no = 1; sp->cinfo.c.comp_info[0].h_samp_factor = sp->h_sampling; sp->cinfo.c.comp_info[0].v_samp_factor = sp->v_sampling; /* Scale expected strip/tile size to match a downsampled component. */ sp->cinfo.c.image_width = TIFFhowmany(segment_width,sp->h_sampling); sp->cinfo.c.image_height=TIFFhowmany(segment_height,sp->v_sampling); }; sp->scancount = 0; /* Mark subsampling buffer(s) empty */ }; return 1; # undef td } static int OJPEGPostEncode(register TIFF *tif) { register OJPEGState *sp = OJState(tif); /* Finish up at the end of a strip or tile. */ if (sp->scancount > 0) /* emit partial buffer of down-sampled data */ { JDIMENSION n; # ifdef C_LOSSLESS_SUPPORTED if ( sp->scancount < sp->cinfo.c.data_unit && sp->cinfo.c.num_components > 0 ) # else if (sp->scancount < DCTSIZE && sp->cinfo.c.num_components > 0) # endif { int ci = 0, /* Pad the data vertically */ # ifdef C_LOSSLESS_SUPPORTED size = sp->cinfo.c.data_unit; # else size = DCTSIZE; # endif register jpeg_component_info *compptr = sp->cinfo.c.comp_info; do # ifdef C_LOSSLESS_SUPPORTED { tsize_t row_width = compptr->width_in_data_units # else tsize_t row_width = compptr->width_in_blocks # endif *size*sizeof(JSAMPLE); int ypos = sp->scancount*compptr->v_samp_factor; do _TIFFmemcpy( (tdata_t)sp->ds_buffer[ci][ypos] , (tdata_t)sp->ds_buffer[ci][ypos-1] , row_width ); while (++ypos < compptr->v_samp_factor*size); } while (++compptr,++ci < sp->cinfo.c.num_components); }; n = sp->cinfo.c.max_v_samp_factor*size; if (CALLJPEG(sp,-1,jpeg_write_raw_data(&sp->cinfo.c,sp->ds_buffer,n)) != n) return 0; }; return CALLVJPEG(sp,jpeg_finish_compress(&sp->cinfo.c)); } #endif /* never */ /* JPEG Decoding begins here. */ /*ARGSUSED*/ static int OJPEGDecode(register TIFF *tif,tidata_t buf,tsize_t cc,tsample_t s) { tsize_t bytesperline = isTiled(tif) ? TIFFTileRowSize(tif) : tif->tif_scanlinesize, rows; /* No. of unprocessed rows in file */ register OJPEGState *sp = OJState(tif); /* Decode a chunk of pixels, where the input data has not NOT been down- sampled, or else the TIFF Library's client has used the "JPEGColorMode" TIFF pseudo-tag to request that the JPEG Library do color-space conversion; this is the normal case. The data is expected to be read in scan-line multiples, and this subroutine is called for both pixel-interleaved and separate color planes. WARNING: Unlike "OJPEGDecodeRawContig()", below, the no. of Bytes in each decoded row is calculated here as "bytesperline" instead of using "sp->bytesperline", which might be a little smaller. This can occur for an old tiled image whose width isn't a multiple of 8 pixels. That's illegal according to the TIFF Version 6 specification, but some test files, like "zackthecat.tif", were built that way. In those cases, we want to embed the image's true width in our caller's buffer (which is presumably allocated according to the expected tile width) by effectively "padding" it with unused Bytes at the end of each row. */ if ( (cc /= bytesperline) /* No. of complete rows in caller's buffer */ > (rows = sp->cinfo.d.output_height - sp->cinfo.d.output_scanline) ) cc = rows; while (--cc >= 0) { if ( CALLJPEG(sp,-1,jpeg_read_scanlines(&sp->cinfo.d,(JSAMPARRAY)&buf,1)) != 1 ) return 0; buf += bytesperline; ++tif->tif_row; }; /* BEWARE OF KLUDGE: If our input file was produced by Microsoft's Wang Imaging for Windows application, the DC coefficients of each JPEG image component (Y,Cb,Cr) must be reset at the end of each TIFF "strip", and any JPEG data bits remaining in the current Byte of the decoder's input buffer must be discarded. To do so, we create an "ad hoc" interface in the "jdhuff.c" module of IJG JPEG Library Version 6 (module "jdshuff.c", if Ken Murchison's lossless-Huffman patch is applied), and we invoke that interface here after decoding each "strip". */ if (sp->is_WANG) jpeg_reset_huff_decode(&sp->cinfo.d); return 1; } /*ARGSUSED*/ static int OJPEGDecodeRawContig(register TIFF *tif,tidata_t buf,tsize_t cc,tsample_t s) { tsize_t rows; /* No. of unprocessed rows in file */ JDIMENSION lines_per_MCU, size; register OJPEGState *sp = OJState(tif); /* Decode a chunk of pixels, where the input data has pixel-interleaved color planes, some of which have been down-sampled, but the TIFF Library's client has NOT used the "JPEGColorMode" TIFF pseudo-tag to request that the JPEG Library do color-space conversion. In other words, we must up-sample/ expand/duplicate image components according to the image's sampling factors, without changing its color space. The data is expected to be read in scan- line multiples. */ if ( (cc /= sp->bytesperline) /* No. of complete rows in caller's buffer */ > (rows = sp->cinfo.d.output_height - sp->cinfo.d.output_scanline) ) cc = rows; lines_per_MCU = sp->cinfo.d.max_v_samp_factor # ifdef D_LOSSLESS_SUPPORTED * (size = sp->cinfo.d.min_codec_data_unit); # else * (size = DCTSIZE); # endif while (--cc >= 0) { int clumpoffset, ci; register jpeg_component_info *compptr; if (sp->scancount >= size) /* reload downsampled-data buffers */ { if ( CALLJPEG(sp,-1,jpeg_read_raw_data(&sp->cinfo.d,sp->ds_buffer,lines_per_MCU)) != lines_per_MCU ) return 0; sp->scancount = 0; }; /* The fastest way to separate the data is: make 1 pass over the scan line for each row of each component. */ clumpoffset = ci = 0; compptr = sp->cinfo.d.comp_info; do { int ypos = 0; if (compptr->h_samp_factor == 1) /* fast path */ do { register JSAMPLE *inptr = sp->ds_buffer[ci][sp->scancount*compptr->v_samp_factor+ypos], *outptr = (JSAMPLE *)buf + clumpoffset; register int clumps_per_line = compptr->downsampled_width; do *outptr = *inptr++; while ((outptr += sp->samplesperclump),--clumps_per_line > 0); } while ( (clumpoffset += compptr->h_samp_factor) , ++ypos < compptr->v_samp_factor ); else /* general case */ do { register JSAMPLE *inptr = sp->ds_buffer[ci][sp->scancount*compptr->v_samp_factor+ypos], *outptr = (JSAMPLE *)buf + clumpoffset; register int clumps_per_line = compptr->downsampled_width; do { register int xpos = 0; do outptr[xpos] = *inptr++; while (++xpos < compptr->h_samp_factor); } while ((outptr += sp->samplesperclump),--clumps_per_line > 0); } while ( (clumpoffset += compptr->h_samp_factor) , ++ypos < compptr->v_samp_factor ); } while (++compptr,++ci < sp->cinfo.d.num_components); ++sp->scancount; buf += sp->bytesperline; ++tif->tif_row; }; /* BEWARE OF KLUDGE: If our input file was produced by Microsoft's Wang Imaging for Windows application, the DC coefficients of each JPEG image component (Y,Cb,Cr) must be reset at the end of each TIFF "strip", and any JPEG data bits remaining in the current Byte of the decoder's input buffer must be discarded. To do so, we create an "ad hoc" interface in the "jdhuff.c" module of IJG JPEG Library Version 6 (module "jdshuff.c", if Ken Murchison's lossless-Huffman patch is applied), and we invoke that interface here after decoding each "strip". */ if (sp->is_WANG) jpeg_reset_huff_decode(&sp->cinfo.d); return 1; } /*ARGSUSED*/ static int OJPEGDecodeRawSeparate(TIFF *tif,register tidata_t buf,tsize_t cc,tsample_t s) { tsize_t rows; /* No. of unprocessed rows in file */ JDIMENSION lines_per_MCU, size, /* ...of MCU */ v; /* Component's vertical up-sampling ratio */ register OJPEGState *sp = OJState(tif); register jpeg_component_info *compptr = sp->cinfo.d.comp_info + s; /* Decode a chunk of pixels, where the input data has separate color planes, some of which have been down-sampled, but the TIFF Library's client has NOT used the "JPEGColorMode" TIFF pseudo-tag to request that the JPEG Library do color-space conversion. The data is expected to be read in scan-line multiples. */ v = sp->cinfo.d.max_v_samp_factor/compptr->v_samp_factor; if ( (cc /= compptr->downsampled_width) /* No. of rows in caller's buffer */ > (rows = (sp->cinfo.d.output_height-sp->cinfo.d.output_scanline+v-1)/v) ) cc = rows; /* No. of rows of "clumps" to read */ lines_per_MCU = sp->cinfo.d.max_v_samp_factor # ifdef D_LOSSLESS_SUPPORTED * (size = sp->cinfo.d.min_codec_data_unit); # else * (size = DCTSIZE); # endif L: if (sp->scancount >= size) /* reload downsampled-data buffers */ { if ( CALLJPEG(sp,-1,jpeg_read_raw_data(&sp->cinfo.d,sp->ds_buffer,lines_per_MCU)) != lines_per_MCU ) return 0; sp->scancount = 0; }; rows = 0; do { register JSAMPLE *inptr = sp->ds_buffer[s][sp->scancount*compptr->v_samp_factor + rows]; register int clumps_per_line = compptr->downsampled_width; do *buf++ = *inptr++; while (--clumps_per_line > 0); /* Copy scanline */ tif->tif_row += v; if (--cc <= 0) return 1; /* End of caller's buffer? */ } while (++rows < compptr->v_samp_factor); ++sp->scancount; goto L; } /* "OJPEGSetupDecode()" temporarily forces the JPEG Library to use the following subroutine as a "dummy" input reader in order to fool the library into thinking that it has read the image's first "Start of Scan" (SOS) marker, so that it initializes accordingly. */ /*ARGSUSED*/ METHODDEF(int) fake_SOS_marker(j_decompress_ptr cinfo){return JPEG_REACHED_SOS;} /*ARGSUSED*/ METHODDEF(int) suspend(j_decompress_ptr cinfo){return JPEG_SUSPENDED;} /* The JPEG Library's "null" color-space converter actually re-packs separate color planes (it's native image representation) into a pixel-interleaved, contiguous plane. But if our TIFF Library client is tryng to process a PLANARCONFIG_SEPARATE image, we don't want that; so here are modifications of code in the JPEG Library's "jdcolor.c" file, which simply copy Bytes to a color plane specified by the current JPEG "scan". */ METHODDEF(void) ycc_rgb_convert(register j_decompress_ptr cinfo,JSAMPIMAGE in,JDIMENSION row, register JSAMPARRAY out,register int nrows) { typedef struct /* "jdcolor.c" color-space conversion state */ { /* WARNING: This declaration is ugly and dangerous! It's supposed to be private to the JPEG Library's "jdcolor.c" module, but we also need it here. Since the library's copy might change without notice, be sure to keep this one synchronized or the following code will break! */ struct jpeg_color_deconverter pub; /* Public fields */ /* Private state for YCC->RGB conversion */ int *Cr_r_tab, /* ->Cr to R conversion table */ *Cb_b_tab; /* ->Cb to B conversion table */ INT32 *Cr_g_tab, /* ->Cr to G conversion table */ *Cb_g_tab; /* ->Cb to G conversion table */ } *my_cconvert_ptr; my_cconvert_ptr cconvert = (my_cconvert_ptr)cinfo->cconvert; JSAMPARRAY irow0p = in[0] + row; register JSAMPLE *range_limit = cinfo->sample_range_limit; register JSAMPROW outp, Y; switch (cinfo->output_scan_number - 1) { JSAMPARRAY irow1p, irow2p; register INT32 *table0, *table1; SHIFT_TEMPS case RGB_RED : irow2p = in[2] + row; table0 = (INT32 *)cconvert->Cr_r_tab; while (--nrows >= 0) { register JSAMPROW Cr = *irow2p++; register int i = cinfo->output_width; Y = *irow0p++; outp = *out++; while (--i >= 0) *outp++ = range_limit[*Y++ + table0[*Cr++]]; }; return; case RGB_GREEN: irow1p = in[1] + row; irow2p = in[2] + row; table0 = cconvert->Cb_g_tab; table1 = cconvert->Cr_g_tab; while (--nrows >= 0) { register JSAMPROW Cb = *irow1p++, Cr = *irow2p++; register int i = cinfo->output_width; Y = *irow0p++; outp = *out++; while (--i >= 0) *outp++ = range_limit[ *Y++ + RIGHT_SHIFT(table0[*Cb++]+table1[*Cr++],16) ]; }; return; case RGB_BLUE : irow1p = in[1] + row; table0 = (INT32 *)cconvert->Cb_b_tab; while (--nrows >= 0) { register JSAMPROW Cb = *irow1p++; register int i = cinfo->output_width; Y = *irow0p++; outp = *out++; while (--i >= 0) *outp++ = range_limit[*Y++ + table0[*Cb++]]; } } } METHODDEF(void) null_convert(register j_decompress_ptr cinfo,JSAMPIMAGE in,JDIMENSION row, register JSAMPARRAY out,register int nrows) { register JSAMPARRAY irowp = in[cinfo->output_scan_number - 1] + row; while (--nrows >= 0) _TIFFmemcpy(*out++,*irowp++,cinfo->output_width); } static int OJPEGSetupDecode(register TIFF *tif) { static char module[]={"OJPEGSetupDecode"}; J_COLOR_SPACE jpeg_color_space, /* Color space of JPEG-compressed image */ out_color_space; /* Color space of decompressed image */ uint32 segment_width; int status = 1; /* Assume success by default */ boolean downsampled_output=FALSE, /* <=> Want JPEG Library's "raw" image? */ is_JFIF; /* <=> JFIF image? */ register OJPEGState *sp = OJState(tif); # define td (&tif->tif_dir) /* Verify miscellaneous parameters. This will need work if the TIFF Library ever supports different depths for different components, or if the JPEG Library ever supports run-time depth selection. Neither seems imminent. */ if (td->td_bitspersample != sp->cinfo.d.data_precision) { TIFFError(module,bad_bps,td->td_bitspersample); status = 0; }; /* The TIFF Version 6.0 specification and IJG JPEG Library accept different sets of color spaces, so verify that our image belongs to the common subset and map its photometry code, then initialize to handle subsampling and optional JPEG Library YCbCr <-> RGB color-space conversion. */ switch (td->td_photometric) { case PHOTOMETRIC_YCBCR : /* ISO IS 10918-1 requires that JPEG subsampling factors be 1-4, but TIFF Version 6.0 is more restrictive: only 1, 2, and 4 are allowed. */ if ( ( td->td_ycbcrsubsampling[0] == 1 || td->td_ycbcrsubsampling[0] == 2 || td->td_ycbcrsubsampling[0] == 4 ) && ( td->td_ycbcrsubsampling[1] == 1 || td->td_ycbcrsubsampling[1] == 2 || td->td_ycbcrsubsampling[1] == 4 ) ) downsampled_output = ( (sp->h_sampling = td->td_ycbcrsubsampling[0]) << 3 | (sp->v_sampling = td->td_ycbcrsubsampling[1]) ) != 011; else { TIFFError(module,bad_subsampling); status = 0; }; jpeg_color_space = JCS_YCbCr; if (sp->jpegcolormode == JPEGCOLORMODE_RGB) { downsampled_output = FALSE; out_color_space = JCS_RGB; break; }; goto L2; case PHOTOMETRIC_MINISBLACK: jpeg_color_space = JCS_GRAYSCALE; goto L1; case PHOTOMETRIC_RGB : jpeg_color_space = JCS_RGB; goto L1; case PHOTOMETRIC_SEPARATED : jpeg_color_space = JCS_CMYK; L1: sp->jpegcolormode = JPEGCOLORMODE_RAW; /* No JPEG Lib. conversion */ L2: out_color_space = jpeg_color_space; break; default : TIFFError(module,bad_photometry,td->td_photometric); status = 0; }; if (status == 0) return 0; /* If TIFF errors, don't bother to continue */ /* Set parameters that are same for all strips/tiles. */ sp->cinfo.d.src = &sp->src; sp->src.init_source = std_init_source; sp->src.fill_input_buffer = std_fill_input_buffer; sp->src.skip_input_data = std_skip_input_data; sp->src.resync_to_restart = jpeg_resync_to_restart; sp->src.term_source = std_term_source; /* BOGOSITY ALERT! The Wang Imaging application for Microsoft Windows produces images containing "JPEGInterchangeFormat[Length]" TIFF records that resemble JFIF-in-TIFF encapsulations but, in fact, violate the TIFF Version 6 specification in several ways; nevertheless, we try to handle them gracefully because there are apparently a lot of them around. The purported "JFIF" data stream in one of these files vaguely resembles a JPEG "tables only" data stream, except that there's no trailing EOI marker. The rest of the JPEG data stream lies in a discontiguous file region, identified by the 0th Strip offset (which is *also* illegal!), where it begins with an SOS marker and apparently continues to the end of the file. There is no trailing EOI marker here, either. */ is_JFIF = !sp->is_WANG && TIFFFieldSet(tif,FIELD_JPEGIFOFFSET); /* Initialize decompression parameters that won't be overridden by JPEG Library defaults set during the "jpeg_read_header()" call, below. */ segment_width = td->td_imagewidth; if (isTiled(tif)) { if (sp->is_WANG) /* we don't know how to handle it */ { TIFFError(module,"Tiled Wang image not supported"); return 0; }; /* BOGOSITY ALERT! "TIFFTileRowSize()" seems to work fine for modern JPEG- in-TIFF encapsulations where the image width--like the tile width--is a multiple of 8 or 16 pixels. But image widths and heights are aren't restricted to 8- or 16-bit multiples, and we need the exact Byte count of decompressed scan lines when we call the JPEG Library. At least one old file ("zackthecat.tif") in the TIFF Library test suite has widths and heights slightly less than the tile sizes, and it apparently used the bogus computation below to determine the number of Bytes per scan line (was this due to an old, broken version of "TIFFhowmany()"?). Before we get here, "OJPEGSetupDecode()" verified that our image uses 8-bit samples, so the following check appears to return the correct answer in all known cases tested to date. */ if (is_JFIF || (segment_width & 7) == 0) sp->bytesperline = TIFFTileRowSize(tif); /* Normal case */ else { /* Was the file-encoder's segment-width calculation bogus? */ segment_width = (segment_width/sp->h_sampling + 1) * sp->h_sampling; sp->bytesperline = segment_width * td->td_samplesperpixel; } } else sp->bytesperline = TIFFVStripSize(tif,1); /* BEWARE OF KLUDGE: If we have JPEG Interchange File Format (JFIF) image, then we want to read "metadata" in the bit-stream's header and validate it against corresponding information in TIFF records. But if we have a *really old* JPEG file that's not JFIF, then we simply assign TIFF-record values to JPEG Library variables without checking. */ if (is_JFIF) /* JFIF image */ { unsigned char *end_of_data; int subsampling_factors; register unsigned char *p; register int i; /* WARNING: Although the image file contains a JFIF bit stream, it might also contain some old TIFF records causing "OJPEGVSetField()" to have allocated quantization or Huffman decoding tables. But when the JPEG Library reads and parses the JFIF header below, it reallocate these tables anew without checking for "dangling" pointers, thereby causing a memory "leak". We have enough information to potentially deallocate the old tables here, but unfortunately JPEG Library Version 6B uses a "pool" allocator for small objects, with no deallocation procedure; instead, it reclaims a whole pool when an image is closed/destroyed, so well-behaved TIFF client applications (i.e., those which close their JPEG images as soon as they're no longer needed) will waste memory for a short time but recover it eventually. But ill-behaved TIFF clients (i.e., those which keep many JPEG images open gratuitously) can exhaust memory prematurely. If the JPEG Library ever implements a deallocation procedure, insert this clean-up code: */ # ifdef someday if (sp->jpegtablesmode & JPEGTABLESMODE_QUANT) /* free quant. tables */ { register int i = 0; do { register JQUANT_TBL *q; if (q = sp->cinfo.d.quant_tbl_ptrs[i]) { jpeg_free_small(&sp->cinfo.comm,q,sizeof *q); sp->cinfo.d.quant_tbl_ptrs[i] = 0; } } while (++i < NUM_QUANT_TBLS); }; if (sp->jpegtablesmode & JPEGTABLESMODE_HUFF) /* free Huffman tables */ { register int i = 0; do { register JHUFF_TBL *h; if (h = sp->cinfo.d.dc_huff_tbl_ptrs[i]) { jpeg_free_small(&sp->cinfo.comm,h,sizeof *h); sp->cinfo.d.dc_huff_tbl_ptrs[i] = 0; }; if (h = sp->cinfo.d.ac_huff_tbl_ptrs[i]) { jpeg_free_small(&sp->cinfo.comm,h,sizeof *h); sp->cinfo.d.ac_huff_tbl_ptrs[i] = 0; } } while (++i < NUM_HUFF_TBLS); }; # endif /* someday */ /* Since we might someday wish to try rewriting "old format" JPEG-in-TIFF encapsulations in "new format" files, try to synthesize the value of a modern "JPEGTables" TIFF record by scanning the JPEG data from just past the "Start of Information" (SOI) marker until something other than a legitimate "table" marker is found, as defined in ISO IS 10918-1 Appending B.2.4; namely: -- Define Quantization Table (DQT) -- Define Huffman Table (DHT) -- Define Arithmetic Coding table (DAC) -- Define Restart Interval (DRI) -- Comment (COM) -- Application data (APPn) For convenience, we also accept "Expansion" (EXP) markers, although they are apparently not a part of normal "table" data. */ sp->jpegtables = p = (unsigned char *)sp->src.next_input_byte; end_of_data = p + sp->src.bytes_in_buffer; p += 2; while (p < end_of_data && p[0] == 0xFF) switch (p[1]) { default : goto L; case 0xC0: /* SOF0 */ case 0xC1: /* SOF1 */ case 0xC2: /* SOF2 */ case 0xC3: /* SOF3 */ case 0xC4: /* DHT */ case 0xC5: /* SOF5 */ case 0xC6: /* SOF6 */ case 0xC7: /* SOF7 */ case 0xC9: /* SOF9 */ case 0xCA: /* SOF10 */ case 0xCB: /* SOF11 */ case 0xCC: /* DAC */ case 0xCD: /* SOF13 */ case 0xCE: /* SOF14 */ case 0xCF: /* SOF15 */ case 0xDB: /* DQT */ case 0xDD: /* DRI */ case 0xDF: /* EXP */ case 0xE0: /* APP0 */ case 0xE1: /* APP1 */ case 0xE2: /* APP2 */ case 0xE3: /* APP3 */ case 0xE4: /* APP4 */ case 0xE5: /* APP5 */ case 0xE6: /* APP6 */ case 0xE7: /* APP7 */ case 0xE8: /* APP8 */ case 0xE9: /* APP9 */ case 0xEA: /* APP10 */ case 0xEB: /* APP11 */ case 0xEC: /* APP12 */ case 0xED: /* APP13 */ case 0xEE: /* APP14 */ case 0xEF: /* APP15 */ case 0xFE: /* COM */ p += (p[2] << 8 | p[3]) + 2; }; L: if (p - (unsigned char *)sp->jpegtables > 2) /* fake "JPEGTables" */ { /* In case our client application asks, pretend that this image file contains a modern "JPEGTables" TIFF record by copying to a buffer the initial part of the JFIF bit-stream that we just scanned, from the SOI marker through the "metadata" tables, then append an EOI marker and flag the "JPEGTables" TIFF record as "present". */ sp->jpegtables_length = p - (unsigned char*)sp->jpegtables + 2; p = sp->jpegtables; if (!(sp->jpegtables = _TIFFmalloc(sp->jpegtables_length))) { TIFFError(module,no_jtable_space); return 0; }; _TIFFmemcpy(sp->jpegtables,p,sp->jpegtables_length-2); p = (unsigned char *)sp->jpegtables + sp->jpegtables_length; p[-2] = 0xFF; p[-1] = JPEG_EOI; /* Append EOI marker */ TIFFSetFieldBit(tif,FIELD_JPEGTABLES); tif->tif_flags |= TIFF_DIRTYDIRECT; } else sp->jpegtables = 0; /* Don't simulate "JPEGTables" */ if ( CALLJPEG(sp,-1,jpeg_read_header(&sp->cinfo.d,TRUE)) != JPEG_HEADER_OK ) return 0; if ( sp->cinfo.d.image_width != segment_width || sp->cinfo.d.image_height != td->td_imagelength ) { TIFFError(module,"Improper JPEG strip/tile size"); return 0; }; if (sp->cinfo.d.num_components != td->td_samplesperpixel) { TIFFError(module,"Improper JPEG component count"); return 0; }; if (sp->cinfo.d.data_precision != td->td_bitspersample) { TIFFError(module,"Improper JPEG data precision"); return 0; }; /* Check that JPEG image components all have the same subsampling factors declared (or defaulted) in the TIFF file, since TIFF Version 6.0 is more restrictive than JPEG: Only the 0th component may have horizontal and vertical subsampling factors other than <1,1>. */ subsampling_factors = sp->h_sampling << 3 | sp->v_sampling; i = 0; do { if ( ( sp->cinfo.d.comp_info[i].h_samp_factor << 3 | sp->cinfo.d.comp_info[i].v_samp_factor ) != subsampling_factors ) { TIFFError(module,"Improper JPEG subsampling factors"); return 0; }; subsampling_factors = 011; /* Required for image components > 0 */ } while (++i < sp->cinfo.d.num_components); } else /* not JFIF image */ { int (*save)(j_decompress_ptr cinfo) = sp->cinfo.d.marker->read_markers; register int i; /* We're not assuming that this file's JPEG bit stream has any header "metadata", so fool the JPEG Library into thinking that we read a "Start of Input" (SOI) marker and a "Start of Frame" (SOFx) marker, then force it to read a simulated "Start of Scan" (SOS) marker when we call "jpeg_read_header()" below. This should cause the JPEG Library to establish reasonable defaults. */ sp->cinfo.d.marker->saw_SOI = /* Pretend we saw SOI marker */ sp->cinfo.d.marker->saw_SOF = TRUE; /* Pretend we saw SOF marker */ sp->cinfo.d.marker->read_markers = sp->is_WANG ? suspend : fake_SOS_marker; sp->cinfo.d.global_state = DSTATE_INHEADER; sp->cinfo.d.Se = DCTSIZE2-1; /* Suppress JPEG Library warning */ sp->cinfo.d.image_width = segment_width; sp->cinfo.d.image_height = td->td_imagelength; /* The following color-space initialization, including the complicated "switch"-statement below, essentially duplicates the logic used by the JPEG Library's "jpeg_init_colorspace()" subroutine during compression. */ sp->cinfo.d.num_components = td->td_samplesperpixel; sp->cinfo.d.comp_info = (jpeg_component_info *) (*sp->cinfo.d.mem->alloc_small) ( &sp->cinfo.comm , JPOOL_IMAGE , sp->cinfo.d.num_components * sizeof *sp->cinfo.d.comp_info ); i = 0; do { sp->cinfo.d.comp_info[i].component_index = i; sp->cinfo.d.comp_info[i].component_needed = TRUE; sp->cinfo.d.cur_comp_info[i] = &sp->cinfo.d.comp_info[i]; } while (++i < sp->cinfo.d.num_components); switch (jpeg_color_space) { case JCS_UNKNOWN : i = 0; do { sp->cinfo.d.comp_info[i].component_id = i; sp->cinfo.d.comp_info[i].h_samp_factor = sp->cinfo.d.comp_info[i].v_samp_factor = 1; } while (++i < sp->cinfo.d.num_components); break; case JCS_GRAYSCALE: sp->cinfo.d.comp_info[0].component_id = sp->cinfo.d.comp_info[0].h_samp_factor = sp->cinfo.d.comp_info[0].v_samp_factor = 1; break; case JCS_RGB : sp->cinfo.d.comp_info[0].component_id = 'R'; sp->cinfo.d.comp_info[1].component_id = 'G'; sp->cinfo.d.comp_info[2].component_id = 'B'; i = 0; do sp->cinfo.d.comp_info[i].h_samp_factor = sp->cinfo.d.comp_info[i].v_samp_factor = 1; while (++i < sp->cinfo.d.num_components); break; case JCS_CMYK : sp->cinfo.d.comp_info[0].component_id = 'C'; sp->cinfo.d.comp_info[1].component_id = 'M'; sp->cinfo.d.comp_info[2].component_id = 'Y'; sp->cinfo.d.comp_info[3].component_id = 'K'; i = 0; do sp->cinfo.d.comp_info[i].h_samp_factor = sp->cinfo.d.comp_info[i].v_samp_factor = 1; while (++i < sp->cinfo.d.num_components); break; case JCS_YCbCr : i = 0; do { sp->cinfo.d.comp_info[i].component_id = i+1; sp->cinfo.d.comp_info[i].h_samp_factor = sp->cinfo.d.comp_info[i].v_samp_factor = 1; sp->cinfo.d.comp_info[i].quant_tbl_no = sp->cinfo.d.comp_info[i].dc_tbl_no = sp->cinfo.d.comp_info[i].ac_tbl_no = i > 0; } while (++i < sp->cinfo.d.num_components); sp->cinfo.d.comp_info[0].h_samp_factor = sp->h_sampling; sp->cinfo.d.comp_info[0].v_samp_factor = sp->v_sampling; }; sp->cinfo.d.comps_in_scan = td->td_planarconfig == PLANARCONFIG_CONTIG ? sp->cinfo.d.num_components : 1; i = CALLJPEG(sp,-1,jpeg_read_header(&sp->cinfo.d,!sp->is_WANG)); sp->cinfo.d.marker->read_markers = save; /* Restore input method */ if (sp->is_WANG) /* produced by Wang Imaging on Microsoft Windows */ { if (i != JPEG_SUSPENDED) return 0; /* BOGOSITY ALERT! Files prooduced by the Wang Imaging application for Microsoft Windows are a special--and, technically illegal--case. A JPEG SOS marker and rest of the data stream should be located at the end of the file, in a position identified by the 0th Strip offset. */ i = td->td_nstrips - 1; sp->src.next_input_byte = tif->tif_base + td->td_stripoffset[0]; sp->src.bytes_in_buffer = td->td_stripoffset[i] - td->td_stripoffset[0] + td->td_stripbytecount[i]; i = CALLJPEG(sp,-1,jpeg_read_header(&sp->cinfo.d,TRUE)); }; if (i != JPEG_HEADER_OK) return 0; }; /* Some of our initialization must wait until the JPEG Library is initialized above, in order to override its defaults. */ if ( (sp->cinfo.d.raw_data_out = downsampled_output) && !alloc_downsampled_buffers(tif,sp->cinfo.d.comp_info, sp->cinfo.d.num_components) ) return 0; sp->cinfo.d.jpeg_color_space = jpeg_color_space; sp->cinfo.d.out_color_space = out_color_space; sp->cinfo.d.dither_mode = JDITHER_NONE; /* Reduce image "noise" */ sp->cinfo.d.two_pass_quantize = FALSE; /* If the image consists of separate, discontiguous TIFF "samples" (= color planes, hopefully = JPEG "scans"), then we must use the JPEG Library's "buffered image" mode to decompress the entire image into temporary buffers, because the JPEG Library must parse the entire JPEG bit-stream in order to be satsified that it has a complete set of color components for each pixel, but the TIFF Library must allow our client to extract 1 component at a time. Initializing the JPEG Library's "buffered image" mode is tricky: First, we start its decompressor, then we tell the decompressor to "consume" (i.e., buffer) the entire bit-stream. WARNING: Disabling "fancy" up-sampling seems to slightly reduce "noise" for certain old Wang Imaging files, but it absolutely *must* be enabled if the image has separate color planes, since in that case, the JPEG Library doesn't use an "sp->cinfo.d.cconvert" structure (so de-referencing this pointer below will cause a fatal crash) but writing our own code to up- sample separate color planes is too much work for right now. Maybe someday? */ sp->cinfo.d.do_fancy_upsampling = /* Always let this default (to TRUE)? */ sp->cinfo.d.buffered_image = td->td_planarconfig == PLANARCONFIG_SEPARATE; if (!CALLJPEG(sp,0,jpeg_start_decompress(&sp->cinfo.d))) return 0; if (sp->cinfo.d.buffered_image) /* separate color planes */ { if (sp->cinfo.d.raw_data_out) tif->tif_decoderow = tif->tif_decodestrip = tif->tif_decodetile = OJPEGDecodeRawSeparate; else { tif->tif_decoderow = tif->tif_decodestrip = tif->tif_decodetile = OJPEGDecode; /* In JPEG Library Version 6B, color-space conversion isn't implemented for separate color planes, so we must do it ourself if our TIFF client doesn't want to: */ sp->cinfo.d.cconvert->color_convert = sp->cinfo.d.jpeg_color_space == sp->cinfo.d.out_color_space ? null_convert : ycc_rgb_convert; }; L3: switch (CALLJPEG(sp,0,jpeg_consume_input(&sp->cinfo.d))) { default : goto L3; /* If no JPEG "End of Information" (EOI) marker is found when bit- stream parsing ends, check whether we have enough data to proceed before reporting an error. */ case JPEG_SUSPENDED : if ( sp->cinfo.d.input_scan_number *sp->cinfo.d.image_height + sp->cinfo.d.input_iMCU_row *sp->cinfo.d.max_v_samp_factor # ifdef D_LOSSLESS_SUPPORTED *sp->cinfo.d.data_units_in_MCU *sp->cinfo.d.min_codec_data_unit # else *sp->cinfo.d.blocks_in_MCU *DCTSIZE # endif < td->td_samplesperpixel *sp->cinfo.d.image_height ) { TIFFError(tif->tif_name, "Premature end of JPEG bit-stream"); return 0; } case JPEG_REACHED_EOI: ; } } else /* pixel-interleaved color planes */ tif->tif_decoderow = tif->tif_decodestrip = tif->tif_decodetile = downsampled_output ? OJPEGDecodeRawContig : OJPEGDecode; return 1; # undef td } static int OJPEGPreDecode(register TIFF *tif,tsample_t s) { register OJPEGState *sp = OJState(tif); # define td (&tif->tif_dir) /* If we are about to read the first row of an image plane (hopefully, these are coincident with JPEG "scans"!), reset the JPEG Library's decompressor appropriately. Otherwise, let the decompressor run "as is" and return a "success" status without further ado. */ if ( (isTiled(tif) ? tif->tif_curtile : tif->tif_curstrip) % td->td_stripsperimage == 0 ) { if ( sp->cinfo.d.buffered_image && !CALLJPEG(sp,0,jpeg_start_output(&sp->cinfo.d,s+1)) ) return 0; sp->cinfo.d.output_scanline = 0; /* Mark subsampling buffers "empty". */ # ifdef D_LOSSLESS_SUPPORTED sp->scancount = sp->cinfo.d.min_codec_data_unit; # else sp->scancount = DCTSIZE; # endif }; return 1; # undef td } /*ARGSUSED*/ static void OJPEGPostDecode(register TIFF *tif,tidata_t buf,tsize_t cc) { register OJPEGState *sp = OJState(tif); # define td (&tif->tif_dir) /* The JPEG Library decompressor has reached the end of a strip/tile. If this is the end of a TIFF image "sample" (= JPEG "scan") in a file with separate components (color planes), then end the "scan". If it ends the image's last sample/scan, then also stop the JPEG Library's decompressor. */ if (sp->cinfo.d.output_scanline >= sp->cinfo.d.output_height) { if (sp->cinfo.d.buffered_image) CALLJPEG(sp,-1,jpeg_finish_output(&sp->cinfo.d)); /* End JPEG scan */ if ( (isTiled(tif) ? tif->tif_curtile : tif->tif_curstrip) >= td->td_nstrips-1 ) CALLJPEG(sp,0,jpeg_finish_decompress(&sp->cinfo.d)); } # undef td } static int OJPEGVSetField(register TIFF *tif,ttag_t tag,va_list ap) { uint32 v32; register OJPEGState *sp = OJState(tif); # define td (&tif->tif_dir) toff_t tiffoff=0; uint32 bufoff=0; uint32 code_count=0; int i2=0; int k2=0; switch (tag) { /* If a "ReferenceBlackWhite" TIFF tag appears in the file explicitly, undo any modified default definition that we might have installed below, then install the real one. */ case TIFFTAG_REFERENCEBLACKWHITE : if (td->td_refblackwhite) { _TIFFfree(td->td_refblackwhite); td->td_refblackwhite = 0; }; default : return (*sp->vsetparent)(tif,tag,ap); /* BEWARE OF KLUDGE: Some old-format JPEG-in-TIFF files, including those produced by the Wang Imaging application for Micro- soft Windows, illegally omit a "ReferenceBlackWhite" TIFF tag, even though the TIFF specification's default is intended for the RGB color space and is inappropriate for the YCbCr color space ordinarily used for JPEG images. Since many TIFF client applications request the value of this tag immediately after a TIFF image directory is parsed, and before any other code in this module receives control, we are forced to fix this problem very early in image-file processing. Fortunately, legal TIFF files are supposed to store their tags in numeric order, so a mandatory "PhotometricInterpretation" tag should always appear before an optional "ReferenceBlackWhite" tag. Hence, we slyly peek ahead when we discover the desired photometry, by installing modified black and white reference levels. */ case TIFFTAG_PHOTOMETRIC : if ( (v32 = (*sp->vsetparent)(tif,tag,ap)) && td->td_photometric == PHOTOMETRIC_YCBCR ) { if ( (td->td_refblackwhite = _TIFFmalloc(6*sizeof(float))) ) { register long top = 1 << td->td_bitspersample; td->td_refblackwhite[0] = 0; td->td_refblackwhite[1] = td->td_refblackwhite[3] = td->td_refblackwhite[5] = top - 1; td->td_refblackwhite[2] = td->td_refblackwhite[4] = top >> 1; } else { TIFFError(tif->tif_name, "Cannot set default reference black and white levels"); v32 = 0; }; } return v32; /* BEWARE OF KLUDGE: According to Charles Auer , if our input is a multi-image (multi-directory) JPEG-in-TIFF file is produced by the Wang Imaging application on Microsoft Windows, for some reason the first directory excludes the vendor-specific "WANG PageControl" tag (32934) that we check below, so the only other way to identify these directories is apparently to look for a software- identification tag with the substring, "Wang Labs". Single-image files can apparently pass both tests, which causes no harm here, but what a mess this is! */ case TIFFTAG_SOFTWARE : { char *software; v32 = (*sp->vsetparent)(tif,tag,ap); if( TIFFGetField( tif, TIFFTAG_SOFTWARE, &software ) && strstr( software, "Wang Labs" ) ) sp->is_WANG = 1; return v32; } case TIFFTAG_JPEGPROC : case TIFFTAG_JPEGIFOFFSET : case TIFFTAG_JPEGIFBYTECOUNT : case TIFFTAG_JPEGRESTARTINTERVAL : case TIFFTAG_JPEGLOSSLESSPREDICTORS: case TIFFTAG_JPEGPOINTTRANSFORM : case TIFFTAG_JPEGQTABLES : case TIFFTAG_JPEGDCTABLES : case TIFFTAG_JPEGACTABLES : case TIFFTAG_WANG_PAGECONTROL : case TIFFTAG_JPEGCOLORMODE : ; }; v32 = va_arg(ap,uint32); /* No. of values in this TIFF record */ /* This switch statement is added for OJPEGVSetField */ if(v32 !=0){ switch(tag){ case TIFFTAG_JPEGPROC: sp->jpegproc=v32; break; case TIFFTAG_JPEGIFOFFSET: sp->jpegifoffset=v32; break; case TIFFTAG_JPEGIFBYTECOUNT: sp->jpegifbytecount=v32; break; case TIFFTAG_JPEGRESTARTINTERVAL: sp->jpegrestartinterval=v32; break; case TIFFTAG_JPEGLOSSLESSPREDICTORS: sp->jpeglosslesspredictors_length=v32; break; case TIFFTAG_JPEGPOINTTRANSFORM: sp->jpegpointtransform_length=v32; break; case TIFFTAG_JPEGQTABLES: sp->jpegqtables_length=v32; break; case TIFFTAG_JPEGACTABLES: sp->jpegactables_length=v32; break; case TIFFTAG_JPEGDCTABLES: sp->jpegdctables_length=v32; break; default: break; } } /* BEWARE: The following actions apply only if we are reading a "source" TIFF image to be decompressed for a client application program. If we ever enhance this file's CODEC to write "destination" JPEG-in-TIFF images, we'll need an "if"- and another "switch"-statement below, because we'll probably want to store these records' values in some different places. Most of these need not be parsed here in order to decode JPEG bit stream, so we set boolean flags to note that they have been seen, but we otherwise ignore them. */ switch (tag) { JHUFF_TBL **h; /* Validate the JPEG-process code. */ case TIFFTAG_JPEGPROC : switch (v32) { default : TIFFError(tif->tif_name, "Unknown JPEG process"); return 0; # ifdef C_LOSSLESS_SUPPORTED /* Image uses (lossy) baseline sequential coding. */ case JPEGPROC_BASELINE: sp->cinfo.d.process = JPROC_SEQUENTIAL; sp->cinfo.d.data_unit = DCTSIZE; break; /* Image uses (lossless) Huffman coding. */ case JPEGPROC_LOSSLESS: sp->cinfo.d.process = JPROC_LOSSLESS; sp->cinfo.d.data_unit = 1; # else /* not C_LOSSLESS_SUPPORTED */ case JPEGPROC_LOSSLESS: TIFFError(JPEGLib_name, "Does not support lossless Huffman coding"); return 0; case JPEGPROC_BASELINE: ; # endif /* C_LOSSLESS_SUPPORTED */ }; break; /* The TIFF Version 6.0 specification says that if the value of a TIFF "JPEGInterchangeFormat" record is 0, then we are to behave as if this record were absent; i.e., the data does *not* represent a JPEG Inter- change Format File (JFIF), so don't even set the boolean "I've been here" flag below. Otherwise, the field's value represents the file offset of the JPEG SOI marker. */ case TIFFTAG_JPEGIFOFFSET : if (v32) { sp->src.next_input_byte = tif->tif_base + v32; break; }; return 1; case TIFFTAG_JPEGIFBYTECOUNT : sp->src.bytes_in_buffer = v32; break; /* The TIFF Version 6.0 specification says that if the JPEG "Restart" marker interval is 0, then the data has no "Restart" markers; i.e., we must behave as if this TIFF record were absent. So, don't even set the boolean "I've been here" flag below. */ /* * Instead, set the field bit so TIFFGetField can get whether or not * it was set. */ case TIFFTAG_JPEGRESTARTINTERVAL : if (v32) sp->cinfo.d.restart_interval = v32; break; /* The TIFF Version 6.0 specification says that this tag is supposed to be a vector containing a value for each image component, but for lossless Huffman coding (the only JPEG process defined by the specification for which this tag should be needed), ISO IS 10918-1 uses only a single value, equivalent to the "Ss" field in a JPEG bit-stream's "Start of Scan" (SOS) marker. So, we extract the first vector element and ignore the rest. (I hope this is correct!) */ case TIFFTAG_JPEGLOSSLESSPREDICTORS: if (v32) { sp->cinfo.d.Ss = *va_arg(ap,uint16 *); sp->jpeglosslesspredictors = _TIFFmalloc(sp->jpeglosslesspredictors_length * sizeof(uint16)); if(sp->jpeglosslesspredictors==NULL){return(0);} for(i2=0;i2jpeglosslesspredictors_length;i2++){ ((uint16*)sp->jpeglosslesspredictors)[i2] = ((uint16*)sp->cinfo.d.Ss)[i2]; } sp->jpeglosslesspredictors_length*=sizeof(uint16); break; }; return v32; /* The TIFF Version 6.0 specification says that this tag is supposed to be a vector containing a value for each image component, but for lossless Huffman coding (the only JPEG process defined by the specification for which this tag should be needed), ISO IS 10918-1 uses only a single value, equivalent to the "Al" field in a JPEG bit-stream's "Start of Scan" (SOS) marker. So, we extract the first vector element and ignore the rest. (I hope this is correct!) */ case TIFFTAG_JPEGPOINTTRANSFORM : if (v32) { sp->cinfo.d.Al = *va_arg(ap,uint16 *); sp->jpegpointtransform = _TIFFmalloc(sp->jpegpointtransform_length*sizeof(uint16)); if(sp->jpegpointtransform==NULL){return(0);} for(i2=0;i2jpegpointtransform_length;i2++) { ((uint16*)sp->jpegpointtransform)[i2] = ((uint16*)sp->cinfo.d.Al)[i2]; } sp->jpegpointtransform_length*=sizeof(uint16); break; } return v32; /* We have a vector of offsets to quantization tables, so load 'em! */ case TIFFTAG_JPEGQTABLES : if (v32) { uint32 *v; int i; if (v32 > NUM_QUANT_TBLS) { TIFFError(tif->tif_name,"Too many quantization tables"); return 0; }; i = 0; v = va_arg(ap,uint32 *); sp->jpegqtables=_TIFFmalloc(64*sp->jpegqtables_length); if(sp->jpegqtables==NULL){return(0);} tiffoff = TIFFSeekFile(tif, 0, SEEK_CUR); bufoff=0; for(i2=0;i2jpegqtables_length;i2++){ TIFFSeekFile(tif, v[i2], SEEK_SET); TIFFReadFile(tif, &(((u_char*)(sp->jpegqtables))[bufoff]), 64); bufoff+=64; } sp->jpegqtables_length=bufoff; TIFFSeekFile(tif, tiffoff, SEEK_SET); do /* read quantization table */ { register UINT8 *from = tif->tif_base + *v++; register UINT16 *to; register int j = DCTSIZE2; if (!( sp->cinfo.d.quant_tbl_ptrs[i] = CALLJPEG(sp,0,jpeg_alloc_quant_table(&sp->cinfo.comm)) ) ) { TIFFError(JPEGLib_name,"No space for quantization table"); return 0; }; to = sp->cinfo.d.quant_tbl_ptrs[i]->quantval; do *to++ = *from++; while (--j > 0); } while (++i < v32); sp->jpegtablesmode |= JPEGTABLESMODE_QUANT; }; break; /* We have a vector of offsets to DC Huffman tables, so load 'em! */ case TIFFTAG_JPEGDCTABLES : h = sp->cinfo.d.dc_huff_tbl_ptrs; goto L; /* We have a vector of offsets to AC Huffman tables, so load 'em! */ case TIFFTAG_JPEGACTABLES : h = sp->cinfo.d.ac_huff_tbl_ptrs; L: if (v32) { uint32 *v; int i; if (v32 > NUM_HUFF_TBLS) { TIFFError(tif->tif_name,"Too many Huffman tables"); return 0; }; v = va_arg(ap,uint32 *); if(tag == TIFFTAG_JPEGDCTABLES) { sp->jpegdctables=_TIFFmalloc(272*sp->jpegdctables_length); if(sp->jpegdctables==NULL){return(0);} tiffoff = TIFFSeekFile(tif, 0, SEEK_CUR); bufoff=0; code_count=0; for(i2=0;i2jpegdctables_length;i2++){ TIFFSeekFile(tif, v[i2], SEEK_SET); TIFFReadFile(tif, &(((u_char*)(sp->jpegdctables))[bufoff]), 16); code_count=0; for(k2=0;k2<16;k2++){ code_count+=((u_char*)(sp->jpegdctables))[k2+bufoff]; } TIFFReadFile(tif, &(((u_char*)(sp->jpegdctables))[bufoff+16]), code_count); bufoff+=16; bufoff+=code_count; } sp->jpegdctables_length=bufoff; TIFFSeekFile(tif, tiffoff, SEEK_SET); } if(tag==TIFFTAG_JPEGACTABLES){ sp->jpegactables=_TIFFmalloc(272*sp->jpegactables_length); if(sp->jpegactables==NULL){return(0);} tiffoff = TIFFSeekFile(tif, 0, SEEK_CUR); bufoff=0; code_count=0; for(i2=0;i2jpegactables_length;i2++){ TIFFSeekFile(tif, v[i2], SEEK_SET); TIFFReadFile(tif, &(((unsigned char*)(sp->jpegactables))[bufoff]), 16); code_count=0; for(k2=0;k2<16;k2++){ code_count+=((unsigned char*)(sp->jpegactables))[k2+bufoff]; } TIFFReadFile(tif, &(((unsigned char*)(sp->jpegactables))[bufoff+16]), code_count); bufoff+=16; bufoff+=code_count; } sp->jpegactables_length=bufoff; TIFFSeekFile(tif, tiffoff, SEEK_SET); } i = 0; do /* copy each Huffman table */ { int size = 0; register UINT8 *from = tif->tif_base + *v++, *to; register int j = sizeof (*h)->bits; /* WARNING: This code relies on the fact that an image file not "memory mapped" was read entirely into a single buffer by "TIFFInitOJPEG()", so we can do a fast memory-to- memory copy here. Each table consists of 16 Bytes, which are suffixed to a 0 Byte when copied, followed by a variable number of Bytes whose length is the sum of the first 16. */ if (!( *h = CALLJPEG(sp,0,jpeg_alloc_huff_table(&sp->cinfo.comm)) ) ) { TIFFError(JPEGLib_name,"No space for Huffman table"); return 0; }; to = (*h++)->bits; *to++ = 0; while (--j > 0) size += *to++ = *from++; /* Copy 16 Bytes */ if (size > sizeof (*h)->huffval/sizeof *(*h)->huffval) { TIFFError(tif->tif_name,"Huffman table too big"); return 0; }; if ((j = size) > 0) do *to++ = *from++; while (--j > 0); while (++size <= sizeof (*h)->huffval/sizeof *(*h)->huffval) *to++ = 0; /* Zero the rest of the table for cleanliness */ } while (++i < v32); sp->jpegtablesmode |= JPEGTABLESMODE_HUFF; }; break; /* The following vendor-specific TIFF tag occurs in (highly illegal) files produced by the Wang Imaging application for Microsoft Windows. These can apparently have several "pages", in which case this tag specifies the offset of a "page control" structure, which we don't currently know how to handle. 0 indicates a 1-page image with no "page control", which we make a feeble effort to handle. */ case TIFFTAG_WANG_PAGECONTROL : if (v32 == 0) v32 = -1; sp->is_WANG = v32; tag = TIFFTAG_JPEGPROC+FIELD_WANG_PAGECONTROL-FIELD_JPEGPROC; break; /* This pseudo tag indicates whether our caller is expected to do YCbCr <-> RGB color-space conversion (JPEGCOLORMODE_RAW <=> 0) or whether we must ask the JPEG Library to do it (JPEGCOLORMODE_RGB <=> 1). */ case TIFFTAG_JPEGCOLORMODE : sp->jpegcolormode = v32; /* Mark the image to indicate whether returned data is up-sampled, so that "TIFF{Strip,Tile}Size()" reflect the true amount of data present. */ v32 = tif->tif_flags; /* Save flags temporarily */ tif->tif_flags &= ~TIFF_UPSAMPLED; if ( td->td_photometric == PHOTOMETRIC_YCBCR && (td->td_ycbcrsubsampling[0]<<3 | td->td_ycbcrsubsampling[1]) != 011 && sp->jpegcolormode == JPEGCOLORMODE_RGB ) tif->tif_flags |= TIFF_UPSAMPLED; /* If the up-sampling state changed, re-calculate tile size. */ if ((tif->tif_flags ^ v32) & TIFF_UPSAMPLED) { tif->tif_tilesize = TIFFTileSize(tif); tif->tif_flags |= TIFF_DIRTYDIRECT; }; return 1; }; TIFFSetFieldBit(tif,tag-TIFFTAG_JPEGPROC+FIELD_JPEGPROC); return 1; # undef td } static int OJPEGVGetField(register TIFF *tif,ttag_t tag,va_list ap) { register OJPEGState *sp = OJState(tif); switch (tag) { /* If this file has managed to synthesize a set of consolidated "metadata" tables for the current (post-TIFF Version 6.0 specification) JPEG-in- TIFF encapsulation strategy, then tell our caller about them; otherwise, keep mum. */ case TIFFTAG_JPEGTABLES : if (sp->jpegtables_length) /* we have "new"-style JPEG tables */ { *va_arg(ap,uint32 *) = sp->jpegtables_length; *va_arg(ap,char **) = sp->jpegtables; return 1; }; /* This pseudo tag indicates whether our caller is expected to do YCbCr <-> RGB color-space conversion (JPEGCOLORMODE_RAW <=> 0) or whether we must ask the JPEG Library to do it (JPEGCOLORMODE_RGB <=> 1). */ case TIFFTAG_JPEGCOLORMODE : *va_arg(ap,uint32 *) = sp->jpegcolormode; return 1; /* The following tags are defined by the TIFF Version 6.0 specification and are obsolete. If our caller asks for information about them, do not return anything, even if we parsed them in an old-format "source" image. */ case TIFFTAG_JPEGPROC : *va_arg(ap, uint16*)=sp->jpegproc; return(1); break; case TIFFTAG_JPEGIFOFFSET : *va_arg(ap, uint32*)=sp->jpegifoffset; return(1); break; case TIFFTAG_JPEGIFBYTECOUNT : *va_arg(ap, uint32*)=sp->jpegifbytecount; return(1); break; case TIFFTAG_JPEGRESTARTINTERVAL : *va_arg(ap, uint32*)=sp->jpegrestartinterval; return(1); break; case TIFFTAG_JPEGLOSSLESSPREDICTORS: *va_arg(ap, uint32*)=sp->jpeglosslesspredictors_length; *va_arg(ap, void**)=sp->jpeglosslesspredictors; return(1); break; case TIFFTAG_JPEGPOINTTRANSFORM : *va_arg(ap, uint32*)=sp->jpegpointtransform_length; *va_arg(ap, void**)=sp->jpegpointtransform; return(1); break; case TIFFTAG_JPEGQTABLES : *va_arg(ap, uint32*)=sp->jpegqtables_length; *va_arg(ap, void**)=sp->jpegqtables; return(1); break; case TIFFTAG_JPEGDCTABLES : *va_arg(ap, uint32*)=sp->jpegdctables_length; *va_arg(ap, void**)=sp->jpegdctables; return(1); break; case TIFFTAG_JPEGACTABLES : *va_arg(ap, uint32*)=sp->jpegactables_length; *va_arg(ap, void**)=sp->jpegactables; return(1); break; }; return (*sp->vgetparent)(tif,tag,ap); } static void OJPEGPrintDir(register TIFF *tif,FILE *fd,long flags) { register OJPEGState *sp = OJState(tif); if ( ( flags & (TIFFPRINT_JPEGQTABLES|TIFFPRINT_JPEGDCTABLES|TIFFPRINT_JPEGACTABLES) ) && sp->jpegtables_length ) fprintf(fd," JPEG Table Data: , %lu bytes\n", sp->jpegtables_length); } static uint32 OJPEGDefaultStripSize(register TIFF *tif,register uint32 s) { register OJPEGState *sp = OJState(tif); # define td (&tif->tif_dir) if ((s = (*sp->defsparent)(tif,s)) < td->td_imagelength) { register tsize_t size = sp->cinfo.comm.is_decompressor # ifdef D_LOSSLESS_SUPPORTED ? sp->cinfo.d.min_codec_data_unit # else ? DCTSIZE # endif # ifdef C_LOSSLESS_SUPPORTED : sp->cinfo.c.data_unit; # else : DCTSIZE; # endif size = TIFFroundup(size,16); s = TIFFroundup(s,td->td_ycbcrsubsampling[1]*size); }; return s; # undef td } static void OJPEGDefaultTileSize(register TIFF *tif,register uint32 *tw,register uint32 *th) { register OJPEGState *sp = OJState(tif); register tsize_t size; # define td (&tif->tif_dir) size = sp->cinfo.comm.is_decompressor # ifdef D_LOSSLESS_SUPPORTED ? sp->cinfo.d.min_codec_data_unit # else ? DCTSIZE # endif # ifdef C_LOSSLESS_SUPPORTED : sp->cinfo.c.data_unit; # else : DCTSIZE; # endif size = TIFFroundup(size,16); (*sp->deftparent)(tif,tw,th); *tw = TIFFroundup(*tw,td->td_ycbcrsubsampling[0]*size); *th = TIFFroundup(*th,td->td_ycbcrsubsampling[1]*size); # undef td } static void OJPEGCleanUp(register TIFF *tif) { register OJPEGState *sp; if ( (sp = OJState(tif)) ) { CALLVJPEG(sp,jpeg_destroy(&sp->cinfo.comm)); /* Free JPEG Lib. vars. */ if (sp->jpegtables) {_TIFFfree(sp->jpegtables);sp->jpegtables=0;} if (sp->jpeglosslesspredictors) { _TIFFfree(sp->jpeglosslesspredictors); sp->jpeglosslesspredictors = 0; } if (sp->jpegpointtransform) { _TIFFfree(sp->jpegpointtransform); sp->jpegpointtransform=0; } if (sp->jpegqtables) {_TIFFfree(sp->jpegqtables);sp->jpegqtables=0;} if (sp->jpegactables) {_TIFFfree(sp->jpegactables);sp->jpegactables=0;} if (sp->jpegdctables) {_TIFFfree(sp->jpegdctables);sp->jpegdctables=0;} /* If the image file isn't "memory mapped" and we read it all into a single, large memory buffer, free the buffer now. */ if (!isMapped(tif) && tif->tif_base) /* free whole-file buffer */ { _TIFFfree(tif->tif_base); tif->tif_base = 0; tif->tif_size = 0; }; _TIFFfree(sp); /* Release local variables */ tif->tif_data = 0; } } int TIFFInitOJPEG(register TIFF *tif,int scheme) { register OJPEGState *sp; # define td (&tif->tif_dir) # ifndef never /* This module supports a decompression-only CODEC, which is intended strictly for viewing old image files using the obsolete JPEG-in-TIFF encapsulation specified by the TIFF Version 6.0 specification. It does not, and never should, support compression for new images. If a client application asks us to, refuse and complain loudly! */ if (tif->tif_mode != O_RDONLY) return _notSupported(tif); # endif /* never */ if (!isMapped(tif)) { /* BEWARE OF KLUDGE: If our host operating-system doesn't let an image file be "memory mapped", then we want to read the entire file into a single (possibly large) memory buffer as if it had been "memory mapped". Although this is likely to waste space, because analysis of the file's content might cause parts of it to be read into smaller buffers duplicatively, it appears to be the lesser of several evils. Very old JPEG-in-TIFF encapsulations aren't guaranteed to be JFIF bit streams, or to have a TIFF "JPEGTables" record or much other "metadata" to help us locate the decoding tables and entropy-coded data, so we're likely do a lot of random-access grokking around, and we must ultimately tell the JPEG Library to sequentially scan much of the file anyway. This is all likely to be easier if we use "brute force" to read the entire file, once, and don't use incremental disc I/O. If our client application tries to process a file so big that we can't buffer it entirely, then tough shit: we'll give up and exit! */ if (!(tif->tif_base = _TIFFmalloc(tif->tif_size=TIFFGetFileSize(tif)))) { TIFFError(tif->tif_name,"Cannot allocate file buffer"); return 0; }; if (!SeekOK(tif,0) || !ReadOK(tif,tif->tif_base,tif->tif_size)) { TIFFError(tif->tif_name,"Cannot read file"); return 0; } }; /* Allocate storage for this module's per-file variables. */ if (!(tif->tif_data = (tidata_t)_TIFFmalloc(sizeof *sp))) { TIFFError("TIFFInitOJPEG","No space for JPEG state block"); return 0; }; (sp = OJState(tif))->tif = tif; /* Initialize reverse pointer */ sp->cinfo.d.err = jpeg_std_error(&sp->err); /* Initialize error handling */ sp->err.error_exit = TIFFojpeg_error_exit; sp->err.output_message = TIFFojpeg_output_message; if (!CALLVJPEG(sp,jpeg_create_decompress(&sp->cinfo.d))) return 0; /* Install CODEC-specific tag information and override default TIFF Library "method" subroutines with our own, CODEC-specific methods. Like all good members of an object-class, we save some of these subroutine pointers for "fall back" in case our own methods fail. */ _TIFFMergeFieldInfo(tif,ojpegFieldInfo, sizeof ojpegFieldInfo/sizeof *ojpegFieldInfo); sp->defsparent = tif->tif_defstripsize; sp->deftparent = tif->tif_deftilesize; sp->vgetparent = tif->tif_tagmethods.vgetfield; sp->vsetparent = tif->tif_tagmethods.vsetfield; tif->tif_defstripsize = OJPEGDefaultStripSize; tif->tif_deftilesize = OJPEGDefaultTileSize; tif->tif_tagmethods.vgetfield = OJPEGVGetField; tif->tif_tagmethods.vsetfield = OJPEGVSetField; tif->tif_tagmethods.printdir = OJPEGPrintDir; # ifdef never tif->tif_setupencode = OJPEGSetupEncode; tif->tif_preencode = OJPEGPreEncode; tif->tif_postencode = OJPEGPostEncode; # else /* well, hardly ever */ tif->tif_setupencode = tif->tif_postencode = _notSupported; tif->tif_preencode = (TIFFPreMethod)_notSupported; # endif /* never */ tif->tif_setupdecode = OJPEGSetupDecode; tif->tif_predecode = OJPEGPreDecode; tif->tif_postdecode = OJPEGPostDecode; tif->tif_cleanup = OJPEGCleanUp; /* If the image file doesn't have "JPEGInterchangeFormat[Length]" TIFF records to guide us, we have few clues about where its encapsulated JPEG bit stream is located, so establish intelligent defaults: If the Image File Directory doesn't immediately follow the TIFF header, assume that the JPEG data lies in between; otherwise, assume that it follows the Image File Directory. */ if (tif->tif_header.tiff_diroff > sizeof tif->tif_header) { sp->src.next_input_byte = tif->tif_base + sizeof tif->tif_header; sp->src.bytes_in_buffer = tif->tif_header.tiff_diroff - sizeof tif->tif_header; } else /* this case is ugly! */ { uint32 maxoffset = tif->tif_size; uint16 dircount; /* Calculate the offset to the next Image File Directory, if there is one, or to the end of the file, if not. Then arrange to read the file from the end of the Image File Directory to that offset. */ if (tif->tif_nextdiroff) maxoffset = tif->tif_nextdiroff; /* Not EOF */ _TIFFmemcpy(&dircount,(const tdata_t) (sp->src.next_input_byte = tif->tif_base+tif->tif_header.tiff_diroff), sizeof dircount); if (tif->tif_flags & TIFF_SWAB) TIFFSwabShort(&dircount); sp->src.next_input_byte += dircount*sizeof(TIFFDirEntry) + sizeof maxoffset + sizeof dircount; sp->src.bytes_in_buffer = tif->tif_base - sp->src.next_input_byte + maxoffset; }; /* IJG JPEG Library Version 6B can be configured for either 8- or 12-bit sample precision, but we assume that "old JPEG" TIFF clients only need 8 bits. */ sp->cinfo.d.data_precision = 8; # ifdef C_LOSSLESS_SUPPORTED /* If the "JPEGProc" TIFF tag is missing from the Image File Dictionary, the JPEG Library will use its (lossy) baseline sequential process by default. */ sp->cinfo.d.data_unit = DCTSIZE; # endif /* C_LOSSLESS_SUPPORTED */ /* Initialize other CODEC-specific variables requiring default values. */ tif->tif_flags |= TIFF_NOBITREV; /* No bit-reversal within data bytes */ sp->h_sampling = sp->v_sampling = 1; /* No subsampling by default */ sp->is_WANG = 0; /* Assume not a MS Windows Wang Imaging file by default */ sp->jpegtables = 0; /* No "new"-style JPEG tables synthesized yet */ sp->jpegtables_length = 0; sp->jpegquality = 75; /* Default IJG quality */ sp->jpegcolormode = JPEGCOLORMODE_RAW; sp->jpegtablesmode = 0; /* No tables found yet */ sp->jpeglosslesspredictors=0; sp->jpeglosslesspredictors_length=0; sp->jpegpointtransform=0; sp->jpegpointtransform_length=0; sp->jpegqtables=0; sp->jpegqtables_length=0; sp->jpegdctables=0; sp->jpegdctables_length=0; sp->jpegactables=0; sp->jpegactables_length=0; return 1; # undef td } #endif /* OJPEG_SUPPORT */