--- /dev/null
+/* $Id: tif_ojpeg.c,v 1.1 2005-06-17 13:54:52 vp153 Exp $ */
+
+#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. <ken@oceana.com> 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 <marovich@hpl.hp.com> with considerable help
+ from Charles Auer <Bumble731@msn.com> 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 <marovich@hpl.hp.com>, 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 <marovich@hpl.hp.com>, 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 <setjmp.h>
+#include <stdio.h>
+#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 */
+ unsigned 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_VARIABLE2,TIFF_VARIABLE2,
+ 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];
+ int code = cinfo->err->msg_code;
+
+ if (((OJPEGState *)cinfo)->is_WANG) {
+ if (code == JERR_SOF_DUPLICATE || code == JERR_SOI_DUPLICATE)
+ return; /* ignore it */
+ }
+
+ (*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 <Bumble731@msn.com>, 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;i2<sp->jpeglosslesspredictors_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;i2<sp->jpegpointtransform_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;i2<sp->jpegqtables_length;i2++){
+ TIFFSeekFile(tif, v[i2], SEEK_SET);
+ TIFFReadFile(tif, &(((unsigned 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;i2<sp->jpegdctables_length;i2++){
+ TIFFSeekFile(tif, v[i2], SEEK_SET);
+ TIFFReadFile(tif,
+ &(((unsigned char*)(sp->jpegdctables))[bufoff]),
+ 16);
+ code_count=0;
+ for(k2=0;k2<16;k2++){
+ code_count+=((unsigned char*)(sp->jpegdctables))[k2+bufoff];
+ }
+ TIFFReadFile(tif,
+ &(((unsigned 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;i2<sp->jpegactables_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 = isTiled(tif) ? TIFFTileSize(tif) : (tsize_t) -1;
+ 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: <present>, %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 */
+
+/* vim: set ts=8 sts=8 sw=8 noet: */
projects / opencv / blobdiff