thirdparty/libtiff/tif_jpeg.c

   1 /* $Id: tif_jpeg.c,v 1.105 2012-02-01 01:51:00 fwarmerdam Exp $ */
   2
   3 /*
   4  * Copyright (c) 1994-1997 Sam Leffler
   5  * Copyright (c) 1994-1997 Silicon Graphics, Inc.
   6  *
   7  * Permission to use, copy, modify, distribute, and sell this software and
   8  * its documentation for any purpose is hereby granted without fee, provided
   9  * that (i) the above copyright notices and this permission notice appear in
  10  * all copies of the software and related documentation, and (ii) the names of
  11  * Sam Leffler and Silicon Graphics may not be used in any advertising or
  12  * publicity relating to the software without the specific, prior written
  13  * permission of Sam Leffler and Silicon Graphics.
  14  *
  15  * THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND,
  16  * EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY
  17  * WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
  18  *
  19  * IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR
  20  * ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND,
  21  * OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
  22  * WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF
  23  * LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
  24  * OF THIS SOFTWARE.
  25  */
  26
  27 #define WIN32_LEAN_AND_MEAN
  28 #define VC_EXTRALEAN
  29
  30 #include "tiffiop.h"
  31 #ifdef JPEG_SUPPORT
  32
  33 /*
  34  * TIFF Library
  35  *
  36  * JPEG Compression support per TIFF Technical Note #2
  37  * (*not* per the original TIFF 6.0 spec).
  38  *
  39  * This file is simply an interface to the libjpeg library written by
  40  * the Independent JPEG Group.  You need release 5 or later of the IJG
  41  * code, which you can find on the Internet at ftp.uu.net:/graphics/jpeg/.
  42  *
  43  * Contributed by Tom Lane <tgl@sss.pgh.pa.us>.
  44  */
  45 #include <setjmp.h>
  46
  47 int TIFFFillStrip(TIFF* tif, uint32 strip);
  48 int TIFFFillTile(TIFF* tif, uint32 tile);
  49 int TIFFReInitJPEG_12( TIFF *tif, int scheme, int is_encode );
  50
  51 /* We undefine FAR to avoid conflict with JPEG definition */
  52
  53 #ifdef FAR
  54 #undef FAR
  55 #endif
  56
  57 /*
  58   Libjpeg's jmorecfg.h defines INT16 and INT32, but only if XMD_H is
  59   not defined.  Unfortunately, the MinGW and Borland compilers include
  60   a typedef for INT32, which causes a conflict.  MSVC does not include
  61   a conficting typedef given the headers which are included.
  62 */
  63 #if defined(__BORLANDC__) || defined(__MINGW32__)
  64 # define XMD_H 1
  65 #endif
  66
  67 /*
  68    The windows RPCNDR.H file defines boolean, but defines it with the
  69    unsigned char size.  You should compile JPEG library using appropriate
  70    definitions in jconfig.h header, but many users compile library in wrong
  71    way. That causes errors of the following type:
  72
  73    "JPEGLib: JPEG parameter struct mismatch: library thinks size is 432,
  74    caller expects 464"
  75
  76    For such users we wil fix the problem here. See install.doc file from
  77    the JPEG library distribution for details.
  78 */
  79
  80 /* Define "boolean" as unsigned char, not int, per Windows custom. */
  81 #if defined(__WIN32__) && !defined(__MINGW32__)
  82 # ifndef __RPCNDR_H__            /* don't conflict if rpcndr.h already read */
  83    typedef unsigned char boolean;
  84 # endif
  85 # define HAVE_BOOLEAN            /* prevent jmorecfg.h from redefining it */
  86 #endif
  87
  88 #include "jpeglib.h"
  89 #include "jerror.h"
  90
  91 /*
  92  * Do we want to do special processing suitable for when JSAMPLE is a
  93  * 16bit value?
  94  */
  95
  96 #if defined(JPEG_LIB_MK1)
  97 #  define JPEG_LIB_MK1_OR_12BIT 1
  98 #elif BITS_IN_JSAMPLE == 12
  99 #  define JPEG_LIB_MK1_OR_12BIT 1
 100 #endif
 101
 102 /*
 103  * We are using width_in_blocks which is supposed to be private to
 104  * libjpeg. Unfortunately, the libjpeg delivered with Cygwin has
 105  * renamed this member to width_in_data_units.  Since the header has
 106  * also renamed a define, use that unique define name in order to
 107  * detect the problem header and adjust to suit.
 108  */
 109 #if defined(D_MAX_DATA_UNITS_IN_MCU)
 110 #define width_in_blocks width_in_data_units
 111 #endif
 112
 113 /*
 114  * On some machines it may be worthwhile to use _setjmp or sigsetjmp
 115  * in place of plain setjmp.  These macros will make it easier.
 116  */
 117 #define SETJMP(jbuf)            setjmp(jbuf)
 118 #define LONGJMP(jbuf,code)      longjmp(jbuf,code)
 119 #define JMP_BUF                 jmp_buf
 120
 121 typedef struct jpeg_destination_mgr jpeg_destination_mgr;
 122 typedef struct jpeg_source_mgr jpeg_source_mgr;
 123 typedef struct jpeg_error_mgr jpeg_error_mgr;
 124
 125 /*
 126  * State block for each open TIFF file using
 127  * libjpeg to do JPEG compression/decompression.
 128  *
 129  * libjpeg's visible state is either a jpeg_compress_struct
 130  * or jpeg_decompress_struct depending on which way we
 131  * are going.  comm can be used to refer to the fields
 132  * which are common to both.
 133  *
 134  * NB: cinfo is required to be the first member of JPEGState,
 135  *     so we can safely cast JPEGState* -> jpeg_xxx_struct*
 136  *     and vice versa!
 137  */
 138 typedef struct {
 139         union {
 140                 struct jpeg_compress_struct c;
 141                 struct jpeg_decompress_struct d;
 142                 struct jpeg_common_struct comm;
 143         } cinfo;                        /* NB: must be first */
 144         int             cinfo_initialized;
 145
 146         jpeg_error_mgr  err;            /* libjpeg error manager */
 147         JMP_BUF         exit_jmpbuf;    /* for catching libjpeg failures */
 148         /*
 149          * The following two members could be a union, but
 150          * they're small enough that it's not worth the effort.
 151          */
 152         jpeg_destination_mgr dest;      /* data dest for compression */
 153         jpeg_source_mgr src;            /* data source for decompression */
 154                                         /* private state */
 155         TIFF*           tif;            /* back link needed by some code */
 156         uint16          photometric;    /* copy of PhotometricInterpretation */
 157         uint16          h_sampling;     /* luminance sampling factors */
 158         uint16          v_sampling;
 159         tmsize_t        bytesperline;   /* decompressed bytes per scanline */
 160         /* pointers to intermediate buffers when processing downsampled data */
 161         JSAMPARRAY      ds_buffer[MAX_COMPONENTS];
 162         int             scancount;      /* number of "scanlines" accumulated */
 163         int             samplesperclump;
 164
 165         TIFFVGetMethod  vgetparent;     /* super-class method */
 166         TIFFVSetMethod  vsetparent;     /* super-class method */
 167         TIFFPrintMethod printdir;       /* super-class method */
 168         TIFFStripMethod defsparent;     /* super-class method */
 169         TIFFTileMethod  deftparent;     /* super-class method */
 170                                         /* pseudo-tag fields */
 171         void*           jpegtables;     /* JPEGTables tag value, or NULL */
 172         uint32          jpegtables_length; /* number of bytes in same */
 173         int             jpegquality;    /* Compression quality level */
 174         int             jpegcolormode;  /* Auto RGB<=>YCbCr convert? */
 175         int             jpegtablesmode; /* What to put in JPEGTables */
 176
 177         int             ycbcrsampling_fetched;
 178 } JPEGState;
 179
 180 #define JState(tif)     ((JPEGState*)(tif)->tif_data)
 181
 182 static int JPEGDecode(TIFF* tif, uint8* buf, tmsize_t cc, uint16 s);
 183 static int JPEGDecodeRaw(TIFF* tif, uint8* buf, tmsize_t cc, uint16 s);
 184 static int JPEGEncode(TIFF* tif, uint8* buf, tmsize_t cc, uint16 s);
 185 static int JPEGEncodeRaw(TIFF* tif, uint8* buf, tmsize_t cc, uint16 s);
 186 static int JPEGInitializeLibJPEG(TIFF * tif, int decode );
 187 static int DecodeRowError(TIFF* tif, uint8* buf, tmsize_t cc, uint16 s);
 188
 189 #define FIELD_JPEGTABLES        (FIELD_CODEC+0)
 190
 191 static const TIFFField jpegFields[] = {
 192     { TIFFTAG_JPEGTABLES, -3, -3, TIFF_UNDEFINED, 0, TIFF_SETGET_C32_UINT8, TIFF_SETGET_C32_UINT8, FIELD_JPEGTABLES, FALSE, TRUE, "JPEGTables", NULL },
 193     { TIFFTAG_JPEGQUALITY, 0, 0, TIFF_ANY, 0, TIFF_SETGET_INT, TIFF_SETGET_UNDEFINED, FIELD_PSEUDO, TRUE, FALSE, "", NULL },
 194     { TIFFTAG_JPEGCOLORMODE, 0, 0, TIFF_ANY, 0, TIFF_SETGET_INT, TIFF_SETGET_UNDEFINED, FIELD_PSEUDO, FALSE, FALSE, "", NULL },
 195     { TIFFTAG_JPEGTABLESMODE, 0, 0, TIFF_ANY, 0, TIFF_SETGET_INT, TIFF_SETGET_UNDEFINED, FIELD_PSEUDO, FALSE, FALSE, "", NULL }
 196 };
 197
 198 /*
 199  * libjpeg interface layer.
 200  *
 201  * We use setjmp/longjmp to return control to libtiff
 202  * when a fatal error is encountered within the JPEG
 203  * library.  We also direct libjpeg error and warning
 204  * messages through the appropriate libtiff handlers.
 205  */
 206
 207 /*
 208  * Error handling routines (these replace corresponding
 209  * IJG routines from jerror.c).  These are used for both
 210  * compression and decompression.
 211  */
 212 static void
 213 TIFFjpeg_error_exit(j_common_ptr cinfo)
 214 {
 215         JPEGState *sp = (JPEGState *) cinfo;    /* NB: cinfo assumed first */
 216         char buffer[JMSG_LENGTH_MAX];
 217
 218         (*cinfo->err->format_message) (cinfo, buffer);
 219         TIFFErrorExt(sp->tif->tif_clientdata, "JPEGLib", "%s", buffer);         /* display the error message */
 220         jpeg_abort(cinfo);                      /* clean up libjpeg state */
 221         LONGJMP(sp->exit_jmpbuf, 1);            /* return to libtiff caller */
 222 }
 223
 224 /*
 225  * This routine is invoked only for warning messages,
 226  * since error_exit does its own thing and trace_level
 227  * is never set > 0.
 228  */
 229 static void
 230 TIFFjpeg_output_message(j_common_ptr cinfo)
 231 {
 232         char buffer[JMSG_LENGTH_MAX];
 233
 234         (*cinfo->err->format_message) (cinfo, buffer);
 235         TIFFWarningExt(((JPEGState *) cinfo)->tif->tif_clientdata, "JPEGLib", "%s", buffer);
 236 }
 237
 238 /*
 239  * Interface routines.  This layer of routines exists
 240  * primarily to limit side-effects from using setjmp.
 241  * Also, normal/error returns are converted into return
 242  * values per libtiff practice.
 243  */
 244 #define CALLJPEG(sp, fail, op)  (SETJMP((sp)->exit_jmpbuf) ? (fail) : (op))
 245 #define CALLVJPEG(sp, op)       CALLJPEG(sp, 0, ((op),1))
 246
 247 static int
 248 TIFFjpeg_create_compress(JPEGState* sp)
 249 {
 250         /* initialize JPEG error handling */
 251         sp->cinfo.c.err = jpeg_std_error(&sp->err);
 252         sp->err.error_exit = TIFFjpeg_error_exit;
 253         sp->err.output_message = TIFFjpeg_output_message;
 254
 255         return CALLVJPEG(sp, jpeg_create_compress(&sp->cinfo.c));
 256 }
 257
 258 static int
 259 TIFFjpeg_create_decompress(JPEGState* sp)
 260 {
 261         /* initialize JPEG error handling */
 262         sp->cinfo.d.err = jpeg_std_error(&sp->err);
 263         sp->err.error_exit = TIFFjpeg_error_exit;
 264         sp->err.output_message = TIFFjpeg_output_message;
 265
 266         return CALLVJPEG(sp, jpeg_create_decompress(&sp->cinfo.d));
 267 }
 268
 269 static int
 270 TIFFjpeg_set_defaults(JPEGState* sp)
 271 {
 272         return CALLVJPEG(sp, jpeg_set_defaults(&sp->cinfo.c));
 273 }
 274
 275 static int
 276 TIFFjpeg_set_colorspace(JPEGState* sp, J_COLOR_SPACE colorspace)
 277 {
 278         return CALLVJPEG(sp, jpeg_set_colorspace(&sp->cinfo.c, colorspace));
 279 }
 280
 281 static int
 282 TIFFjpeg_set_quality(JPEGState* sp, int quality, boolean force_baseline)
 283 {
 284         return CALLVJPEG(sp,
 285             jpeg_set_quality(&sp->cinfo.c, quality, force_baseline));
 286 }
 287
 288 static int
 289 TIFFjpeg_suppress_tables(JPEGState* sp, boolean suppress)
 290 {
 291         return CALLVJPEG(sp, jpeg_suppress_tables(&sp->cinfo.c, suppress));
 292 }
 293
 294 static int
 295 TIFFjpeg_start_compress(JPEGState* sp, boolean write_all_tables)
 296 {
 297         return CALLVJPEG(sp,
 298             jpeg_start_compress(&sp->cinfo.c, write_all_tables));
 299 }
 300
 301 static int
 302 TIFFjpeg_write_scanlines(JPEGState* sp, JSAMPARRAY scanlines, int num_lines)
 303 {
 304         return CALLJPEG(sp, -1, (int) jpeg_write_scanlines(&sp->cinfo.c,
 305             scanlines, (JDIMENSION) num_lines));
 306 }
 307
 308 static int
 309 TIFFjpeg_write_raw_data(JPEGState* sp, JSAMPIMAGE data, int num_lines)
 310 {
 311         return CALLJPEG(sp, -1, (int) jpeg_write_raw_data(&sp->cinfo.c,
 312             data, (JDIMENSION) num_lines));
 313 }
 314
 315 static int
 316 TIFFjpeg_finish_compress(JPEGState* sp)
 317 {
 318         return CALLVJPEG(sp, jpeg_finish_compress(&sp->cinfo.c));
 319 }
 320
 321 static int
 322 TIFFjpeg_write_tables(JPEGState* sp)
 323 {
 324         return CALLVJPEG(sp, jpeg_write_tables(&sp->cinfo.c));
 325 }
 326
 327 static int
 328 TIFFjpeg_read_header(JPEGState* sp, boolean require_image)
 329 {
 330         return CALLJPEG(sp, -1, jpeg_read_header(&sp->cinfo.d, require_image));
 331 }
 332
 333 static int
 334 TIFFjpeg_start_decompress(JPEGState* sp)
 335 {
 336         return CALLVJPEG(sp, jpeg_start_decompress(&sp->cinfo.d));
 337 }
 338
 339 static int
 340 TIFFjpeg_read_scanlines(JPEGState* sp, JSAMPARRAY scanlines, int max_lines)
 341 {
 342         return CALLJPEG(sp, -1, (int) jpeg_read_scanlines(&sp->cinfo.d,
 343             scanlines, (JDIMENSION) max_lines));
 344 }
 345
 346 static int
 347 TIFFjpeg_read_raw_data(JPEGState* sp, JSAMPIMAGE data, int max_lines)
 348 {
 349         return CALLJPEG(sp, -1, (int) jpeg_read_raw_data(&sp->cinfo.d,
 350             data, (JDIMENSION) max_lines));
 351 }
 352
 353 static int
 354 TIFFjpeg_finish_decompress(JPEGState* sp)
 355 {
 356         return CALLJPEG(sp, -1, (int) jpeg_finish_decompress(&sp->cinfo.d));
 357 }
 358
 359 static int
 360 TIFFjpeg_abort(JPEGState* sp)
 361 {
 362         return CALLVJPEG(sp, jpeg_abort(&sp->cinfo.comm));
 363 }
 364
 365 static int
 366 TIFFjpeg_destroy(JPEGState* sp)
 367 {
 368         return CALLVJPEG(sp, jpeg_destroy(&sp->cinfo.comm));
 369 }
 370
 371 static JSAMPARRAY
 372 TIFFjpeg_alloc_sarray(JPEGState* sp, int pool_id,
 373                       JDIMENSION samplesperrow, JDIMENSION numrows)
 374 {
 375         return CALLJPEG(sp, (JSAMPARRAY) NULL,
 376             (*sp->cinfo.comm.mem->alloc_sarray)
 377                 (&sp->cinfo.comm, pool_id, samplesperrow, numrows));
 378 }
 379
 380 /*
 381  * JPEG library destination data manager.
 382  * These routines direct compressed data from libjpeg into the
 383  * libtiff output buffer.
 384  */
 385
 386 static void
 387 std_init_destination(j_compress_ptr cinfo)
 388 {
 389         JPEGState* sp = (JPEGState*) cinfo;
 390         TIFF* tif = sp->tif;
 391
 392         sp->dest.next_output_byte = (JOCTET*) tif->tif_rawdata;
 393         sp->dest.free_in_buffer = (size_t) tif->tif_rawdatasize;
 394 }
 395
 396 static boolean
 397 std_empty_output_buffer(j_compress_ptr cinfo)
 398 {
 399         JPEGState* sp = (JPEGState*) cinfo;
 400         TIFF* tif = sp->tif;
 401
 402         /* the entire buffer has been filled */
 403         tif->tif_rawcc = tif->tif_rawdatasize;
 404
 405 #ifdef IPPJ_HUFF
 406        /*
 407         * The Intel IPP performance library does not necessarily fill up
 408         * the whole output buffer on each pass, so only dump out the parts
 409         * that have been filled.
 410         *   http://trac.osgeo.org/gdal/wiki/JpegIPP
 411         */
 412        if ( sp->dest.free_in_buffer >= 0 ) {
 413                tif->tif_rawcc = tif->tif_rawdatasize - sp->dest.free_in_buffer;
 414        }
 415 #endif
 416
 417         TIFFFlushData1(tif);
 418         sp->dest.next_output_byte = (JOCTET*) tif->tif_rawdata;
 419         sp->dest.free_in_buffer = (size_t) tif->tif_rawdatasize;
 420
 421         return (TRUE);
 422 }
 423
 424 static void
 425 std_term_destination(j_compress_ptr cinfo)
 426 {
 427         JPEGState* sp = (JPEGState*) cinfo;
 428         TIFF* tif = sp->tif;
 429
 430         tif->tif_rawcp = (uint8*) sp->dest.next_output_byte;
 431         tif->tif_rawcc =
 432             tif->tif_rawdatasize - (tmsize_t) sp->dest.free_in_buffer;
 433         /* NB: libtiff does the final buffer flush */
 434 }
 435
 436 static void
 437 TIFFjpeg_data_dest(JPEGState* sp, TIFF* tif)
 438 {
 439         (void) tif;
 440         sp->cinfo.c.dest = &sp->dest;
 441         sp->dest.init_destination = std_init_destination;
 442         sp->dest.empty_output_buffer = std_empty_output_buffer;
 443         sp->dest.term_destination = std_term_destination;
 444 }
 445
 446 /*
 447  * Alternate destination manager for outputting to JPEGTables field.
 448  */
 449
 450 static void
 451 tables_init_destination(j_compress_ptr cinfo)
 452 {
 453         JPEGState* sp = (JPEGState*) cinfo;
 454
 455         /* while building, jpegtables_length is allocated buffer size */
 456         sp->dest.next_output_byte = (JOCTET*) sp->jpegtables;
 457         sp->dest.free_in_buffer = (size_t) sp->jpegtables_length;
 458 }
 459
 460 static boolean
 461 tables_empty_output_buffer(j_compress_ptr cinfo)
 462 {
 463         JPEGState* sp = (JPEGState*) cinfo;
 464         void* newbuf;
 465
 466         /* the entire buffer has been filled; enlarge it by 1000 bytes */
 467         newbuf = _TIFFrealloc((void*) sp->jpegtables,
 468                               (tmsize_t) (sp->jpegtables_length + 1000));
 469         if (newbuf == NULL)
 470                 ERREXIT1(cinfo, JERR_OUT_OF_MEMORY, 100);
 471         sp->dest.next_output_byte = (JOCTET*) newbuf + sp->jpegtables_length;
 472         sp->dest.free_in_buffer = (size_t) 1000;
 473         sp->jpegtables = newbuf;
 474         sp->jpegtables_length += 1000;
 475         return (TRUE);
 476 }
 477
 478 static void
 479 tables_term_destination(j_compress_ptr cinfo)
 480 {
 481         JPEGState* sp = (JPEGState*) cinfo;
 482
 483         /* set tables length to number of bytes actually emitted */
 484         sp->jpegtables_length -= (uint32) sp->dest.free_in_buffer;
 485 }
 486
 487 static int
 488 TIFFjpeg_tables_dest(JPEGState* sp, TIFF* tif)
 489 {
 490         (void) tif;
 491         /*
 492          * Allocate a working buffer for building tables.
 493          * Initial size is 1000 bytes, which is usually adequate.
 494          */
 495         if (sp->jpegtables)
 496                 _TIFFfree(sp->jpegtables);
 497         sp->jpegtables_length = 1000;
 498         sp->jpegtables = (void*) _TIFFmalloc((tmsize_t) sp->jpegtables_length);
 499         if (sp->jpegtables == NULL) {
 500                 sp->jpegtables_length = 0;
 501                 TIFFErrorExt(sp->tif->tif_clientdata, "TIFFjpeg_tables_dest", "No space for JPEGTables");
 502                 return (0);
 503         }
 504         sp->cinfo.c.dest = &sp->dest;
 505         sp->dest.init_destination = tables_init_destination;
 506         sp->dest.empty_output_buffer = tables_empty_output_buffer;
 507         sp->dest.term_destination = tables_term_destination;
 508         return (1);
 509 }
 510
 511 /*
 512  * JPEG library source data manager.
 513  * These routines supply compressed data to libjpeg.
 514  */
 515
 516 static void
 517 std_init_source(j_decompress_ptr cinfo)
 518 {
 519         JPEGState* sp = (JPEGState*) cinfo;
 520         TIFF* tif = sp->tif;
 521
 522         sp->src.next_input_byte = (const JOCTET*) tif->tif_rawdata;
 523         sp->src.bytes_in_buffer = (size_t) tif->tif_rawcc;
 524 }
 525
 526 static boolean
 527 std_fill_input_buffer(j_decompress_ptr cinfo)
 528 {
 529         JPEGState* sp = (JPEGState* ) cinfo;
 530         static const JOCTET dummy_EOI[2] = { 0xFF, JPEG_EOI };
 531
 532 #ifdef IPPJ_HUFF
 533         /*
 534          * The Intel IPP performance library does not necessarily read the whole
 535          * input buffer in one pass, so it is possible to get here with data
 536          * yet to read.
 537          *
 538          * We just return without doing anything, until the entire buffer has
 539          * been read.
 540          * http://trac.osgeo.org/gdal/wiki/JpegIPP
 541          */
 542         if( sp->src.bytes_in_buffer > 0 ) {
 543             return (TRUE);
 544         }
 545 #endif
 546
 547         /*
 548          * Normally the whole strip/tile is read and so we don't need to do
 549          * a fill.  In the case of CHUNKY_STRIP_READ_SUPPORT we might not have
 550          * all the data, but the rawdata is refreshed between scanlines and
 551          * we push this into the io machinery in JPEGDecode().
 552          * http://trac.osgeo.org/gdal/ticket/3894
 553          */
 554
 555         WARNMS(cinfo, JWRN_JPEG_EOF);
 556         /* insert a fake EOI marker */
 557         sp->src.next_input_byte = dummy_EOI;
 558         sp->src.bytes_in_buffer = 2;
 559         return (TRUE);
 560 }
 561
 562 static void
 563 std_skip_input_data(j_decompress_ptr cinfo, long num_bytes)
 564 {
 565         JPEGState* sp = (JPEGState*) cinfo;
 566
 567         if (num_bytes > 0) {
 568                 if ((size_t)num_bytes > sp->src.bytes_in_buffer) {
 569                         /* oops, buffer overrun */
 570                         (void) std_fill_input_buffer(cinfo);
 571                 } else {
 572                         sp->src.next_input_byte += (size_t) num_bytes;
 573                         sp->src.bytes_in_buffer -= (size_t) num_bytes;
 574                 }
 575         }
 576 }
 577
 578 static void
 579 std_term_source(j_decompress_ptr cinfo)
 580 {
 581         /* No work necessary here */
 582         (void) cinfo;
 583 }
 584
 585 static void
 586 TIFFjpeg_data_src(JPEGState* sp, TIFF* tif)
 587 {
 588         (void) tif;
 589         sp->cinfo.d.src = &sp->src;
 590         sp->src.init_source = std_init_source;
 591         sp->src.fill_input_buffer = std_fill_input_buffer;
 592         sp->src.skip_input_data = std_skip_input_data;
 593         sp->src.resync_to_restart = jpeg_resync_to_restart;
 594         sp->src.term_source = std_term_source;
 595         sp->src.bytes_in_buffer = 0;            /* for safety */
 596         sp->src.next_input_byte = NULL;
 597 }
 598
 599 /*
 600  * Alternate source manager for reading from JPEGTables.
 601  * We can share all the code except for the init routine.
 602  */
 603
 604 static void
 605 tables_init_source(j_decompress_ptr cinfo)
 606 {
 607         JPEGState* sp = (JPEGState*) cinfo;
 608
 609         sp->src.next_input_byte = (const JOCTET*) sp->jpegtables;
 610         sp->src.bytes_in_buffer = (size_t) sp->jpegtables_length;
 611 }
 612
 613 static void
 614 TIFFjpeg_tables_src(JPEGState* sp, TIFF* tif)
 615 {
 616         TIFFjpeg_data_src(sp, tif);
 617         sp->src.init_source = tables_init_source;
 618 }
 619
 620 /*
 621  * Allocate downsampled-data buffers needed for downsampled I/O.
 622  * We use values computed in jpeg_start_compress or jpeg_start_decompress.
 623  * We use libjpeg's allocator so that buffers will be released automatically
 624  * when done with strip/tile.
 625  * This is also a handy place to compute samplesperclump, bytesperline.
 626  */
 627 static int
 628 alloc_downsampled_buffers(TIFF* tif, jpeg_component_info* comp_info,
 629                           int num_components)
 630 {
 631         JPEGState* sp = JState(tif);
 632         int ci;
 633         jpeg_component_info* compptr;
 634         JSAMPARRAY buf;
 635         int samples_per_clump = 0;
 636
 637         for (ci = 0, compptr = comp_info; ci < num_components;
 638              ci++, compptr++) {
 639                 samples_per_clump += compptr->h_samp_factor *
 640                         compptr->v_samp_factor;
 641                 buf = TIFFjpeg_alloc_sarray(sp, JPOOL_IMAGE,
 642                                 compptr->width_in_blocks * DCTSIZE,
 643                                 (JDIMENSION) (compptr->v_samp_factor*DCTSIZE));
 644                 if (buf == NULL)
 645                         return (0);
 646                 sp->ds_buffer[ci] = buf;
 647         }
 648         sp->samplesperclump = samples_per_clump;
 649         return (1);
 650 }
 651
 652
 653 /*
 654  * JPEG Decoding.
 655  */
 656
 657 #ifdef CHECK_JPEG_YCBCR_SUBSAMPLING
 658
 659 #define JPEG_MARKER_SOF0 0xC0
 660 #define JPEG_MARKER_SOF1 0xC1
 661 #define JPEG_MARKER_SOF3 0xC3
 662 #define JPEG_MARKER_DHT 0xC4
 663 #define JPEG_MARKER_SOI 0xD8
 664 #define JPEG_MARKER_SOS 0xDA
 665 #define JPEG_MARKER_DQT 0xDB
 666 #define JPEG_MARKER_DRI 0xDD
 667 #define JPEG_MARKER_APP0 0xE0
 668 #define JPEG_MARKER_COM 0xFE
 669 struct JPEGFixupTagsSubsamplingData
 670 {
 671         TIFF* tif;
 672         void* buffer;
 673         uint32 buffersize;
 674         uint8* buffercurrentbyte;
 675         uint32 bufferbytesleft;
 676         uint64 fileoffset;
 677         uint64 filebytesleft;
 678         uint8 filepositioned;
 679 };
 680 static void JPEGFixupTagsSubsampling(TIFF* tif);
 681 static int JPEGFixupTagsSubsamplingSec(struct JPEGFixupTagsSubsamplingData* data);
 682 static int JPEGFixupTagsSubsamplingReadByte(struct JPEGFixupTagsSubsamplingData* data, uint8* result);
 683 static int JPEGFixupTagsSubsamplingReadWord(struct JPEGFixupTagsSubsamplingData* data, uint16* result);
 684 static void JPEGFixupTagsSubsamplingSkip(struct JPEGFixupTagsSubsamplingData* data, uint16 skiplength);
 685
 686 #endif
 687
 688 static int
 689 JPEGFixupTags(TIFF* tif)
 690 {
 691 #ifdef CHECK_JPEG_YCBCR_SUBSAMPLING
 692         if ((tif->tif_dir.td_photometric==PHOTOMETRIC_YCBCR)&&
 693             (tif->tif_dir.td_planarconfig==PLANARCONFIG_CONTIG)&&
 694             (tif->tif_dir.td_samplesperpixel==3))
 695                 JPEGFixupTagsSubsampling(tif);
 696 #endif
 697
 698         return(1);
 699 }
 700
 701 #ifdef CHECK_JPEG_YCBCR_SUBSAMPLING
 702
 703 static void
 704 JPEGFixupTagsSubsampling(TIFF* tif)
 705 {
 706         /*
 707          * Some JPEG-in-TIFF produces do not emit the YCBCRSUBSAMPLING values in
 708          * the TIFF tags, but still use non-default (2,2) values within the jpeg
 709          * data stream itself.  In order for TIFF applications to work properly
 710          * - for instance to get the strip buffer size right - it is imperative
 711          * that the subsampling be available before we start reading the image
 712          * data normally.  This function will attempt to analyze the first strip in
 713          * order to get the sampling values from the jpeg data stream.
 714          *
 715          * Note that JPEGPreDeocode() will produce a fairly loud warning when the
 716          * discovered sampling does not match the default sampling (2,2) or whatever
 717          * was actually in the tiff tags.
 718          *
 719          * See the bug in bugzilla for details:
 720          *
 721          * http://bugzilla.remotesensing.org/show_bug.cgi?id=168
 722          *
 723          * Frank Warmerdam, July 2002
 724          * Joris Van Damme, May 2007
 725          */
 726         static const char module[] = "JPEGFixupTagsSubsampling";
 727         struct JPEGFixupTagsSubsamplingData m;
 728
 729         _TIFFFillStriles( tif );
 730
 731         if( tif->tif_dir.td_stripbytecount == NULL
 732             || tif->tif_dir.td_stripbytecount[0] == 0 )
 733         {
 734             /* Do not even try to check if the first strip/tile does not
 735                yet exist, as occurs when GDAL has created a new NULL file
 736                for instance. */
 737             return;
 738         }
 739
 740         m.tif=tif;
 741         m.buffersize=2048;
 742         m.buffer=_TIFFmalloc(m.buffersize);
 743         if (m.buffer==NULL)
 744         {
 745                 TIFFWarningExt(tif->tif_clientdata,module,
 746                     "Unable to allocate memory for auto-correcting of subsampling values; auto-correcting skipped");
 747                 return;
 748         }
 749         m.buffercurrentbyte=NULL;
 750         m.bufferbytesleft=0;
 751         m.fileoffset=tif->tif_dir.td_stripoffset[0];
 752         m.filepositioned=0;
 753         m.filebytesleft=tif->tif_dir.td_stripbytecount[0];
 754         if (!JPEGFixupTagsSubsamplingSec(&m))
 755                 TIFFWarningExt(tif->tif_clientdata,module,
 756                     "Unable to auto-correct subsampling values, likely corrupt JPEG compressed data in first strip/tile; auto-correcting skipped");
 757         _TIFFfree(m.buffer);
 758 }
 759
 760 static int
 761 JPEGFixupTagsSubsamplingSec(struct JPEGFixupTagsSubsamplingData* data)
 762 {
 763         static const char module[] = "JPEGFixupTagsSubsamplingSec";
 764         uint8 m;
 765         while (1)
 766         {
 767                 while (1)
 768                 {
 769                         if (!JPEGFixupTagsSubsamplingReadByte(data,&m))
 770                                 return(0);
 771                         if (m==255)
 772                                 break;
 773                 }
 774                 while (1)
 775                 {
 776                         if (!JPEGFixupTagsSubsamplingReadByte(data,&m))
 777                                 return(0);
 778                         if (m!=255)
 779                                 break;
 780                 }
 781                 switch (m)
 782                 {
 783                         case JPEG_MARKER_SOI:
 784                                 /* this type of marker has no data and should be skipped */
 785                                 break;
 786                         case JPEG_MARKER_COM:
 787                         case JPEG_MARKER_APP0:
 788                         case JPEG_MARKER_APP0+1:
 789                         case JPEG_MARKER_APP0+2:
 790                         case JPEG_MARKER_APP0+3:
 791                         case JPEG_MARKER_APP0+4:
 792                         case JPEG_MARKER_APP0+5:
 793                         case JPEG_MARKER_APP0+6:
 794                         case JPEG_MARKER_APP0+7:
 795                         case JPEG_MARKER_APP0+8:
 796                         case JPEG_MARKER_APP0+9:
 797                         case JPEG_MARKER_APP0+10:
 798                         case JPEG_MARKER_APP0+11:
 799                         case JPEG_MARKER_APP0+12:
 800                         case JPEG_MARKER_APP0+13:
 801                         case JPEG_MARKER_APP0+14:
 802                         case JPEG_MARKER_APP0+15:
 803                         case JPEG_MARKER_DQT:
 804                         case JPEG_MARKER_SOS:
 805                         case JPEG_MARKER_DHT:
 806                         case JPEG_MARKER_DRI:
 807                                 /* this type of marker has data, but it has no use to us and should be skipped */
 808                                 {
 809                                         uint16 n;
 810                                         if (!JPEGFixupTagsSubsamplingReadWord(data,&n))
 811                                                 return(0);
 812                                         if (n<2)
 813                                                 return(0);
 814                                         n-=2;
 815                                         if (n>0)
 816                                                 JPEGFixupTagsSubsamplingSkip(data,n);
 817                                 }
 818                                 break;
 819                         case JPEG_MARKER_SOF0:
 820                         case JPEG_MARKER_SOF1:
 821                                 /* this marker contains the subsampling factors we're scanning for */
 822                                 {
 823                                         uint16 n;
 824                                         uint16 o;
 825                                         uint8 p;
 826                                         uint8 ph,pv;
 827                                         if (!JPEGFixupTagsSubsamplingReadWord(data,&n))
 828                                                 return(0);
 829                                         if (n!=8+data->tif->tif_dir.td_samplesperpixel*3)
 830                                                 return(0);
 831                                         JPEGFixupTagsSubsamplingSkip(data,7);
 832                                         if (!JPEGFixupTagsSubsamplingReadByte(data,&p))
 833                                                 return(0);
 834                                         ph=(p>>4);
 835                                         pv=(p&15);
 836                                         JPEGFixupTagsSubsamplingSkip(data,1);
 837                                         for (o=1; o<data->tif->tif_dir.td_samplesperpixel; o++)
 838                                         {
 839                                                 JPEGFixupTagsSubsamplingSkip(data,1);
 840                                                 if (!JPEGFixupTagsSubsamplingReadByte(data,&p))
 841                                                         return(0);
 842                                                 if (p!=0x11)
 843                                                 {
 844                                                         TIFFWarningExt(data->tif->tif_clientdata,module,
 845                                                             "Subsampling values inside JPEG compressed data have no TIFF equivalent, auto-correction of TIFF subsampling values failed");
 846                                                         return(1);
 847                                                 }
 848                                                 JPEGFixupTagsSubsamplingSkip(data,1);
 849                                         }
 850                                         if (((ph!=1)&&(ph!=2)&&(ph!=4))||((pv!=1)&&(pv!=2)&&(pv!=4)))
 851                                         {
 852                                                 TIFFWarningExt(data->tif->tif_clientdata,module,
 853                                                     "Subsampling values inside JPEG compressed data have no TIFF equivalent, auto-correction of TIFF subsampling values failed");
 854                                                 return(1);
 855                                         }
 856                                         if ((ph!=data->tif->tif_dir.td_ycbcrsubsampling[0])||(pv!=data->tif->tif_dir.td_ycbcrsubsampling[1]))
 857                                         {
 858                                                 TIFFWarningExt(data->tif->tif_clientdata,module,
 859                                                     "Auto-corrected former TIFF subsampling values [%d,%d] to match subsampling values inside JPEG compressed data [%d,%d]",
 860                                                     (int)data->tif->tif_dir.td_ycbcrsubsampling[0],
 861                                                     (int)data->tif->tif_dir.td_ycbcrsubsampling[1],
 862                                                     (int)ph,(int)pv);
 863                                                 data->tif->tif_dir.td_ycbcrsubsampling[0]=ph;
 864                                                 data->tif->tif_dir.td_ycbcrsubsampling[1]=pv;
 865                                         }
 866                                 }
 867                                 return(1);
 868                         default:
 869                                 return(0);
 870                 }
 871         }
 872 }
 873
 874 static int
 875 JPEGFixupTagsSubsamplingReadByte(struct JPEGFixupTagsSubsamplingData* data, uint8* result)
 876 {
 877         if (data->bufferbytesleft==0)
 878         {
 879                 uint32 m;
 880                 if (data->filebytesleft==0)
 881                         return(0);
 882                 if (!data->filepositioned)
 883                 {
 884                         TIFFSeekFile(data->tif,data->fileoffset,SEEK_SET);
 885                         data->filepositioned=1;
 886                 }
 887                 m=data->buffersize;
 888                 if ((uint64)m>data->filebytesleft)
 889                         m=(uint32)data->filebytesleft;
 890                 assert(m<0x80000000UL);
 891                 if (TIFFReadFile(data->tif,data->buffer,(tmsize_t)m)!=(tmsize_t)m)
 892                         return(0);
 893                 data->buffercurrentbyte=data->buffer;
 894                 data->bufferbytesleft=m;
 895                 data->fileoffset+=m;
 896                 data->filebytesleft-=m;
 897         }
 898         *result=*data->buffercurrentbyte;
 899         data->buffercurrentbyte++;
 900         data->bufferbytesleft--;
 901         return(1);
 902 }
 903
 904 static int
 905 JPEGFixupTagsSubsamplingReadWord(struct JPEGFixupTagsSubsamplingData* data, uint16* result)
 906 {
 907         uint8 ma;
 908         uint8 mb;
 909         if (!JPEGFixupTagsSubsamplingReadByte(data,&ma))
 910                 return(0);
 911         if (!JPEGFixupTagsSubsamplingReadByte(data,&mb))
 912                 return(0);
 913         *result=(ma<<8)|mb;
 914         return(1);
 915 }
 916
 917 static void
 918 JPEGFixupTagsSubsamplingSkip(struct JPEGFixupTagsSubsamplingData* data, uint16 skiplength)
 919 {
 920         if ((uint32)skiplength<=data->bufferbytesleft)
 921         {
 922                 data->buffercurrentbyte+=skiplength;
 923                 data->bufferbytesleft-=skiplength;
 924         }
 925         else
 926         {
 927                 uint16 m;
 928                 m=skiplength-data->bufferbytesleft;
 929                 if (m<=data->filebytesleft)
 930                 {
 931                         data->bufferbytesleft=0;
 932                         data->fileoffset+=m;
 933                         data->filebytesleft-=m;
 934                         data->filepositioned=0;
 935                 }
 936                 else
 937                 {
 938                         data->bufferbytesleft=0;
 939                         data->filebytesleft=0;
 940                 }
 941         }
 942 }
 943
 944 #endif
 945
 946
 947 static int
 948 JPEGSetupDecode(TIFF* tif)
 949 {
 950         JPEGState* sp = JState(tif);
 951         TIFFDirectory *td = &tif->tif_dir;
 952
 953 #if defined(JPEG_DUAL_MODE_8_12) && !defined(TIFFInitJPEG)
 954         if( tif->tif_dir.td_bitspersample == 12 )
 955             return TIFFReInitJPEG_12( tif, COMPRESSION_JPEG, 0 );
 956 #endif
 957
 958         JPEGInitializeLibJPEG( tif, TRUE );
 959
 960         assert(sp != NULL);
 961         assert(sp->cinfo.comm.is_decompressor);
 962
 963         /* Read JPEGTables if it is present */
 964         if (TIFFFieldSet(tif,FIELD_JPEGTABLES)) {
 965                 TIFFjpeg_tables_src(sp, tif);
 966                 if(TIFFjpeg_read_header(sp,FALSE) != JPEG_HEADER_TABLES_ONLY) {
 967                         TIFFErrorExt(tif->tif_clientdata, "JPEGSetupDecode", "Bogus JPEGTables field");
 968                         return (0);
 969                 }
 970         }
 971
 972         /* Grab parameters that are same for all strips/tiles */
 973         sp->photometric = td->td_photometric;
 974         switch (sp->photometric) {
 975         case PHOTOMETRIC_YCBCR:
 976                 sp->h_sampling = td->td_ycbcrsubsampling[0];
 977                 sp->v_sampling = td->td_ycbcrsubsampling[1];
 978                 break;
 979         default:
 980                 /* TIFF 6.0 forbids subsampling of all other color spaces */
 981                 sp->h_sampling = 1;
 982                 sp->v_sampling = 1;
 983                 break;
 984         }
 985
 986         /* Set up for reading normal data */
 987         TIFFjpeg_data_src(sp, tif);
 988         tif->tif_postdecode = _TIFFNoPostDecode; /* override byte swapping */
 989         return (1);
 990 }
 991
 992 /*
 993  * Set up for decoding a strip or tile.
 994  */
 995 static int
 996 JPEGPreDecode(TIFF* tif, uint16 s)
 997 {
 998         JPEGState *sp = JState(tif);
 999         TIFFDirectory *td = &tif->tif_dir;
1000         static const char module[] = "JPEGPreDecode";
1001         uint32 segment_width, segment_height;
1002         int downsampled_output;
1003         int ci;
1004
1005         assert(sp != NULL);
1006
1007         if (sp->cinfo.comm.is_decompressor == 0)
1008         {
1009                 tif->tif_setupdecode( tif );
1010         }
1011
1012         assert(sp->cinfo.comm.is_decompressor);
1013         /*
1014          * Reset decoder state from any previous strip/tile,
1015          * in case application didn't read the whole strip.
1016          */
1017         if (!TIFFjpeg_abort(sp))
1018                 return (0);
1019         /*
1020          * Read the header for this strip/tile.
1021          */
1022
1023         if (TIFFjpeg_read_header(sp, TRUE) != JPEG_HEADER_OK)
1024                 return (0);
1025
1026         tif->tif_rawcp = (uint8*) sp->src.next_input_byte;
1027         tif->tif_rawcc = sp->src.bytes_in_buffer;
1028
1029         /*
1030          * Check image parameters and set decompression parameters.
1031          */
1032         segment_width = td->td_imagewidth;
1033         segment_height = td->td_imagelength - tif->tif_row;
1034         if (isTiled(tif)) {
1035                 segment_width = td->td_tilewidth;
1036                 segment_height = td->td_tilelength;
1037                 sp->bytesperline = TIFFTileRowSize(tif);
1038         } else {
1039                 if (segment_height > td->td_rowsperstrip)
1040                         segment_height = td->td_rowsperstrip;
1041                 sp->bytesperline = TIFFScanlineSize(tif);
1042         }
1043         if (td->td_planarconfig == PLANARCONFIG_SEPARATE && s > 0) {
1044                 /*
1045                  * For PC 2, scale down the expected strip/tile size
1046                  * to match a downsampled component
1047                  */
1048                 segment_width = TIFFhowmany_32(segment_width, sp->h_sampling);
1049                 segment_height = TIFFhowmany_32(segment_height, sp->v_sampling);
1050         }
1051         if (sp->cinfo.d.image_width < segment_width ||
1052             sp->cinfo.d.image_height < segment_height) {
1053                 TIFFWarningExt(tif->tif_clientdata, module,
1054                                "Improper JPEG strip/tile size, "
1055                                "expected %dx%d, got %dx%d",
1056                                segment_width, segment_height,
1057                                sp->cinfo.d.image_width,
1058                                sp->cinfo.d.image_height);
1059         }
1060         if (sp->cinfo.d.image_width > segment_width ||
1061             sp->cinfo.d.image_height > segment_height) {
1062                 /*
1063                  * This case could be dangerous, if the strip or tile size has
1064                  * been reported as less than the amount of data jpeg will
1065                  * return, some potential security issues arise. Catch this
1066                  * case and error out.
1067                  */
1068                 TIFFErrorExt(tif->tif_clientdata, module,
1069                              "JPEG strip/tile size exceeds expected dimensions,"
1070                              " expected %dx%d, got %dx%d",
1071                              segment_width, segment_height,
1072                              sp->cinfo.d.image_width, sp->cinfo.d.image_height);
1073                 return (0);
1074         }
1075         if (sp->cinfo.d.num_components !=
1076             (td->td_planarconfig == PLANARCONFIG_CONTIG ?
1077              td->td_samplesperpixel : 1)) {
1078                 TIFFErrorExt(tif->tif_clientdata, module, "Improper JPEG component count");
1079                 return (0);
1080         }
1081 #ifdef JPEG_LIB_MK1
1082         if (12 != td->td_bitspersample && 8 != td->td_bitspersample) {
1083                 TIFFErrorExt(tif->tif_clientdata, module, "Improper JPEG data precision");
1084                 return (0);
1085         }
1086         sp->cinfo.d.data_precision = td->td_bitspersample;
1087         sp->cinfo.d.bits_in_jsample = td->td_bitspersample;
1088 #else
1089         if (sp->cinfo.d.data_precision != td->td_bitspersample) {
1090                 TIFFErrorExt(tif->tif_clientdata, module, "Improper JPEG data precision");
1091                 return (0);
1092         }
1093 #endif
1094         if (td->td_planarconfig == PLANARCONFIG_CONTIG) {
1095                 /* Component 0 should have expected sampling factors */
1096                 if (sp->cinfo.d.comp_info[0].h_samp_factor != sp->h_sampling ||
1097                     sp->cinfo.d.comp_info[0].v_samp_factor != sp->v_sampling) {
1098                                 TIFFWarningExt(tif->tif_clientdata, module,
1099                                     "Improper JPEG sampling factors %d,%d\n"
1100                                     "Apparently should be %d,%d.",
1101                                     sp->cinfo.d.comp_info[0].h_samp_factor,
1102                                     sp->cinfo.d.comp_info[0].v_samp_factor,
1103                                     sp->h_sampling, sp->v_sampling);
1104
1105                                 /*
1106                                  * There are potential security issues here
1107                                  * for decoders that have already allocated
1108                                  * buffers based on the expected sampling
1109                                  * factors. Lets check the sampling factors
1110                                  * dont exceed what we were expecting.
1111                                  */
1112                                 if (sp->cinfo.d.comp_info[0].h_samp_factor
1113                                         > sp->h_sampling
1114                                     || sp->cinfo.d.comp_info[0].v_samp_factor
1115                                         > sp->v_sampling) {
1116                                         TIFFErrorExt(tif->tif_clientdata,
1117                                                      module,
1118                                         "Cannot honour JPEG sampling factors"
1119                                         " that exceed those specified.");
1120                                         return (0);
1121                                 }
1122
1123                             /*
1124                              * XXX: Files written by the Intergraph software
1125                              * has different sampling factors stored in the
1126                              * TIFF tags and in the JPEG structures. We will
1127                              * try to deduce Intergraph files by the presense
1128                              * of the tag 33918.
1129                              */
1130                             if (!TIFFFindField(tif, 33918, TIFF_ANY)) {
1131                                         TIFFWarningExt(tif->tif_clientdata, module,
1132                                         "Decompressor will try reading with "
1133                                         "sampling %d,%d.",
1134                                         sp->cinfo.d.comp_info[0].h_samp_factor,
1135                                         sp->cinfo.d.comp_info[0].v_samp_factor);
1136
1137                                     sp->h_sampling = (uint16)
1138                                         sp->cinfo.d.comp_info[0].h_samp_factor;
1139                                     sp->v_sampling = (uint16)
1140                                         sp->cinfo.d.comp_info[0].v_samp_factor;
1141                             }
1142                 }
1143                 /* Rest should have sampling factors 1,1 */
1144                 for (ci = 1; ci < sp->cinfo.d.num_components; ci++) {
1145                         if (sp->cinfo.d.comp_info[ci].h_samp_factor != 1 ||
1146                             sp->cinfo.d.comp_info[ci].v_samp_factor != 1) {
1147                                 TIFFErrorExt(tif->tif_clientdata, module, "Improper JPEG sampling factors");
1148                                 return (0);
1149                         }
1150                 }
1151         } else {
1152                 /* PC 2's single component should have sampling factors 1,1 */
1153                 if (sp->cinfo.d.comp_info[0].h_samp_factor != 1 ||
1154                     sp->cinfo.d.comp_info[0].v_samp_factor != 1) {
1155                         TIFFErrorExt(tif->tif_clientdata, module, "Improper JPEG sampling factors");
1156                         return (0);
1157                 }
1158         }
1159         downsampled_output = FALSE;
1160         if (td->td_planarconfig == PLANARCONFIG_CONTIG &&
1161             sp->photometric == PHOTOMETRIC_YCBCR &&
1162             sp->jpegcolormode == JPEGCOLORMODE_RGB) {
1163         /* Convert YCbCr to RGB */
1164                 sp->cinfo.d.jpeg_color_space = JCS_YCbCr;
1165                 sp->cinfo.d.out_color_space = JCS_RGB;
1166         } else {
1167                         /* Suppress colorspace handling */
1168                 sp->cinfo.d.jpeg_color_space = JCS_UNKNOWN;
1169                 sp->cinfo.d.out_color_space = JCS_UNKNOWN;
1170                 if (td->td_planarconfig == PLANARCONFIG_CONTIG &&
1171                     (sp->h_sampling != 1 || sp->v_sampling != 1))
1172                         downsampled_output = TRUE;
1173                 /* XXX what about up-sampling? */
1174         }
1175         if (downsampled_output) {
1176                 /* Need to use raw-data interface to libjpeg */
1177                 sp->cinfo.d.raw_data_out = TRUE;
1178                 tif->tif_decoderow = DecodeRowError;
1179                 tif->tif_decodestrip = JPEGDecodeRaw;
1180                 tif->tif_decodetile = JPEGDecodeRaw;
1181         } else {
1182                 /* Use normal interface to libjpeg */
1183                 sp->cinfo.d.raw_data_out = FALSE;
1184                 tif->tif_decoderow = JPEGDecode;
1185                 tif->tif_decodestrip = JPEGDecode;
1186                 tif->tif_decodetile = JPEGDecode;
1187         }
1188         /* Start JPEG decompressor */
1189         if (!TIFFjpeg_start_decompress(sp))
1190                 return (0);
1191         /* Allocate downsampled-data buffers if needed */
1192         if (downsampled_output) {
1193                 if (!alloc_downsampled_buffers(tif, sp->cinfo.d.comp_info,
1194                                                sp->cinfo.d.num_components))
1195                         return (0);
1196                 sp->scancount = DCTSIZE;        /* mark buffer empty */
1197         }
1198         return (1);
1199 }
1200
1201 /*
1202  * Decode a chunk of pixels.
1203  * "Standard" case: returned data is not downsampled.
1204  */
1205 /*ARGSUSED*/ static int
1206 JPEGDecode(TIFF* tif, uint8* buf, tmsize_t cc, uint16 s)
1207 {
1208         JPEGState *sp = JState(tif);
1209         tmsize_t nrows;
1210         (void) s;
1211
1212         /*
1213         ** Update available information, buffer may have been refilled
1214         ** between decode requests
1215         */
1216         sp->src.next_input_byte = (const JOCTET*) tif->tif_rawcp;
1217         sp->src.bytes_in_buffer = (size_t) tif->tif_rawcc;
1218
1219         if( sp->bytesperline == 0 )
1220                 return 0;
1221
1222         nrows = cc / sp->bytesperline;
1223         if (cc % sp->bytesperline)
1224                 TIFFWarningExt(tif->tif_clientdata, tif->tif_name, "fractional scanline not read");
1225
1226         if( nrows > (tmsize_t) sp->cinfo.d.image_height )
1227                 nrows = sp->cinfo.d.image_height;
1228
1229         /* data is expected to be read in multiples of a scanline */
1230         if (nrows)
1231         {
1232                 JSAMPROW line_work_buf = NULL;
1233
1234                 /*
1235                  * For 6B, only use temporary buffer for 12 bit imagery.
1236                  * For Mk1 always use it.
1237                  */
1238 #if !defined(JPEG_LIB_MK1)
1239                 if( sp->cinfo.d.data_precision == 12 )
1240 #endif
1241                 {
1242                         line_work_buf = (JSAMPROW)
1243                             _TIFFmalloc(sizeof(short) * sp->cinfo.d.output_width
1244                             * sp->cinfo.d.num_components );
1245                 }
1246
1247                 do {
1248                         if( line_work_buf != NULL )
1249                         {
1250                                 /*
1251                                  * In the MK1 case, we aways read into a 16bit buffer, and then
1252                                  * pack down to 12bit or 8bit.  In 6B case we only read into 16
1253                                  * bit buffer for 12bit data, which we need to repack.
1254                                 */
1255                                 if (TIFFjpeg_read_scanlines(sp, &line_work_buf, 1) != 1)
1256                                         return (0);
1257
1258                                 if( sp->cinfo.d.data_precision == 12 )
1259                                 {
1260                                         int value_pairs = (sp->cinfo.d.output_width
1261                                             * sp->cinfo.d.num_components) / 2;
1262                                         int iPair;
1263
1264                                         for( iPair = 0; iPair < value_pairs; iPair++ )
1265                                         {
1266                                                 unsigned char *out_ptr =
1267                                                     ((unsigned char *) buf) + iPair * 3;
1268                                                 JSAMPLE *in_ptr = line_work_buf + iPair * 2;
1269
1270                                                 out_ptr[0] = (in_ptr[0] & 0xff0) >> 4;
1271                                                 out_ptr[1] = ((in_ptr[0] & 0xf) << 4)
1272                                                     | ((in_ptr[1] & 0xf00) >> 8);
1273                                                 out_ptr[2] = ((in_ptr[1] & 0xff) >> 0);
1274                                         }
1275                                 }
1276                                 else if( sp->cinfo.d.data_precision == 8 )
1277                                 {
1278                                         int value_count = (sp->cinfo.d.output_width
1279                                             * sp->cinfo.d.num_components);
1280                                         int iValue;
1281
1282                                         for( iValue = 0; iValue < value_count; iValue++ )
1283                                         {
1284                                                 ((unsigned char *) buf)[iValue] =
1285                                                     line_work_buf[iValue] & 0xff;
1286                                         }
1287                                 }
1288                         }
1289                         else
1290                         {
1291                                 /*
1292                                  * In the libjpeg6b 8bit case.  We read directly into the
1293                                  * TIFF buffer.
1294                                 */
1295                                 JSAMPROW bufptr = (JSAMPROW)buf;
1296
1297                                 if (TIFFjpeg_read_scanlines(sp, &bufptr, 1) != 1)
1298                                         return (0);
1299                         }
1300
1301                         ++tif->tif_row;
1302                         buf += sp->bytesperline;
1303                         cc -= sp->bytesperline;
1304                 } while (--nrows > 0);
1305
1306                 if( line_work_buf != NULL )
1307                         _TIFFfree( line_work_buf );
1308         }
1309
1310         /* Update information on consumed data */
1311         tif->tif_rawcp = (uint8*) sp->src.next_input_byte;
1312         tif->tif_rawcc = sp->src.bytes_in_buffer;
1313
1314         /* Close down the decompressor if we've finished the strip or tile. */
1315         return sp->cinfo.d.output_scanline < sp->cinfo.d.output_height
1316             || TIFFjpeg_finish_decompress(sp);
1317 }
1318
1319 /*ARGSUSED*/ static int
1320 DecodeRowError(TIFF* tif, uint8* buf, tmsize_t cc, uint16 s)
1321
1322 {
1323     (void) buf;
1324     (void) cc;
1325     (void) s;
1326
1327     TIFFErrorExt(tif->tif_clientdata, "TIFFReadScanline",
1328                  "scanline oriented access is not supported for downsampled JPEG compressed images, consider enabling TIFF_JPEGCOLORMODE as JPEGCOLORMODE_RGB." );
1329     return 0;
1330 }
1331
1332 /*
1333  * Decode a chunk of pixels.
1334  * Returned data is downsampled per sampling factors.
1335  */
1336 /*ARGSUSED*/ static int
1337 JPEGDecodeRaw(TIFF* tif, uint8* buf, tmsize_t cc, uint16 s)
1338 {
1339         JPEGState *sp = JState(tif);
1340         tmsize_t nrows;
1341         (void) s;
1342
1343         /* data is expected to be read in multiples of a scanline */
1344         if ( (nrows = sp->cinfo.d.image_height) ) {
1345
1346                 /* Cb,Cr both have sampling factors 1, so this is correct */
1347                 JDIMENSION clumps_per_line = sp->cinfo.d.comp_info[1].downsampled_width;
1348                 int samples_per_clump = sp->samplesperclump;
1349
1350 #if defined(JPEG_LIB_MK1_OR_12BIT)
1351                 unsigned short* tmpbuf = _TIFFmalloc(sizeof(unsigned short) *
1352                     sp->cinfo.d.output_width *
1353                     sp->cinfo.d.num_components);
1354                 if(tmpbuf==NULL) {
1355                         TIFFErrorExt(tif->tif_clientdata, "JPEGDecodeRaw",
1356                                      "Out of memory");
1357                         return 0;
1358                 }
1359 #endif
1360
1361                 do {
1362                         jpeg_component_info *compptr;
1363                         int ci, clumpoffset;
1364
1365                         if( cc < sp->bytesperline * sp->v_sampling ) {
1366                             TIFFErrorExt(tif->tif_clientdata, "JPEGDecodeRaw",
1367                                          "application buffer not large enough for all data.");
1368                             return 0;
1369                         }
1370
1371                         /* Reload downsampled-data buffer if needed */
1372                         if (sp->scancount >= DCTSIZE) {
1373                                 int n = sp->cinfo.d.max_v_samp_factor * DCTSIZE;
1374                                 if (TIFFjpeg_read_raw_data(sp, sp->ds_buffer, n) != n)
1375                                         return (0);
1376                                 sp->scancount = 0;
1377                         }
1378                         /*
1379                          * Fastest way to unseparate data is to make one pass
1380                          * over the scanline for each row of each component.
1381                          */
1382                         clumpoffset = 0;    /* first sample in clump */
1383                         for (ci = 0, compptr = sp->cinfo.d.comp_info;
1384                             ci < sp->cinfo.d.num_components;
1385                             ci++, compptr++) {
1386                                 int hsamp = compptr->h_samp_factor;
1387                                 int vsamp = compptr->v_samp_factor;
1388                                 int ypos;
1389
1390                                 for (ypos = 0; ypos < vsamp; ypos++) {
1391                                         JSAMPLE *inptr = sp->ds_buffer[ci][sp->scancount*vsamp + ypos];
1392 #if defined(JPEG_LIB_MK1_OR_12BIT)
1393                                         JSAMPLE *outptr = (JSAMPLE*)tmpbuf + clumpoffset;
1394 #else
1395                                         JSAMPLE *outptr = (JSAMPLE*)buf + clumpoffset;
1396 #endif
1397                                         JDIMENSION nclump;
1398
1399                                         if (hsamp == 1) {
1400                                                 /* fast path for at least Cb and Cr */
1401                                                 for (nclump = clumps_per_line; nclump-- > 0; ) {
1402                                                         outptr[0] = *inptr++;
1403                                                         outptr += samples_per_clump;
1404                                                 }
1405                                         } else {
1406                                                 int xpos;
1407
1408                         /* general case */
1409                                                 for (nclump = clumps_per_line; nclump-- > 0; ) {
1410                                                         for (xpos = 0; xpos < hsamp; xpos++)
1411                                                                 outptr[xpos] = *inptr++;
1412                                                         outptr += samples_per_clump;
1413                                                 }
1414                                         }
1415                                         clumpoffset += hsamp;
1416                                 }
1417                         }
1418
1419 #if defined(JPEG_LIB_MK1_OR_12BIT)
1420                         {
1421                                 if (sp->cinfo.d.data_precision == 8)
1422                                 {
1423                                         int i=0;
1424                                         int len = sp->cinfo.d.output_width * sp->cinfo.d.num_components;
1425                                         for (i=0; i<len; i++)
1426                                         {
1427                                                 ((unsigned char*)buf)[i] = tmpbuf[i] & 0xff;
1428                                         }
1429                                 }
1430                                 else
1431                                         {         /* 12-bit */
1432                                         int value_pairs = (sp->cinfo.d.output_width
1433                                             * sp->cinfo.d.num_components) / 2;
1434                                         int iPair;
1435                                         for( iPair = 0; iPair < value_pairs; iPair++ )
1436                                         {
1437                                                 unsigned char *out_ptr = ((unsigned char *) buf) + iPair * 3;
1438                                                 JSAMPLE *in_ptr = (JSAMPLE *) (tmpbuf + iPair * 2);
1439                                                 out_ptr[0] = (in_ptr[0] & 0xff0) >> 4;
1440                                                 out_ptr[1] = ((in_ptr[0] & 0xf) << 4)
1441                                                     | ((in_ptr[1] & 0xf00) >> 8);
1442                                                 out_ptr[2] = ((in_ptr[1] & 0xff) >> 0);
1443                                         }
1444                                 }
1445                         }
1446 #endif
1447
1448                         sp->scancount ++;
1449                         tif->tif_row += sp->v_sampling;
1450 /*
1451                         buf += clumps_per_line*samples_per_clump;
1452                         cc -= clumps_per_line*samples_per_clump;
1453 */
1454                         buf += sp->bytesperline * sp->v_sampling;
1455                         cc -= sp->bytesperline * sp->v_sampling;
1456
1457                         nrows -= sp->v_sampling;
1458                 } while (nrows > 0);
1459
1460 #if defined(JPEG_LIB_MK1_OR_12BIT)
1461                 _TIFFfree(tmpbuf);
1462 #endif
1463
1464         }
1465
1466         /* Close down the decompressor if done. */
1467         return sp->cinfo.d.output_scanline < sp->cinfo.d.output_height
1468             || TIFFjpeg_finish_decompress(sp);
1469 }
1470
1471
1472 /*
1473  * JPEG Encoding.
1474  */
1475
1476 static void
1477 unsuppress_quant_table (JPEGState* sp, int tblno)
1478 {
1479         JQUANT_TBL* qtbl;
1480
1481         if ((qtbl = sp->cinfo.c.quant_tbl_ptrs[tblno]) != NULL)
1482                 qtbl->sent_table = FALSE;
1483 }
1484
1485 static void
1486 unsuppress_huff_table (JPEGState* sp, int tblno)
1487 {
1488         JHUFF_TBL* htbl;
1489
1490         if ((htbl = sp->cinfo.c.dc_huff_tbl_ptrs[tblno]) != NULL)
1491                 htbl->sent_table = FALSE;
1492         if ((htbl = sp->cinfo.c.ac_huff_tbl_ptrs[tblno]) != NULL)
1493                 htbl->sent_table = FALSE;
1494 }
1495
1496 static int
1497 prepare_JPEGTables(TIFF* tif)
1498 {
1499         JPEGState* sp = JState(tif);
1500
1501         /* Initialize quant tables for current quality setting */
1502         if (!TIFFjpeg_set_quality(sp, sp->jpegquality, FALSE))
1503                 return (0);
1504         /* Mark only the tables we want for output */
1505         /* NB: chrominance tables are currently used only with YCbCr */
1506         if (!TIFFjpeg_suppress_tables(sp, TRUE))
1507                 return (0);
1508         if (sp->jpegtablesmode & JPEGTABLESMODE_QUANT) {
1509                 unsuppress_quant_table(sp, 0);
1510                 if (sp->photometric == PHOTOMETRIC_YCBCR)
1511                         unsuppress_quant_table(sp, 1);
1512         }
1513         if (sp->jpegtablesmode & JPEGTABLESMODE_HUFF) {
1514                 unsuppress_huff_table(sp, 0);
1515                 if (sp->photometric == PHOTOMETRIC_YCBCR)
1516                         unsuppress_huff_table(sp, 1);
1517         }
1518         /* Direct libjpeg output into jpegtables */
1519         if (!TIFFjpeg_tables_dest(sp, tif))
1520                 return (0);
1521         /* Emit tables-only datastream */
1522         if (!TIFFjpeg_write_tables(sp))
1523                 return (0);
1524
1525         return (1);
1526 }
1527
1528 static int
1529 JPEGSetupEncode(TIFF* tif)
1530 {
1531         JPEGState* sp = JState(tif);
1532         TIFFDirectory *td = &tif->tif_dir;
1533         static const char module[] = "JPEGSetupEncode";
1534
1535 #if defined(JPEG_DUAL_MODE_8_12) && !defined(TIFFInitJPEG)
1536         if( tif->tif_dir.td_bitspersample == 12 )
1537             return TIFFReInitJPEG_12( tif, COMPRESSION_JPEG, 1 );
1538 #endif
1539
1540         JPEGInitializeLibJPEG( tif, FALSE );
1541
1542         assert(sp != NULL);
1543         assert(!sp->cinfo.comm.is_decompressor);
1544
1545         /*
1546          * Initialize all JPEG parameters to default values.
1547          * Note that jpeg_set_defaults needs legal values for
1548          * in_color_space and input_components.
1549          */
1550         sp->cinfo.c.in_color_space = JCS_UNKNOWN;
1551         sp->cinfo.c.input_components = 1;
1552         if (!TIFFjpeg_set_defaults(sp))
1553                 return (0);
1554         /* Set per-file parameters */
1555         sp->photometric = td->td_photometric;
1556         switch (sp->photometric) {
1557         case PHOTOMETRIC_YCBCR:
1558                 sp->h_sampling = td->td_ycbcrsubsampling[0];
1559                 sp->v_sampling = td->td_ycbcrsubsampling[1];
1560                 /*
1561                  * A ReferenceBlackWhite field *must* be present since the
1562                  * default value is inappropriate for YCbCr.  Fill in the
1563                  * proper value if application didn't set it.
1564                  */
1565                 {
1566                         float *ref;
1567                         if (!TIFFGetField(tif, TIFFTAG_REFERENCEBLACKWHITE,
1568                                           &ref)) {
1569                                 float refbw[6];
1570                                 long top = 1L << td->td_bitspersample;
1571                                 refbw[0] = 0;
1572                                 refbw[1] = (float)(top-1L);
1573                                 refbw[2] = (float)(top>>1);
1574                                 refbw[3] = refbw[1];
1575                                 refbw[4] = refbw[2];
1576                                 refbw[5] = refbw[1];
1577                                 TIFFSetField(tif, TIFFTAG_REFERENCEBLACKWHITE,
1578                                              refbw);
1579                         }
1580                 }
1581                 break;
1582         case PHOTOMETRIC_PALETTE:               /* disallowed by Tech Note */
1583         case PHOTOMETRIC_MASK:
1584                 TIFFErrorExt(tif->tif_clientdata, module,
1585                           "PhotometricInterpretation %d not allowed for JPEG",
1586                           (int) sp->photometric);
1587                 return (0);
1588         default:
1589                 /* TIFF 6.0 forbids subsampling of all other color spaces */
1590                 sp->h_sampling = 1;
1591                 sp->v_sampling = 1;
1592                 break;
1593         }
1594
1595         /* Verify miscellaneous parameters */
1596
1597         /*
1598          * This would need work if libtiff ever supports different
1599          * depths for different components, or if libjpeg ever supports
1600          * run-time selection of depth.  Neither is imminent.
1601          */
1602 #ifdef JPEG_LIB_MK1
1603         /* BITS_IN_JSAMPLE now permits 8 and 12 --- dgilbert */
1604         if (td->td_bitspersample != 8 && td->td_bitspersample != 12)
1605 #else
1606         if (td->td_bitspersample != BITS_IN_JSAMPLE )
1607 #endif
1608         {
1609                 TIFFErrorExt(tif->tif_clientdata, module, "BitsPerSample %d not allowed for JPEG",
1610                           (int) td->td_bitspersample);
1611                 return (0);
1612         }
1613         sp->cinfo.c.data_precision = td->td_bitspersample;
1614 #ifdef JPEG_LIB_MK1
1615         sp->cinfo.c.bits_in_jsample = td->td_bitspersample;
1616 #endif
1617         if (isTiled(tif)) {
1618                 if ((td->td_tilelength % (sp->v_sampling * DCTSIZE)) != 0) {
1619                         TIFFErrorExt(tif->tif_clientdata, module,
1620                                   "JPEG tile height must be multiple of %d",
1621                                   sp->v_sampling * DCTSIZE);
1622                         return (0);
1623                 }
1624                 if ((td->td_tilewidth % (sp->h_sampling * DCTSIZE)) != 0) {
1625                         TIFFErrorExt(tif->tif_clientdata, module,
1626                                   "JPEG tile width must be multiple of %d",
1627                                   sp->h_sampling * DCTSIZE);
1628                         return (0);
1629                 }
1630         } else {
1631                 if (td->td_rowsperstrip < td->td_imagelength &&
1632                     (td->td_rowsperstrip % (sp->v_sampling * DCTSIZE)) != 0) {
1633                         TIFFErrorExt(tif->tif_clientdata, module,
1634                                   "RowsPerStrip must be multiple of %d for JPEG",
1635                                   sp->v_sampling * DCTSIZE);
1636                         return (0);
1637                 }
1638         }
1639
1640         /* Create a JPEGTables field if appropriate */
1641         if (sp->jpegtablesmode & (JPEGTABLESMODE_QUANT|JPEGTABLESMODE_HUFF)) {
1642                 if( sp->jpegtables == NULL
1643                     || memcmp(sp->jpegtables,"\0\0\0\0\0\0\0\0\0",8) == 0 )
1644                 {
1645                         if (!prepare_JPEGTables(tif))
1646                                 return (0);
1647                         /* Mark the field present */
1648                         /* Can't use TIFFSetField since BEENWRITING is already set! */
1649                         tif->tif_flags |= TIFF_DIRTYDIRECT;
1650                         TIFFSetFieldBit(tif, FIELD_JPEGTABLES);
1651                 }
1652         } else {
1653                 /* We do not support application-supplied JPEGTables, */
1654                 /* so mark the field not present */
1655                 TIFFClrFieldBit(tif, FIELD_JPEGTABLES);
1656         }
1657
1658         /* Direct libjpeg output to libtiff's output buffer */
1659         TIFFjpeg_data_dest(sp, tif);
1660
1661         return (1);
1662 }
1663
1664 /*
1665  * Set encoding state at the start of a strip or tile.
1666  */
1667 static int
1668 JPEGPreEncode(TIFF* tif, uint16 s)
1669 {
1670         JPEGState *sp = JState(tif);
1671         TIFFDirectory *td = &tif->tif_dir;
1672         static const char module[] = "JPEGPreEncode";
1673         uint32 segment_width, segment_height;
1674         int downsampled_input;
1675
1676         assert(sp != NULL);
1677
1678         if (sp->cinfo.comm.is_decompressor == 1)
1679         {
1680                 tif->tif_setupencode( tif );
1681         }
1682
1683         assert(!sp->cinfo.comm.is_decompressor);
1684         /*
1685          * Set encoding parameters for this strip/tile.
1686          */
1687         if (isTiled(tif)) {
1688                 segment_width = td->td_tilewidth;
1689                 segment_height = td->td_tilelength;
1690                 sp->bytesperline = TIFFTileRowSize(tif);
1691         } else {
1692                 segment_width = td->td_imagewidth;
1693                 segment_height = td->td_imagelength - tif->tif_row;
1694                 if (segment_height > td->td_rowsperstrip)
1695                         segment_height = td->td_rowsperstrip;
1696                 sp->bytesperline = TIFFScanlineSize(tif);
1697         }
1698         if (td->td_planarconfig == PLANARCONFIG_SEPARATE && s > 0) {
1699                 /* for PC 2, scale down the strip/tile size
1700                  * to match a downsampled component
1701                  */
1702                 segment_width = TIFFhowmany_32(segment_width, sp->h_sampling);
1703                 segment_height = TIFFhowmany_32(segment_height, sp->v_sampling);
1704         }
1705         if (segment_width > 65535 || segment_height > 65535) {
1706                 TIFFErrorExt(tif->tif_clientdata, module, "Strip/tile too large for JPEG");
1707                 return (0);
1708         }
1709         sp->cinfo.c.image_width = segment_width;
1710         sp->cinfo.c.image_height = segment_height;
1711         downsampled_input = FALSE;
1712         if (td->td_planarconfig == PLANARCONFIG_CONTIG) {
1713                 sp->cinfo.c.input_components = td->td_samplesperpixel;
1714                 if (sp->photometric == PHOTOMETRIC_YCBCR) {
1715                         if (sp->jpegcolormode == JPEGCOLORMODE_RGB) {
1716                                 sp->cinfo.c.in_color_space = JCS_RGB;
1717                         } else {
1718                                 sp->cinfo.c.in_color_space = JCS_YCbCr;
1719                                 if (sp->h_sampling != 1 || sp->v_sampling != 1)
1720                                         downsampled_input = TRUE;
1721                         }
1722                         if (!TIFFjpeg_set_colorspace(sp, JCS_YCbCr))
1723                                 return (0);
1724                         /*
1725                          * Set Y sampling factors;
1726                          * we assume jpeg_set_colorspace() set the rest to 1
1727                          */
1728                         sp->cinfo.c.comp_info[0].h_samp_factor = sp->h_sampling;
1729                         sp->cinfo.c.comp_info[0].v_samp_factor = sp->v_sampling;
1730                 } else {
1731                         if ((td->td_photometric == PHOTOMETRIC_MINISWHITE || td->td_photometric == PHOTOMETRIC_MINISBLACK) && td->td_samplesperpixel == 1)
1732                                 sp->cinfo.c.in_color_space = JCS_GRAYSCALE;
1733                         else if (td->td_photometric == PHOTOMETRIC_RGB)
1734                                 sp->cinfo.c.in_color_space = JCS_RGB;
1735                         else if (td->td_photometric == PHOTOMETRIC_SEPARATED && td->td_samplesperpixel == 4)
1736                                 sp->cinfo.c.in_color_space = JCS_CMYK;
1737                         else
1738                                 sp->cinfo.c.in_color_space = JCS_UNKNOWN;
1739                         if (!TIFFjpeg_set_colorspace(sp, sp->cinfo.c.in_color_space))
1740                                 return (0);
1741                         /* jpeg_set_colorspace set all sampling factors to 1 */
1742                 }
1743         } else {
1744                 sp->cinfo.c.input_components = 1;
1745                 sp->cinfo.c.in_color_space = JCS_UNKNOWN;
1746                 if (!TIFFjpeg_set_colorspace(sp, JCS_UNKNOWN))
1747                         return (0);
1748                 sp->cinfo.c.comp_info[0].component_id = s;
1749                 /* jpeg_set_colorspace() set sampling factors to 1 */
1750                 if (sp->photometric == PHOTOMETRIC_YCBCR && s > 0) {
1751                         sp->cinfo.c.comp_info[0].quant_tbl_no = 1;
1752                         sp->cinfo.c.comp_info[0].dc_tbl_no = 1;
1753                         sp->cinfo.c.comp_info[0].ac_tbl_no = 1;
1754                 }
1755         }
1756         /* ensure libjpeg won't write any extraneous markers */
1757         sp->cinfo.c.write_JFIF_header = FALSE;
1758         sp->cinfo.c.write_Adobe_marker = FALSE;
1759         /* set up table handling correctly */
1760         if (!TIFFjpeg_set_quality(sp, sp->jpegquality, FALSE))
1761                 return (0);
1762         if (! (sp->jpegtablesmode & JPEGTABLESMODE_QUANT)) {
1763                 unsuppress_quant_table(sp, 0);
1764                 unsuppress_quant_table(sp, 1);
1765         }
1766         if (sp->jpegtablesmode & JPEGTABLESMODE_HUFF)
1767                 sp->cinfo.c.optimize_coding = FALSE;
1768         else
1769                 sp->cinfo.c.optimize_coding = TRUE;
1770         if (downsampled_input) {
1771                 /* Need to use raw-data interface to libjpeg */
1772                 sp->cinfo.c.raw_data_in = TRUE;
1773                 tif->tif_encoderow = JPEGEncodeRaw;
1774                 tif->tif_encodestrip = JPEGEncodeRaw;
1775                 tif->tif_encodetile = JPEGEncodeRaw;
1776         } else {
1777                 /* Use normal interface to libjpeg */
1778                 sp->cinfo.c.raw_data_in = FALSE;
1779                 tif->tif_encoderow = JPEGEncode;
1780                 tif->tif_encodestrip = JPEGEncode;
1781                 tif->tif_encodetile = JPEGEncode;
1782         }
1783         /* Start JPEG compressor */
1784         if (!TIFFjpeg_start_compress(sp, FALSE))
1785                 return (0);
1786         /* Allocate downsampled-data buffers if needed */
1787         if (downsampled_input) {
1788                 if (!alloc_downsampled_buffers(tif, sp->cinfo.c.comp_info,
1789                                                sp->cinfo.c.num_components))
1790                         return (0);
1791         }
1792         sp->scancount = 0;
1793
1794         return (1);
1795 }
1796
1797 /*
1798  * Encode a chunk of pixels.
1799  * "Standard" case: incoming data is not downsampled.
1800  */
1801 static int
1802 JPEGEncode(TIFF* tif, uint8* buf, tmsize_t cc, uint16 s)
1803 {
1804         JPEGState *sp = JState(tif);
1805         tmsize_t nrows;
1806         JSAMPROW bufptr[1];
1807         short *line16 = NULL;
1808         int    line16_count = 0;
1809
1810         (void) s;
1811         assert(sp != NULL);
1812         /* data is expected to be supplied in multiples of a scanline */
1813         nrows = cc / sp->bytesperline;
1814         if (cc % sp->bytesperline)
1815             TIFFWarningExt(tif->tif_clientdata, tif->tif_name,
1816                            "fractional scanline discarded");
1817
1818         /* The last strip will be limited to image size */
1819         if( !isTiled(tif) && tif->tif_row+nrows > tif->tif_dir.td_imagelength )
1820             nrows = tif->tif_dir.td_imagelength - tif->tif_row;
1821
1822         if( sp->cinfo.c.data_precision == 12 )
1823         {
1824             line16_count = (sp->bytesperline * 2) / 3;
1825             line16 = (short *) _TIFFmalloc(sizeof(short) * line16_count);
1826             // FIXME: undiagnosed malloc failure
1827         }
1828
1829         while (nrows-- > 0) {
1830
1831             if( sp->cinfo.c.data_precision == 12 )
1832             {
1833
1834                 int value_pairs = line16_count / 2;
1835                 int iPair;
1836
1837                 bufptr[0] = (JSAMPROW) line16;
1838
1839                 for( iPair = 0; iPair < value_pairs; iPair++ )
1840                 {
1841                     unsigned char *in_ptr =
1842                         ((unsigned char *) buf) + iPair * 3;
1843                     JSAMPLE *out_ptr = (JSAMPLE *) (line16 + iPair * 2);
1844
1845                     out_ptr[0] = (in_ptr[0] << 4) | ((in_ptr[1] & 0xf0) >> 4);
1846                     out_ptr[1] = ((in_ptr[1] & 0x0f) << 8) | in_ptr[2];
1847                 }
1848             }
1849             else
1850             {
1851                 bufptr[0] = (JSAMPROW) buf;
1852             }
1853             if (TIFFjpeg_write_scanlines(sp, bufptr, 1) != 1)
1854                 return (0);
1855             if (nrows > 0)
1856                 tif->tif_row++;
1857             buf += sp->bytesperline;
1858         }
1859
1860         if( sp->cinfo.c.data_precision == 12 )
1861         {
1862             _TIFFfree( line16 );
1863         }
1864
1865         return (1);
1866 }
1867
1868 /*
1869  * Encode a chunk of pixels.
1870  * Incoming data is expected to be downsampled per sampling factors.
1871  */
1872 static int
1873 JPEGEncodeRaw(TIFF* tif, uint8* buf, tmsize_t cc, uint16 s)
1874 {
1875         JPEGState *sp = JState(tif);
1876         JSAMPLE* inptr;
1877         JSAMPLE* outptr;
1878         tmsize_t nrows;
1879         JDIMENSION clumps_per_line, nclump;
1880         int clumpoffset, ci, xpos, ypos;
1881         jpeg_component_info* compptr;
1882         int samples_per_clump = sp->samplesperclump;
1883         tmsize_t bytesperclumpline;
1884
1885         (void) s;
1886         assert(sp != NULL);
1887         /* data is expected to be supplied in multiples of a clumpline */
1888         /* a clumpline is equivalent to v_sampling desubsampled scanlines */
1889         /* TODO: the following calculation of bytesperclumpline, should substitute calculation of sp->bytesperline, except that it is per v_sampling lines */
1890         bytesperclumpline = (((sp->cinfo.c.image_width+sp->h_sampling-1)/sp->h_sampling)
1891                              *(sp->h_sampling*sp->v_sampling+2)*sp->cinfo.c.data_precision+7)
1892                             /8;
1893
1894         nrows = ( cc / bytesperclumpline ) * sp->v_sampling;
1895         if (cc % bytesperclumpline)
1896                 TIFFWarningExt(tif->tif_clientdata, tif->tif_name, "fractional scanline discarded");
1897
1898         /* Cb,Cr both have sampling factors 1, so this is correct */
1899         clumps_per_line = sp->cinfo.c.comp_info[1].downsampled_width;
1900
1901         while (nrows > 0) {
1902                 /*
1903                  * Fastest way to separate the data is to make one pass
1904                  * over the scanline for each row of each component.
1905                  */
1906                 clumpoffset = 0;                /* first sample in clump */
1907                 for (ci = 0, compptr = sp->cinfo.c.comp_info;
1908                      ci < sp->cinfo.c.num_components;
1909                      ci++, compptr++) {
1910                     int hsamp = compptr->h_samp_factor;
1911                     int vsamp = compptr->v_samp_factor;
1912                     int padding = (int) (compptr->width_in_blocks * DCTSIZE -
1913                                          clumps_per_line * hsamp);
1914                     for (ypos = 0; ypos < vsamp; ypos++) {
1915                         inptr = ((JSAMPLE*) buf) + clumpoffset;
1916                         outptr = sp->ds_buffer[ci][sp->scancount*vsamp + ypos];
1917                         if (hsamp == 1) {
1918                             /* fast path for at least Cb and Cr */
1919                             for (nclump = clumps_per_line; nclump-- > 0; ) {
1920                                 *outptr++ = inptr[0];
1921                                 inptr += samples_per_clump;
1922                             }
1923                         } else {
1924                             /* general case */
1925                             for (nclump = clumps_per_line; nclump-- > 0; ) {
1926                                 for (xpos = 0; xpos < hsamp; xpos++)
1927                                     *outptr++ = inptr[xpos];
1928                                 inptr += samples_per_clump;
1929                             }
1930                         }
1931                         /* pad each scanline as needed */
1932                         for (xpos = 0; xpos < padding; xpos++) {
1933                             *outptr = outptr[-1];
1934                             outptr++;
1935                         }
1936                         clumpoffset += hsamp;
1937                     }
1938                 }
1939                 sp->scancount++;
1940                 if (sp->scancount >= DCTSIZE) {
1941                         int n = sp->cinfo.c.max_v_samp_factor * DCTSIZE;
1942                         if (TIFFjpeg_write_raw_data(sp, sp->ds_buffer, n) != n)
1943                                 return (0);
1944                         sp->scancount = 0;
1945                 }
1946                 tif->tif_row += sp->v_sampling;
1947                 buf += bytesperclumpline;
1948                 nrows -= sp->v_sampling;
1949         }
1950         return (1);
1951 }
1952
1953 /*
1954  * Finish up at the end of a strip or tile.
1955  */
1956 static int
1957 JPEGPostEncode(TIFF* tif)
1958 {
1959         JPEGState *sp = JState(tif);
1960
1961         if (sp->scancount > 0) {
1962                 /*
1963                  * Need to emit a partial bufferload of downsampled data.
1964                  * Pad the data vertically.
1965                  */
1966                 int ci, ypos, n;
1967                 jpeg_component_info* compptr;
1968
1969                 for (ci = 0, compptr = sp->cinfo.c.comp_info;
1970                      ci < sp->cinfo.c.num_components;
1971                      ci++, compptr++) {
1972                         int vsamp = compptr->v_samp_factor;
1973                         tmsize_t row_width = compptr->width_in_blocks * DCTSIZE
1974                                 * sizeof(JSAMPLE);
1975                         for (ypos = sp->scancount * vsamp;
1976                              ypos < DCTSIZE * vsamp; ypos++) {
1977                                 _TIFFmemcpy((void*)sp->ds_buffer[ci][ypos],
1978                                             (void*)sp->ds_buffer[ci][ypos-1],
1979                                             row_width);
1980
1981                         }
1982                 }
1983                 n = sp->cinfo.c.max_v_samp_factor * DCTSIZE;
1984                 if (TIFFjpeg_write_raw_data(sp, sp->ds_buffer, n) != n)
1985                         return (0);
1986         }
1987
1988         return (TIFFjpeg_finish_compress(JState(tif)));
1989 }
1990
1991 static void
1992 JPEGCleanup(TIFF* tif)
1993 {
1994         JPEGState *sp = JState(tif);
1995
1996         assert(sp != 0);
1997
1998         tif->tif_tagmethods.vgetfield = sp->vgetparent;
1999         tif->tif_tagmethods.vsetfield = sp->vsetparent;
2000         tif->tif_tagmethods.printdir = sp->printdir;
2001
2002         if( sp != NULL ) {
2003                 if( sp->cinfo_initialized )
2004                     TIFFjpeg_destroy(sp);       /* release libjpeg resources */
2005                 if (sp->jpegtables)             /* tag value */
2006                         _TIFFfree(sp->jpegtables);
2007         }
2008         _TIFFfree(tif->tif_data);       /* release local state */
2009         tif->tif_data = NULL;
2010
2011         _TIFFSetDefaultCompressionState(tif);
2012 }
2013
2014 static void
2015 JPEGResetUpsampled( TIFF* tif )
2016 {
2017         JPEGState* sp = JState(tif);
2018         TIFFDirectory* td = &tif->tif_dir;
2019
2020         /*
2021          * Mark whether returned data is up-sampled or not so TIFFStripSize
2022          * and TIFFTileSize return values that reflect the true amount of
2023          * data.
2024          */
2025         tif->tif_flags &= ~TIFF_UPSAMPLED;
2026         if (td->td_planarconfig == PLANARCONFIG_CONTIG) {
2027                 if (td->td_photometric == PHOTOMETRIC_YCBCR &&
2028                     sp->jpegcolormode == JPEGCOLORMODE_RGB) {
2029                         tif->tif_flags |= TIFF_UPSAMPLED;
2030                 } else {
2031 #ifdef notdef
2032                         if (td->td_ycbcrsubsampling[0] != 1 ||
2033                             td->td_ycbcrsubsampling[1] != 1)
2034                                 ; /* XXX what about up-sampling? */
2035 #endif
2036                 }
2037         }
2038
2039         /*
2040          * Must recalculate cached tile size in case sampling state changed.
2041          * Should we really be doing this now if image size isn't set?
2042          */
2043         if( tif->tif_tilesize > 0 )
2044             tif->tif_tilesize = isTiled(tif) ? TIFFTileSize(tif) : (tmsize_t)(-1);
2045         if( tif->tif_scanlinesize > 0 )
2046             tif->tif_scanlinesize = TIFFScanlineSize(tif);
2047 }
2048
2049 static int
2050 JPEGVSetField(TIFF* tif, uint32 tag, va_list ap)
2051 {
2052         JPEGState* sp = JState(tif);
2053         const TIFFField* fip;
2054         uint32 v32;
2055
2056         assert(sp != NULL);
2057
2058         switch (tag) {
2059         case TIFFTAG_JPEGTABLES:
2060                 v32 = (uint32) va_arg(ap, uint32);
2061                 if (v32 == 0) {
2062                         /* XXX */
2063                         return (0);
2064                 }
2065                 _TIFFsetByteArray(&sp->jpegtables, va_arg(ap, void*),
2066                     (long) v32);
2067                 sp->jpegtables_length = v32;
2068                 TIFFSetFieldBit(tif, FIELD_JPEGTABLES);
2069                 break;
2070         case TIFFTAG_JPEGQUALITY:
2071                 sp->jpegquality = (int) va_arg(ap, int);
2072                 return (1);                     /* pseudo tag */
2073         case TIFFTAG_JPEGCOLORMODE:
2074                 sp->jpegcolormode = (int) va_arg(ap, int);
2075                 JPEGResetUpsampled( tif );
2076                 return (1);                     /* pseudo tag */
2077         case TIFFTAG_PHOTOMETRIC:
2078         {
2079                 int ret_value = (*sp->vsetparent)(tif, tag, ap);
2080                 JPEGResetUpsampled( tif );
2081                 return ret_value;
2082         }
2083         case TIFFTAG_JPEGTABLESMODE:
2084                 sp->jpegtablesmode = (int) va_arg(ap, int);
2085                 return (1);                     /* pseudo tag */
2086         case TIFFTAG_YCBCRSUBSAMPLING:
2087                 /* mark the fact that we have a real ycbcrsubsampling! */
2088                 sp->ycbcrsampling_fetched = 1;
2089                 /* should we be recomputing upsampling info here? */
2090                 return (*sp->vsetparent)(tif, tag, ap);
2091         default:
2092                 return (*sp->vsetparent)(tif, tag, ap);
2093         }
2094
2095         if ((fip = TIFFFieldWithTag(tif, tag))) {
2096                 TIFFSetFieldBit(tif, fip->field_bit);
2097         } else {
2098                 return (0);
2099         }
2100
2101         tif->tif_flags |= TIFF_DIRTYDIRECT;
2102         return (1);
2103 }
2104
2105 static int
2106 JPEGVGetField(TIFF* tif, uint32 tag, va_list ap)
2107 {
2108         JPEGState* sp = JState(tif);
2109
2110         assert(sp != NULL);
2111
2112         switch (tag) {
2113                 case TIFFTAG_JPEGTABLES:
2114                         *va_arg(ap, uint32*) = sp->jpegtables_length;
2115                         *va_arg(ap, void**) = sp->jpegtables;
2116                         break;
2117                 case TIFFTAG_JPEGQUALITY:
2118                         *va_arg(ap, int*) = sp->jpegquality;
2119                         break;
2120                 case TIFFTAG_JPEGCOLORMODE:
2121                         *va_arg(ap, int*) = sp->jpegcolormode;
2122                         break;
2123                 case TIFFTAG_JPEGTABLESMODE:
2124                         *va_arg(ap, int*) = sp->jpegtablesmode;
2125                         break;
2126                 default:
2127                         return (*sp->vgetparent)(tif, tag, ap);
2128         }
2129         return (1);
2130 }
2131
2132 static void
2133 JPEGPrintDir(TIFF* tif, FILE* fd, long flags)
2134 {
2135         JPEGState* sp = JState(tif);
2136
2137         assert(sp != NULL);
2138         (void) flags;
2139
2140         if( sp != NULL ) {
2141                 if (TIFFFieldSet(tif,FIELD_JPEGTABLES))
2142                         fprintf(fd, "  JPEG Tables: (%lu bytes)\n",
2143                                 (unsigned long) sp->jpegtables_length);
2144                 if (sp->printdir)
2145                         (*sp->printdir)(tif, fd, flags);
2146         }
2147 }
2148
2149 static uint32
2150 JPEGDefaultStripSize(TIFF* tif, uint32 s)
2151 {
2152         JPEGState* sp = JState(tif);
2153         TIFFDirectory *td = &tif->tif_dir;
2154
2155         s = (*sp->defsparent)(tif, s);
2156         if (s < td->td_imagelength)
2157                 s = TIFFroundup_32(s, td->td_ycbcrsubsampling[1] * DCTSIZE);
2158         return (s);
2159 }
2160
2161 static void
2162 JPEGDefaultTileSize(TIFF* tif, uint32* tw, uint32* th)
2163 {
2164         JPEGState* sp = JState(tif);
2165         TIFFDirectory *td = &tif->tif_dir;
2166
2167         (*sp->deftparent)(tif, tw, th);
2168         *tw = TIFFroundup_32(*tw, td->td_ycbcrsubsampling[0] * DCTSIZE);
2169         *th = TIFFroundup_32(*th, td->td_ycbcrsubsampling[1] * DCTSIZE);
2170 }
2171
2172 /*
2173  * The JPEG library initialized used to be done in TIFFInitJPEG(), but
2174  * now that we allow a TIFF file to be opened in update mode it is necessary
2175  * to have some way of deciding whether compression or decompression is
2176  * desired other than looking at tif->tif_mode.  We accomplish this by
2177  * examining {TILE/STRIP}BYTECOUNTS to see if there is a non-zero entry.
2178  * If so, we assume decompression is desired.
2179  *
2180  * This is tricky, because TIFFInitJPEG() is called while the directory is
2181  * being read, and generally speaking the BYTECOUNTS tag won't have been read
2182  * at that point.  So we try to defer jpeg library initialization till we
2183  * do have that tag ... basically any access that might require the compressor
2184  * or decompressor that occurs after the reading of the directory.
2185  *
2186  * In an ideal world compressors or decompressors would be setup
2187  * at the point where a single tile or strip was accessed (for read or write)
2188  * so that stuff like update of missing tiles, or replacement of tiles could
2189  * be done. However, we aren't trying to crack that nut just yet ...
2190  *
2191  * NFW, Feb 3rd, 2003.
2192  */
2193
2194 static int JPEGInitializeLibJPEG( TIFF * tif, int decompress )
2195 {
2196     JPEGState* sp = JState(tif);
2197
2198     if(sp->cinfo_initialized)
2199     {
2200         if( !decompress && sp->cinfo.comm.is_decompressor )
2201             TIFFjpeg_destroy( sp );
2202         else if( decompress && !sp->cinfo.comm.is_decompressor )
2203             TIFFjpeg_destroy( sp );
2204         else
2205             return 1;
2206
2207         sp->cinfo_initialized = 0;
2208     }
2209
2210     /*
2211      * Initialize libjpeg.
2212      */
2213     if ( decompress ) {
2214         if (!TIFFjpeg_create_decompress(sp))
2215             return (0);
2216     } else {
2217         if (!TIFFjpeg_create_compress(sp))
2218             return (0);
2219     }
2220
2221     sp->cinfo_initialized = TRUE;
2222
2223     return 1;
2224 }
2225
2226 int
2227 TIFFInitJPEG(TIFF* tif, int scheme)
2228 {
2229         JPEGState* sp;
2230
2231         assert(scheme == COMPRESSION_JPEG);
2232
2233         /*
2234          * Merge codec-specific tag information.
2235          */
2236         if (!_TIFFMergeFields(tif, jpegFields, TIFFArrayCount(jpegFields))) {
2237                 TIFFErrorExt(tif->tif_clientdata,
2238                              "TIFFInitJPEG",
2239                              "Merging JPEG codec-specific tags failed");
2240                 return 0;
2241         }
2242
2243         /*
2244          * Allocate state block so tag methods have storage to record values.
2245          */
2246         tif->tif_data = (uint8*) _TIFFmalloc(sizeof (JPEGState));
2247
2248         if (tif->tif_data == NULL) {
2249                 TIFFErrorExt(tif->tif_clientdata,
2250                              "TIFFInitJPEG", "No space for JPEG state block");
2251                 return 0;
2252         }
2253         _TIFFmemset(tif->tif_data, 0, sizeof(JPEGState));
2254
2255         sp = JState(tif);
2256         sp->tif = tif;                          /* back link */
2257
2258         /*
2259          * Override parent get/set field methods.
2260          */
2261         sp->vgetparent = tif->tif_tagmethods.vgetfield;
2262         tif->tif_tagmethods.vgetfield = JPEGVGetField; /* hook for codec tags */
2263         sp->vsetparent = tif->tif_tagmethods.vsetfield;
2264         tif->tif_tagmethods.vsetfield = JPEGVSetField; /* hook for codec tags */
2265         sp->printdir = tif->tif_tagmethods.printdir;
2266         tif->tif_tagmethods.printdir = JPEGPrintDir;   /* hook for codec tags */
2267
2268         /* Default values for codec-specific fields */
2269         sp->jpegtables = NULL;
2270         sp->jpegtables_length = 0;
2271         sp->jpegquality = 75;                   /* Default IJG quality */
2272         sp->jpegcolormode = JPEGCOLORMODE_RAW;
2273         sp->jpegtablesmode = JPEGTABLESMODE_QUANT | JPEGTABLESMODE_HUFF;
2274         sp->ycbcrsampling_fetched = 0;
2275
2276         /*
2277          * Install codec methods.
2278          */
2279         tif->tif_fixuptags = JPEGFixupTags;
2280         tif->tif_setupdecode = JPEGSetupDecode;
2281         tif->tif_predecode = JPEGPreDecode;
2282         tif->tif_decoderow = JPEGDecode;
2283         tif->tif_decodestrip = JPEGDecode;
2284         tif->tif_decodetile = JPEGDecode;
2285         tif->tif_setupencode = JPEGSetupEncode;
2286         tif->tif_preencode = JPEGPreEncode;
2287         tif->tif_postencode = JPEGPostEncode;
2288         tif->tif_encoderow = JPEGEncode;
2289         tif->tif_encodestrip = JPEGEncode;
2290         tif->tif_encodetile = JPEGEncode;
2291         tif->tif_cleanup = JPEGCleanup;
2292         sp->defsparent = tif->tif_defstripsize;
2293         tif->tif_defstripsize = JPEGDefaultStripSize;
2294         sp->deftparent = tif->tif_deftilesize;
2295         tif->tif_deftilesize = JPEGDefaultTileSize;
2296         tif->tif_flags |= TIFF_NOBITREV;        /* no bit reversal, please */
2297
2298         sp->cinfo_initialized = FALSE;
2299
2300         /*
2301         ** Create a JPEGTables field if no directory has yet been created.
2302         ** We do this just to ensure that sufficient space is reserved for
2303         ** the JPEGTables field.  It will be properly created the right
2304         ** size later.
2305         */
2306         if( tif->tif_diroff == 0 )
2307         {
2308 #define SIZE_OF_JPEGTABLES 2000
2309 /*
2310 The following line assumes incorrectly that all JPEG-in-TIFF files will have
2311 a JPEGTABLES tag generated and causes null-filled JPEGTABLES tags to be written
2312 when the JPEG data is placed with TIFFWriteRawStrip.  The field bit should be
2313 set, anyway, later when actual JPEGTABLES header is generated, so removing it
2314 here hopefully is harmless.
2315             TIFFSetFieldBit(tif, FIELD_JPEGTABLES);
2316 */
2317             sp->jpegtables_length = SIZE_OF_JPEGTABLES;
2318             sp->jpegtables = (void *) _TIFFmalloc(sp->jpegtables_length);
2319             // FIXME: NULL-deref after malloc failure
2320             _TIFFmemset(sp->jpegtables, 0, SIZE_OF_JPEGTABLES);
2321 #undef SIZE_OF_JPEGTABLES
2322         }
2323
2324         return 1;
2325 }
2326 #endif /* JPEG_SUPPORT */
2327
2328 /* vim: set ts=8 sts=8 sw=8 noet: */
2329
2330 /*
2331  * Local Variables:
2332  * mode: c
2333  * c-basic-offset: 8
2334  * fill-column: 78
2335  * End:
2336  */