text: /* $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: */
  