thirdparty/libtiff/tif_ojpeg.c

   1 /* $Id: tif_ojpeg.c,v 1.60 2015-05-31 00:38:46 bfriesen Exp $ */
   2
   3 /* WARNING: The type of JPEG encapsulation defined by the TIFF Version 6.0
   4    specification is now totally obsolete and deprecated for new applications and
   5    images. This file was was created solely in order to read unconverted images
   6    still present on some users' computer systems. It will never be extended
   7    to write such files. Writing new-style JPEG compressed TIFFs is implemented
   8    in tif_jpeg.c.
   9
  10    The code is carefully crafted to robustly read all gathered JPEG-in-TIFF
  11    testfiles, and anticipate as much as possible all other... But still, it may
  12    fail on some. If you encounter problems, please report them on the TIFF
  13    mailing list and/or to Joris Van Damme <info@awaresystems.be>.
  14
  15    Please read the file called "TIFF Technical Note #2" if you need to be
  16    convinced this compression scheme is bad and breaks TIFF. That document
  17    is linked to from the LibTiff site <http://www.remotesensing.org/libtiff/>
  18    and from AWare Systems' TIFF section
  19    <http://www.awaresystems.be/imaging/tiff.html>. It is also absorbed
  20    in Adobe's specification supplements, marked "draft" up to this day, but
  21    supported by the TIFF community.
  22
  23    This file interfaces with Release 6B of the JPEG Library written by the
  24    Independent JPEG Group. Previous versions of this file required a hack inside
  25    the LibJpeg library. This version no longer requires that. Remember to
  26    remove the hack if you update from the old version.
  27
  28    Copyright (c) Joris Van Damme <info@awaresystems.be>
  29    Copyright (c) AWare Systems <http://www.awaresystems.be/>
  30
  31    The licence agreement for this file is the same as the rest of the LibTiff
  32    library.
  33
  34    IN NO EVENT SHALL JORIS VAN DAMME OR AWARE SYSTEMS BE LIABLE FOR
  35    ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND,
  36    OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
  37    WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF
  38    LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
  39    OF THIS SOFTWARE.
  40
  41    Joris Van Damme and/or AWare Systems may be available for custom
  42    development. If you like what you see, and need anything similar or related,
  43    contact <info@awaresystems.be>.
  44 */
  45
  46 /* What is what, and what is not?
  47
  48    This decoder starts with an input stream, that is essentially the JpegInterchangeFormat
  49    stream, if any, followed by the strile data, if any. This stream is read in
  50    OJPEGReadByte and related functions.
  51
  52    It analyzes the start of this stream, until it encounters non-marker data, i.e.
  53    compressed image data. Some of the header markers it sees have no actual content,
  54    like the SOI marker, and APP/COM markers that really shouldn't even be there. Some
  55    other markers do have content, and the valuable bits and pieces of information
  56    in these markers are saved, checking all to verify that the stream is more or
  57    less within expected bounds. This happens inside the OJPEGReadHeaderInfoSecStreamXxx
  58    functions.
  59
  60    Some OJPEG imagery contains no valid JPEG header markers. This situation is picked
  61    up on if we've seen no SOF marker when we're at the start of the compressed image
  62    data. In this case, the tables are read from JpegXxxTables tags, and the other
  63    bits and pieces of information is initialized to its most basic value. This is
  64    implemented in the OJPEGReadHeaderInfoSecTablesXxx functions.
  65
  66    When this is complete, a good and valid JPEG header can be assembled, and this is
  67    passed through to LibJpeg. When that's done, the remainder of the input stream, i.e.
  68    the compressed image data, can be passed through unchanged. This is done in
  69    OJPEGWriteStream functions.
  70
  71    LibTiff rightly expects to know the subsampling values before decompression. Just like
  72    in new-style JPEG-in-TIFF, though, or even more so, actually, the YCbCrsubsampling
  73    tag is notoriously unreliable. To correct these tag values with the ones inside
  74    the JPEG stream, the first part of the input stream is pre-scanned in
  75    OJPEGSubsamplingCorrect, making no note of any other data, reporting no warnings
  76    or errors, up to the point where either these values are read, or it's clear they
  77    aren't there. This means that some of the data is read twice, but we feel speed
  78    in correcting these values is important enough to warrant this sacrifice. Allthough
  79    there is currently no define or other configuration mechanism to disable this behaviour,
  80    the actual header scanning is build to robustly respond with error report if it
  81    should encounter an uncorrected mismatch of subsampling values. See
  82    OJPEGReadHeaderInfoSecStreamSof.
  83
  84    The restart interval and restart markers are the most tricky part... The restart
  85    interval can be specified in a tag. It can also be set inside the input JPEG stream.
  86    It can be used inside the input JPEG stream. If reading from strile data, we've
  87    consistenly discovered the need to insert restart markers in between the different
  88    striles, as is also probably the most likely interpretation of the original TIFF 6.0
  89    specification. With all this setting of interval, and actual use of markers that is not
  90    predictable at the time of valid JPEG header assembly, the restart thing may turn
  91    out the Achilles heel of this implementation. Fortunately, most OJPEG writer vendors
  92    succeed in reading back what they write, which may be the reason why we've been able
  93    to discover ways that seem to work.
  94
  95    Some special provision is made for planarconfig separate OJPEG files. These seem
  96    to consistently contain header info, a SOS marker, a plane, SOS marker, plane, SOS,
  97    and plane. This may or may not be a valid JPEG configuration, we don't know and don't
  98    care. We want LibTiff to be able to access the planes individually, without huge
  99    buffering inside LibJpeg, anyway. So we compose headers to feed to LibJpeg, in this
 100    case, that allow us to pass a single plane such that LibJpeg sees a valid
 101    single-channel JPEG stream. Locating subsequent SOS markers, and thus subsequent
 102    planes, is done inside OJPEGReadSecondarySos.
 103
 104    The benefit of the scheme is... that it works, basically. We know of no other that
 105    does. It works without checking software tag, or otherwise going about things in an
 106    OJPEG flavor specific manner. Instead, it is a single scheme, that covers the cases
 107    with and without JpegInterchangeFormat, with and without striles, with part of
 108    the header in JpegInterchangeFormat and remainder in first strile, etc. It is forgiving
 109    and robust, may likely work with OJPEG flavors we've not seen yet, and makes most out
 110    of the data.
 111
 112    Another nice side-effect is that a complete JPEG single valid stream is build if
 113    planarconfig is not separate (vast majority). We may one day use that to build
 114    converters to JPEG, and/or to new-style JPEG compression inside TIFF.
 115
 116    A dissadvantage is the lack of random access to the individual striles. This is the
 117    reason for much of the complicated restart-and-position stuff inside OJPEGPreDecode.
 118    Applications would do well accessing all striles in order, as this will result in
 119    a single sequential scan of the input stream, and no restarting of LibJpeg decoding
 120    session.
 121 */
 122
 123 #define WIN32_LEAN_AND_MEAN
 124 #define VC_EXTRALEAN
 125
 126 #include "tiffiop.h"
 127 #ifdef OJPEG_SUPPORT
 128
 129 /* Configuration defines here are:
 130  * JPEG_ENCAP_EXTERNAL: The normal way to call libjpeg, uses longjump. In some environments,
 131  *      like eg LibTiffDelphi, this is not possible. For this reason, the actual calls to
 132  *      libjpeg, with longjump stuff, are encapsulated in dedicated functions. When
 133  *      JPEG_ENCAP_EXTERNAL is defined, these encapsulating functions are declared external
 134  *      to this unit, and can be defined elsewhere to use stuff other then longjump.
 135  *      The default mode, without JPEG_ENCAP_EXTERNAL, implements the call encapsulators
 136  *      here, internally, with normal longjump.
 137  * SETJMP, LONGJMP, JMP_BUF: On some machines/environments a longjump equivalent is
 138  *      conviniently available, but still it may be worthwhile to use _setjmp or sigsetjmp
 139  *      in place of plain setjmp. These macros will make it easier. It is useless
 140  *      to fiddle with these if you define JPEG_ENCAP_EXTERNAL.
 141  * OJPEG_BUFFER: Define the size of the desired buffer here. Should be small enough so as to guarantee
 142  *      instant processing, optimal streaming and optimal use of processor cache, but also big
 143  *      enough so as to not result in significant call overhead. It should be at least a few
 144  *      bytes to accommodate some structures (this is verified in asserts), but it would not be
 145  *      sensible to make it this small anyway, and it should be at most 64K since it is indexed
 146  *      with uint16. We recommend 2K.
 147  * EGYPTIANWALK: You could also define EGYPTIANWALK here, but it is not used anywhere and has
 148  *      absolutely no effect. That is why most people insist the EGYPTIANWALK is a bit silly.
 149  */
 150
 151 /* define LIBJPEG_ENCAP_EXTERNAL */
 152 #define SETJMP(jbuf) setjmp(jbuf)
 153 #define LONGJMP(jbuf,code) longjmp(jbuf,code)
 154 #define JMP_BUF jmp_buf
 155 #define OJPEG_BUFFER 2048
 156 /* define EGYPTIANWALK */
 157
 158 #define JPEG_MARKER_SOF0 0xC0
 159 #define JPEG_MARKER_SOF1 0xC1
 160 #define JPEG_MARKER_SOF3 0xC3
 161 #define JPEG_MARKER_DHT 0xC4
 162 #define JPEG_MARKER_RST0 0XD0
 163 #define JPEG_MARKER_SOI 0xD8
 164 #define JPEG_MARKER_EOI 0xD9
 165 #define JPEG_MARKER_SOS 0xDA
 166 #define JPEG_MARKER_DQT 0xDB
 167 #define JPEG_MARKER_DRI 0xDD
 168 #define JPEG_MARKER_APP0 0xE0
 169 #define JPEG_MARKER_COM 0xFE
 170
 171 #define FIELD_OJPEG_JPEGINTERCHANGEFORMAT (FIELD_CODEC+0)
 172 #define FIELD_OJPEG_JPEGINTERCHANGEFORMATLENGTH (FIELD_CODEC+1)
 173 #define FIELD_OJPEG_JPEGQTABLES (FIELD_CODEC+2)
 174 #define FIELD_OJPEG_JPEGDCTABLES (FIELD_CODEC+3)
 175 #define FIELD_OJPEG_JPEGACTABLES (FIELD_CODEC+4)
 176 #define FIELD_OJPEG_JPEGPROC (FIELD_CODEC+5)
 177 #define FIELD_OJPEG_JPEGRESTARTINTERVAL (FIELD_CODEC+6)
 178
 179 static const TIFFField ojpegFields[] = {
 180         {TIFFTAG_JPEGIFOFFSET,1,1,TIFF_LONG8,0,TIFF_SETGET_UINT64,TIFF_SETGET_UNDEFINED,FIELD_OJPEG_JPEGINTERCHANGEFORMAT,TRUE,FALSE,"JpegInterchangeFormat",NULL},
 181         {TIFFTAG_JPEGIFBYTECOUNT,1,1,TIFF_LONG8,0,TIFF_SETGET_UINT64,TIFF_SETGET_UNDEFINED,FIELD_OJPEG_JPEGINTERCHANGEFORMATLENGTH,TRUE,FALSE,"JpegInterchangeFormatLength",NULL},
 182         {TIFFTAG_JPEGQTABLES,TIFF_VARIABLE2,TIFF_VARIABLE2,TIFF_LONG8,0,TIFF_SETGET_C32_UINT64,TIFF_SETGET_UNDEFINED,FIELD_OJPEG_JPEGQTABLES,FALSE,TRUE,"JpegQTables",NULL},
 183         {TIFFTAG_JPEGDCTABLES,TIFF_VARIABLE2,TIFF_VARIABLE2,TIFF_LONG8,0,TIFF_SETGET_C32_UINT64,TIFF_SETGET_UNDEFINED,FIELD_OJPEG_JPEGDCTABLES,FALSE,TRUE,"JpegDcTables",NULL},
 184         {TIFFTAG_JPEGACTABLES,TIFF_VARIABLE2,TIFF_VARIABLE2,TIFF_LONG8,0,TIFF_SETGET_C32_UINT64,TIFF_SETGET_UNDEFINED,FIELD_OJPEG_JPEGACTABLES,FALSE,TRUE,"JpegAcTables",NULL},
 185         {TIFFTAG_JPEGPROC,1,1,TIFF_SHORT,0,TIFF_SETGET_UINT16,TIFF_SETGET_UNDEFINED,FIELD_OJPEG_JPEGPROC,FALSE,FALSE,"JpegProc",NULL},
 186         {TIFFTAG_JPEGRESTARTINTERVAL,1,1,TIFF_SHORT,0,TIFF_SETGET_UINT16,TIFF_SETGET_UNDEFINED,FIELD_OJPEG_JPEGRESTARTINTERVAL,FALSE,FALSE,"JpegRestartInterval",NULL},
 187 };
 188
 189 #ifndef LIBJPEG_ENCAP_EXTERNAL
 190 #include <setjmp.h>
 191 #endif
 192
 193 /* We undefine FAR to avoid conflict with JPEG definition */
 194
 195 #ifdef FAR
 196 #undef FAR
 197 #endif
 198
 199 /*
 200   Libjpeg's jmorecfg.h defines INT16 and INT32, but only if XMD_H is
 201   not defined.  Unfortunately, the MinGW and Borland compilers include
 202   a typedef for INT32, which causes a conflict.  MSVC does not include
 203   a conficting typedef given the headers which are included.
 204 */
 205 #if defined(__BORLANDC__) || defined(__MINGW32__)
 206 # define XMD_H 1
 207 #endif
 208
 209 /* Define "boolean" as unsigned char, not int, per Windows custom. */
 210 #if defined(__WIN32__) && !defined(__MINGW32__)
 211 # ifndef __RPCNDR_H__            /* don't conflict if rpcndr.h already read */
 212    typedef unsigned char boolean;
 213 # endif
 214 # define HAVE_BOOLEAN            /* prevent jmorecfg.h from redefining it */
 215 #endif
 216
 217 #include "jpeglib.h"
 218 #include "jerror.h"
 219
 220 typedef struct jpeg_error_mgr jpeg_error_mgr;
 221 typedef struct jpeg_common_struct jpeg_common_struct;
 222 typedef struct jpeg_decompress_struct jpeg_decompress_struct;
 223 typedef struct jpeg_source_mgr jpeg_source_mgr;
 224
 225 typedef enum {
 226         osibsNotSetYet,
 227         osibsJpegInterchangeFormat,
 228         osibsStrile,
 229         osibsEof
 230 } OJPEGStateInBufferSource;
 231
 232 typedef enum {
 233         ososSoi,
 234         ososQTable0,ososQTable1,ososQTable2,ososQTable3,
 235         ososDcTable0,ososDcTable1,ososDcTable2,ososDcTable3,
 236         ososAcTable0,ososAcTable1,ososAcTable2,ososAcTable3,
 237         ososDri,
 238         ososSof,
 239         ososSos,
 240         ososCompressed,
 241         ososRst,
 242         ososEoi
 243 } OJPEGStateOutState;
 244
 245 typedef struct {
 246         TIFF* tif;
 247         #ifndef LIBJPEG_ENCAP_EXTERNAL
 248         JMP_BUF exit_jmpbuf;
 249         #endif
 250         TIFFVGetMethod vgetparent;
 251         TIFFVSetMethod vsetparent;
 252         TIFFPrintMethod printdir;
 253         uint64 file_size;
 254         uint32 image_width;
 255         uint32 image_length;
 256         uint32 strile_width;
 257         uint32 strile_length;
 258         uint32 strile_length_total;
 259         uint8 samples_per_pixel;
 260         uint8 plane_sample_offset;
 261         uint8 samples_per_pixel_per_plane;
 262         uint64 jpeg_interchange_format;
 263         uint64 jpeg_interchange_format_length;
 264         uint8 jpeg_proc;
 265         uint8 subsamplingcorrect;
 266         uint8 subsamplingcorrect_done;
 267         uint8 subsampling_tag;
 268         uint8 subsampling_hor;
 269         uint8 subsampling_ver;
 270         uint8 subsampling_force_desubsampling_inside_decompression;
 271         uint8 qtable_offset_count;
 272         uint8 dctable_offset_count;
 273         uint8 actable_offset_count;
 274         uint64 qtable_offset[3];
 275         uint64 dctable_offset[3];
 276         uint64 actable_offset[3];
 277         uint8* qtable[4];
 278         uint8* dctable[4];
 279         uint8* actable[4];
 280         uint16 restart_interval;
 281         uint8 restart_index;
 282         uint8 sof_log;
 283         uint8 sof_marker_id;
 284         uint32 sof_x;
 285         uint32 sof_y;
 286         uint8 sof_c[3];
 287         uint8 sof_hv[3];
 288         uint8 sof_tq[3];
 289         uint8 sos_cs[3];
 290         uint8 sos_tda[3];
 291         struct {
 292                 uint8 log;
 293                 OJPEGStateInBufferSource in_buffer_source;
 294                 uint32 in_buffer_next_strile;
 295                 uint64 in_buffer_file_pos;
 296                 uint64 in_buffer_file_togo;
 297         } sos_end[3];
 298         uint8 readheader_done;
 299         uint8 writeheader_done;
 300         uint16 write_cursample;
 301         uint32 write_curstrile;
 302         uint8 libjpeg_session_active;
 303         uint8 libjpeg_jpeg_query_style;
 304         jpeg_error_mgr libjpeg_jpeg_error_mgr;
 305         jpeg_decompress_struct libjpeg_jpeg_decompress_struct;
 306         jpeg_source_mgr libjpeg_jpeg_source_mgr;
 307         uint8 subsampling_convert_log;
 308         uint32 subsampling_convert_ylinelen;
 309         uint32 subsampling_convert_ylines;
 310         uint32 subsampling_convert_clinelen;
 311         uint32 subsampling_convert_clines;
 312         uint32 subsampling_convert_ybuflen;
 313         uint32 subsampling_convert_cbuflen;
 314         uint32 subsampling_convert_ycbcrbuflen;
 315         uint8* subsampling_convert_ycbcrbuf;
 316         uint8* subsampling_convert_ybuf;
 317         uint8* subsampling_convert_cbbuf;
 318         uint8* subsampling_convert_crbuf;
 319         uint32 subsampling_convert_ycbcrimagelen;
 320         uint8** subsampling_convert_ycbcrimage;
 321         uint32 subsampling_convert_clinelenout;
 322         uint32 subsampling_convert_state;
 323         uint32 bytes_per_line;   /* if the codec outputs subsampled data, a 'line' in bytes_per_line */
 324         uint32 lines_per_strile; /* and lines_per_strile means subsampling_ver desubsampled rows     */
 325         OJPEGStateInBufferSource in_buffer_source;
 326         uint32 in_buffer_next_strile;
 327         uint32 in_buffer_strile_count;
 328         uint64 in_buffer_file_pos;
 329         uint8 in_buffer_file_pos_log;
 330         uint64 in_buffer_file_togo;
 331         uint16 in_buffer_togo;
 332         uint8* in_buffer_cur;
 333         uint8 in_buffer[OJPEG_BUFFER];
 334         OJPEGStateOutState out_state;
 335         uint8 out_buffer[OJPEG_BUFFER];
 336         uint8* skip_buffer;
 337 } OJPEGState;
 338
 339 static int OJPEGVGetField(TIFF* tif, uint32 tag, va_list ap);
 340 static int OJPEGVSetField(TIFF* tif, uint32 tag, va_list ap);
 341 static void OJPEGPrintDir(TIFF* tif, FILE* fd, long flags);
 342
 343 static int OJPEGFixupTags(TIFF* tif);
 344 static int OJPEGSetupDecode(TIFF* tif);
 345 static int OJPEGPreDecode(TIFF* tif, uint16 s);
 346 static int OJPEGPreDecodeSkipRaw(TIFF* tif);
 347 static int OJPEGPreDecodeSkipScanlines(TIFF* tif);
 348 static int OJPEGDecode(TIFF* tif, uint8* buf, tmsize_t cc, uint16 s);
 349 static int OJPEGDecodeRaw(TIFF* tif, uint8* buf, tmsize_t cc);
 350 static int OJPEGDecodeScanlines(TIFF* tif, uint8* buf, tmsize_t cc);
 351 static void OJPEGPostDecode(TIFF* tif, uint8* buf, tmsize_t cc);
 352 static int OJPEGSetupEncode(TIFF* tif);
 353 static int OJPEGPreEncode(TIFF* tif, uint16 s);
 354 static int OJPEGEncode(TIFF* tif, uint8* buf, tmsize_t cc, uint16 s);
 355 static int OJPEGPostEncode(TIFF* tif);
 356 static void OJPEGCleanup(TIFF* tif);
 357
 358 static void OJPEGSubsamplingCorrect(TIFF* tif);
 359 static int OJPEGReadHeaderInfo(TIFF* tif);
 360 static int OJPEGReadSecondarySos(TIFF* tif, uint16 s);
 361 static int OJPEGWriteHeaderInfo(TIFF* tif);
 362 static void OJPEGLibjpegSessionAbort(TIFF* tif);
 363
 364 static int OJPEGReadHeaderInfoSec(TIFF* tif);
 365 static int OJPEGReadHeaderInfoSecStreamDri(TIFF* tif);
 366 static int OJPEGReadHeaderInfoSecStreamDqt(TIFF* tif);
 367 static int OJPEGReadHeaderInfoSecStreamDht(TIFF* tif);
 368 static int OJPEGReadHeaderInfoSecStreamSof(TIFF* tif, uint8 marker_id);
 369 static int OJPEGReadHeaderInfoSecStreamSos(TIFF* tif);
 370 static int OJPEGReadHeaderInfoSecTablesQTable(TIFF* tif);
 371 static int OJPEGReadHeaderInfoSecTablesDcTable(TIFF* tif);
 372 static int OJPEGReadHeaderInfoSecTablesAcTable(TIFF* tif);
 373
 374 static int OJPEGReadBufferFill(OJPEGState* sp);
 375 static int OJPEGReadByte(OJPEGState* sp, uint8* byte);
 376 static int OJPEGReadBytePeek(OJPEGState* sp, uint8* byte);
 377 static void OJPEGReadByteAdvance(OJPEGState* sp);
 378 static int OJPEGReadWord(OJPEGState* sp, uint16* word);
 379 static int OJPEGReadBlock(OJPEGState* sp, uint16 len, void* mem);
 380 static void OJPEGReadSkip(OJPEGState* sp, uint16 len);
 381
 382 static int OJPEGWriteStream(TIFF* tif, void** mem, uint32* len);
 383 static void OJPEGWriteStreamSoi(TIFF* tif, void** mem, uint32* len);
 384 static void OJPEGWriteStreamQTable(TIFF* tif, uint8 table_index, void** mem, uint32* len);
 385 static void OJPEGWriteStreamDcTable(TIFF* tif, uint8 table_index, void** mem, uint32* len);
 386 static void OJPEGWriteStreamAcTable(TIFF* tif, uint8 table_index, void** mem, uint32* len);
 387 static void OJPEGWriteStreamDri(TIFF* tif, void** mem, uint32* len);
 388 static void OJPEGWriteStreamSof(TIFF* tif, void** mem, uint32* len);
 389 static void OJPEGWriteStreamSos(TIFF* tif, void** mem, uint32* len);
 390 static int OJPEGWriteStreamCompressed(TIFF* tif, void** mem, uint32* len);
 391 static void OJPEGWriteStreamRst(TIFF* tif, void** mem, uint32* len);
 392 static void OJPEGWriteStreamEoi(TIFF* tif, void** mem, uint32* len);
 393
 394 #ifdef LIBJPEG_ENCAP_EXTERNAL
 395 extern int jpeg_create_decompress_encap(OJPEGState* sp, jpeg_decompress_struct* cinfo);
 396 extern int jpeg_read_header_encap(OJPEGState* sp, jpeg_decompress_struct* cinfo, uint8 require_image);
 397 extern int jpeg_start_decompress_encap(OJPEGState* sp, jpeg_decompress_struct* cinfo);
 398 extern int jpeg_read_scanlines_encap(OJPEGState* sp, jpeg_decompress_struct* cinfo, void* scanlines, uint32 max_lines);
 399 extern int jpeg_read_raw_data_encap(OJPEGState* sp, jpeg_decompress_struct* cinfo, void* data, uint32 max_lines);
 400 extern void jpeg_encap_unwind(TIFF* tif);
 401 #else
 402 static int jpeg_create_decompress_encap(OJPEGState* sp, jpeg_decompress_struct* j);
 403 static int jpeg_read_header_encap(OJPEGState* sp, jpeg_decompress_struct* cinfo, uint8 require_image);
 404 static int jpeg_start_decompress_encap(OJPEGState* sp, jpeg_decompress_struct* cinfo);
 405 static int jpeg_read_scanlines_encap(OJPEGState* sp, jpeg_decompress_struct* cinfo, void* scanlines, uint32 max_lines);
 406 static int jpeg_read_raw_data_encap(OJPEGState* sp, jpeg_decompress_struct* cinfo, void* data, uint32 max_lines);
 407 static void jpeg_encap_unwind(TIFF* tif);
 408 #endif
 409
 410 static void OJPEGLibjpegJpegErrorMgrOutputMessage(jpeg_common_struct* cinfo);
 411 static void OJPEGLibjpegJpegErrorMgrErrorExit(jpeg_common_struct* cinfo);
 412 static void OJPEGLibjpegJpegSourceMgrInitSource(jpeg_decompress_struct* cinfo);
 413 static boolean OJPEGLibjpegJpegSourceMgrFillInputBuffer(jpeg_decompress_struct* cinfo);
 414 static void OJPEGLibjpegJpegSourceMgrSkipInputData(jpeg_decompress_struct* cinfo, long num_bytes);
 415 static boolean OJPEGLibjpegJpegSourceMgrResyncToRestart(jpeg_decompress_struct* cinfo, int desired);
 416 static void OJPEGLibjpegJpegSourceMgrTermSource(jpeg_decompress_struct* cinfo);
 417
 418 int
 419 TIFFInitOJPEG(TIFF* tif, int scheme)
 420 {
 421         static const char module[]="TIFFInitOJPEG";
 422         OJPEGState* sp;
 423
 424         assert(scheme==COMPRESSION_OJPEG);
 425
 426         /*
 427          * Merge codec-specific tag information.
 428          */
 429         if (!_TIFFMergeFields(tif, ojpegFields, TIFFArrayCount(ojpegFields))) {
 430                 TIFFErrorExt(tif->tif_clientdata, module,
 431                     "Merging Old JPEG codec-specific tags failed");
 432                 return 0;
 433         }
 434
 435         /* state block */
 436         sp=_TIFFmalloc(sizeof(OJPEGState));
 437         if (sp==NULL)
 438         {
 439                 TIFFErrorExt(tif->tif_clientdata,module,"No space for OJPEG state block");
 440                 return(0);
 441         }
 442         _TIFFmemset(sp,0,sizeof(OJPEGState));
 443         sp->tif=tif;
 444         sp->jpeg_proc=1;
 445         sp->subsampling_hor=2;
 446         sp->subsampling_ver=2;
 447         TIFFSetField(tif,TIFFTAG_YCBCRSUBSAMPLING,2,2);
 448         /* tif codec methods */
 449         tif->tif_fixuptags=OJPEGFixupTags;
 450         tif->tif_setupdecode=OJPEGSetupDecode;
 451         tif->tif_predecode=OJPEGPreDecode;
 452         tif->tif_postdecode=OJPEGPostDecode;
 453         tif->tif_decoderow=OJPEGDecode;
 454         tif->tif_decodestrip=OJPEGDecode;
 455         tif->tif_decodetile=OJPEGDecode;
 456         tif->tif_setupencode=OJPEGSetupEncode;
 457         tif->tif_preencode=OJPEGPreEncode;
 458         tif->tif_postencode=OJPEGPostEncode;
 459         tif->tif_encoderow=OJPEGEncode;
 460         tif->tif_encodestrip=OJPEGEncode;
 461         tif->tif_encodetile=OJPEGEncode;
 462         tif->tif_cleanup=OJPEGCleanup;
 463         tif->tif_data=(uint8*)sp;
 464         /* tif tag methods */
 465         sp->vgetparent=tif->tif_tagmethods.vgetfield;
 466         tif->tif_tagmethods.vgetfield=OJPEGVGetField;
 467         sp->vsetparent=tif->tif_tagmethods.vsetfield;
 468         tif->tif_tagmethods.vsetfield=OJPEGVSetField;
 469         sp->printdir=tif->tif_tagmethods.printdir;
 470         tif->tif_tagmethods.printdir=OJPEGPrintDir;
 471         /* Some OJPEG files don't have strip or tile offsets or bytecounts tags.
 472            Some others do, but have totally meaningless or corrupt values
 473            in these tags. In these cases, the JpegInterchangeFormat stream is
 474            reliable. In any case, this decoder reads the compressed data itself,
 475            from the most reliable locations, and we need to notify encapsulating
 476            LibTiff not to read raw strips or tiles for us. */
 477         tif->tif_flags|=TIFF_NOREADRAW;
 478         return(1);
 479 }
 480
 481 static int
 482 OJPEGVGetField(TIFF* tif, uint32 tag, va_list ap)
 483 {
 484         OJPEGState* sp=(OJPEGState*)tif->tif_data;
 485         switch(tag)
 486         {
 487                 case TIFFTAG_JPEGIFOFFSET:
 488                         *va_arg(ap,uint64*)=(uint64)sp->jpeg_interchange_format;
 489                         break;
 490                 case TIFFTAG_JPEGIFBYTECOUNT:
 491                         *va_arg(ap,uint64*)=(uint64)sp->jpeg_interchange_format_length;
 492                         break;
 493                 case TIFFTAG_YCBCRSUBSAMPLING:
 494                         if (sp->subsamplingcorrect_done==0)
 495                                 OJPEGSubsamplingCorrect(tif);
 496                         *va_arg(ap,uint16*)=(uint16)sp->subsampling_hor;
 497                         *va_arg(ap,uint16*)=(uint16)sp->subsampling_ver;
 498                         break;
 499                 case TIFFTAG_JPEGQTABLES:
 500                         *va_arg(ap,uint32*)=(uint32)sp->qtable_offset_count;
 501                         *va_arg(ap,void**)=(void*)sp->qtable_offset;
 502                         break;
 503                 case TIFFTAG_JPEGDCTABLES:
 504                         *va_arg(ap,uint32*)=(uint32)sp->dctable_offset_count;
 505                         *va_arg(ap,void**)=(void*)sp->dctable_offset;
 506                         break;
 507                 case TIFFTAG_JPEGACTABLES:
 508                         *va_arg(ap,uint32*)=(uint32)sp->actable_offset_count;
 509                         *va_arg(ap,void**)=(void*)sp->actable_offset;
 510                         break;
 511                 case TIFFTAG_JPEGPROC:
 512                         *va_arg(ap,uint16*)=(uint16)sp->jpeg_proc;
 513                         break;
 514                 case TIFFTAG_JPEGRESTARTINTERVAL:
 515                         *va_arg(ap,uint16*)=sp->restart_interval;
 516                         break;
 517                 default:
 518                         return (*sp->vgetparent)(tif,tag,ap);
 519         }
 520         return (1);
 521 }
 522
 523 static int
 524 OJPEGVSetField(TIFF* tif, uint32 tag, va_list ap)
 525 {
 526         static const char module[]="OJPEGVSetField";
 527         OJPEGState* sp=(OJPEGState*)tif->tif_data;
 528         uint32 ma;
 529         uint64* mb;
 530         uint32 n;
 531         const TIFFField* fip;
 532
 533         switch(tag)
 534         {
 535                 case TIFFTAG_JPEGIFOFFSET:
 536                         sp->jpeg_interchange_format=(uint64)va_arg(ap,uint64);
 537                         break;
 538                 case TIFFTAG_JPEGIFBYTECOUNT:
 539                         sp->jpeg_interchange_format_length=(uint64)va_arg(ap,uint64);
 540                         break;
 541                 case TIFFTAG_YCBCRSUBSAMPLING:
 542                         sp->subsampling_tag=1;
 543                         sp->subsampling_hor=(uint8)va_arg(ap,uint16_vap);
 544                         sp->subsampling_ver=(uint8)va_arg(ap,uint16_vap);
 545                         tif->tif_dir.td_ycbcrsubsampling[0]=sp->subsampling_hor;
 546                         tif->tif_dir.td_ycbcrsubsampling[1]=sp->subsampling_ver;
 547                         break;
 548                 case TIFFTAG_JPEGQTABLES:
 549                         ma=(uint32)va_arg(ap,uint32);
 550                         if (ma!=0)
 551                         {
 552                                 if (ma>3)
 553                                 {
 554                                         TIFFErrorExt(tif->tif_clientdata,module,"JpegQTables tag has incorrect count");
 555                                         return(0);
 556                                 }
 557                                 sp->qtable_offset_count=(uint8)ma;
 558                                 mb=(uint64*)va_arg(ap,uint64*);
 559                                 for (n=0; n<ma; n++)
 560                                         sp->qtable_offset[n]=mb[n];
 561                         }
 562                         break;
 563                 case TIFFTAG_JPEGDCTABLES:
 564                         ma=(uint32)va_arg(ap,uint32);
 565                         if (ma!=0)
 566                         {
 567                                 if (ma>3)
 568                                 {
 569                                         TIFFErrorExt(tif->tif_clientdata,module,"JpegDcTables tag has incorrect count");
 570                                         return(0);
 571                                 }
 572                                 sp->dctable_offset_count=(uint8)ma;
 573                                 mb=(uint64*)va_arg(ap,uint64*);
 574                                 for (n=0; n<ma; n++)
 575                                         sp->dctable_offset[n]=mb[n];
 576                         }
 577                         break;
 578                 case TIFFTAG_JPEGACTABLES:
 579                         ma=(uint32)va_arg(ap,uint32);
 580                         if (ma!=0)
 581                         {
 582                                 if (ma>3)
 583                                 {
 584                                         TIFFErrorExt(tif->tif_clientdata,module,"JpegAcTables tag has incorrect count");
 585                                         return(0);
 586                                 }
 587                                 sp->actable_offset_count=(uint8)ma;
 588                                 mb=(uint64*)va_arg(ap,uint64*);
 589                                 for (n=0; n<ma; n++)
 590                                         sp->actable_offset[n]=mb[n];
 591                         }
 592                         break;
 593                 case TIFFTAG_JPEGPROC:
 594                         sp->jpeg_proc=(uint8)va_arg(ap,uint16_vap);
 595                         break;
 596                 case TIFFTAG_JPEGRESTARTINTERVAL:
 597                         sp->restart_interval=(uint16)va_arg(ap,uint16_vap);
 598                         break;
 599                 default:
 600                         return (*sp->vsetparent)(tif,tag,ap);
 601         }
 602         fip = TIFFFieldWithTag(tif,tag);
 603         if( fip == NULL ) /* shouldn't happen */
 604             return(0);
 605         TIFFSetFieldBit(tif,fip->field_bit);
 606         tif->tif_flags|=TIFF_DIRTYDIRECT;
 607         return(1);
 608 }
 609
 610 static void
 611 OJPEGPrintDir(TIFF* tif, FILE* fd, long flags)
 612 {
 613         OJPEGState* sp=(OJPEGState*)tif->tif_data;
 614         uint8 m;
 615         (void)flags;
 616         assert(sp!=NULL);
 617         if (TIFFFieldSet(tif,FIELD_OJPEG_JPEGINTERCHANGEFORMAT))
 618                 fprintf(fd,"  JpegInterchangeFormat: " TIFF_UINT64_FORMAT "\n",(TIFF_UINT64_T)sp->jpeg_interchange_format);
 619         if (TIFFFieldSet(tif,FIELD_OJPEG_JPEGINTERCHANGEFORMATLENGTH))
 620                 fprintf(fd,"  JpegInterchangeFormatLength: " TIFF_UINT64_FORMAT "\n",(TIFF_UINT64_T)sp->jpeg_interchange_format_length);
 621         if (TIFFFieldSet(tif,FIELD_OJPEG_JPEGQTABLES))
 622         {
 623                 fprintf(fd,"  JpegQTables:");
 624                 for (m=0; m<sp->qtable_offset_count; m++)
 625                         fprintf(fd," " TIFF_UINT64_FORMAT,(TIFF_UINT64_T)sp->qtable_offset[m]);
 626                 fprintf(fd,"\n");
 627         }
 628         if (TIFFFieldSet(tif,FIELD_OJPEG_JPEGDCTABLES))
 629         {
 630                 fprintf(fd,"  JpegDcTables:");
 631                 for (m=0; m<sp->dctable_offset_count; m++)
 632                         fprintf(fd," " TIFF_UINT64_FORMAT,(TIFF_UINT64_T)sp->dctable_offset[m]);
 633                 fprintf(fd,"\n");
 634         }
 635         if (TIFFFieldSet(tif,FIELD_OJPEG_JPEGACTABLES))
 636         {
 637                 fprintf(fd,"  JpegAcTables:");
 638                 for (m=0; m<sp->actable_offset_count; m++)
 639                         fprintf(fd," " TIFF_UINT64_FORMAT,(TIFF_UINT64_T)sp->actable_offset[m]);
 640                 fprintf(fd,"\n");
 641         }
 642         if (TIFFFieldSet(tif,FIELD_OJPEG_JPEGPROC))
 643                 fprintf(fd,"  JpegProc: %u\n",(unsigned int)sp->jpeg_proc);
 644         if (TIFFFieldSet(tif,FIELD_OJPEG_JPEGRESTARTINTERVAL))
 645                 fprintf(fd,"  JpegRestartInterval: %u\n",(unsigned int)sp->restart_interval);
 646         if (sp->printdir)
 647                 (*sp->printdir)(tif, fd, flags);
 648 }
 649
 650 static int
 651 OJPEGFixupTags(TIFF* tif)
 652 {
 653         (void) tif;
 654         return(1);
 655 }
 656
 657 static int
 658 OJPEGSetupDecode(TIFF* tif)
 659 {
 660         static const char module[]="OJPEGSetupDecode";
 661         TIFFWarningExt(tif->tif_clientdata,module,"Depreciated and troublesome old-style JPEG compression mode, please convert to new-style JPEG compression and notify vendor of writing software");
 662         return(1);
 663 }
 664
 665 static int
 666 OJPEGPreDecode(TIFF* tif, uint16 s)
 667 {
 668         OJPEGState* sp=(OJPEGState*)tif->tif_data;
 669         uint32 m;
 670         if (sp->subsamplingcorrect_done==0)
 671                 OJPEGSubsamplingCorrect(tif);
 672         if (sp->readheader_done==0)
 673         {
 674                 if (OJPEGReadHeaderInfo(tif)==0)
 675                         return(0);
 676         }
 677         if (sp->sos_end[s].log==0)
 678         {
 679                 if (OJPEGReadSecondarySos(tif,s)==0)
 680                         return(0);
 681         }
 682         if isTiled(tif)
 683                 m=tif->tif_curtile;
 684         else
 685                 m=tif->tif_curstrip;
 686         if ((sp->writeheader_done!=0) && ((sp->write_cursample!=s) || (sp->write_curstrile>m)))
 687         {
 688                 if (sp->libjpeg_session_active!=0)
 689                         OJPEGLibjpegSessionAbort(tif);
 690                 sp->writeheader_done=0;
 691         }
 692         if (sp->writeheader_done==0)
 693         {
 694                 sp->plane_sample_offset=(uint8)s;
 695                 sp->write_cursample=s;
 696                 sp->write_curstrile=s*tif->tif_dir.td_stripsperimage;
 697                 if ((sp->in_buffer_file_pos_log==0) ||
 698                     (sp->in_buffer_file_pos-sp->in_buffer_togo!=sp->sos_end[s].in_buffer_file_pos))
 699                 {
 700                         sp->in_buffer_source=sp->sos_end[s].in_buffer_source;
 701                         sp->in_buffer_next_strile=sp->sos_end[s].in_buffer_next_strile;
 702                         sp->in_buffer_file_pos=sp->sos_end[s].in_buffer_file_pos;
 703                         sp->in_buffer_file_pos_log=0;
 704                         sp->in_buffer_file_togo=sp->sos_end[s].in_buffer_file_togo;
 705                         sp->in_buffer_togo=0;
 706                         sp->in_buffer_cur=0;
 707                 }
 708                 if (OJPEGWriteHeaderInfo(tif)==0)
 709                         return(0);
 710         }
 711         while (sp->write_curstrile<m)
 712         {
 713                 if (sp->libjpeg_jpeg_query_style==0)
 714                 {
 715                         if (OJPEGPreDecodeSkipRaw(tif)==0)
 716                                 return(0);
 717                 }
 718                 else
 719                 {
 720                         if (OJPEGPreDecodeSkipScanlines(tif)==0)
 721                                 return(0);
 722                 }
 723                 sp->write_curstrile++;
 724         }
 725         return(1);
 726 }
 727
 728 static int
 729 OJPEGPreDecodeSkipRaw(TIFF* tif)
 730 {
 731         OJPEGState* sp=(OJPEGState*)tif->tif_data;
 732         uint32 m;
 733         m=sp->lines_per_strile;
 734         if (sp->subsampling_convert_state!=0)
 735         {
 736                 if (sp->subsampling_convert_clines-sp->subsampling_convert_state>=m)
 737                 {
 738                         sp->subsampling_convert_state+=m;
 739                         if (sp->subsampling_convert_state==sp->subsampling_convert_clines)
 740                                 sp->subsampling_convert_state=0;
 741                         return(1);
 742                 }
 743                 m-=sp->subsampling_convert_clines-sp->subsampling_convert_state;
 744                 sp->subsampling_convert_state=0;
 745         }
 746         while (m>=sp->subsampling_convert_clines)
 747         {
 748                 if (jpeg_read_raw_data_encap(sp,&(sp->libjpeg_jpeg_decompress_struct),sp->subsampling_convert_ycbcrimage,sp->subsampling_ver*8)==0)
 749                         return(0);
 750                 m-=sp->subsampling_convert_clines;
 751         }
 752         if (m>0)
 753         {
 754                 if (jpeg_read_raw_data_encap(sp,&(sp->libjpeg_jpeg_decompress_struct),sp->subsampling_convert_ycbcrimage,sp->subsampling_ver*8)==0)
 755                         return(0);
 756                 sp->subsampling_convert_state=m;
 757         }
 758         return(1);
 759 }
 760
 761 static int
 762 OJPEGPreDecodeSkipScanlines(TIFF* tif)
 763 {
 764         static const char module[]="OJPEGPreDecodeSkipScanlines";
 765         OJPEGState* sp=(OJPEGState*)tif->tif_data;
 766         uint32 m;
 767         if (sp->skip_buffer==NULL)
 768         {
 769                 sp->skip_buffer=_TIFFmalloc(sp->bytes_per_line);
 770                 if (sp->skip_buffer==NULL)
 771                 {
 772                         TIFFErrorExt(tif->tif_clientdata,module,"Out of memory");
 773                         return(0);
 774                 }
 775         }
 776         for (m=0; m<sp->lines_per_strile; m++)
 777         {
 778                 if (jpeg_read_scanlines_encap(sp,&(sp->libjpeg_jpeg_decompress_struct),&sp->skip_buffer,1)==0)
 779                         return(0);
 780         }
 781         return(1);
 782 }
 783
 784 static int
 785 OJPEGDecode(TIFF* tif, uint8* buf, tmsize_t cc, uint16 s)
 786 {
 787         OJPEGState* sp=(OJPEGState*)tif->tif_data;
 788         (void)s;
 789         if (sp->libjpeg_jpeg_query_style==0)
 790         {
 791                 if (OJPEGDecodeRaw(tif,buf,cc)==0)
 792                         return(0);
 793         }
 794         else
 795         {
 796                 if (OJPEGDecodeScanlines(tif,buf,cc)==0)
 797                         return(0);
 798         }
 799         return(1);
 800 }
 801
 802 static int
 803 OJPEGDecodeRaw(TIFF* tif, uint8* buf, tmsize_t cc)
 804 {
 805         static const char module[]="OJPEGDecodeRaw";
 806         OJPEGState* sp=(OJPEGState*)tif->tif_data;
 807         uint8* m;
 808         tmsize_t n;
 809         uint8* oy;
 810         uint8* ocb;
 811         uint8* ocr;
 812         uint8* p;
 813         uint32 q;
 814         uint8* r;
 815         uint8 sx,sy;
 816         if (cc%sp->bytes_per_line!=0)
 817         {
 818                 TIFFErrorExt(tif->tif_clientdata,module,"Fractional scanline not read");
 819                 return(0);
 820         }
 821         assert(cc>0);
 822         m=buf;
 823         n=cc;
 824         do
 825         {
 826                 if (sp->subsampling_convert_state==0)
 827                 {
 828                         if (jpeg_read_raw_data_encap(sp,&(sp->libjpeg_jpeg_decompress_struct),sp->subsampling_convert_ycbcrimage,sp->subsampling_ver*8)==0)
 829                                 return(0);
 830                 }
 831                 oy=sp->subsampling_convert_ybuf+sp->subsampling_convert_state*sp->subsampling_ver*sp->subsampling_convert_ylinelen;
 832                 ocb=sp->subsampling_convert_cbbuf+sp->subsampling_convert_state*sp->subsampling_convert_clinelen;
 833                 ocr=sp->subsampling_convert_crbuf+sp->subsampling_convert_state*sp->subsampling_convert_clinelen;
 834                 p=m;
 835                 for (q=0; q<sp->subsampling_convert_clinelenout; q++)
 836                 {
 837                         r=oy;
 838                         for (sy=0; sy<sp->subsampling_ver; sy++)
 839                         {
 840                                 for (sx=0; sx<sp->subsampling_hor; sx++)
 841                                         *p++=*r++;
 842                                 r+=sp->subsampling_convert_ylinelen-sp->subsampling_hor;
 843                         }
 844                         oy+=sp->subsampling_hor;
 845                         *p++=*ocb++;
 846                         *p++=*ocr++;
 847                 }
 848                 sp->subsampling_convert_state++;
 849                 if (sp->subsampling_convert_state==sp->subsampling_convert_clines)
 850                         sp->subsampling_convert_state=0;
 851                 m+=sp->bytes_per_line;
 852                 n-=sp->bytes_per_line;
 853         } while(n>0);
 854         return(1);
 855 }
 856
 857 static int
 858 OJPEGDecodeScanlines(TIFF* tif, uint8* buf, tmsize_t cc)
 859 {
 860         static const char module[]="OJPEGDecodeScanlines";
 861         OJPEGState* sp=(OJPEGState*)tif->tif_data;
 862         uint8* m;
 863         tmsize_t n;
 864         if (cc%sp->bytes_per_line!=0)
 865         {
 866                 TIFFErrorExt(tif->tif_clientdata,module,"Fractional scanline not read");
 867                 return(0);
 868         }
 869         assert(cc>0);
 870         m=buf;
 871         n=cc;
 872         do
 873         {
 874                 if (jpeg_read_scanlines_encap(sp,&(sp->libjpeg_jpeg_decompress_struct),&m,1)==0)
 875                         return(0);
 876                 m+=sp->bytes_per_line;
 877                 n-=sp->bytes_per_line;
 878         } while(n>0);
 879         return(1);
 880 }
 881
 882 static void
 883 OJPEGPostDecode(TIFF* tif, uint8* buf, tmsize_t cc)
 884 {
 885         OJPEGState* sp=(OJPEGState*)tif->tif_data;
 886         (void)buf;
 887         (void)cc;
 888         sp->write_curstrile++;
 889         if (sp->write_curstrile%tif->tif_dir.td_stripsperimage==0)
 890         {
 891                 assert(sp->libjpeg_session_active!=0);
 892                 OJPEGLibjpegSessionAbort(tif);
 893                 sp->writeheader_done=0;
 894         }
 895 }
 896
 897 static int
 898 OJPEGSetupEncode(TIFF* tif)
 899 {
 900         static const char module[]="OJPEGSetupEncode";
 901         TIFFErrorExt(tif->tif_clientdata,module,"OJPEG encoding not supported; use new-style JPEG compression instead");
 902         return(0);
 903 }
 904
 905 static int
 906 OJPEGPreEncode(TIFF* tif, uint16 s)
 907 {
 908         static const char module[]="OJPEGPreEncode";
 909         (void)s;
 910         TIFFErrorExt(tif->tif_clientdata,module,"OJPEG encoding not supported; use new-style JPEG compression instead");
 911         return(0);
 912 }
 913
 914 static int
 915 OJPEGEncode(TIFF* tif, uint8* buf, tmsize_t cc, uint16 s)
 916 {
 917         static const char module[]="OJPEGEncode";
 918         (void)buf;
 919         (void)cc;
 920         (void)s;
 921         TIFFErrorExt(tif->tif_clientdata,module,"OJPEG encoding not supported; use new-style JPEG compression instead");
 922         return(0);
 923 }
 924
 925 static int
 926 OJPEGPostEncode(TIFF* tif)
 927 {
 928         static const char module[]="OJPEGPostEncode";
 929         TIFFErrorExt(tif->tif_clientdata,module,"OJPEG encoding not supported; use new-style JPEG compression instead");
 930         return(0);
 931 }
 932
 933 static void
 934 OJPEGCleanup(TIFF* tif)
 935 {
 936         OJPEGState* sp=(OJPEGState*)tif->tif_data;
 937         if (sp!=0)
 938         {
 939                 tif->tif_tagmethods.vgetfield=sp->vgetparent;
 940                 tif->tif_tagmethods.vsetfield=sp->vsetparent;
 941                 tif->tif_tagmethods.printdir=sp->printdir;
 942                 if (sp->qtable[0]!=0)
 943                         _TIFFfree(sp->qtable[0]);
 944                 if (sp->qtable[1]!=0)
 945                         _TIFFfree(sp->qtable[1]);
 946                 if (sp->qtable[2]!=0)
 947                         _TIFFfree(sp->qtable[2]);
 948                 if (sp->qtable[3]!=0)
 949                         _TIFFfree(sp->qtable[3]);
 950                 if (sp->dctable[0]!=0)
 951                         _TIFFfree(sp->dctable[0]);
 952                 if (sp->dctable[1]!=0)
 953                         _TIFFfree(sp->dctable[1]);
 954                 if (sp->dctable[2]!=0)
 955                         _TIFFfree(sp->dctable[2]);
 956                 if (sp->dctable[3]!=0)
 957                         _TIFFfree(sp->dctable[3]);
 958                 if (sp->actable[0]!=0)
 959                         _TIFFfree(sp->actable[0]);
 960                 if (sp->actable[1]!=0)
 961                         _TIFFfree(sp->actable[1]);
 962                 if (sp->actable[2]!=0)
 963                         _TIFFfree(sp->actable[2]);
 964                 if (sp->actable[3]!=0)
 965                         _TIFFfree(sp->actable[3]);
 966                 if (sp->libjpeg_session_active!=0)
 967                         OJPEGLibjpegSessionAbort(tif);
 968                 if (sp->subsampling_convert_ycbcrbuf!=0)
 969                         _TIFFfree(sp->subsampling_convert_ycbcrbuf);
 970                 if (sp->subsampling_convert_ycbcrimage!=0)
 971                         _TIFFfree(sp->subsampling_convert_ycbcrimage);
 972                 if (sp->skip_buffer!=0)
 973                         _TIFFfree(sp->skip_buffer);
 974                 _TIFFfree(sp);
 975                 tif->tif_data=NULL;
 976                 _TIFFSetDefaultCompressionState(tif);
 977         }
 978 }
 979
 980 static void
 981 OJPEGSubsamplingCorrect(TIFF* tif)
 982 {
 983         static const char module[]="OJPEGSubsamplingCorrect";
 984         OJPEGState* sp=(OJPEGState*)tif->tif_data;
 985         uint8 mh;
 986         uint8 mv;
 987         _TIFFFillStriles( tif );
 988
 989         assert(sp->subsamplingcorrect_done==0);
 990         if ((tif->tif_dir.td_samplesperpixel!=3) || ((tif->tif_dir.td_photometric!=PHOTOMETRIC_YCBCR) &&
 991             (tif->tif_dir.td_photometric!=PHOTOMETRIC_ITULAB)))
 992         {
 993                 if (sp->subsampling_tag!=0)
 994                         TIFFWarningExt(tif->tif_clientdata,module,"Subsampling tag not appropriate for this Photometric and/or SamplesPerPixel");
 995                 sp->subsampling_hor=1;
 996                 sp->subsampling_ver=1;
 997                 sp->subsampling_force_desubsampling_inside_decompression=0;
 998         }
 999         else
1000         {
1001                 sp->subsamplingcorrect_done=1;
1002                 mh=sp->subsampling_hor;
1003                 mv=sp->subsampling_ver;
1004                 sp->subsamplingcorrect=1;
1005                 OJPEGReadHeaderInfoSec(tif);
1006                 if (sp->subsampling_force_desubsampling_inside_decompression!=0)
1007                 {
1008                         sp->subsampling_hor=1;
1009                         sp->subsampling_ver=1;
1010                 }
1011                 sp->subsamplingcorrect=0;
1012                 if (((sp->subsampling_hor!=mh) || (sp->subsampling_ver!=mv)) && (sp->subsampling_force_desubsampling_inside_decompression==0))
1013                 {
1014                         if (sp->subsampling_tag==0)
1015                                 TIFFWarningExt(tif->tif_clientdata,module,"Subsampling tag is not set, yet subsampling inside JPEG data [%d,%d] does not match default values [2,2]; assuming subsampling inside JPEG data is correct",sp->subsampling_hor,sp->subsampling_ver);
1016                         else
1017                                 TIFFWarningExt(tif->tif_clientdata,module,"Subsampling inside JPEG data [%d,%d] does not match subsampling tag values [%d,%d]; assuming subsampling inside JPEG data is correct",sp->subsampling_hor,sp->subsampling_ver,mh,mv);
1018                 }
1019                 if (sp->subsampling_force_desubsampling_inside_decompression!=0)
1020                 {
1021                         if (sp->subsampling_tag==0)
1022                                 TIFFWarningExt(tif->tif_clientdata,module,"Subsampling tag is not set, yet subsampling inside JPEG data does not match default values [2,2] (nor any other values allowed in TIFF); assuming subsampling inside JPEG data is correct and desubsampling inside JPEG decompression");
1023                         else
1024                                 TIFFWarningExt(tif->tif_clientdata,module,"Subsampling inside JPEG data does not match subsampling tag values [%d,%d] (nor any other values allowed in TIFF); assuming subsampling inside JPEG data is correct and desubsampling inside JPEG decompression",mh,mv);
1025                 }
1026                 if (sp->subsampling_force_desubsampling_inside_decompression==0)
1027                 {
1028                         if (sp->subsampling_hor<sp->subsampling_ver)
1029                                 TIFFWarningExt(tif->tif_clientdata,module,"Subsampling values [%d,%d] are not allowed in TIFF",sp->subsampling_hor,sp->subsampling_ver);
1030                 }
1031         }
1032         sp->subsamplingcorrect_done=1;
1033 }
1034
1035 static int
1036 OJPEGReadHeaderInfo(TIFF* tif)
1037 {
1038         static const char module[]="OJPEGReadHeaderInfo";
1039         OJPEGState* sp=(OJPEGState*)tif->tif_data;
1040         assert(sp->readheader_done==0);
1041         sp->image_width=tif->tif_dir.td_imagewidth;
1042         sp->image_length=tif->tif_dir.td_imagelength;
1043         if isTiled(tif)
1044         {
1045                 sp->strile_width=tif->tif_dir.td_tilewidth;
1046                 sp->strile_length=tif->tif_dir.td_tilelength;
1047                 sp->strile_length_total=((sp->image_length+sp->strile_length-1)/sp->strile_length)*sp->strile_length;
1048         }
1049         else
1050         {
1051                 sp->strile_width=sp->image_width;
1052                 sp->strile_length=tif->tif_dir.td_rowsperstrip;
1053                 sp->strile_length_total=sp->image_length;
1054         }
1055         if (tif->tif_dir.td_samplesperpixel==1)
1056         {
1057                 sp->samples_per_pixel=1;
1058                 sp->plane_sample_offset=0;
1059                 sp->samples_per_pixel_per_plane=sp->samples_per_pixel;
1060                 sp->subsampling_hor=1;
1061                 sp->subsampling_ver=1;
1062         }
1063         else
1064         {
1065                 if (tif->tif_dir.td_samplesperpixel!=3)
1066                 {
1067                         TIFFErrorExt(tif->tif_clientdata,module,"SamplesPerPixel %d not supported for this compression scheme",sp->samples_per_pixel);
1068                         return(0);
1069                 }
1070                 sp->samples_per_pixel=3;
1071                 sp->plane_sample_offset=0;
1072                 if (tif->tif_dir.td_planarconfig==PLANARCONFIG_CONTIG)
1073                         sp->samples_per_pixel_per_plane=3;
1074                 else
1075                         sp->samples_per_pixel_per_plane=1;
1076         }
1077         if (sp->strile_length<sp->image_length)
1078         {
1079                 if (sp->strile_length%(sp->subsampling_ver*8)!=0)
1080                 {
1081                         TIFFErrorExt(tif->tif_clientdata,module,"Incompatible vertical subsampling and image strip/tile length");
1082                         return(0);
1083                 }
1084                 sp->restart_interval=((sp->strile_width+sp->subsampling_hor*8-1)/(sp->subsampling_hor*8))*(sp->strile_length/(sp->subsampling_ver*8));
1085         }
1086         if (OJPEGReadHeaderInfoSec(tif)==0)
1087                 return(0);
1088         sp->sos_end[0].log=1;
1089         sp->sos_end[0].in_buffer_source=sp->in_buffer_source;
1090         sp->sos_end[0].in_buffer_next_strile=sp->in_buffer_next_strile;
1091         sp->sos_end[0].in_buffer_file_pos=sp->in_buffer_file_pos-sp->in_buffer_togo;
1092         sp->sos_end[0].in_buffer_file_togo=sp->in_buffer_file_togo+sp->in_buffer_togo;
1093         sp->readheader_done=1;
1094         return(1);
1095 }
1096
1097 static int
1098 OJPEGReadSecondarySos(TIFF* tif, uint16 s)
1099 {
1100         OJPEGState* sp=(OJPEGState*)tif->tif_data;
1101         uint8 m;
1102         assert(s>0);
1103         assert(s<3);
1104         assert(sp->sos_end[0].log!=0);
1105         assert(sp->sos_end[s].log==0);
1106         sp->plane_sample_offset=s-1;
1107         while(sp->sos_end[sp->plane_sample_offset].log==0)
1108                 sp->plane_sample_offset--;
1109         sp->in_buffer_source=sp->sos_end[sp->plane_sample_offset].in_buffer_source;
1110         sp->in_buffer_next_strile=sp->sos_end[sp->plane_sample_offset].in_buffer_next_strile;
1111         sp->in_buffer_file_pos=sp->sos_end[sp->plane_sample_offset].in_buffer_file_pos;
1112         sp->in_buffer_file_pos_log=0;
1113         sp->in_buffer_file_togo=sp->sos_end[sp->plane_sample_offset].in_buffer_file_togo;
1114         sp->in_buffer_togo=0;
1115         sp->in_buffer_cur=0;
1116         while(sp->plane_sample_offset<s)
1117         {
1118                 do
1119                 {
1120                         if (OJPEGReadByte(sp,&m)==0)
1121                                 return(0);
1122                         if (m==255)
1123                         {
1124                                 do
1125                                 {
1126                                         if (OJPEGReadByte(sp,&m)==0)
1127                                                 return(0);
1128                                         if (m!=255)
1129                                                 break;
1130                                 } while(1);
1131                                 if (m==JPEG_MARKER_SOS)
1132                                         break;
1133                         }
1134                 } while(1);
1135                 sp->plane_sample_offset++;
1136                 if (OJPEGReadHeaderInfoSecStreamSos(tif)==0)
1137                         return(0);
1138                 sp->sos_end[sp->plane_sample_offset].log=1;
1139                 sp->sos_end[sp->plane_sample_offset].in_buffer_source=sp->in_buffer_source;
1140                 sp->sos_end[sp->plane_sample_offset].in_buffer_next_strile=sp->in_buffer_next_strile;
1141                 sp->sos_end[sp->plane_sample_offset].in_buffer_file_pos=sp->in_buffer_file_pos-sp->in_buffer_togo;
1142                 sp->sos_end[sp->plane_sample_offset].in_buffer_file_togo=sp->in_buffer_file_togo+sp->in_buffer_togo;
1143         }
1144         return(1);
1145 }
1146
1147 static int
1148 OJPEGWriteHeaderInfo(TIFF* tif)
1149 {
1150         static const char module[]="OJPEGWriteHeaderInfo";
1151         OJPEGState* sp=(OJPEGState*)tif->tif_data;
1152         uint8** m;
1153         uint32 n;
1154         /* if a previous attempt failed, don't try again */
1155         if (sp->libjpeg_session_active != 0)
1156                 return 0;
1157         sp->out_state=ososSoi;
1158         sp->restart_index=0;
1159         jpeg_std_error(&(sp->libjpeg_jpeg_error_mgr));
1160         sp->libjpeg_jpeg_error_mgr.output_message=OJPEGLibjpegJpegErrorMgrOutputMessage;
1161         sp->libjpeg_jpeg_error_mgr.error_exit=OJPEGLibjpegJpegErrorMgrErrorExit;
1162         sp->libjpeg_jpeg_decompress_struct.err=&(sp->libjpeg_jpeg_error_mgr);
1163         sp->libjpeg_jpeg_decompress_struct.client_data=(void*)tif;
1164         if (jpeg_create_decompress_encap(sp,&(sp->libjpeg_jpeg_decompress_struct))==0)
1165                 return(0);
1166         sp->libjpeg_session_active=1;
1167         sp->libjpeg_jpeg_source_mgr.bytes_in_buffer=0;
1168         sp->libjpeg_jpeg_source_mgr.init_source=OJPEGLibjpegJpegSourceMgrInitSource;
1169         sp->libjpeg_jpeg_source_mgr.fill_input_buffer=OJPEGLibjpegJpegSourceMgrFillInputBuffer;
1170         sp->libjpeg_jpeg_source_mgr.skip_input_data=OJPEGLibjpegJpegSourceMgrSkipInputData;
1171         sp->libjpeg_jpeg_source_mgr.resync_to_restart=OJPEGLibjpegJpegSourceMgrResyncToRestart;
1172         sp->libjpeg_jpeg_source_mgr.term_source=OJPEGLibjpegJpegSourceMgrTermSource;
1173         sp->libjpeg_jpeg_decompress_struct.src=&(sp->libjpeg_jpeg_source_mgr);
1174         if (jpeg_read_header_encap(sp,&(sp->libjpeg_jpeg_decompress_struct),1)==0)
1175                 return(0);
1176         if ((sp->subsampling_force_desubsampling_inside_decompression==0) && (sp->samples_per_pixel_per_plane>1))
1177         {
1178                 sp->libjpeg_jpeg_decompress_struct.raw_data_out=1;
1179 #if JPEG_LIB_VERSION >= 70
1180                 sp->libjpeg_jpeg_decompress_struct.do_fancy_upsampling=FALSE;
1181 #endif
1182                 sp->libjpeg_jpeg_query_style=0;
1183                 if (sp->subsampling_convert_log==0)
1184                 {
1185                         assert(sp->subsampling_convert_ycbcrbuf==0);
1186                         assert(sp->subsampling_convert_ycbcrimage==0);
1187                         sp->subsampling_convert_ylinelen=((sp->strile_width+sp->subsampling_hor*8-1)/(sp->subsampling_hor*8)*sp->subsampling_hor*8);
1188                         sp->subsampling_convert_ylines=sp->subsampling_ver*8;
1189                         sp->subsampling_convert_clinelen=sp->subsampling_convert_ylinelen/sp->subsampling_hor;
1190                         sp->subsampling_convert_clines=8;
1191                         sp->subsampling_convert_ybuflen=sp->subsampling_convert_ylinelen*sp->subsampling_convert_ylines;
1192                         sp->subsampling_convert_cbuflen=sp->subsampling_convert_clinelen*sp->subsampling_convert_clines;
1193                         sp->subsampling_convert_ycbcrbuflen=sp->subsampling_convert_ybuflen+2*sp->subsampling_convert_cbuflen;
1194                         sp->subsampling_convert_ycbcrbuf=_TIFFmalloc(sp->subsampling_convert_ycbcrbuflen);
1195                         if (sp->subsampling_convert_ycbcrbuf==0)
1196                         {
1197                                 TIFFErrorExt(tif->tif_clientdata,module,"Out of memory");
1198                                 return(0);
1199                         }
1200                         sp->subsampling_convert_ybuf=sp->subsampling_convert_ycbcrbuf;
1201                         sp->subsampling_convert_cbbuf=sp->subsampling_convert_ybuf+sp->subsampling_convert_ybuflen;
1202                         sp->subsampling_convert_crbuf=sp->subsampling_convert_cbbuf+sp->subsampling_convert_cbuflen;
1203                         sp->subsampling_convert_ycbcrimagelen=3+sp->subsampling_convert_ylines+2*sp->subsampling_convert_clines;
1204                         sp->subsampling_convert_ycbcrimage=_TIFFmalloc(sp->subsampling_convert_ycbcrimagelen*sizeof(uint8*));
1205                         if (sp->subsampling_convert_ycbcrimage==0)
1206                         {
1207                                 TIFFErrorExt(tif->tif_clientdata,module,"Out of memory");
1208                                 return(0);
1209                         }
1210                         m=sp->subsampling_convert_ycbcrimage;
1211                         *m++=(uint8*)(sp->subsampling_convert_ycbcrimage+3);
1212                         *m++=(uint8*)(sp->subsampling_convert_ycbcrimage+3+sp->subsampling_convert_ylines);
1213                         *m++=(uint8*)(sp->subsampling_convert_ycbcrimage+3+sp->subsampling_convert_ylines+sp->subsampling_convert_clines);
1214                         for (n=0; n<sp->subsampling_convert_ylines; n++)
1215                                 *m++=sp->subsampling_convert_ybuf+n*sp->subsampling_convert_ylinelen;
1216                         for (n=0; n<sp->subsampling_convert_clines; n++)
1217                                 *m++=sp->subsampling_convert_cbbuf+n*sp->subsampling_convert_clinelen;
1218                         for (n=0; n<sp->subsampling_convert_clines; n++)
1219                                 *m++=sp->subsampling_convert_crbuf+n*sp->subsampling_convert_clinelen;
1220                         sp->subsampling_convert_clinelenout=((sp->strile_width+sp->subsampling_hor-1)/sp->subsampling_hor);
1221                         sp->subsampling_convert_state=0;
1222                         sp->bytes_per_line=sp->subsampling_convert_clinelenout*(sp->subsampling_ver*sp->subsampling_hor+2);
1223                         sp->lines_per_strile=((sp->strile_length+sp->subsampling_ver-1)/sp->subsampling_ver);
1224                         sp->subsampling_convert_log=1;
1225                 }
1226         }
1227         else
1228         {
1229                 sp->libjpeg_jpeg_decompress_struct.jpeg_color_space=JCS_UNKNOWN;
1230                 sp->libjpeg_jpeg_decompress_struct.out_color_space=JCS_UNKNOWN;
1231                 sp->libjpeg_jpeg_query_style=1;
1232                 sp->bytes_per_line=sp->samples_per_pixel_per_plane*sp->strile_width;
1233                 sp->lines_per_strile=sp->strile_length;
1234         }
1235         if (jpeg_start_decompress_encap(sp,&(sp->libjpeg_jpeg_decompress_struct))==0)
1236                 return(0);
1237         sp->writeheader_done=1;
1238         return(1);
1239 }
1240
1241 static void
1242 OJPEGLibjpegSessionAbort(TIFF* tif)
1243 {
1244         OJPEGState* sp=(OJPEGState*)tif->tif_data;
1245         assert(sp->libjpeg_session_active!=0);
1246         jpeg_destroy((jpeg_common_struct*)(&(sp->libjpeg_jpeg_decompress_struct)));
1247         sp->libjpeg_session_active=0;
1248 }
1249
1250 static int
1251 OJPEGReadHeaderInfoSec(TIFF* tif)
1252 {
1253         static const char module[]="OJPEGReadHeaderInfoSec";
1254         OJPEGState* sp=(OJPEGState*)tif->tif_data;
1255         uint8 m;
1256         uint16 n;
1257         uint8 o;
1258         if (sp->file_size==0)
1259                 sp->file_size=TIFFGetFileSize(tif);
1260         if (sp->jpeg_interchange_format!=0)
1261         {
1262                 if (sp->jpeg_interchange_format>=sp->file_size)
1263                 {
1264                         sp->jpeg_interchange_format=0;
1265                         sp->jpeg_interchange_format_length=0;
1266                 }
1267                 else
1268                 {
1269                         if ((sp->jpeg_interchange_format_length==0) || (sp->jpeg_interchange_format+sp->jpeg_interchange_format_length>sp->file_size))
1270                                 sp->jpeg_interchange_format_length=sp->file_size-sp->jpeg_interchange_format;
1271                 }
1272         }
1273         sp->in_buffer_source=osibsNotSetYet;
1274         sp->in_buffer_next_strile=0;
1275         sp->in_buffer_strile_count=tif->tif_dir.td_nstrips;
1276         sp->in_buffer_file_togo=0;
1277         sp->in_buffer_togo=0;
1278         do
1279         {
1280                 if (OJPEGReadBytePeek(sp,&m)==0)
1281                         return(0);
1282                 if (m!=255)
1283                         break;
1284                 OJPEGReadByteAdvance(sp);
1285                 do
1286                 {
1287                         if (OJPEGReadByte(sp,&m)==0)
1288                                 return(0);
1289                 } while(m==255);
1290                 switch(m)
1291                 {
1292                         case JPEG_MARKER_SOI:
1293                                 /* this type of marker has no data, and should be skipped */
1294                                 break;
1295                         case JPEG_MARKER_COM:
1296                         case JPEG_MARKER_APP0:
1297                         case JPEG_MARKER_APP0+1:
1298                         case JPEG_MARKER_APP0+2:
1299                         case JPEG_MARKER_APP0+3:
1300                         case JPEG_MARKER_APP0+4:
1301                         case JPEG_MARKER_APP0+5:
1302                         case JPEG_MARKER_APP0+6:
1303                         case JPEG_MARKER_APP0+7:
1304                         case JPEG_MARKER_APP0+8:
1305                         case JPEG_MARKER_APP0+9:
1306                         case JPEG_MARKER_APP0+10:
1307                         case JPEG_MARKER_APP0+11:
1308                         case JPEG_MARKER_APP0+12:
1309                         case JPEG_MARKER_APP0+13:
1310                         case JPEG_MARKER_APP0+14:
1311                         case JPEG_MARKER_APP0+15:
1312                                 /* this type of marker has data, but it has no use to us (and no place here) and should be skipped */
1313                                 if (OJPEGReadWord(sp,&n)==0)
1314                                         return(0);
1315                                 if (n<2)
1316                                 {
1317                                         if (sp->subsamplingcorrect==0)
1318                                                 TIFFErrorExt(tif->tif_clientdata,module,"Corrupt JPEG data");
1319                                         return(0);
1320                                 }
1321                                 if (n>2)
1322                                         OJPEGReadSkip(sp,n-2);
1323                                 break;
1324                         case JPEG_MARKER_DRI:
1325                                 if (OJPEGReadHeaderInfoSecStreamDri(tif)==0)
1326                                         return(0);
1327                                 break;
1328                         case JPEG_MARKER_DQT:
1329                                 if (OJPEGReadHeaderInfoSecStreamDqt(tif)==0)
1330                                         return(0);
1331                                 break;
1332                         case JPEG_MARKER_DHT:
1333                                 if (OJPEGReadHeaderInfoSecStreamDht(tif)==0)
1334                                         return(0);
1335                                 break;
1336                         case JPEG_MARKER_SOF0:
1337                         case JPEG_MARKER_SOF1:
1338                         case JPEG_MARKER_SOF3:
1339                                 if (OJPEGReadHeaderInfoSecStreamSof(tif,m)==0)
1340                                         return(0);
1341                                 if (sp->subsamplingcorrect!=0)
1342                                         return(1);
1343                                 break;
1344                         case JPEG_MARKER_SOS:
1345                                 if (sp->subsamplingcorrect!=0)
1346                                         return(1);
1347                                 assert(sp->plane_sample_offset==0);
1348                                 if (OJPEGReadHeaderInfoSecStreamSos(tif)==0)
1349                                         return(0);
1350                                 break;
1351                         default:
1352                                 TIFFErrorExt(tif->tif_clientdata,module,"Unknown marker type %d in JPEG data",m);
1353                                 return(0);
1354                 }
1355         } while(m!=JPEG_MARKER_SOS);
1356         if (sp->subsamplingcorrect)
1357                 return(1);
1358         if (sp->sof_log==0)
1359         {
1360                 if (OJPEGReadHeaderInfoSecTablesQTable(tif)==0)
1361                         return(0);
1362                 sp->sof_marker_id=JPEG_MARKER_SOF0;
1363                 for (o=0; o<sp->samples_per_pixel; o++)
1364                         sp->sof_c[o]=o;
1365                 sp->sof_hv[0]=((sp->subsampling_hor<<4)|sp->subsampling_ver);
1366                 for (o=1; o<sp->samples_per_pixel; o++)
1367                         sp->sof_hv[o]=17;
1368                 sp->sof_x=sp->strile_width;
1369                 sp->sof_y=sp->strile_length_total;
1370                 sp->sof_log=1;
1371                 if (OJPEGReadHeaderInfoSecTablesDcTable(tif)==0)
1372                         return(0);
1373                 if (OJPEGReadHeaderInfoSecTablesAcTable(tif)==0)
1374                         return(0);
1375                 for (o=1; o<sp->samples_per_pixel; o++)
1376                         sp->sos_cs[o]=o;
1377         }
1378         return(1);
1379 }
1380
1381 static int
1382 OJPEGReadHeaderInfoSecStreamDri(TIFF* tif)
1383 {
1384         /* this could easilly cause trouble in some cases... but no such cases have occured sofar */
1385         static const char module[]="OJPEGReadHeaderInfoSecStreamDri";
1386         OJPEGState* sp=(OJPEGState*)tif->tif_data;
1387         uint16 m;
1388         if (OJPEGReadWord(sp,&m)==0)
1389                 return(0);
1390         if (m!=4)
1391         {
1392                 TIFFErrorExt(tif->tif_clientdata,module,"Corrupt DRI marker in JPEG data");
1393                 return(0);
1394         }
1395         if (OJPEGReadWord(sp,&m)==0)
1396                 return(0);
1397         sp->restart_interval=m;
1398         return(1);
1399 }
1400
1401 static int
1402 OJPEGReadHeaderInfoSecStreamDqt(TIFF* tif)
1403 {
1404         /* this is a table marker, and it is to be saved as a whole for exact pushing on the jpeg stream later on */
1405         static const char module[]="OJPEGReadHeaderInfoSecStreamDqt";
1406         OJPEGState* sp=(OJPEGState*)tif->tif_data;
1407         uint16 m;
1408         uint32 na;
1409         uint8* nb;
1410         uint8 o;
1411         if (OJPEGReadWord(sp,&m)==0)
1412                 return(0);
1413         if (m<=2)
1414         {
1415                 if (sp->subsamplingcorrect==0)
1416                         TIFFErrorExt(tif->tif_clientdata,module,"Corrupt DQT marker in JPEG data");
1417                 return(0);
1418         }
1419         if (sp->subsamplingcorrect!=0)
1420                 OJPEGReadSkip(sp,m-2);
1421         else
1422         {
1423                 m-=2;
1424                 do
1425                 {
1426                         if (m<65)
1427                         {
1428                                 TIFFErrorExt(tif->tif_clientdata,module,"Corrupt DQT marker in JPEG data");
1429                                 return(0);
1430                         }
1431                         na=sizeof(uint32)+69;
1432                         nb=_TIFFmalloc(na);
1433                         if (nb==0)
1434                         {
1435                                 TIFFErrorExt(tif->tif_clientdata,module,"Out of memory");
1436                                 return(0);
1437                         }
1438                         *(uint32*)nb=na;
1439                         nb[sizeof(uint32)]=255;
1440                         nb[sizeof(uint32)+1]=JPEG_MARKER_DQT;
1441                         nb[sizeof(uint32)+2]=0;
1442                         nb[sizeof(uint32)+3]=67;
1443                         if (OJPEGReadBlock(sp,65,&nb[sizeof(uint32)+4])==0) {
1444                                 _TIFFfree(nb);
1445                                 return(0);
1446                         }
1447                         o=nb[sizeof(uint32)+4]&15;
1448                         if (3<o)
1449                         {
1450                                 TIFFErrorExt(tif->tif_clientdata,module,"Corrupt DQT marker in JPEG data");
1451                                 _TIFFfree(nb);
1452                                 return(0);
1453                         }
1454                         if (sp->qtable[o]!=0)
1455                                 _TIFFfree(sp->qtable[o]);
1456                         sp->qtable[o]=nb;
1457                         m-=65;
1458                 } while(m>0);
1459         }
1460         return(1);
1461 }
1462
1463 static int
1464 OJPEGReadHeaderInfoSecStreamDht(TIFF* tif)
1465 {
1466         /* this is a table marker, and it is to be saved as a whole for exact pushing on the jpeg stream later on */
1467         /* TODO: the following assumes there is only one table in this marker... but i'm not quite sure that assumption is guaranteed correct */
1468         static const char module[]="OJPEGReadHeaderInfoSecStreamDht";
1469         OJPEGState* sp=(OJPEGState*)tif->tif_data;
1470         uint16 m;
1471         uint32 na;
1472         uint8* nb;
1473         uint8 o;
1474         if (OJPEGReadWord(sp,&m)==0)
1475                 return(0);
1476         if (m<=2)
1477         {
1478                 if (sp->subsamplingcorrect==0)
1479                         TIFFErrorExt(tif->tif_clientdata,module,"Corrupt DHT marker in JPEG data");
1480                 return(0);
1481         }
1482         if (sp->subsamplingcorrect!=0)
1483         {
1484                 OJPEGReadSkip(sp,m-2);
1485         }
1486         else
1487         {
1488                 na=sizeof(uint32)+2+m;
1489                 nb=_TIFFmalloc(na);
1490                 if (nb==0)
1491                 {
1492                         TIFFErrorExt(tif->tif_clientdata,module,"Out of memory");
1493                         return(0);
1494                 }
1495                 *(uint32*)nb=na;
1496                 nb[sizeof(uint32)]=255;
1497                 nb[sizeof(uint32)+1]=JPEG_MARKER_DHT;
1498                 nb[sizeof(uint32)+2]=(m>>8);
1499                 nb[sizeof(uint32)+3]=(m&255);
1500                 if (OJPEGReadBlock(sp,m-2,&nb[sizeof(uint32)+4])==0) {
1501                         _TIFFfree(nb);
1502                         return(0);
1503                 }
1504                 o=nb[sizeof(uint32)+4];
1505                 if ((o&240)==0)
1506                 {
1507                         if (3<o)
1508                         {
1509                                 TIFFErrorExt(tif->tif_clientdata,module,"Corrupt DHT marker in JPEG data");
1510                                 _TIFFfree(nb);
1511                                 return(0);
1512                         }
1513                         if (sp->dctable[o]!=0)
1514                                 _TIFFfree(sp->dctable[o]);
1515                         sp->dctable[o]=nb;
1516                 }
1517                 else
1518                 {
1519                         if ((o&240)!=16)
1520                         {
1521                                 TIFFErrorExt(tif->tif_clientdata,module,"Corrupt DHT marker in JPEG data");
1522                                 _TIFFfree(nb);
1523                                 return(0);
1524                         }
1525                         o&=15;
1526                         if (3<o)
1527                         {
1528                                 TIFFErrorExt(tif->tif_clientdata,module,"Corrupt DHT marker in JPEG data");
1529                                 _TIFFfree(nb);
1530                                 return(0);
1531                         }
1532                         if (sp->actable[o]!=0)
1533                                 _TIFFfree(sp->actable[o]);
1534                         sp->actable[o]=nb;
1535                 }
1536         }
1537         return(1);
1538 }
1539
1540 static int
1541 OJPEGReadHeaderInfoSecStreamSof(TIFF* tif, uint8 marker_id)
1542 {
1543         /* this marker needs to be checked, and part of its data needs to be saved for regeneration later on */
1544         static const char module[]="OJPEGReadHeaderInfoSecStreamSof";
1545         OJPEGState* sp=(OJPEGState*)tif->tif_data;
1546         uint16 m;
1547         uint16 n;
1548         uint8 o;
1549         uint16 p;
1550         uint16 q;
1551         if (sp->sof_log!=0)
1552         {
1553                 TIFFErrorExt(tif->tif_clientdata,module,"Corrupt JPEG data");
1554                 return(0);
1555         }
1556         if (sp->subsamplingcorrect==0)
1557                 sp->sof_marker_id=marker_id;
1558         /* Lf: data length */
1559         if (OJPEGReadWord(sp,&m)==0)
1560                 return(0);
1561         if (m<11)
1562         {
1563                 if (sp->subsamplingcorrect==0)
1564                         TIFFErrorExt(tif->tif_clientdata,module,"Corrupt SOF marker in JPEG data");
1565                 return(0);
1566         }
1567         m-=8;
1568         if (m%3!=0)
1569         {
1570                 if (sp->subsamplingcorrect==0)
1571                         TIFFErrorExt(tif->tif_clientdata,module,"Corrupt SOF marker in JPEG data");
1572                 return(0);
1573         }
1574         n=m/3;
1575         if (sp->subsamplingcorrect==0)
1576         {
1577                 if (n!=sp->samples_per_pixel)
1578                 {
1579                         TIFFErrorExt(tif->tif_clientdata,module,"JPEG compressed data indicates unexpected number of samples");
1580                         return(0);
1581                 }
1582         }
1583         /* P: Sample precision */
1584         if (OJPEGReadByte(sp,&o)==0)
1585                 return(0);
1586         if (o!=8)
1587         {
1588                 if (sp->subsamplingcorrect==0)
1589                         TIFFErrorExt(tif->tif_clientdata,module,"JPEG compressed data indicates unexpected number of bits per sample");
1590                 return(0);
1591         }
1592         /* Y: Number of lines, X: Number of samples per line */
1593         if (sp->subsamplingcorrect)
1594                 OJPEGReadSkip(sp,4);
1595         else
1596         {
1597                 /* Y: Number of lines */
1598                 if (OJPEGReadWord(sp,&p)==0)
1599                         return(0);
1600                 if (((uint32)p<sp->image_length) && ((uint32)p<sp->strile_length_total))
1601                 {
1602                         TIFFErrorExt(tif->tif_clientdata,module,"JPEG compressed data indicates unexpected height");
1603                         return(0);
1604                 }
1605                 sp->sof_y=p;
1606                 /* X: Number of samples per line */
1607                 if (OJPEGReadWord(sp,&p)==0)
1608                         return(0);
1609                 if (((uint32)p<sp->image_width) && ((uint32)p<sp->strile_width))
1610                 {
1611                         TIFFErrorExt(tif->tif_clientdata,module,"JPEG compressed data indicates unexpected width");
1612                         return(0);
1613                 }
1614                 if ((uint32)p>sp->strile_width)
1615                 {
1616                         TIFFErrorExt(tif->tif_clientdata,module,"JPEG compressed data image width exceeds expected image width");
1617                         return(0);
1618                 }
1619                 sp->sof_x=p;
1620         }
1621         /* Nf: Number of image components in frame */
1622         if (OJPEGReadByte(sp,&o)==0)
1623                 return(0);
1624         if (o!=n)
1625         {
1626                 if (sp->subsamplingcorrect==0)
1627                         TIFFErrorExt(tif->tif_clientdata,module,"Corrupt SOF marker in JPEG data");
1628                 return(0);
1629         }
1630         /* per component stuff */
1631         /* TODO: double-check that flow implies that n cannot be as big as to make us overflow sof_c, sof_hv and sof_tq arrays */
1632         for (q=0; q<n; q++)
1633         {
1634                 /* C: Component identifier */
1635                 if (OJPEGReadByte(sp,&o)==0)
1636                         return(0);
1637                 if (sp->subsamplingcorrect==0)
1638                         sp->sof_c[q]=o;
1639                 /* H: Horizontal sampling factor, and V: Vertical sampling factor */
1640                 if (OJPEGReadByte(sp,&o)==0)
1641                         return(0);
1642                 if (sp->subsamplingcorrect!=0)
1643                 {
1644                         if (q==0)
1645                         {
1646                                 sp->subsampling_hor=(o>>4);
1647                                 sp->subsampling_ver=(o&15);
1648                                 if (((sp->subsampling_hor!=1) && (sp->subsampling_hor!=2) && (sp->subsampling_hor!=4)) ||
1649                                         ((sp->subsampling_ver!=1) && (sp->subsampling_ver!=2) && (sp->subsampling_ver!=4)))
1650                                         sp->subsampling_force_desubsampling_inside_decompression=1;
1651                         }
1652                         else
1653                         {
1654                                 if (o!=17)
1655                                         sp->subsampling_force_desubsampling_inside_decompression=1;
1656                         }
1657                 }
1658                 else
1659                 {
1660                         sp->sof_hv[q]=o;
1661                         if (sp->subsampling_force_desubsampling_inside_decompression==0)
1662                         {
1663                                 if (q==0)
1664                                 {
1665                                         if (o!=((sp->subsampling_hor<<4)|sp->subsampling_ver))
1666                                         {
1667                                                 TIFFErrorExt(tif->tif_clientdata,module,"JPEG compressed data indicates unexpected subsampling values");
1668                                                 return(0);
1669                                         }
1670                                 }
1671                                 else
1672                                 {
1673                                         if (o!=17)
1674                                         {
1675                                                 TIFFErrorExt(tif->tif_clientdata,module,"JPEG compressed data indicates unexpected subsampling values");
1676                                                 return(0);
1677                                         }
1678                                 }
1679                         }
1680                 }
1681                 /* Tq: Quantization table destination selector */
1682                 if (OJPEGReadByte(sp,&o)==0)
1683                         return(0);
1684                 if (sp->subsamplingcorrect==0)
1685                         sp->sof_tq[q]=o;
1686         }
1687         if (sp->subsamplingcorrect==0)
1688                 sp->sof_log=1;
1689         return(1);
1690 }
1691
1692 static int
1693 OJPEGReadHeaderInfoSecStreamSos(TIFF* tif)
1694 {
1695         /* this marker needs to be checked, and part of its data needs to be saved for regeneration later on */
1696         static const char module[]="OJPEGReadHeaderInfoSecStreamSos";
1697         OJPEGState* sp=(OJPEGState*)tif->tif_data;
1698         uint16 m;
1699         uint8 n;
1700         uint8 o;
1701         assert(sp->subsamplingcorrect==0);
1702         if (sp->sof_log==0)
1703         {
1704                 TIFFErrorExt(tif->tif_clientdata,module,"Corrupt SOS marker in JPEG data");
1705                 return(0);
1706         }
1707         /* Ls */
1708         if (OJPEGReadWord(sp,&m)==0)
1709                 return(0);
1710         if (m!=6+sp->samples_per_pixel_per_plane*2)
1711         {
1712                 TIFFErrorExt(tif->tif_clientdata,module,"Corrupt SOS marker in JPEG data");
1713                 return(0);
1714         }
1715         /* Ns */
1716         if (OJPEGReadByte(sp,&n)==0)
1717                 return(0);
1718         if (n!=sp->samples_per_pixel_per_plane)
1719         {
1720                 TIFFErrorExt(tif->tif_clientdata,module,"Corrupt SOS marker in JPEG data");
1721                 return(0);
1722         }
1723         /* Cs, Td, and Ta */
1724         for (o=0; o<sp->samples_per_pixel_per_plane; o++)
1725         {
1726                 /* Cs */
1727                 if (OJPEGReadByte(sp,&n)==0)
1728                         return(0);
1729                 sp->sos_cs[sp->plane_sample_offset+o]=n;
1730                 /* Td and Ta */
1731                 if (OJPEGReadByte(sp,&n)==0)
1732                         return(0);
1733                 sp->sos_tda[sp->plane_sample_offset+o]=n;
1734         }
1735         /* skip Ss, Se, Ah, en Al -> no check, as per Tom Lane recommendation, as per LibJpeg source */
1736         OJPEGReadSkip(sp,3);
1737         return(1);
1738 }
1739
1740 static int
1741 OJPEGReadHeaderInfoSecTablesQTable(TIFF* tif)
1742 {
1743         static const char module[]="OJPEGReadHeaderInfoSecTablesQTable";
1744         OJPEGState* sp=(OJPEGState*)tif->tif_data;
1745         uint8 m;
1746         uint8 n;
1747         uint32 oa;
1748         uint8* ob;
1749         uint32 p;
1750         if (sp->qtable_offset[0]==0)
1751         {
1752                 TIFFErrorExt(tif->tif_clientdata,module,"Missing JPEG tables");
1753                 return(0);
1754         }
1755         sp->in_buffer_file_pos_log=0;
1756         for (m=0; m<sp->samples_per_pixel; m++)
1757         {
1758                 if ((sp->qtable_offset[m]!=0) && ((m==0) || (sp->qtable_offset[m]!=sp->qtable_offset[m-1])))
1759                 {
1760                         for (n=0; n<m-1; n++)
1761                         {
1762                                 if (sp->qtable_offset[m]==sp->qtable_offset[n])
1763                                 {
1764                                         TIFFErrorExt(tif->tif_clientdata,module,"Corrupt JpegQTables tag value");
1765                                         return(0);
1766                                 }
1767                         }
1768                         oa=sizeof(uint32)+69;
1769                         ob=_TIFFmalloc(oa);
1770                         if (ob==0)
1771                         {
1772                                 TIFFErrorExt(tif->tif_clientdata,module,"Out of memory");
1773                                 return(0);
1774                         }
1775                         *(uint32*)ob=oa;
1776                         ob[sizeof(uint32)]=255;
1777                         ob[sizeof(uint32)+1]=JPEG_MARKER_DQT;
1778                         ob[sizeof(uint32)+2]=0;
1779                         ob[sizeof(uint32)+3]=67;
1780                         ob[sizeof(uint32)+4]=m;
1781                         TIFFSeekFile(tif,sp->qtable_offset[m],SEEK_SET);
1782                         p=TIFFReadFile(tif,&ob[sizeof(uint32)+5],64);
1783                         if (p!=64)
1784                                 return(0);
1785                         sp->qtable[m]=ob;
1786                         sp->sof_tq[m]=m;
1787                 }
1788                 else
1789                         sp->sof_tq[m]=sp->sof_tq[m-1];
1790         }
1791         return(1);
1792 }
1793
1794 static int
1795 OJPEGReadHeaderInfoSecTablesDcTable(TIFF* tif)
1796 {
1797         static const char module[]="OJPEGReadHeaderInfoSecTablesDcTable";
1798         OJPEGState* sp=(OJPEGState*)tif->tif_data;
1799         uint8 m;
1800         uint8 n;
1801         uint8 o[16];
1802         uint32 p;
1803         uint32 q;
1804         uint32 ra;
1805         uint8* rb;
1806         if (sp->dctable_offset[0]==0)
1807         {
1808                 TIFFErrorExt(tif->tif_clientdata,module,"Missing JPEG tables");
1809                 return(0);
1810         }
1811         sp->in_buffer_file_pos_log=0;
1812         for (m=0; m<sp->samples_per_pixel; m++)
1813         {
1814                 if ((sp->dctable_offset[m]!=0) && ((m==0) || (sp->dctable_offset[m]!=sp->dctable_offset[m-1])))
1815                 {
1816                         for (n=0; n<m-1; n++)
1817                         {
1818                                 if (sp->dctable_offset[m]==sp->dctable_offset[n])
1819                                 {
1820                                         TIFFErrorExt(tif->tif_clientdata,module,"Corrupt JpegDcTables tag value");
1821                                         return(0);
1822                                 }
1823                         }
1824                         TIFFSeekFile(tif,sp->dctable_offset[m],SEEK_SET);
1825                         p=TIFFReadFile(tif,o,16);
1826                         if (p!=16)
1827                                 return(0);
1828                         q=0;
1829                         for (n=0; n<16; n++)
1830                                 q+=o[n];
1831                         ra=sizeof(uint32)+21+q;
1832                         rb=_TIFFmalloc(ra);
1833                         if (rb==0)
1834                         {
1835                                 TIFFErrorExt(tif->tif_clientdata,module,"Out of memory");
1836                                 return(0);
1837                         }
1838                         *(uint32*)rb=ra;
1839                         rb[sizeof(uint32)]=255;
1840                         rb[sizeof(uint32)+1]=JPEG_MARKER_DHT;
1841                         rb[sizeof(uint32)+2]=((19+q)>>8);
1842                         rb[sizeof(uint32)+3]=((19+q)&255);
1843                         rb[sizeof(uint32)+4]=m;
1844                         for (n=0; n<16; n++)
1845                                 rb[sizeof(uint32)+5+n]=o[n];
1846                         p=TIFFReadFile(tif,&(rb[sizeof(uint32)+21]),q);
1847                         if (p!=q)
1848                                 return(0);
1849                         sp->dctable[m]=rb;
1850                         sp->sos_tda[m]=(m<<4);
1851                 }
1852                 else
1853                         sp->sos_tda[m]=sp->sos_tda[m-1];
1854         }
1855         return(1);
1856 }
1857
1858 static int
1859 OJPEGReadHeaderInfoSecTablesAcTable(TIFF* tif)
1860 {
1861         static const char module[]="OJPEGReadHeaderInfoSecTablesAcTable";
1862         OJPEGState* sp=(OJPEGState*)tif->tif_data;
1863         uint8 m;
1864         uint8 n;
1865         uint8 o[16];
1866         uint32 p;
1867         uint32 q;
1868         uint32 ra;
1869         uint8* rb;
1870         if (sp->actable_offset[0]==0)
1871         {
1872                 TIFFErrorExt(tif->tif_clientdata,module,"Missing JPEG tables");
1873                 return(0);
1874         }
1875         sp->in_buffer_file_pos_log=0;
1876         for (m=0; m<sp->samples_per_pixel; m++)
1877         {
1878                 if ((sp->actable_offset[m]!=0) && ((m==0) || (sp->actable_offset[m]!=sp->actable_offset[m-1])))
1879                 {
1880                         for (n=0; n<m-1; n++)
1881                         {
1882                                 if (sp->actable_offset[m]==sp->actable_offset[n])
1883                                 {
1884                                         TIFFErrorExt(tif->tif_clientdata,module,"Corrupt JpegAcTables tag value");
1885                                         return(0);
1886                                 }
1887                         }
1888                         TIFFSeekFile(tif,sp->actable_offset[m],SEEK_SET);
1889                         p=TIFFReadFile(tif,o,16);
1890                         if (p!=16)
1891                                 return(0);
1892                         q=0;
1893                         for (n=0; n<16; n++)
1894                                 q+=o[n];
1895                         ra=sizeof(uint32)+21+q;
1896                         rb=_TIFFmalloc(ra);
1897                         if (rb==0)
1898                         {
1899                                 TIFFErrorExt(tif->tif_clientdata,module,"Out of memory");
1900                                 return(0);
1901                         }
1902                         *(uint32*)rb=ra;
1903                         rb[sizeof(uint32)]=255;
1904                         rb[sizeof(uint32)+1]=JPEG_MARKER_DHT;
1905                         rb[sizeof(uint32)+2]=((19+q)>>8);
1906                         rb[sizeof(uint32)+3]=((19+q)&255);
1907                         rb[sizeof(uint32)+4]=(16|m);
1908                         for (n=0; n<16; n++)
1909                                 rb[sizeof(uint32)+5+n]=o[n];
1910                         p=TIFFReadFile(tif,&(rb[sizeof(uint32)+21]),q);
1911                         if (p!=q)
1912                                 return(0);
1913                         sp->actable[m]=rb;
1914                         sp->sos_tda[m]=(sp->sos_tda[m]|m);
1915                 }
1916                 else
1917                         sp->sos_tda[m]=(sp->sos_tda[m]|(sp->sos_tda[m-1]&15));
1918         }
1919         return(1);
1920 }
1921
1922 static int
1923 OJPEGReadBufferFill(OJPEGState* sp)
1924 {
1925         uint16 m;
1926         tmsize_t n;
1927         /* TODO: double-check: when subsamplingcorrect is set, no call to TIFFErrorExt or TIFFWarningExt should be made
1928          * in any other case, seek or read errors should be passed through */
1929         do
1930         {
1931                 if (sp->in_buffer_file_togo!=0)
1932                 {
1933                         if (sp->in_buffer_file_pos_log==0)
1934                         {
1935                                 TIFFSeekFile(sp->tif,sp->in_buffer_file_pos,SEEK_SET);
1936                                 sp->in_buffer_file_pos_log=1;
1937                         }
1938                         m=OJPEG_BUFFER;
1939                         if ((uint64)m>sp->in_buffer_file_togo)
1940                                 m=(uint16)sp->in_buffer_file_togo;
1941                         n=TIFFReadFile(sp->tif,sp->in_buffer,(tmsize_t)m);
1942                         if (n==0)
1943                                 return(0);
1944                         assert(n>0);
1945                         assert(n<=OJPEG_BUFFER);
1946                         assert(n<65536);
1947                         assert((uint64)n<=sp->in_buffer_file_togo);
1948                         m=(uint16)n;
1949                         sp->in_buffer_togo=m;
1950                         sp->in_buffer_cur=sp->in_buffer;
1951                         sp->in_buffer_file_togo-=m;
1952                         sp->in_buffer_file_pos+=m;
1953                         break;
1954                 }
1955                 sp->in_buffer_file_pos_log=0;
1956                 switch(sp->in_buffer_source)
1957                 {
1958                         case osibsNotSetYet:
1959                                 if (sp->jpeg_interchange_format!=0)
1960                                 {
1961                                         sp->in_buffer_file_pos=sp->jpeg_interchange_format;
1962                                         sp->in_buffer_file_togo=sp->jpeg_interchange_format_length;
1963                                 }
1964                                 sp->in_buffer_source=osibsJpegInterchangeFormat;
1965                                 break;
1966                         case osibsJpegInterchangeFormat:
1967                                 sp->in_buffer_source=osibsStrile;
1968                                 break;
1969                         case osibsStrile:
1970                                 if (!_TIFFFillStriles( sp->tif )
1971                                     || sp->tif->tif_dir.td_stripoffset == NULL
1972                                     || sp->tif->tif_dir.td_stripbytecount == NULL)
1973                                         return 0;
1974
1975                                 if (sp->in_buffer_next_strile==sp->in_buffer_strile_count)
1976                                         sp->in_buffer_source=osibsEof;
1977                                 else
1978                                 {
1979                                         sp->in_buffer_file_pos=sp->tif->tif_dir.td_stripoffset[sp->in_buffer_next_strile];
1980                                         if (sp->in_buffer_file_pos!=0)
1981                                         {
1982                                                 if (sp->in_buffer_file_pos>=sp->file_size)
1983                                                         sp->in_buffer_file_pos=0;
1984                                                 else if (sp->tif->tif_dir.td_stripbytecount==NULL)
1985                                                         sp->in_buffer_file_togo=sp->file_size-sp->in_buffer_file_pos;
1986                                                 else
1987                                                 {
1988                                                         if (sp->tif->tif_dir.td_stripbytecount == 0) {
1989                                                                 TIFFErrorExt(sp->tif->tif_clientdata,sp->tif->tif_name,"Strip byte counts are missing");
1990                                                                 return(0);
1991                                                         }
1992                                                         sp->in_buffer_file_togo=sp->tif->tif_dir.td_stripbytecount[sp->in_buffer_next_strile];
1993                                                         if (sp->in_buffer_file_togo==0)
1994                                                                 sp->in_buffer_file_pos=0;
1995                                                         else if (sp->in_buffer_file_pos+sp->in_buffer_file_togo>sp->file_size)
1996                                                                 sp->in_buffer_file_togo=sp->file_size-sp->in_buffer_file_pos;
1997                                                 }
1998                                         }
1999                                         sp->in_buffer_next_strile++;
2000                                 }
2001                                 break;
2002                         default:
2003                                 return(0);
2004                 }
2005         } while (1);
2006         return(1);
2007 }
2008
2009 static int
2010 OJPEGReadByte(OJPEGState* sp, uint8* byte)
2011 {
2012         if (sp->in_buffer_togo==0)
2013         {
2014                 if (OJPEGReadBufferFill(sp)==0)
2015                         return(0);
2016                 assert(sp->in_buffer_togo>0);
2017         }
2018         *byte=*(sp->in_buffer_cur);
2019         sp->in_buffer_cur++;
2020         sp->in_buffer_togo--;
2021         return(1);
2022 }
2023
2024 static int
2025 OJPEGReadBytePeek(OJPEGState* sp, uint8* byte)
2026 {
2027         if (sp->in_buffer_togo==0)
2028         {
2029                 if (OJPEGReadBufferFill(sp)==0)
2030                         return(0);
2031                 assert(sp->in_buffer_togo>0);
2032         }
2033         *byte=*(sp->in_buffer_cur);
2034         return(1);
2035 }
2036
2037 static void
2038 OJPEGReadByteAdvance(OJPEGState* sp)
2039 {
2040         assert(sp->in_buffer_togo>0);
2041         sp->in_buffer_cur++;
2042         sp->in_buffer_togo--;
2043 }
2044
2045 static int
2046 OJPEGReadWord(OJPEGState* sp, uint16* word)
2047 {
2048         uint8 m;
2049         if (OJPEGReadByte(sp,&m)==0)
2050                 return(0);
2051         *word=(m<<8);
2052         if (OJPEGReadByte(sp,&m)==0)
2053                 return(0);
2054         *word|=m;
2055         return(1);
2056 }
2057
2058 static int
2059 OJPEGReadBlock(OJPEGState* sp, uint16 len, void* mem)
2060 {
2061         uint16 mlen;
2062         uint8* mmem;
2063         uint16 n;
2064         assert(len>0);
2065         mlen=len;
2066         mmem=mem;
2067         do
2068         {
2069                 if (sp->in_buffer_togo==0)
2070                 {
2071                         if (OJPEGReadBufferFill(sp)==0)
2072                                 return(0);
2073                         assert(sp->in_buffer_togo>0);
2074                 }
2075                 n=mlen;
2076                 if (n>sp->in_buffer_togo)
2077                         n=sp->in_buffer_togo;
2078                 _TIFFmemcpy(mmem,sp->in_buffer_cur,n);
2079                 sp->in_buffer_cur+=n;
2080                 sp->in_buffer_togo-=n;
2081                 mlen-=n;
2082                 mmem+=n;
2083         } while(mlen>0);
2084         return(1);
2085 }
2086
2087 static void
2088 OJPEGReadSkip(OJPEGState* sp, uint16 len)
2089 {
2090         uint16 m;
2091         uint16 n;
2092         m=len;
2093         n=m;
2094         if (n>sp->in_buffer_togo)
2095                 n=sp->in_buffer_togo;
2096         sp->in_buffer_cur+=n;
2097         sp->in_buffer_togo-=n;
2098         m-=n;
2099         if (m>0)
2100         {
2101                 assert(sp->in_buffer_togo==0);
2102                 n=m;
2103                 if ((uint64)n>sp->in_buffer_file_togo)
2104                         n=(uint16)sp->in_buffer_file_togo;
2105                 sp->in_buffer_file_pos+=n;
2106                 sp->in_buffer_file_togo-=n;
2107                 sp->in_buffer_file_pos_log=0;
2108                 /* we don't skip past jpeginterchangeformat/strile block...
2109                  * if that is asked from us, we're dealing with totally bazurk
2110                  * data anyway, and we've not seen this happening on any
2111                  * testfile, so we might as well likely cause some other
2112                  * meaningless error to be passed at some later time
2113                  */
2114         }
2115 }
2116
2117 static int
2118 OJPEGWriteStream(TIFF* tif, void** mem, uint32* len)
2119 {
2120         OJPEGState* sp=(OJPEGState*)tif->tif_data;
2121         *len=0;
2122         do
2123         {
2124                 assert(sp->out_state<=ososEoi);
2125                 switch(sp->out_state)
2126                 {
2127                         case ososSoi:
2128                                 OJPEGWriteStreamSoi(tif,mem,len);
2129                                 break;
2130                         case ososQTable0:
2131                                 OJPEGWriteStreamQTable(tif,0,mem,len);
2132                                 break;
2133                         case ososQTable1:
2134                                 OJPEGWriteStreamQTable(tif,1,mem,len);
2135                                 break;
2136                         case ososQTable2:
2137                                 OJPEGWriteStreamQTable(tif,2,mem,len);
2138                                 break;
2139                         case ososQTable3:
2140                                 OJPEGWriteStreamQTable(tif,3,mem,len);
2141                                 break;
2142                         case ososDcTable0:
2143                                 OJPEGWriteStreamDcTable(tif,0,mem,len);
2144                                 break;
2145                         case ososDcTable1:
2146                                 OJPEGWriteStreamDcTable(tif,1,mem,len);
2147                                 break;
2148                         case ososDcTable2:
2149                                 OJPEGWriteStreamDcTable(tif,2,mem,len);
2150                                 break;
2151                         case ososDcTable3:
2152                                 OJPEGWriteStreamDcTable(tif,3,mem,len);
2153                                 break;
2154                         case ososAcTable0:
2155                                 OJPEGWriteStreamAcTable(tif,0,mem,len);
2156                                 break;
2157                         case ososAcTable1:
2158                                 OJPEGWriteStreamAcTable(tif,1,mem,len);
2159                                 break;
2160                         case ososAcTable2:
2161                                 OJPEGWriteStreamAcTable(tif,2,mem,len);
2162                                 break;
2163                         case ososAcTable3:
2164                                 OJPEGWriteStreamAcTable(tif,3,mem,len);
2165                                 break;
2166                         case ososDri:
2167                                 OJPEGWriteStreamDri(tif,mem,len);
2168                                 break;
2169                         case ososSof:
2170                                 OJPEGWriteStreamSof(tif,mem,len);
2171                                 break;
2172                         case ososSos:
2173                                 OJPEGWriteStreamSos(tif,mem,len);
2174                                 break;
2175                         case ososCompressed:
2176                                 if (OJPEGWriteStreamCompressed(tif,mem,len)==0)
2177                                         return(0);
2178                                 break;
2179                         case ososRst:
2180                                 OJPEGWriteStreamRst(tif,mem,len);
2181                                 break;
2182                         case ososEoi:
2183                                 OJPEGWriteStreamEoi(tif,mem,len);
2184                                 break;
2185                 }
2186         } while (*len==0);
2187         return(1);
2188 }
2189
2190 static void
2191 OJPEGWriteStreamSoi(TIFF* tif, void** mem, uint32* len)
2192 {
2193         OJPEGState* sp=(OJPEGState*)tif->tif_data;
2194         assert(OJPEG_BUFFER>=2);
2195         sp->out_buffer[0]=255;
2196         sp->out_buffer[1]=JPEG_MARKER_SOI;
2197         *len=2;
2198         *mem=(void*)sp->out_buffer;
2199         sp->out_state++;
2200 }
2201
2202 static void
2203 OJPEGWriteStreamQTable(TIFF* tif, uint8 table_index, void** mem, uint32* len)
2204 {
2205         OJPEGState* sp=(OJPEGState*)tif->tif_data;
2206         if (sp->qtable[table_index]!=0)
2207         {
2208                 *mem=(void*)(sp->qtable[table_index]+sizeof(uint32));
2209                 *len=*((uint32*)sp->qtable[table_index])-sizeof(uint32);
2210         }
2211         sp->out_state++;
2212 }
2213
2214 static void
2215 OJPEGWriteStreamDcTable(TIFF* tif, uint8 table_index, void** mem, uint32* len)
2216 {
2217         OJPEGState* sp=(OJPEGState*)tif->tif_data;
2218         if (sp->dctable[table_index]!=0)
2219         {
2220                 *mem=(void*)(sp->dctable[table_index]+sizeof(uint32));
2221                 *len=*((uint32*)sp->dctable[table_index])-sizeof(uint32);
2222         }
2223         sp->out_state++;
2224 }
2225
2226 static void
2227 OJPEGWriteStreamAcTable(TIFF* tif, uint8 table_index, void** mem, uint32* len)
2228 {
2229         OJPEGState* sp=(OJPEGState*)tif->tif_data;
2230         if (sp->actable[table_index]!=0)
2231         {
2232                 *mem=(void*)(sp->actable[table_index]+sizeof(uint32));
2233                 *len=*((uint32*)sp->actable[table_index])-sizeof(uint32);
2234         }
2235         sp->out_state++;
2236 }
2237
2238 static void
2239 OJPEGWriteStreamDri(TIFF* tif, void** mem, uint32* len)
2240 {
2241         OJPEGState* sp=(OJPEGState*)tif->tif_data;
2242         assert(OJPEG_BUFFER>=6);
2243         if (sp->restart_interval!=0)
2244         {
2245                 sp->out_buffer[0]=255;
2246                 sp->out_buffer[1]=JPEG_MARKER_DRI;
2247                 sp->out_buffer[2]=0;
2248                 sp->out_buffer[3]=4;
2249                 sp->out_buffer[4]=(sp->restart_interval>>8);
2250                 sp->out_buffer[5]=(sp->restart_interval&255);
2251                 *len=6;
2252                 *mem=(void*)sp->out_buffer;
2253         }
2254         sp->out_state++;
2255 }
2256
2257 static void
2258 OJPEGWriteStreamSof(TIFF* tif, void** mem, uint32* len)
2259 {
2260         OJPEGState* sp=(OJPEGState*)tif->tif_data;
2261         uint8 m;
2262         assert(OJPEG_BUFFER>=2+8+sp->samples_per_pixel_per_plane*3);
2263         assert(255>=8+sp->samples_per_pixel_per_plane*3);
2264         sp->out_buffer[0]=255;
2265         sp->out_buffer[1]=sp->sof_marker_id;
2266         /* Lf */
2267         sp->out_buffer[2]=0;
2268         sp->out_buffer[3]=8+sp->samples_per_pixel_per_plane*3;
2269         /* P */
2270         sp->out_buffer[4]=8;
2271         /* Y */
2272         sp->out_buffer[5]=(sp->sof_y>>8);
2273         sp->out_buffer[6]=(sp->sof_y&255);
2274         /* X */
2275         sp->out_buffer[7]=(sp->sof_x>>8);
2276         sp->out_buffer[8]=(sp->sof_x&255);
2277         /* Nf */
2278         sp->out_buffer[9]=sp->samples_per_pixel_per_plane;
2279         for (m=0; m<sp->samples_per_pixel_per_plane; m++)
2280         {
2281                 /* C */
2282                 sp->out_buffer[10+m*3]=sp->sof_c[sp->plane_sample_offset+m];
2283                 /* H and V */
2284                 sp->out_buffer[10+m*3+1]=sp->sof_hv[sp->plane_sample_offset+m];
2285                 /* Tq */
2286                 sp->out_buffer[10+m*3+2]=sp->sof_tq[sp->plane_sample_offset+m];
2287         }
2288         *len=10+sp->samples_per_pixel_per_plane*3;
2289         *mem=(void*)sp->out_buffer;
2290         sp->out_state++;
2291 }
2292
2293 static void
2294 OJPEGWriteStreamSos(TIFF* tif, void** mem, uint32* len)
2295 {
2296         OJPEGState* sp=(OJPEGState*)tif->tif_data;
2297         uint8 m;
2298         assert(OJPEG_BUFFER>=2+6+sp->samples_per_pixel_per_plane*2);
2299         assert(255>=6+sp->samples_per_pixel_per_plane*2);
2300         sp->out_buffer[0]=255;
2301         sp->out_buffer[1]=JPEG_MARKER_SOS;
2302         /* Ls */
2303         sp->out_buffer[2]=0;
2304         sp->out_buffer[3]=6+sp->samples_per_pixel_per_plane*2;
2305         /* Ns */
2306         sp->out_buffer[4]=sp->samples_per_pixel_per_plane;
2307         for (m=0; m<sp->samples_per_pixel_per_plane; m++)
2308         {
2309                 /* Cs */
2310                 sp->out_buffer[5+m*2]=sp->sos_cs[sp->plane_sample_offset+m];
2311                 /* Td and Ta */
2312                 sp->out_buffer[5+m*2+1]=sp->sos_tda[sp->plane_sample_offset+m];
2313         }
2314         /* Ss */
2315         sp->out_buffer[5+sp->samples_per_pixel_per_plane*2]=0;
2316         /* Se */
2317         sp->out_buffer[5+sp->samples_per_pixel_per_plane*2+1]=63;
2318         /* Ah and Al */
2319         sp->out_buffer[5+sp->samples_per_pixel_per_plane*2+2]=0;
2320         *len=8+sp->samples_per_pixel_per_plane*2;
2321         *mem=(void*)sp->out_buffer;
2322         sp->out_state++;
2323 }
2324
2325 static int
2326 OJPEGWriteStreamCompressed(TIFF* tif, void** mem, uint32* len)
2327 {
2328         OJPEGState* sp=(OJPEGState*)tif->tif_data;
2329         if (sp->in_buffer_togo==0)
2330         {
2331                 if (OJPEGReadBufferFill(sp)==0)
2332                         return(0);
2333                 assert(sp->in_buffer_togo>0);
2334         }
2335         *len=sp->in_buffer_togo;
2336         *mem=(void*)sp->in_buffer_cur;
2337         sp->in_buffer_togo=0;
2338         if (sp->in_buffer_file_togo==0)
2339         {
2340                 switch(sp->in_buffer_source)
2341                 {
2342                         case osibsStrile:
2343                                 if (sp->in_buffer_next_strile<sp->in_buffer_strile_count)
2344                                         sp->out_state=ososRst;
2345                                 else
2346                                         sp->out_state=ososEoi;
2347                                 break;
2348                         case osibsEof:
2349                                 sp->out_state=ososEoi;
2350                                 break;
2351                         default:
2352                                 break;
2353                 }
2354         }
2355         return(1);
2356 }
2357
2358 static void
2359 OJPEGWriteStreamRst(TIFF* tif, void** mem, uint32* len)
2360 {
2361         OJPEGState* sp=(OJPEGState*)tif->tif_data;
2362         assert(OJPEG_BUFFER>=2);
2363         sp->out_buffer[0]=255;
2364         sp->out_buffer[1]=JPEG_MARKER_RST0+sp->restart_index;
2365         sp->restart_index++;
2366         if (sp->restart_index==8)
2367                 sp->restart_index=0;
2368         *len=2;
2369         *mem=(void*)sp->out_buffer;
2370         sp->out_state=ososCompressed;
2371 }
2372
2373 static void
2374 OJPEGWriteStreamEoi(TIFF* tif, void** mem, uint32* len)
2375 {
2376         OJPEGState* sp=(OJPEGState*)tif->tif_data;
2377         assert(OJPEG_BUFFER>=2);
2378         sp->out_buffer[0]=255;
2379         sp->out_buffer[1]=JPEG_MARKER_EOI;
2380         *len=2;
2381         *mem=(void*)sp->out_buffer;
2382 }
2383
2384 #ifndef LIBJPEG_ENCAP_EXTERNAL
2385 static int
2386 jpeg_create_decompress_encap(OJPEGState* sp, jpeg_decompress_struct* cinfo)
2387 {
2388         return(SETJMP(sp->exit_jmpbuf)?0:(jpeg_create_decompress(cinfo),1));
2389 }
2390 #endif
2391
2392 #ifndef LIBJPEG_ENCAP_EXTERNAL
2393 static int
2394 jpeg_read_header_encap(OJPEGState* sp, jpeg_decompress_struct* cinfo, uint8 require_image)
2395 {
2396         return(SETJMP(sp->exit_jmpbuf)?0:(jpeg_read_header(cinfo,require_image),1));
2397 }
2398 #endif
2399
2400 #ifndef LIBJPEG_ENCAP_EXTERNAL
2401 static int
2402 jpeg_start_decompress_encap(OJPEGState* sp, jpeg_decompress_struct* cinfo)
2403 {
2404         return(SETJMP(sp->exit_jmpbuf)?0:(jpeg_start_decompress(cinfo),1));
2405 }
2406 #endif
2407
2408 #ifndef LIBJPEG_ENCAP_EXTERNAL
2409 static int
2410 jpeg_read_scanlines_encap(OJPEGState* sp, jpeg_decompress_struct* cinfo, void* scanlines, uint32 max_lines)
2411 {
2412         return(SETJMP(sp->exit_jmpbuf)?0:(jpeg_read_scanlines(cinfo,scanlines,max_lines),1));
2413 }
2414 #endif
2415
2416 #ifndef LIBJPEG_ENCAP_EXTERNAL
2417 static int
2418 jpeg_read_raw_data_encap(OJPEGState* sp, jpeg_decompress_struct* cinfo, void* data, uint32 max_lines)
2419 {
2420         return(SETJMP(sp->exit_jmpbuf)?0:(jpeg_read_raw_data(cinfo,data,max_lines),1));
2421 }
2422 #endif
2423
2424 #ifndef LIBJPEG_ENCAP_EXTERNAL
2425 static void
2426 jpeg_encap_unwind(TIFF* tif)
2427 {
2428         OJPEGState* sp=(OJPEGState*)tif->tif_data;
2429         LONGJMP(sp->exit_jmpbuf,1);
2430 }
2431 #endif
2432
2433 static void
2434 OJPEGLibjpegJpegErrorMgrOutputMessage(jpeg_common_struct* cinfo)
2435 {
2436         char buffer[JMSG_LENGTH_MAX];
2437         (*cinfo->err->format_message)(cinfo,buffer);
2438         TIFFWarningExt(((TIFF*)(cinfo->client_data))->tif_clientdata,"LibJpeg","%s",buffer);
2439 }
2440
2441 static void
2442 OJPEGLibjpegJpegErrorMgrErrorExit(jpeg_common_struct* cinfo)
2443 {
2444         char buffer[JMSG_LENGTH_MAX];
2445         (*cinfo->err->format_message)(cinfo,buffer);
2446         TIFFErrorExt(((TIFF*)(cinfo->client_data))->tif_clientdata,"LibJpeg","%s",buffer);
2447         jpeg_encap_unwind((TIFF*)(cinfo->client_data));
2448 }
2449
2450 static void
2451 OJPEGLibjpegJpegSourceMgrInitSource(jpeg_decompress_struct* cinfo)
2452 {
2453         (void)cinfo;
2454 }
2455
2456 static boolean
2457 OJPEGLibjpegJpegSourceMgrFillInputBuffer(jpeg_decompress_struct* cinfo)
2458 {
2459         TIFF* tif=(TIFF*)cinfo->client_data;
2460         OJPEGState* sp=(OJPEGState*)tif->tif_data;
2461         void* mem=0;
2462         uint32 len=0U;
2463         if (OJPEGWriteStream(tif,&mem,&len)==0)
2464         {
2465                 TIFFErrorExt(tif->tif_clientdata,"LibJpeg","Premature end of JPEG data");
2466                 jpeg_encap_unwind(tif);
2467         }
2468         sp->libjpeg_jpeg_source_mgr.bytes_in_buffer=len;
2469         sp->libjpeg_jpeg_source_mgr.next_input_byte=mem;
2470         return(1);
2471 }
2472
2473 static void
2474 OJPEGLibjpegJpegSourceMgrSkipInputData(jpeg_decompress_struct* cinfo, long num_bytes)
2475 {
2476         TIFF* tif=(TIFF*)cinfo->client_data;
2477         (void)num_bytes;
2478         TIFFErrorExt(tif->tif_clientdata,"LibJpeg","Unexpected error");
2479         jpeg_encap_unwind(tif);
2480 }
2481
2482 static boolean
2483 OJPEGLibjpegJpegSourceMgrResyncToRestart(jpeg_decompress_struct* cinfo, int desired)
2484 {
2485         TIFF* tif=(TIFF*)cinfo->client_data;
2486         (void)desired;
2487         TIFFErrorExt(tif->tif_clientdata,"LibJpeg","Unexpected error");
2488         jpeg_encap_unwind(tif);
2489         return(0);
2490 }
2491
2492 static void
2493 OJPEGLibjpegJpegSourceMgrTermSource(jpeg_decompress_struct* cinfo)
2494 {
2495         (void)cinfo;
2496 }
2497
2498 #endif
2499
2500
2501 /*
2502  * Local Variables:
2503  * mode: c
2504  * c-basic-offset: 8
2505  * fill-column: 78
2506  * End:
2507  */