thirdparty/libtiff/tif_ojpeg.c

   1 /* $Id: tif_ojpeg.c,v 1.54 2011-05-31 17:05:07 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    developement. 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 accomodate 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         switch(tag)
 532         {
 533                 case TIFFTAG_JPEGIFOFFSET:
 534                         sp->jpeg_interchange_format=(uint64)va_arg(ap,uint64);
 535                         break;
 536                 case TIFFTAG_JPEGIFBYTECOUNT:
 537                         sp->jpeg_interchange_format_length=(uint64)va_arg(ap,uint64);
 538                         break;
 539                 case TIFFTAG_YCBCRSUBSAMPLING:
 540                         sp->subsampling_tag=1;
 541                         sp->subsampling_hor=(uint8)va_arg(ap,uint16_vap);
 542                         sp->subsampling_ver=(uint8)va_arg(ap,uint16_vap);
 543                         tif->tif_dir.td_ycbcrsubsampling[0]=sp->subsampling_hor;
 544                         tif->tif_dir.td_ycbcrsubsampling[1]=sp->subsampling_ver;
 545                         break;
 546                 case TIFFTAG_JPEGQTABLES:
 547                         ma=(uint32)va_arg(ap,uint32);
 548                         if (ma!=0)
 549                         {
 550                                 if (ma>3)
 551                                 {
 552                                         TIFFErrorExt(tif->tif_clientdata,module,"JpegQTables tag has incorrect count");
 553                                         return(0);
 554                                 }
 555                                 sp->qtable_offset_count=(uint8)ma;
 556                                 mb=(uint64*)va_arg(ap,uint64*);
 557                                 for (n=0; n<ma; n++)
 558                                         sp->qtable_offset[n]=mb[n];
 559                         }
 560                         break;
 561                 case TIFFTAG_JPEGDCTABLES:
 562                         ma=(uint32)va_arg(ap,uint32);
 563                         if (ma!=0)
 564                         {
 565                                 if (ma>3)
 566                                 {
 567                                         TIFFErrorExt(tif->tif_clientdata,module,"JpegDcTables tag has incorrect count");
 568                                         return(0);
 569                                 }
 570                                 sp->dctable_offset_count=(uint8)ma;
 571                                 mb=(uint64*)va_arg(ap,uint64*);
 572                                 for (n=0; n<ma; n++)
 573                                         sp->dctable_offset[n]=mb[n];
 574                         }
 575                         break;
 576                 case TIFFTAG_JPEGACTABLES:
 577                         ma=(uint32)va_arg(ap,uint32);
 578                         if (ma!=0)
 579                         {
 580                                 if (ma>3)
 581                                 {
 582                                         TIFFErrorExt(tif->tif_clientdata,module,"JpegAcTables tag has incorrect count");
 583                                         return(0);
 584                                 }
 585                                 sp->actable_offset_count=(uint8)ma;
 586                                 mb=(uint64*)va_arg(ap,uint64*);
 587                                 for (n=0; n<ma; n++)
 588                                         sp->actable_offset[n]=mb[n];
 589                         }
 590                         break;
 591                 case TIFFTAG_JPEGPROC:
 592                         sp->jpeg_proc=(uint8)va_arg(ap,uint16_vap);
 593                         break;
 594                 case TIFFTAG_JPEGRESTARTINTERVAL:
 595                         sp->restart_interval=(uint16)va_arg(ap,uint16_vap);
 596                         break;
 597                 default:
 598                         return (*sp->vsetparent)(tif,tag,ap);
 599         }
 600         TIFFSetFieldBit(tif,TIFFFieldWithTag(tif,tag)->field_bit);
 601         tif->tif_flags|=TIFF_DIRTYDIRECT;
 602         return(1);
 603 }
 604
 605 static void
 606 OJPEGPrintDir(TIFF* tif, FILE* fd, long flags)
 607 {
 608         OJPEGState* sp=(OJPEGState*)tif->tif_data;
 609         uint8 m;
 610         (void)flags;
 611         assert(sp!=NULL);
 612         if (TIFFFieldSet(tif,FIELD_OJPEG_JPEGINTERCHANGEFORMAT))
 613                 fprintf(fd,"  JpegInterchangeFormat: " TIFF_UINT64_FORMAT "\n",(TIFF_UINT64_T)sp->jpeg_interchange_format);
 614         if (TIFFFieldSet(tif,FIELD_OJPEG_JPEGINTERCHANGEFORMATLENGTH))
 615                 fprintf(fd,"  JpegInterchangeFormatLength: " TIFF_UINT64_FORMAT "\n",(TIFF_UINT64_T)sp->jpeg_interchange_format_length);
 616         if (TIFFFieldSet(tif,FIELD_OJPEG_JPEGQTABLES))
 617         {
 618                 fprintf(fd,"  JpegQTables:");
 619                 for (m=0; m<sp->qtable_offset_count; m++)
 620                         fprintf(fd," " TIFF_UINT64_FORMAT,(TIFF_UINT64_T)sp->qtable_offset[m]);
 621                 fprintf(fd,"\n");
 622         }
 623         if (TIFFFieldSet(tif,FIELD_OJPEG_JPEGDCTABLES))
 624         {
 625                 fprintf(fd,"  JpegDcTables:");
 626                 for (m=0; m<sp->dctable_offset_count; m++)
 627                         fprintf(fd," " TIFF_UINT64_FORMAT,(TIFF_UINT64_T)sp->dctable_offset[m]);
 628                 fprintf(fd,"\n");
 629         }
 630         if (TIFFFieldSet(tif,FIELD_OJPEG_JPEGACTABLES))
 631         {
 632                 fprintf(fd,"  JpegAcTables:");
 633                 for (m=0; m<sp->actable_offset_count; m++)
 634                         fprintf(fd," " TIFF_UINT64_FORMAT,(TIFF_UINT64_T)sp->actable_offset[m]);
 635                 fprintf(fd,"\n");
 636         }
 637         if (TIFFFieldSet(tif,FIELD_OJPEG_JPEGPROC))
 638                 fprintf(fd,"  JpegProc: %u\n",(unsigned int)sp->jpeg_proc);
 639         if (TIFFFieldSet(tif,FIELD_OJPEG_JPEGRESTARTINTERVAL))
 640                 fprintf(fd,"  JpegRestartInterval: %u\n",(unsigned int)sp->restart_interval);
 641         if (sp->printdir)
 642                 (*sp->printdir)(tif, fd, flags);
 643 }
 644
 645 static int
 646 OJPEGFixupTags(TIFF* tif)
 647 {
 648         (void) tif;
 649         return(1);
 650 }
 651
 652 static int
 653 OJPEGSetupDecode(TIFF* tif)
 654 {
 655         static const char module[]="OJPEGSetupDecode";
 656         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");
 657         return(1);
 658 }
 659
 660 static int
 661 OJPEGPreDecode(TIFF* tif, uint16 s)
 662 {
 663         OJPEGState* sp=(OJPEGState*)tif->tif_data;
 664         uint32 m;
 665         if (sp->subsamplingcorrect_done==0)
 666                 OJPEGSubsamplingCorrect(tif);
 667         if (sp->readheader_done==0)
 668         {
 669                 if (OJPEGReadHeaderInfo(tif)==0)
 670                         return(0);
 671         }
 672         if (sp->sos_end[s].log==0)
 673         {
 674                 if (OJPEGReadSecondarySos(tif,s)==0)
 675                         return(0);
 676         }
 677         if isTiled(tif)
 678                 m=tif->tif_curtile;
 679         else
 680                 m=tif->tif_curstrip;
 681         if ((sp->writeheader_done!=0) && ((sp->write_cursample!=s) || (sp->write_curstrile>m)))
 682         {
 683                 if (sp->libjpeg_session_active!=0)
 684                         OJPEGLibjpegSessionAbort(tif);
 685                 sp->writeheader_done=0;
 686         }
 687         if (sp->writeheader_done==0)
 688         {
 689                 sp->plane_sample_offset=(uint8)s;
 690                 sp->write_cursample=s;
 691                 sp->write_curstrile=s*tif->tif_dir.td_stripsperimage;
 692                 if ((sp->in_buffer_file_pos_log==0) ||
 693                     (sp->in_buffer_file_pos-sp->in_buffer_togo!=sp->sos_end[s].in_buffer_file_pos))
 694                 {
 695                         sp->in_buffer_source=sp->sos_end[s].in_buffer_source;
 696                         sp->in_buffer_next_strile=sp->sos_end[s].in_buffer_next_strile;
 697                         sp->in_buffer_file_pos=sp->sos_end[s].in_buffer_file_pos;
 698                         sp->in_buffer_file_pos_log=0;
 699                         sp->in_buffer_file_togo=sp->sos_end[s].in_buffer_file_togo;
 700                         sp->in_buffer_togo=0;
 701                         sp->in_buffer_cur=0;
 702                 }
 703                 if (OJPEGWriteHeaderInfo(tif)==0)
 704                         return(0);
 705         }
 706         while (sp->write_curstrile<m)
 707         {
 708                 if (sp->libjpeg_jpeg_query_style==0)
 709                 {
 710                         if (OJPEGPreDecodeSkipRaw(tif)==0)
 711                                 return(0);
 712                 }
 713                 else
 714                 {
 715                         if (OJPEGPreDecodeSkipScanlines(tif)==0)
 716                                 return(0);
 717                 }
 718                 sp->write_curstrile++;
 719         }
 720         return(1);
 721 }
 722
 723 static int
 724 OJPEGPreDecodeSkipRaw(TIFF* tif)
 725 {
 726         OJPEGState* sp=(OJPEGState*)tif->tif_data;
 727         uint32 m;
 728         m=sp->lines_per_strile;
 729         if (sp->subsampling_convert_state!=0)
 730         {
 731                 if (sp->subsampling_convert_clines-sp->subsampling_convert_state>=m)
 732                 {
 733                         sp->subsampling_convert_state+=m;
 734                         if (sp->subsampling_convert_state==sp->subsampling_convert_clines)
 735                                 sp->subsampling_convert_state=0;
 736                         return(1);
 737                 }
 738                 m-=sp->subsampling_convert_clines-sp->subsampling_convert_state;
 739                 sp->subsampling_convert_state=0;
 740         }
 741         while (m>=sp->subsampling_convert_clines)
 742         {
 743                 if (jpeg_read_raw_data_encap(sp,&(sp->libjpeg_jpeg_decompress_struct),sp->subsampling_convert_ycbcrimage,sp->subsampling_ver*8)==0)
 744                         return(0);
 745                 m-=sp->subsampling_convert_clines;
 746         }
 747         if (m>0)
 748         {
 749                 if (jpeg_read_raw_data_encap(sp,&(sp->libjpeg_jpeg_decompress_struct),sp->subsampling_convert_ycbcrimage,sp->subsampling_ver*8)==0)
 750                         return(0);
 751                 sp->subsampling_convert_state=m;
 752         }
 753         return(1);
 754 }
 755
 756 static int
 757 OJPEGPreDecodeSkipScanlines(TIFF* tif)
 758 {
 759         static const char module[]="OJPEGPreDecodeSkipScanlines";
 760         OJPEGState* sp=(OJPEGState*)tif->tif_data;
 761         uint32 m;
 762         if (sp->skip_buffer==NULL)
 763         {
 764                 sp->skip_buffer=_TIFFmalloc(sp->bytes_per_line);
 765                 if (sp->skip_buffer==NULL)
 766                 {
 767                         TIFFErrorExt(tif->tif_clientdata,module,"Out of memory");
 768                         return(0);
 769                 }
 770         }
 771         for (m=0; m<sp->lines_per_strile; m++)
 772         {
 773                 if (jpeg_read_scanlines_encap(sp,&(sp->libjpeg_jpeg_decompress_struct),&sp->skip_buffer,1)==0)
 774                         return(0);
 775         }
 776         return(1);
 777 }
 778
 779 static int
 780 OJPEGDecode(TIFF* tif, uint8* buf, tmsize_t cc, uint16 s)
 781 {
 782         OJPEGState* sp=(OJPEGState*)tif->tif_data;
 783         (void)s;
 784         if (sp->libjpeg_jpeg_query_style==0)
 785         {
 786                 if (OJPEGDecodeRaw(tif,buf,cc)==0)
 787                         return(0);
 788         }
 789         else
 790         {
 791                 if (OJPEGDecodeScanlines(tif,buf,cc)==0)
 792                         return(0);
 793         }
 794         return(1);
 795 }
 796
 797 static int
 798 OJPEGDecodeRaw(TIFF* tif, uint8* buf, tmsize_t cc)
 799 {
 800         static const char module[]="OJPEGDecodeRaw";
 801         OJPEGState* sp=(OJPEGState*)tif->tif_data;
 802         uint8* m;
 803         tmsize_t n;
 804         uint8* oy;
 805         uint8* ocb;
 806         uint8* ocr;
 807         uint8* p;
 808         uint32 q;
 809         uint8* r;
 810         uint8 sx,sy;
 811         if (cc%sp->bytes_per_line!=0)
 812         {
 813                 TIFFErrorExt(tif->tif_clientdata,module,"Fractional scanline not read");
 814                 return(0);
 815         }
 816         assert(cc>0);
 817         m=buf;
 818         n=cc;
 819         do
 820         {
 821                 if (sp->subsampling_convert_state==0)
 822                 {
 823                         if (jpeg_read_raw_data_encap(sp,&(sp->libjpeg_jpeg_decompress_struct),sp->subsampling_convert_ycbcrimage,sp->subsampling_ver*8)==0)
 824                                 return(0);
 825                 }
 826                 oy=sp->subsampling_convert_ybuf+sp->subsampling_convert_state*sp->subsampling_ver*sp->subsampling_convert_ylinelen;
 827                 ocb=sp->subsampling_convert_cbbuf+sp->subsampling_convert_state*sp->subsampling_convert_clinelen;
 828                 ocr=sp->subsampling_convert_crbuf+sp->subsampling_convert_state*sp->subsampling_convert_clinelen;
 829                 p=m;
 830                 for (q=0; q<sp->subsampling_convert_clinelenout; q++)
 831                 {
 832                         r=oy;
 833                         for (sy=0; sy<sp->subsampling_ver; sy++)
 834                         {
 835                                 for (sx=0; sx<sp->subsampling_hor; sx++)
 836                                         *p++=*r++;
 837                                 r+=sp->subsampling_convert_ylinelen-sp->subsampling_hor;
 838                         }
 839                         oy+=sp->subsampling_hor;
 840                         *p++=*ocb++;
 841                         *p++=*ocr++;
 842                 }
 843                 sp->subsampling_convert_state++;
 844                 if (sp->subsampling_convert_state==sp->subsampling_convert_clines)
 845                         sp->subsampling_convert_state=0;
 846                 m+=sp->bytes_per_line;
 847                 n-=sp->bytes_per_line;
 848         } while(n>0);
 849         return(1);
 850 }
 851
 852 static int
 853 OJPEGDecodeScanlines(TIFF* tif, uint8* buf, tmsize_t cc)
 854 {
 855         static const char module[]="OJPEGDecodeScanlines";
 856         OJPEGState* sp=(OJPEGState*)tif->tif_data;
 857         uint8* m;
 858         tmsize_t n;
 859         if (cc%sp->bytes_per_line!=0)
 860         {
 861                 TIFFErrorExt(tif->tif_clientdata,module,"Fractional scanline not read");
 862                 return(0);
 863         }
 864         assert(cc>0);
 865         m=buf;
 866         n=cc;
 867         do
 868         {
 869                 if (jpeg_read_scanlines_encap(sp,&(sp->libjpeg_jpeg_decompress_struct),&m,1)==0)
 870                         return(0);
 871                 m+=sp->bytes_per_line;
 872                 n-=sp->bytes_per_line;
 873         } while(n>0);
 874         return(1);
 875 }
 876
 877 static void
 878 OJPEGPostDecode(TIFF* tif, uint8* buf, tmsize_t cc)
 879 {
 880         OJPEGState* sp=(OJPEGState*)tif->tif_data;
 881         (void)buf;
 882         (void)cc;
 883         sp->write_curstrile++;
 884         if (sp->write_curstrile%tif->tif_dir.td_stripsperimage==0)
 885         {
 886                 assert(sp->libjpeg_session_active!=0);
 887                 OJPEGLibjpegSessionAbort(tif);
 888                 sp->writeheader_done=0;
 889         }
 890 }
 891
 892 static int
 893 OJPEGSetupEncode(TIFF* tif)
 894 {
 895         static const char module[]="OJPEGSetupEncode";
 896         TIFFErrorExt(tif->tif_clientdata,module,"OJPEG encoding not supported; use new-style JPEG compression instead");
 897         return(0);
 898 }
 899
 900 static int
 901 OJPEGPreEncode(TIFF* tif, uint16 s)
 902 {
 903         static const char module[]="OJPEGPreEncode";
 904         (void)s;
 905         TIFFErrorExt(tif->tif_clientdata,module,"OJPEG encoding not supported; use new-style JPEG compression instead");
 906         return(0);
 907 }
 908
 909 static int
 910 OJPEGEncode(TIFF* tif, uint8* buf, tmsize_t cc, uint16 s)
 911 {
 912         static const char module[]="OJPEGEncode";
 913         (void)buf;
 914         (void)cc;
 915         (void)s;
 916         TIFFErrorExt(tif->tif_clientdata,module,"OJPEG encoding not supported; use new-style JPEG compression instead");
 917         return(0);
 918 }
 919
 920 static int
 921 OJPEGPostEncode(TIFF* tif)
 922 {
 923         static const char module[]="OJPEGPostEncode";
 924         TIFFErrorExt(tif->tif_clientdata,module,"OJPEG encoding not supported; use new-style JPEG compression instead");
 925         return(0);
 926 }
 927
 928 static void
 929 OJPEGCleanup(TIFF* tif)
 930 {
 931         OJPEGState* sp=(OJPEGState*)tif->tif_data;
 932         if (sp!=0)
 933         {
 934                 tif->tif_tagmethods.vgetfield=sp->vgetparent;
 935                 tif->tif_tagmethods.vsetfield=sp->vsetparent;
 936                 tif->tif_tagmethods.printdir=sp->printdir;
 937                 if (sp->qtable[0]!=0)
 938                         _TIFFfree(sp->qtable[0]);
 939                 if (sp->qtable[1]!=0)
 940                         _TIFFfree(sp->qtable[1]);
 941                 if (sp->qtable[2]!=0)
 942                         _TIFFfree(sp->qtable[2]);
 943                 if (sp->qtable[3]!=0)
 944                         _TIFFfree(sp->qtable[3]);
 945                 if (sp->dctable[0]!=0)
 946                         _TIFFfree(sp->dctable[0]);
 947                 if (sp->dctable[1]!=0)
 948                         _TIFFfree(sp->dctable[1]);
 949                 if (sp->dctable[2]!=0)
 950                         _TIFFfree(sp->dctable[2]);
 951                 if (sp->dctable[3]!=0)
 952                         _TIFFfree(sp->dctable[3]);
 953                 if (sp->actable[0]!=0)
 954                         _TIFFfree(sp->actable[0]);
 955                 if (sp->actable[1]!=0)
 956                         _TIFFfree(sp->actable[1]);
 957                 if (sp->actable[2]!=0)
 958                         _TIFFfree(sp->actable[2]);
 959                 if (sp->actable[3]!=0)
 960                         _TIFFfree(sp->actable[3]);
 961                 if (sp->libjpeg_session_active!=0)
 962                         OJPEGLibjpegSessionAbort(tif);
 963                 if (sp->subsampling_convert_ycbcrbuf!=0)
 964                         _TIFFfree(sp->subsampling_convert_ycbcrbuf);
 965                 if (sp->subsampling_convert_ycbcrimage!=0)
 966                         _TIFFfree(sp->subsampling_convert_ycbcrimage);
 967                 if (sp->skip_buffer!=0)
 968                         _TIFFfree(sp->skip_buffer);
 969                 _TIFFfree(sp);
 970                 tif->tif_data=NULL;
 971                 _TIFFSetDefaultCompressionState(tif);
 972         }
 973 }
 974
 975 static void
 976 OJPEGSubsamplingCorrect(TIFF* tif)
 977 {
 978         static const char module[]="OJPEGSubsamplingCorrect";
 979         OJPEGState* sp=(OJPEGState*)tif->tif_data;
 980         uint8 mh;
 981         uint8 mv;
 982         _TIFFFillStriles( tif );
 983
 984         assert(sp->subsamplingcorrect_done==0);
 985         if ((tif->tif_dir.td_samplesperpixel!=3) || ((tif->tif_dir.td_photometric!=PHOTOMETRIC_YCBCR) &&
 986             (tif->tif_dir.td_photometric!=PHOTOMETRIC_ITULAB)))
 987         {
 988                 if (sp->subsampling_tag!=0)
 989                         TIFFWarningExt(tif->tif_clientdata,module,"Subsampling tag not appropriate for this Photometric and/or SamplesPerPixel");
 990                 sp->subsampling_hor=1;
 991                 sp->subsampling_ver=1;
 992                 sp->subsampling_force_desubsampling_inside_decompression=0;
 993         }
 994         else
 995         {
 996                 sp->subsamplingcorrect_done=1;
 997                 mh=sp->subsampling_hor;
 998                 mv=sp->subsampling_ver;
 999                 sp->subsamplingcorrect=1;
1000                 OJPEGReadHeaderInfoSec(tif);
1001                 if (sp->subsampling_force_desubsampling_inside_decompression!=0)
1002                 {
1003                         sp->subsampling_hor=1;
1004                         sp->subsampling_ver=1;
1005                 }
1006                 sp->subsamplingcorrect=0;
1007                 if (((sp->subsampling_hor!=mh) || (sp->subsampling_ver!=mv)) && (sp->subsampling_force_desubsampling_inside_decompression==0))
1008                 {
1009                         if (sp->subsampling_tag==0)
1010                                 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);
1011                         else
1012                                 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);
1013                 }
1014                 if (sp->subsampling_force_desubsampling_inside_decompression!=0)
1015                 {
1016                         if (sp->subsampling_tag==0)
1017                                 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");
1018                         else
1019                                 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);
1020                 }
1021                 if (sp->subsampling_force_desubsampling_inside_decompression==0)
1022                 {
1023                         if (sp->subsampling_hor<sp->subsampling_ver)
1024                                 TIFFWarningExt(tif->tif_clientdata,module,"Subsampling values [%d,%d] are not allowed in TIFF",sp->subsampling_hor,sp->subsampling_ver);
1025                 }
1026         }
1027         sp->subsamplingcorrect_done=1;
1028 }
1029
1030 static int
1031 OJPEGReadHeaderInfo(TIFF* tif)
1032 {
1033         static const char module[]="OJPEGReadHeaderInfo";
1034         OJPEGState* sp=(OJPEGState*)tif->tif_data;
1035         assert(sp->readheader_done==0);
1036         sp->image_width=tif->tif_dir.td_imagewidth;
1037         sp->image_length=tif->tif_dir.td_imagelength;
1038         if isTiled(tif)
1039         {
1040                 sp->strile_width=tif->tif_dir.td_tilewidth;
1041                 sp->strile_length=tif->tif_dir.td_tilelength;
1042                 sp->strile_length_total=((sp->image_length+sp->strile_length-1)/sp->strile_length)*sp->strile_length;
1043         }
1044         else
1045         {
1046                 sp->strile_width=sp->image_width;
1047                 sp->strile_length=tif->tif_dir.td_rowsperstrip;
1048                 sp->strile_length_total=sp->image_length;
1049         }
1050         if (tif->tif_dir.td_samplesperpixel==1)
1051         {
1052                 sp->samples_per_pixel=1;
1053                 sp->plane_sample_offset=0;
1054                 sp->samples_per_pixel_per_plane=sp->samples_per_pixel;
1055                 sp->subsampling_hor=1;
1056                 sp->subsampling_ver=1;
1057         }
1058         else
1059         {
1060                 if (tif->tif_dir.td_samplesperpixel!=3)
1061                 {
1062                         TIFFErrorExt(tif->tif_clientdata,module,"SamplesPerPixel %d not supported for this compression scheme",sp->samples_per_pixel);
1063                         return(0);
1064                 }
1065                 sp->samples_per_pixel=3;
1066                 sp->plane_sample_offset=0;
1067                 if (tif->tif_dir.td_planarconfig==PLANARCONFIG_CONTIG)
1068                         sp->samples_per_pixel_per_plane=3;
1069                 else
1070                         sp->samples_per_pixel_per_plane=1;
1071         }
1072         if (sp->strile_length<sp->image_length)
1073         {
1074                 if (sp->strile_length%(sp->subsampling_ver*8)!=0)
1075                 {
1076                         TIFFErrorExt(tif->tif_clientdata,module,"Incompatible vertical subsampling and image strip/tile length");
1077                         return(0);
1078                 }
1079                 sp->restart_interval=((sp->strile_width+sp->subsampling_hor*8-1)/(sp->subsampling_hor*8))*(sp->strile_length/(sp->subsampling_ver*8));
1080         }
1081         if (OJPEGReadHeaderInfoSec(tif)==0)
1082                 return(0);
1083         sp->sos_end[0].log=1;
1084         sp->sos_end[0].in_buffer_source=sp->in_buffer_source;
1085         sp->sos_end[0].in_buffer_next_strile=sp->in_buffer_next_strile;
1086         sp->sos_end[0].in_buffer_file_pos=sp->in_buffer_file_pos-sp->in_buffer_togo;
1087         sp->sos_end[0].in_buffer_file_togo=sp->in_buffer_file_togo+sp->in_buffer_togo;
1088         sp->readheader_done=1;
1089         return(1);
1090 }
1091
1092 static int
1093 OJPEGReadSecondarySos(TIFF* tif, uint16 s)
1094 {
1095         OJPEGState* sp=(OJPEGState*)tif->tif_data;
1096         uint8 m;
1097         assert(s>0);
1098         assert(s<3);
1099         assert(sp->sos_end[0].log!=0);
1100         assert(sp->sos_end[s].log==0);
1101         sp->plane_sample_offset=s-1;
1102         while(sp->sos_end[sp->plane_sample_offset].log==0)
1103                 sp->plane_sample_offset--;
1104         sp->in_buffer_source=sp->sos_end[sp->plane_sample_offset].in_buffer_source;
1105         sp->in_buffer_next_strile=sp->sos_end[sp->plane_sample_offset].in_buffer_next_strile;
1106         sp->in_buffer_file_pos=sp->sos_end[sp->plane_sample_offset].in_buffer_file_pos;
1107         sp->in_buffer_file_pos_log=0;
1108         sp->in_buffer_file_togo=sp->sos_end[sp->plane_sample_offset].in_buffer_file_togo;
1109         sp->in_buffer_togo=0;
1110         sp->in_buffer_cur=0;
1111         while(sp->plane_sample_offset<s)
1112         {
1113                 do
1114                 {
1115                         if (OJPEGReadByte(sp,&m)==0)
1116                                 return(0);
1117                         if (m==255)
1118                         {
1119                                 do
1120                                 {
1121                                         if (OJPEGReadByte(sp,&m)==0)
1122                                                 return(0);
1123                                         if (m!=255)
1124                                                 break;
1125                                 } while(1);
1126                                 if (m==JPEG_MARKER_SOS)
1127                                         break;
1128                         }
1129                 } while(1);
1130                 sp->plane_sample_offset++;
1131                 if (OJPEGReadHeaderInfoSecStreamSos(tif)==0)
1132                         return(0);
1133                 sp->sos_end[sp->plane_sample_offset].log=1;
1134                 sp->sos_end[sp->plane_sample_offset].in_buffer_source=sp->in_buffer_source;
1135                 sp->sos_end[sp->plane_sample_offset].in_buffer_next_strile=sp->in_buffer_next_strile;
1136                 sp->sos_end[sp->plane_sample_offset].in_buffer_file_pos=sp->in_buffer_file_pos-sp->in_buffer_togo;
1137                 sp->sos_end[sp->plane_sample_offset].in_buffer_file_togo=sp->in_buffer_file_togo+sp->in_buffer_togo;
1138         }
1139         return(1);
1140 }
1141
1142 static int
1143 OJPEGWriteHeaderInfo(TIFF* tif)
1144 {
1145         static const char module[]="OJPEGWriteHeaderInfo";
1146         OJPEGState* sp=(OJPEGState*)tif->tif_data;
1147         uint8** m;
1148         uint32 n;
1149         assert(sp->libjpeg_session_active==0);
1150         sp->out_state=ososSoi;
1151         sp->restart_index=0;
1152         jpeg_std_error(&(sp->libjpeg_jpeg_error_mgr));
1153         sp->libjpeg_jpeg_error_mgr.output_message=OJPEGLibjpegJpegErrorMgrOutputMessage;
1154         sp->libjpeg_jpeg_error_mgr.error_exit=OJPEGLibjpegJpegErrorMgrErrorExit;
1155         sp->libjpeg_jpeg_decompress_struct.err=&(sp->libjpeg_jpeg_error_mgr);
1156         sp->libjpeg_jpeg_decompress_struct.client_data=(void*)tif;
1157         if (jpeg_create_decompress_encap(sp,&(sp->libjpeg_jpeg_decompress_struct))==0)
1158                 return(0);
1159         sp->libjpeg_session_active=1;
1160         sp->libjpeg_jpeg_source_mgr.bytes_in_buffer=0;
1161         sp->libjpeg_jpeg_source_mgr.init_source=OJPEGLibjpegJpegSourceMgrInitSource;
1162         sp->libjpeg_jpeg_source_mgr.fill_input_buffer=OJPEGLibjpegJpegSourceMgrFillInputBuffer;
1163         sp->libjpeg_jpeg_source_mgr.skip_input_data=OJPEGLibjpegJpegSourceMgrSkipInputData;
1164         sp->libjpeg_jpeg_source_mgr.resync_to_restart=OJPEGLibjpegJpegSourceMgrResyncToRestart;
1165         sp->libjpeg_jpeg_source_mgr.term_source=OJPEGLibjpegJpegSourceMgrTermSource;
1166         sp->libjpeg_jpeg_decompress_struct.src=&(sp->libjpeg_jpeg_source_mgr);
1167         if (jpeg_read_header_encap(sp,&(sp->libjpeg_jpeg_decompress_struct),1)==0)
1168                 return(0);
1169         if ((sp->subsampling_force_desubsampling_inside_decompression==0) && (sp->samples_per_pixel_per_plane>1))
1170         {
1171                 sp->libjpeg_jpeg_decompress_struct.raw_data_out=1;
1172 #if JPEG_LIB_VERSION >= 70
1173                 sp->libjpeg_jpeg_decompress_struct.do_fancy_upsampling=FALSE;
1174 #endif
1175                 sp->libjpeg_jpeg_query_style=0;
1176                 if (sp->subsampling_convert_log==0)
1177                 {
1178                         assert(sp->subsampling_convert_ycbcrbuf==0);
1179                         assert(sp->subsampling_convert_ycbcrimage==0);
1180                         sp->subsampling_convert_ylinelen=((sp->strile_width+sp->subsampling_hor*8-1)/(sp->subsampling_hor*8)*sp->subsampling_hor*8);
1181                         sp->subsampling_convert_ylines=sp->subsampling_ver*8;
1182                         sp->subsampling_convert_clinelen=sp->subsampling_convert_ylinelen/sp->subsampling_hor;
1183                         sp->subsampling_convert_clines=8;
1184                         sp->subsampling_convert_ybuflen=sp->subsampling_convert_ylinelen*sp->subsampling_convert_ylines;
1185                         sp->subsampling_convert_cbuflen=sp->subsampling_convert_clinelen*sp->subsampling_convert_clines;
1186                         sp->subsampling_convert_ycbcrbuflen=sp->subsampling_convert_ybuflen+2*sp->subsampling_convert_cbuflen;
1187                         sp->subsampling_convert_ycbcrbuf=_TIFFmalloc(sp->subsampling_convert_ycbcrbuflen);
1188                         if (sp->subsampling_convert_ycbcrbuf==0)
1189                         {
1190                                 TIFFErrorExt(tif->tif_clientdata,module,"Out of memory");
1191                                 return(0);
1192                         }
1193                         sp->subsampling_convert_ybuf=sp->subsampling_convert_ycbcrbuf;
1194                         sp->subsampling_convert_cbbuf=sp->subsampling_convert_ybuf+sp->subsampling_convert_ybuflen;
1195                         sp->subsampling_convert_crbuf=sp->subsampling_convert_cbbuf+sp->subsampling_convert_cbuflen;
1196                         sp->subsampling_convert_ycbcrimagelen=3+sp->subsampling_convert_ylines+2*sp->subsampling_convert_clines;
1197                         sp->subsampling_convert_ycbcrimage=_TIFFmalloc(sp->subsampling_convert_ycbcrimagelen*sizeof(uint8*));
1198                         if (sp->subsampling_convert_ycbcrimage==0)
1199                         {
1200                                 TIFFErrorExt(tif->tif_clientdata,module,"Out of memory");
1201                                 return(0);
1202                         }
1203                         m=sp->subsampling_convert_ycbcrimage;
1204                         *m++=(uint8*)(sp->subsampling_convert_ycbcrimage+3);
1205                         *m++=(uint8*)(sp->subsampling_convert_ycbcrimage+3+sp->subsampling_convert_ylines);
1206                         *m++=(uint8*)(sp->subsampling_convert_ycbcrimage+3+sp->subsampling_convert_ylines+sp->subsampling_convert_clines);
1207                         for (n=0; n<sp->subsampling_convert_ylines; n++)
1208                                 *m++=sp->subsampling_convert_ybuf+n*sp->subsampling_convert_ylinelen;
1209                         for (n=0; n<sp->subsampling_convert_clines; n++)
1210                                 *m++=sp->subsampling_convert_cbbuf+n*sp->subsampling_convert_clinelen;
1211                         for (n=0; n<sp->subsampling_convert_clines; n++)
1212                                 *m++=sp->subsampling_convert_crbuf+n*sp->subsampling_convert_clinelen;
1213                         sp->subsampling_convert_clinelenout=((sp->strile_width+sp->subsampling_hor-1)/sp->subsampling_hor);
1214                         sp->subsampling_convert_state=0;
1215                         sp->bytes_per_line=sp->subsampling_convert_clinelenout*(sp->subsampling_ver*sp->subsampling_hor+2);
1216                         sp->lines_per_strile=((sp->strile_length+sp->subsampling_ver-1)/sp->subsampling_ver);
1217                         sp->subsampling_convert_log=1;
1218                 }
1219         }
1220         else
1221         {
1222                 sp->libjpeg_jpeg_decompress_struct.jpeg_color_space=JCS_UNKNOWN;
1223                 sp->libjpeg_jpeg_decompress_struct.out_color_space=JCS_UNKNOWN;
1224                 sp->libjpeg_jpeg_query_style=1;
1225                 sp->bytes_per_line=sp->samples_per_pixel_per_plane*sp->strile_width;
1226                 sp->lines_per_strile=sp->strile_length;
1227         }
1228         if (jpeg_start_decompress_encap(sp,&(sp->libjpeg_jpeg_decompress_struct))==0)
1229                 return(0);
1230         sp->writeheader_done=1;
1231         return(1);
1232 }
1233
1234 static void
1235 OJPEGLibjpegSessionAbort(TIFF* tif)
1236 {
1237         OJPEGState* sp=(OJPEGState*)tif->tif_data;
1238         assert(sp->libjpeg_session_active!=0);
1239         jpeg_destroy((jpeg_common_struct*)(&(sp->libjpeg_jpeg_decompress_struct)));
1240         sp->libjpeg_session_active=0;
1241 }
1242
1243 static int
1244 OJPEGReadHeaderInfoSec(TIFF* tif)
1245 {
1246         static const char module[]="OJPEGReadHeaderInfoSec";
1247         OJPEGState* sp=(OJPEGState*)tif->tif_data;
1248         uint8 m;
1249         uint16 n;
1250         uint8 o;
1251         if (sp->file_size==0)
1252                 sp->file_size=TIFFGetFileSize(tif);
1253         if (sp->jpeg_interchange_format!=0)
1254         {
1255                 if (sp->jpeg_interchange_format>=sp->file_size)
1256                 {
1257                         sp->jpeg_interchange_format=0;
1258                         sp->jpeg_interchange_format_length=0;
1259                 }
1260                 else
1261                 {
1262                         if ((sp->jpeg_interchange_format_length==0) || (sp->jpeg_interchange_format+sp->jpeg_interchange_format_length>sp->file_size))
1263                                 sp->jpeg_interchange_format_length=sp->file_size-sp->jpeg_interchange_format;
1264                 }
1265         }
1266         sp->in_buffer_source=osibsNotSetYet;
1267         sp->in_buffer_next_strile=0;
1268         sp->in_buffer_strile_count=tif->tif_dir.td_nstrips;
1269         sp->in_buffer_file_togo=0;
1270         sp->in_buffer_togo=0;
1271         do
1272         {
1273                 if (OJPEGReadBytePeek(sp,&m)==0)
1274                         return(0);
1275                 if (m!=255)
1276                         break;
1277                 OJPEGReadByteAdvance(sp);
1278                 do
1279                 {
1280                         if (OJPEGReadByte(sp,&m)==0)
1281                                 return(0);
1282                 } while(m==255);
1283                 switch(m)
1284                 {
1285                         case JPEG_MARKER_SOI:
1286                                 /* this type of marker has no data, and should be skipped */
1287                                 break;
1288                         case JPEG_MARKER_COM:
1289                         case JPEG_MARKER_APP0:
1290                         case JPEG_MARKER_APP0+1:
1291                         case JPEG_MARKER_APP0+2:
1292                         case JPEG_MARKER_APP0+3:
1293                         case JPEG_MARKER_APP0+4:
1294                         case JPEG_MARKER_APP0+5:
1295                         case JPEG_MARKER_APP0+6:
1296                         case JPEG_MARKER_APP0+7:
1297                         case JPEG_MARKER_APP0+8:
1298                         case JPEG_MARKER_APP0+9:
1299                         case JPEG_MARKER_APP0+10:
1300                         case JPEG_MARKER_APP0+11:
1301                         case JPEG_MARKER_APP0+12:
1302                         case JPEG_MARKER_APP0+13:
1303                         case JPEG_MARKER_APP0+14:
1304                         case JPEG_MARKER_APP0+15:
1305                                 /* this type of marker has data, but it has no use to us (and no place here) and should be skipped */
1306                                 if (OJPEGReadWord(sp,&n)==0)
1307                                         return(0);
1308                                 if (n<2)
1309                                 {
1310                                         if (sp->subsamplingcorrect==0)
1311                                                 TIFFErrorExt(tif->tif_clientdata,module,"Corrupt JPEG data");
1312                                         return(0);
1313                                 }
1314                                 if (n>2)
1315                                         OJPEGReadSkip(sp,n-2);
1316                                 break;
1317                         case JPEG_MARKER_DRI:
1318                                 if (OJPEGReadHeaderInfoSecStreamDri(tif)==0)
1319                                         return(0);
1320                                 break;
1321                         case JPEG_MARKER_DQT:
1322                                 if (OJPEGReadHeaderInfoSecStreamDqt(tif)==0)
1323                                         return(0);
1324                                 break;
1325                         case JPEG_MARKER_DHT:
1326                                 if (OJPEGReadHeaderInfoSecStreamDht(tif)==0)
1327                                         return(0);
1328                                 break;
1329                         case JPEG_MARKER_SOF0:
1330                         case JPEG_MARKER_SOF1:
1331                         case JPEG_MARKER_SOF3:
1332                                 if (OJPEGReadHeaderInfoSecStreamSof(tif,m)==0)
1333                                         return(0);
1334                                 if (sp->subsamplingcorrect!=0)
1335                                         return(1);
1336                                 break;
1337                         case JPEG_MARKER_SOS:
1338                                 if (sp->subsamplingcorrect!=0)
1339                                         return(1);
1340                                 assert(sp->plane_sample_offset==0);
1341                                 if (OJPEGReadHeaderInfoSecStreamSos(tif)==0)
1342                                         return(0);
1343                                 break;
1344                         default:
1345                                 TIFFErrorExt(tif->tif_clientdata,module,"Unknown marker type %d in JPEG data",m);
1346                                 return(0);
1347                 }
1348         } while(m!=JPEG_MARKER_SOS);
1349         if (sp->subsamplingcorrect)
1350                 return(1);
1351         if (sp->sof_log==0)
1352         {
1353                 if (OJPEGReadHeaderInfoSecTablesQTable(tif)==0)
1354                         return(0);
1355                 sp->sof_marker_id=JPEG_MARKER_SOF0;
1356                 for (o=0; o<sp->samples_per_pixel; o++)
1357                         sp->sof_c[o]=o;
1358                 sp->sof_hv[0]=((sp->subsampling_hor<<4)|sp->subsampling_ver);
1359                 for (o=1; o<sp->samples_per_pixel; o++)
1360                         sp->sof_hv[o]=17;
1361                 sp->sof_x=sp->strile_width;
1362                 sp->sof_y=sp->strile_length_total;
1363                 sp->sof_log=1;
1364                 if (OJPEGReadHeaderInfoSecTablesDcTable(tif)==0)
1365                         return(0);
1366                 if (OJPEGReadHeaderInfoSecTablesAcTable(tif)==0)
1367                         return(0);
1368                 for (o=1; o<sp->samples_per_pixel; o++)
1369                         sp->sos_cs[o]=o;
1370         }
1371         return(1);
1372 }
1373
1374 static int
1375 OJPEGReadHeaderInfoSecStreamDri(TIFF* tif)
1376 {
1377         /* this could easilly cause trouble in some cases... but no such cases have occured sofar */
1378         static const char module[]="OJPEGReadHeaderInfoSecStreamDri";
1379         OJPEGState* sp=(OJPEGState*)tif->tif_data;
1380         uint16 m;
1381         if (OJPEGReadWord(sp,&m)==0)
1382                 return(0);
1383         if (m!=4)
1384         {
1385                 TIFFErrorExt(tif->tif_clientdata,module,"Corrupt DRI marker in JPEG data");
1386                 return(0);
1387         }
1388         if (OJPEGReadWord(sp,&m)==0)
1389                 return(0);
1390         sp->restart_interval=m;
1391         return(1);
1392 }
1393
1394 static int
1395 OJPEGReadHeaderInfoSecStreamDqt(TIFF* tif)
1396 {
1397         /* this is a table marker, and it is to be saved as a whole for exact pushing on the jpeg stream later on */
1398         static const char module[]="OJPEGReadHeaderInfoSecStreamDqt";
1399         OJPEGState* sp=(OJPEGState*)tif->tif_data;
1400         uint16 m;
1401         uint32 na;
1402         uint8* nb;
1403         uint8 o;
1404         if (OJPEGReadWord(sp,&m)==0)
1405                 return(0);
1406         if (m<=2)
1407         {
1408                 if (sp->subsamplingcorrect==0)
1409                         TIFFErrorExt(tif->tif_clientdata,module,"Corrupt DQT marker in JPEG data");
1410                 return(0);
1411         }
1412         if (sp->subsamplingcorrect!=0)
1413                 OJPEGReadSkip(sp,m-2);
1414         else
1415         {
1416                 m-=2;
1417                 do
1418                 {
1419                         if (m<65)
1420                         {
1421                                 TIFFErrorExt(tif->tif_clientdata,module,"Corrupt DQT marker in JPEG data");
1422                                 return(0);
1423                         }
1424                         na=sizeof(uint32)+69;
1425                         nb=_TIFFmalloc(na);
1426                         if (nb==0)
1427                         {
1428                                 TIFFErrorExt(tif->tif_clientdata,module,"Out of memory");
1429                                 return(0);
1430                         }
1431                         *(uint32*)nb=na;
1432                         nb[sizeof(uint32)]=255;
1433                         nb[sizeof(uint32)+1]=JPEG_MARKER_DQT;
1434                         nb[sizeof(uint32)+2]=0;
1435                         nb[sizeof(uint32)+3]=67;
1436                         if (OJPEGReadBlock(sp,65,&nb[sizeof(uint32)+4])==0) {
1437                                 _TIFFfree(nb);
1438                                 return(0);
1439                         }
1440                         o=nb[sizeof(uint32)+4]&15;
1441                         if (3<o)
1442                         {
1443                                 TIFFErrorExt(tif->tif_clientdata,module,"Corrupt DQT marker in JPEG data");
1444                                 _TIFFfree(nb);
1445                                 return(0);
1446                         }
1447                         if (sp->qtable[o]!=0)
1448                                 _TIFFfree(sp->qtable[o]);
1449                         sp->qtable[o]=nb;
1450                         m-=65;
1451                 } while(m>0);
1452         }
1453         return(1);
1454 }
1455
1456 static int
1457 OJPEGReadHeaderInfoSecStreamDht(TIFF* tif)
1458 {
1459         /* this is a table marker, and it is to be saved as a whole for exact pushing on the jpeg stream later on */
1460         /* TODO: the following assumes there is only one table in this marker... but i'm not quite sure that assumption is guaranteed correct */
1461         static const char module[]="OJPEGReadHeaderInfoSecStreamDht";
1462         OJPEGState* sp=(OJPEGState*)tif->tif_data;
1463         uint16 m;
1464         uint32 na;
1465         uint8* nb;
1466         uint8 o;
1467         if (OJPEGReadWord(sp,&m)==0)
1468                 return(0);
1469         if (m<=2)
1470         {
1471                 if (sp->subsamplingcorrect==0)
1472                         TIFFErrorExt(tif->tif_clientdata,module,"Corrupt DHT marker in JPEG data");
1473                 return(0);
1474         }
1475         if (sp->subsamplingcorrect!=0)
1476         {
1477                 OJPEGReadSkip(sp,m-2);
1478         }
1479         else
1480         {
1481                 na=sizeof(uint32)+2+m;
1482                 nb=_TIFFmalloc(na);
1483                 if (nb==0)
1484                 {
1485                         TIFFErrorExt(tif->tif_clientdata,module,"Out of memory");
1486                         return(0);
1487                 }
1488                 *(uint32*)nb=na;
1489                 nb[sizeof(uint32)]=255;
1490                 nb[sizeof(uint32)+1]=JPEG_MARKER_DHT;
1491                 nb[sizeof(uint32)+2]=(m>>8);
1492                 nb[sizeof(uint32)+3]=(m&255);
1493                 if (OJPEGReadBlock(sp,m-2,&nb[sizeof(uint32)+4])==0)
1494                         return(0);
1495                 o=nb[sizeof(uint32)+4];
1496                 if ((o&240)==0)
1497                 {
1498                         if (3<o)
1499                         {
1500                                 TIFFErrorExt(tif->tif_clientdata,module,"Corrupt DHT marker in JPEG data");
1501                                 return(0);
1502                         }
1503                         if (sp->dctable[o]!=0)
1504                                 _TIFFfree(sp->dctable[o]);
1505                         sp->dctable[o]=nb;
1506                 }
1507                 else
1508                 {
1509                         if ((o&240)!=16)
1510                         {
1511                                 TIFFErrorExt(tif->tif_clientdata,module,"Corrupt DHT marker in JPEG data");
1512                                 return(0);
1513                         }
1514                         o&=15;
1515                         if (3<o)
1516                         {
1517                                 TIFFErrorExt(tif->tif_clientdata,module,"Corrupt DHT marker in JPEG data");
1518                                 return(0);
1519                         }
1520                         if (sp->actable[o]!=0)
1521                                 _TIFFfree(sp->actable[o]);
1522                         sp->actable[o]=nb;
1523                 }
1524         }
1525         return(1);
1526 }
1527
1528 static int
1529 OJPEGReadHeaderInfoSecStreamSof(TIFF* tif, uint8 marker_id)
1530 {
1531         /* this marker needs to be checked, and part of its data needs to be saved for regeneration later on */
1532         static const char module[]="OJPEGReadHeaderInfoSecStreamSof";
1533         OJPEGState* sp=(OJPEGState*)tif->tif_data;
1534         uint16 m;
1535         uint16 n;
1536         uint8 o;
1537         uint16 p;
1538         uint16 q;
1539         if (sp->sof_log!=0)
1540         {
1541                 TIFFErrorExt(tif->tif_clientdata,module,"Corrupt JPEG data");
1542                 return(0);
1543         }
1544         if (sp->subsamplingcorrect==0)
1545                 sp->sof_marker_id=marker_id;
1546         /* Lf: data length */
1547         if (OJPEGReadWord(sp,&m)==0)
1548                 return(0);
1549         if (m<11)
1550         {
1551                 if (sp->subsamplingcorrect==0)
1552                         TIFFErrorExt(tif->tif_clientdata,module,"Corrupt SOF marker in JPEG data");
1553                 return(0);
1554         }
1555         m-=8;
1556         if (m%3!=0)
1557         {
1558                 if (sp->subsamplingcorrect==0)
1559                         TIFFErrorExt(tif->tif_clientdata,module,"Corrupt SOF marker in JPEG data");
1560                 return(0);
1561         }
1562         n=m/3;
1563         if (sp->subsamplingcorrect==0)
1564         {
1565                 if (n!=sp->samples_per_pixel)
1566                 {
1567                         TIFFErrorExt(tif->tif_clientdata,module,"JPEG compressed data indicates unexpected number of samples");
1568                         return(0);
1569                 }
1570         }
1571         /* P: Sample precision */
1572         if (OJPEGReadByte(sp,&o)==0)
1573                 return(0);
1574         if (o!=8)
1575         {
1576                 if (sp->subsamplingcorrect==0)
1577                         TIFFErrorExt(tif->tif_clientdata,module,"JPEG compressed data indicates unexpected number of bits per sample");
1578                 return(0);
1579         }
1580         /* Y: Number of lines, X: Number of samples per line */
1581         if (sp->subsamplingcorrect)
1582                 OJPEGReadSkip(sp,4);
1583         else
1584         {
1585                 /* Y: Number of lines */
1586                 if (OJPEGReadWord(sp,&p)==0)
1587                         return(0);
1588                 if (((uint32)p<sp->image_length) && ((uint32)p<sp->strile_length_total))
1589                 {
1590                         TIFFErrorExt(tif->tif_clientdata,module,"JPEG compressed data indicates unexpected height");
1591                         return(0);
1592                 }
1593                 sp->sof_y=p;
1594                 /* X: Number of samples per line */
1595                 if (OJPEGReadWord(sp,&p)==0)
1596                         return(0);
1597                 if (((uint32)p<sp->image_width) && ((uint32)p<sp->strile_width))
1598                 {
1599                         TIFFErrorExt(tif->tif_clientdata,module,"JPEG compressed data indicates unexpected width");
1600                         return(0);
1601                 }
1602                 if ((uint32)p>sp->strile_width)
1603                 {
1604                         TIFFErrorExt(tif->tif_clientdata,module,"JPEG compressed data image width exceeds expected image width");
1605                         return(0);
1606                 }
1607                 sp->sof_x=p;
1608         }
1609         /* Nf: Number of image components in frame */
1610         if (OJPEGReadByte(sp,&o)==0)
1611                 return(0);
1612         if (o!=n)
1613         {
1614                 if (sp->subsamplingcorrect==0)
1615                         TIFFErrorExt(tif->tif_clientdata,module,"Corrupt SOF marker in JPEG data");
1616                 return(0);
1617         }
1618         /* per component stuff */
1619         /* 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 */
1620         for (q=0; q<n; q++)
1621         {
1622                 /* C: Component identifier */
1623                 if (OJPEGReadByte(sp,&o)==0)
1624                         return(0);
1625                 if (sp->subsamplingcorrect==0)
1626                         sp->sof_c[q]=o;
1627                 /* H: Horizontal sampling factor, and V: Vertical sampling factor */
1628                 if (OJPEGReadByte(sp,&o)==0)
1629                         return(0);
1630                 if (sp->subsamplingcorrect!=0)
1631                 {
1632                         if (q==0)
1633                         {
1634                                 sp->subsampling_hor=(o>>4);
1635                                 sp->subsampling_ver=(o&15);
1636                                 if (((sp->subsampling_hor!=1) && (sp->subsampling_hor!=2) && (sp->subsampling_hor!=4)) ||
1637                                         ((sp->subsampling_ver!=1) && (sp->subsampling_ver!=2) && (sp->subsampling_ver!=4)))
1638                                         sp->subsampling_force_desubsampling_inside_decompression=1;
1639                         }
1640                         else
1641                         {
1642                                 if (o!=17)
1643                                         sp->subsampling_force_desubsampling_inside_decompression=1;
1644                         }
1645                 }
1646                 else
1647                 {
1648                         sp->sof_hv[q]=o;
1649                         if (sp->subsampling_force_desubsampling_inside_decompression==0)
1650                         {
1651                                 if (q==0)
1652                                 {
1653                                         if (o!=((sp->subsampling_hor<<4)|sp->subsampling_ver))
1654                                         {
1655                                                 TIFFErrorExt(tif->tif_clientdata,module,"JPEG compressed data indicates unexpected subsampling values");
1656                                                 return(0);
1657                                         }
1658                                 }
1659                                 else
1660                                 {
1661                                         if (o!=17)
1662                                         {
1663                                                 TIFFErrorExt(tif->tif_clientdata,module,"JPEG compressed data indicates unexpected subsampling values");
1664                                                 return(0);
1665                                         }
1666                                 }
1667                         }
1668                 }
1669                 /* Tq: Quantization table destination selector */
1670                 if (OJPEGReadByte(sp,&o)==0)
1671                         return(0);
1672                 if (sp->subsamplingcorrect==0)
1673                         sp->sof_tq[q]=o;
1674         }
1675         if (sp->subsamplingcorrect==0)
1676                 sp->sof_log=1;
1677         return(1);
1678 }
1679
1680 static int
1681 OJPEGReadHeaderInfoSecStreamSos(TIFF* tif)
1682 {
1683         /* this marker needs to be checked, and part of its data needs to be saved for regeneration later on */
1684         static const char module[]="OJPEGReadHeaderInfoSecStreamSos";
1685         OJPEGState* sp=(OJPEGState*)tif->tif_data;
1686         uint16 m;
1687         uint8 n;
1688         uint8 o;
1689         assert(sp->subsamplingcorrect==0);
1690         if (sp->sof_log==0)
1691         {
1692                 TIFFErrorExt(tif->tif_clientdata,module,"Corrupt SOS marker in JPEG data");
1693                 return(0);
1694         }
1695         /* Ls */
1696         if (OJPEGReadWord(sp,&m)==0)
1697                 return(0);
1698         if (m!=6+sp->samples_per_pixel_per_plane*2)
1699         {
1700                 TIFFErrorExt(tif->tif_clientdata,module,"Corrupt SOS marker in JPEG data");
1701                 return(0);
1702         }
1703         /* Ns */
1704         if (OJPEGReadByte(sp,&n)==0)
1705                 return(0);
1706         if (n!=sp->samples_per_pixel_per_plane)
1707         {
1708                 TIFFErrorExt(tif->tif_clientdata,module,"Corrupt SOS marker in JPEG data");
1709                 return(0);
1710         }
1711         /* Cs, Td, and Ta */
1712         for (o=0; o<sp->samples_per_pixel_per_plane; o++)
1713         {
1714                 /* Cs */
1715                 if (OJPEGReadByte(sp,&n)==0)
1716                         return(0);
1717                 sp->sos_cs[sp->plane_sample_offset+o]=n;
1718                 /* Td and Ta */
1719                 if (OJPEGReadByte(sp,&n)==0)
1720                         return(0);
1721                 sp->sos_tda[sp->plane_sample_offset+o]=n;
1722         }
1723         /* skip Ss, Se, Ah, en Al -> no check, as per Tom Lane recommendation, as per LibJpeg source */
1724         OJPEGReadSkip(sp,3);
1725         return(1);
1726 }
1727
1728 static int
1729 OJPEGReadHeaderInfoSecTablesQTable(TIFF* tif)
1730 {
1731         static const char module[]="OJPEGReadHeaderInfoSecTablesQTable";
1732         OJPEGState* sp=(OJPEGState*)tif->tif_data;
1733         uint8 m;
1734         uint8 n;
1735         uint32 oa;
1736         uint8* ob;
1737         uint32 p;
1738         if (sp->qtable_offset[0]==0)
1739         {
1740                 TIFFErrorExt(tif->tif_clientdata,module,"Missing JPEG tables");
1741                 return(0);
1742         }
1743         sp->in_buffer_file_pos_log=0;
1744         for (m=0; m<sp->samples_per_pixel; m++)
1745         {
1746                 if ((sp->qtable_offset[m]!=0) && ((m==0) || (sp->qtable_offset[m]!=sp->qtable_offset[m-1])))
1747                 {
1748                         for (n=0; n<m-1; n++)
1749                         {
1750                                 if (sp->qtable_offset[m]==sp->qtable_offset[n])
1751                                 {
1752                                         TIFFErrorExt(tif->tif_clientdata,module,"Corrupt JpegQTables tag value");
1753                                         return(0);
1754                                 }
1755                         }
1756                         oa=sizeof(uint32)+69;
1757                         ob=_TIFFmalloc(oa);
1758                         if (ob==0)
1759                         {
1760                                 TIFFErrorExt(tif->tif_clientdata,module,"Out of memory");
1761                                 return(0);
1762                         }
1763                         *(uint32*)ob=oa;
1764                         ob[sizeof(uint32)]=255;
1765                         ob[sizeof(uint32)+1]=JPEG_MARKER_DQT;
1766                         ob[sizeof(uint32)+2]=0;
1767                         ob[sizeof(uint32)+3]=67;
1768                         ob[sizeof(uint32)+4]=m;
1769                         TIFFSeekFile(tif,sp->qtable_offset[m],SEEK_SET);
1770                         p=TIFFReadFile(tif,&ob[sizeof(uint32)+5],64);
1771                         if (p!=64)
1772                                 return(0);
1773                         sp->qtable[m]=ob;
1774                         sp->sof_tq[m]=m;
1775                 }
1776                 else
1777                         sp->sof_tq[m]=sp->sof_tq[m-1];
1778         }
1779         return(1);
1780 }
1781
1782 static int
1783 OJPEGReadHeaderInfoSecTablesDcTable(TIFF* tif)
1784 {
1785         static const char module[]="OJPEGReadHeaderInfoSecTablesDcTable";
1786         OJPEGState* sp=(OJPEGState*)tif->tif_data;
1787         uint8 m;
1788         uint8 n;
1789         uint8 o[16];
1790         uint32 p;
1791         uint32 q;
1792         uint32 ra;
1793         uint8* rb;
1794         if (sp->dctable_offset[0]==0)
1795         {
1796                 TIFFErrorExt(tif->tif_clientdata,module,"Missing JPEG tables");
1797                 return(0);
1798         }
1799         sp->in_buffer_file_pos_log=0;
1800         for (m=0; m<sp->samples_per_pixel; m++)
1801         {
1802                 if ((sp->dctable_offset[m]!=0) && ((m==0) || (sp->dctable_offset[m]!=sp->dctable_offset[m-1])))
1803                 {
1804                         for (n=0; n<m-1; n++)
1805                         {
1806                                 if (sp->dctable_offset[m]==sp->dctable_offset[n])
1807                                 {
1808                                         TIFFErrorExt(tif->tif_clientdata,module,"Corrupt JpegDcTables tag value");
1809                                         return(0);
1810                                 }
1811                         }
1812                         TIFFSeekFile(tif,sp->dctable_offset[m],SEEK_SET);
1813                         p=TIFFReadFile(tif,o,16);
1814                         if (p!=16)
1815                                 return(0);
1816                         q=0;
1817                         for (n=0; n<16; n++)
1818                                 q+=o[n];
1819                         ra=sizeof(uint32)+21+q;
1820                         rb=_TIFFmalloc(ra);
1821                         if (rb==0)
1822                         {
1823                                 TIFFErrorExt(tif->tif_clientdata,module,"Out of memory");
1824                                 return(0);
1825                         }
1826                         *(uint32*)rb=ra;
1827                         rb[sizeof(uint32)]=255;
1828                         rb[sizeof(uint32)+1]=JPEG_MARKER_DHT;
1829                         rb[sizeof(uint32)+2]=((19+q)>>8);
1830                         rb[sizeof(uint32)+3]=((19+q)&255);
1831                         rb[sizeof(uint32)+4]=m;
1832                         for (n=0; n<16; n++)
1833                                 rb[sizeof(uint32)+5+n]=o[n];
1834                         p=TIFFReadFile(tif,&(rb[sizeof(uint32)+21]),q);
1835                         if (p!=q)
1836                                 return(0);
1837                         sp->dctable[m]=rb;
1838                         sp->sos_tda[m]=(m<<4);
1839                 }
1840                 else
1841                         sp->sos_tda[m]=sp->sos_tda[m-1];
1842         }
1843         return(1);
1844 }
1845
1846 static int
1847 OJPEGReadHeaderInfoSecTablesAcTable(TIFF* tif)
1848 {
1849         static const char module[]="OJPEGReadHeaderInfoSecTablesAcTable";
1850         OJPEGState* sp=(OJPEGState*)tif->tif_data;
1851         uint8 m;
1852         uint8 n;
1853         uint8 o[16];
1854         uint32 p;
1855         uint32 q;
1856         uint32 ra;
1857         uint8* rb;
1858         if (sp->actable_offset[0]==0)
1859         {
1860                 TIFFErrorExt(tif->tif_clientdata,module,"Missing JPEG tables");
1861                 return(0);
1862         }
1863         sp->in_buffer_file_pos_log=0;
1864         for (m=0; m<sp->samples_per_pixel; m++)
1865         {
1866                 if ((sp->actable_offset[m]!=0) && ((m==0) || (sp->actable_offset[m]!=sp->actable_offset[m-1])))
1867                 {
1868                         for (n=0; n<m-1; n++)
1869                         {
1870                                 if (sp->actable_offset[m]==sp->actable_offset[n])
1871                                 {
1872                                         TIFFErrorExt(tif->tif_clientdata,module,"Corrupt JpegAcTables tag value");
1873                                         return(0);
1874                                 }
1875                         }
1876                         TIFFSeekFile(tif,sp->actable_offset[m],SEEK_SET);
1877                         p=TIFFReadFile(tif,o,16);
1878                         if (p!=16)
1879                                 return(0);
1880                         q=0;
1881                         for (n=0; n<16; n++)
1882                                 q+=o[n];
1883                         ra=sizeof(uint32)+21+q;
1884                         rb=_TIFFmalloc(ra);
1885                         if (rb==0)
1886                         {
1887                                 TIFFErrorExt(tif->tif_clientdata,module,"Out of memory");
1888                                 return(0);
1889                         }
1890                         *(uint32*)rb=ra;
1891                         rb[sizeof(uint32)]=255;
1892                         rb[sizeof(uint32)+1]=JPEG_MARKER_DHT;
1893                         rb[sizeof(uint32)+2]=((19+q)>>8);
1894                         rb[sizeof(uint32)+3]=((19+q)&255);
1895                         rb[sizeof(uint32)+4]=(16|m);
1896                         for (n=0; n<16; n++)
1897                                 rb[sizeof(uint32)+5+n]=o[n];
1898                         p=TIFFReadFile(tif,&(rb[sizeof(uint32)+21]),q);
1899                         if (p!=q)
1900                                 return(0);
1901                         sp->actable[m]=rb;
1902                         sp->sos_tda[m]=(sp->sos_tda[m]|m);
1903                 }
1904                 else
1905                         sp->sos_tda[m]=(sp->sos_tda[m]|(sp->sos_tda[m-1]&15));
1906         }
1907         return(1);
1908 }
1909
1910 static int
1911 OJPEGReadBufferFill(OJPEGState* sp)
1912 {
1913         uint16 m;
1914         tmsize_t n;
1915         /* TODO: double-check: when subsamplingcorrect is set, no call to TIFFErrorExt or TIFFWarningExt should be made
1916          * in any other case, seek or read errors should be passed through */
1917         do
1918         {
1919                 if (sp->in_buffer_file_togo!=0)
1920                 {
1921                         if (sp->in_buffer_file_pos_log==0)
1922                         {
1923                                 TIFFSeekFile(sp->tif,sp->in_buffer_file_pos,SEEK_SET);
1924                                 sp->in_buffer_file_pos_log=1;
1925                         }
1926                         m=OJPEG_BUFFER;
1927                         if ((uint64)m>sp->in_buffer_file_togo)
1928                                 m=(uint16)sp->in_buffer_file_togo;
1929                         n=TIFFReadFile(sp->tif,sp->in_buffer,(tmsize_t)m);
1930                         if (n==0)
1931                                 return(0);
1932                         assert(n>0);
1933                         assert(n<=OJPEG_BUFFER);
1934                         assert(n<65536);
1935                         assert((uint64)n<=sp->in_buffer_file_togo);
1936                         m=(uint16)n;
1937                         sp->in_buffer_togo=m;
1938                         sp->in_buffer_cur=sp->in_buffer;
1939                         sp->in_buffer_file_togo-=m;
1940                         sp->in_buffer_file_pos+=m;
1941                         break;
1942                 }
1943                 sp->in_buffer_file_pos_log=0;
1944                 switch(sp->in_buffer_source)
1945                 {
1946                         case osibsNotSetYet:
1947                                 if (sp->jpeg_interchange_format!=0)
1948                                 {
1949                                         sp->in_buffer_file_pos=sp->jpeg_interchange_format;
1950                                         sp->in_buffer_file_togo=sp->jpeg_interchange_format_length;
1951                                 }
1952                                 sp->in_buffer_source=osibsJpegInterchangeFormat;
1953                                 break;
1954                         case osibsJpegInterchangeFormat:
1955                                 sp->in_buffer_source=osibsStrile;
1956                         case osibsStrile:
1957                                 if (sp->in_buffer_next_strile==sp->in_buffer_strile_count)
1958                                         sp->in_buffer_source=osibsEof;
1959                                 else
1960                                 {
1961                                         sp->in_buffer_file_pos=sp->tif->tif_dir.td_stripoffset[sp->in_buffer_next_strile];
1962                                         if (sp->in_buffer_file_pos!=0)
1963                                         {
1964                                                 if (sp->in_buffer_file_pos>=sp->file_size)
1965                                                         sp->in_buffer_file_pos=0;
1966                                                 else if (sp->tif->tif_dir.td_stripbytecount==NULL)
1967                                                         sp->in_buffer_file_togo=sp->file_size-sp->in_buffer_file_pos;
1968                                                 else
1969                                                 {
1970                                                         if (sp->tif->tif_dir.td_stripbytecount == 0) {
1971                                                                 TIFFErrorExt(sp->tif->tif_clientdata,sp->tif->tif_name,"Strip byte counts are missing");
1972                                                                 return(0);
1973                                                         }
1974                                                         sp->in_buffer_file_togo=sp->tif->tif_dir.td_stripbytecount[sp->in_buffer_next_strile];
1975                                                         if (sp->in_buffer_file_togo==0)
1976                                                                 sp->in_buffer_file_pos=0;
1977                                                         else if (sp->in_buffer_file_pos+sp->in_buffer_file_togo>sp->file_size)
1978                                                                 sp->in_buffer_file_togo=sp->file_size-sp->in_buffer_file_pos;
1979                                                 }
1980                                         }
1981                                         sp->in_buffer_next_strile++;
1982                                 }
1983                                 break;
1984                         default:
1985                                 return(0);
1986                 }
1987         } while (1);
1988         return(1);
1989 }
1990
1991 static int
1992 OJPEGReadByte(OJPEGState* sp, uint8* byte)
1993 {
1994         if (sp->in_buffer_togo==0)
1995         {
1996                 if (OJPEGReadBufferFill(sp)==0)
1997                         return(0);
1998                 assert(sp->in_buffer_togo>0);
1999         }
2000         *byte=*(sp->in_buffer_cur);
2001         sp->in_buffer_cur++;
2002         sp->in_buffer_togo--;
2003         return(1);
2004 }
2005
2006 static int
2007 OJPEGReadBytePeek(OJPEGState* sp, uint8* byte)
2008 {
2009         if (sp->in_buffer_togo==0)
2010         {
2011                 if (OJPEGReadBufferFill(sp)==0)
2012                         return(0);
2013                 assert(sp->in_buffer_togo>0);
2014         }
2015         *byte=*(sp->in_buffer_cur);
2016         return(1);
2017 }
2018
2019 static void
2020 OJPEGReadByteAdvance(OJPEGState* sp)
2021 {
2022         assert(sp->in_buffer_togo>0);
2023         sp->in_buffer_cur++;
2024         sp->in_buffer_togo--;
2025 }
2026
2027 static int
2028 OJPEGReadWord(OJPEGState* sp, uint16* word)
2029 {
2030         uint8 m;
2031         if (OJPEGReadByte(sp,&m)==0)
2032                 return(0);
2033         *word=(m<<8);
2034         if (OJPEGReadByte(sp,&m)==0)
2035                 return(0);
2036         *word|=m;
2037         return(1);
2038 }
2039
2040 static int
2041 OJPEGReadBlock(OJPEGState* sp, uint16 len, void* mem)
2042 {
2043         uint16 mlen;
2044         uint8* mmem;
2045         uint16 n;
2046         assert(len>0);
2047         mlen=len;
2048         mmem=mem;
2049         do
2050         {
2051                 if (sp->in_buffer_togo==0)
2052                 {
2053                         if (OJPEGReadBufferFill(sp)==0)
2054                                 return(0);
2055                         assert(sp->in_buffer_togo>0);
2056                 }
2057                 n=mlen;
2058                 if (n>sp->in_buffer_togo)
2059                         n=sp->in_buffer_togo;
2060                 _TIFFmemcpy(mmem,sp->in_buffer_cur,n);
2061                 sp->in_buffer_cur+=n;
2062                 sp->in_buffer_togo-=n;
2063                 mlen-=n;
2064                 mmem+=n;
2065         } while(mlen>0);
2066         return(1);
2067 }
2068
2069 static void
2070 OJPEGReadSkip(OJPEGState* sp, uint16 len)
2071 {
2072         uint16 m;
2073         uint16 n;
2074         m=len;
2075         n=m;
2076         if (n>sp->in_buffer_togo)
2077                 n=sp->in_buffer_togo;
2078         sp->in_buffer_cur+=n;
2079         sp->in_buffer_togo-=n;
2080         m-=n;
2081         if (m>0)
2082         {
2083                 assert(sp->in_buffer_togo==0);
2084                 n=m;
2085                 if ((uint64)n>sp->in_buffer_file_togo)
2086                         n=(uint16)sp->in_buffer_file_togo;
2087                 sp->in_buffer_file_pos+=n;
2088                 sp->in_buffer_file_togo-=n;
2089                 sp->in_buffer_file_pos_log=0;
2090                 /* we don't skip past jpeginterchangeformat/strile block...
2091                  * if that is asked from us, we're dealing with totally bazurk
2092                  * data anyway, and we've not seen this happening on any
2093                  * testfile, so we might as well likely cause some other
2094                  * meaningless error to be passed at some later time
2095                  */
2096         }
2097 }
2098
2099 static int
2100 OJPEGWriteStream(TIFF* tif, void** mem, uint32* len)
2101 {
2102         OJPEGState* sp=(OJPEGState*)tif->tif_data;
2103         *len=0;
2104         do
2105         {
2106                 assert(sp->out_state<=ososEoi);
2107                 switch(sp->out_state)
2108                 {
2109                         case ososSoi:
2110                                 OJPEGWriteStreamSoi(tif,mem,len);
2111                                 break;
2112                         case ososQTable0:
2113                                 OJPEGWriteStreamQTable(tif,0,mem,len);
2114                                 break;
2115                         case ososQTable1:
2116                                 OJPEGWriteStreamQTable(tif,1,mem,len);
2117                                 break;
2118                         case ososQTable2:
2119                                 OJPEGWriteStreamQTable(tif,2,mem,len);
2120                                 break;
2121                         case ososQTable3:
2122                                 OJPEGWriteStreamQTable(tif,3,mem,len);
2123                                 break;
2124                         case ososDcTable0:
2125                                 OJPEGWriteStreamDcTable(tif,0,mem,len);
2126                                 break;
2127                         case ososDcTable1:
2128                                 OJPEGWriteStreamDcTable(tif,1,mem,len);
2129                                 break;
2130                         case ososDcTable2:
2131                                 OJPEGWriteStreamDcTable(tif,2,mem,len);
2132                                 break;
2133                         case ososDcTable3:
2134                                 OJPEGWriteStreamDcTable(tif,3,mem,len);
2135                                 break;
2136                         case ososAcTable0:
2137                                 OJPEGWriteStreamAcTable(tif,0,mem,len);
2138                                 break;
2139                         case ososAcTable1:
2140                                 OJPEGWriteStreamAcTable(tif,1,mem,len);
2141                                 break;
2142                         case ososAcTable2:
2143                                 OJPEGWriteStreamAcTable(tif,2,mem,len);
2144                                 break;
2145                         case ososAcTable3:
2146                                 OJPEGWriteStreamAcTable(tif,3,mem,len);
2147                                 break;
2148                         case ososDri:
2149                                 OJPEGWriteStreamDri(tif,mem,len);
2150                                 break;
2151                         case ososSof:
2152                                 OJPEGWriteStreamSof(tif,mem,len);
2153                                 break;
2154                         case ososSos:
2155                                 OJPEGWriteStreamSos(tif,mem,len);
2156                                 break;
2157                         case ososCompressed:
2158                                 if (OJPEGWriteStreamCompressed(tif,mem,len)==0)
2159                                         return(0);
2160                                 break;
2161                         case ososRst:
2162                                 OJPEGWriteStreamRst(tif,mem,len);
2163                                 break;
2164                         case ososEoi:
2165                                 OJPEGWriteStreamEoi(tif,mem,len);
2166                                 break;
2167                 }
2168         } while (*len==0);
2169         return(1);
2170 }
2171
2172 static void
2173 OJPEGWriteStreamSoi(TIFF* tif, void** mem, uint32* len)
2174 {
2175         OJPEGState* sp=(OJPEGState*)tif->tif_data;
2176         assert(OJPEG_BUFFER>=2);
2177         sp->out_buffer[0]=255;
2178         sp->out_buffer[1]=JPEG_MARKER_SOI;
2179         *len=2;
2180         *mem=(void*)sp->out_buffer;
2181         sp->out_state++;
2182 }
2183
2184 static void
2185 OJPEGWriteStreamQTable(TIFF* tif, uint8 table_index, void** mem, uint32* len)
2186 {
2187         OJPEGState* sp=(OJPEGState*)tif->tif_data;
2188         if (sp->qtable[table_index]!=0)
2189         {
2190                 *mem=(void*)(sp->qtable[table_index]+sizeof(uint32));
2191                 *len=*((uint32*)sp->qtable[table_index])-sizeof(uint32);
2192         }
2193         sp->out_state++;
2194 }
2195
2196 static void
2197 OJPEGWriteStreamDcTable(TIFF* tif, uint8 table_index, void** mem, uint32* len)
2198 {
2199         OJPEGState* sp=(OJPEGState*)tif->tif_data;
2200         if (sp->dctable[table_index]!=0)
2201         {
2202                 *mem=(void*)(sp->dctable[table_index]+sizeof(uint32));
2203                 *len=*((uint32*)sp->dctable[table_index])-sizeof(uint32);
2204         }
2205         sp->out_state++;
2206 }
2207
2208 static void
2209 OJPEGWriteStreamAcTable(TIFF* tif, uint8 table_index, void** mem, uint32* len)
2210 {
2211         OJPEGState* sp=(OJPEGState*)tif->tif_data;
2212         if (sp->actable[table_index]!=0)
2213         {
2214                 *mem=(void*)(sp->actable[table_index]+sizeof(uint32));
2215                 *len=*((uint32*)sp->actable[table_index])-sizeof(uint32);
2216         }
2217         sp->out_state++;
2218 }
2219
2220 static void
2221 OJPEGWriteStreamDri(TIFF* tif, void** mem, uint32* len)
2222 {
2223         OJPEGState* sp=(OJPEGState*)tif->tif_data;
2224         assert(OJPEG_BUFFER>=6);
2225         if (sp->restart_interval!=0)
2226         {
2227                 sp->out_buffer[0]=255;
2228                 sp->out_buffer[1]=JPEG_MARKER_DRI;
2229                 sp->out_buffer[2]=0;
2230                 sp->out_buffer[3]=4;
2231                 sp->out_buffer[4]=(sp->restart_interval>>8);
2232                 sp->out_buffer[5]=(sp->restart_interval&255);
2233                 *len=6;
2234                 *mem=(void*)sp->out_buffer;
2235         }
2236         sp->out_state++;
2237 }
2238
2239 static void
2240 OJPEGWriteStreamSof(TIFF* tif, void** mem, uint32* len)
2241 {
2242         OJPEGState* sp=(OJPEGState*)tif->tif_data;
2243         uint8 m;
2244         assert(OJPEG_BUFFER>=2+8+sp->samples_per_pixel_per_plane*3);
2245         assert(255>=8+sp->samples_per_pixel_per_plane*3);
2246         sp->out_buffer[0]=255;
2247         sp->out_buffer[1]=sp->sof_marker_id;
2248         /* Lf */
2249         sp->out_buffer[2]=0;
2250         sp->out_buffer[3]=8+sp->samples_per_pixel_per_plane*3;
2251         /* P */
2252         sp->out_buffer[4]=8;
2253         /* Y */
2254         sp->out_buffer[5]=(sp->sof_y>>8);
2255         sp->out_buffer[6]=(sp->sof_y&255);
2256         /* X */
2257         sp->out_buffer[7]=(sp->sof_x>>8);
2258         sp->out_buffer[8]=(sp->sof_x&255);
2259         /* Nf */
2260         sp->out_buffer[9]=sp->samples_per_pixel_per_plane;
2261         for (m=0; m<sp->samples_per_pixel_per_plane; m++)
2262         {
2263                 /* C */
2264                 sp->out_buffer[10+m*3]=sp->sof_c[sp->plane_sample_offset+m];
2265                 /* H and V */
2266                 sp->out_buffer[10+m*3+1]=sp->sof_hv[sp->plane_sample_offset+m];
2267                 /* Tq */
2268                 sp->out_buffer[10+m*3+2]=sp->sof_tq[sp->plane_sample_offset+m];
2269         }
2270         *len=10+sp->samples_per_pixel_per_plane*3;
2271         *mem=(void*)sp->out_buffer;
2272         sp->out_state++;
2273 }
2274
2275 static void
2276 OJPEGWriteStreamSos(TIFF* tif, void** mem, uint32* len)
2277 {
2278         OJPEGState* sp=(OJPEGState*)tif->tif_data;
2279         uint8 m;
2280         assert(OJPEG_BUFFER>=2+6+sp->samples_per_pixel_per_plane*2);
2281         assert(255>=6+sp->samples_per_pixel_per_plane*2);
2282         sp->out_buffer[0]=255;
2283         sp->out_buffer[1]=JPEG_MARKER_SOS;
2284         /* Ls */
2285         sp->out_buffer[2]=0;
2286         sp->out_buffer[3]=6+sp->samples_per_pixel_per_plane*2;
2287         /* Ns */
2288         sp->out_buffer[4]=sp->samples_per_pixel_per_plane;
2289         for (m=0; m<sp->samples_per_pixel_per_plane; m++)
2290         {
2291                 /* Cs */
2292                 sp->out_buffer[5+m*2]=sp->sos_cs[sp->plane_sample_offset+m];
2293                 /* Td and Ta */
2294                 sp->out_buffer[5+m*2+1]=sp->sos_tda[sp->plane_sample_offset+m];
2295         }
2296         /* Ss */
2297         sp->out_buffer[5+sp->samples_per_pixel_per_plane*2]=0;
2298         /* Se */
2299         sp->out_buffer[5+sp->samples_per_pixel_per_plane*2+1]=63;
2300         /* Ah and Al */
2301         sp->out_buffer[5+sp->samples_per_pixel_per_plane*2+2]=0;
2302         *len=8+sp->samples_per_pixel_per_plane*2;
2303         *mem=(void*)sp->out_buffer;
2304         sp->out_state++;
2305 }
2306
2307 static int
2308 OJPEGWriteStreamCompressed(TIFF* tif, void** mem, uint32* len)
2309 {
2310         OJPEGState* sp=(OJPEGState*)tif->tif_data;
2311         if (sp->in_buffer_togo==0)
2312         {
2313                 if (OJPEGReadBufferFill(sp)==0)
2314                         return(0);
2315                 assert(sp->in_buffer_togo>0);
2316         }
2317         *len=sp->in_buffer_togo;
2318         *mem=(void*)sp->in_buffer_cur;
2319         sp->in_buffer_togo=0;
2320         if (sp->in_buffer_file_togo==0)
2321         {
2322                 switch(sp->in_buffer_source)
2323                 {
2324                         case osibsStrile:
2325                                 if (sp->in_buffer_next_strile<sp->in_buffer_strile_count)
2326                                         sp->out_state=ososRst;
2327                                 else
2328                                         sp->out_state=ososEoi;
2329                                 break;
2330                         case osibsEof:
2331                                 sp->out_state=ososEoi;
2332                                 break;
2333                         default:
2334                                 break;
2335                 }
2336         }
2337         return(1);
2338 }
2339
2340 static void
2341 OJPEGWriteStreamRst(TIFF* tif, void** mem, uint32* len)
2342 {
2343         OJPEGState* sp=(OJPEGState*)tif->tif_data;
2344         assert(OJPEG_BUFFER>=2);
2345         sp->out_buffer[0]=255;
2346         sp->out_buffer[1]=JPEG_MARKER_RST0+sp->restart_index;
2347         sp->restart_index++;
2348         if (sp->restart_index==8)
2349                 sp->restart_index=0;
2350         *len=2;
2351         *mem=(void*)sp->out_buffer;
2352         sp->out_state=ososCompressed;
2353 }
2354
2355 static void
2356 OJPEGWriteStreamEoi(TIFF* tif, void** mem, uint32* len)
2357 {
2358         OJPEGState* sp=(OJPEGState*)tif->tif_data;
2359         assert(OJPEG_BUFFER>=2);
2360         sp->out_buffer[0]=255;
2361         sp->out_buffer[1]=JPEG_MARKER_EOI;
2362         *len=2;
2363         *mem=(void*)sp->out_buffer;
2364 }
2365
2366 #ifndef LIBJPEG_ENCAP_EXTERNAL
2367 static int
2368 jpeg_create_decompress_encap(OJPEGState* sp, jpeg_decompress_struct* cinfo)
2369 {
2370         return(SETJMP(sp->exit_jmpbuf)?0:(jpeg_create_decompress(cinfo),1));
2371 }
2372 #endif
2373
2374 #ifndef LIBJPEG_ENCAP_EXTERNAL
2375 static int
2376 jpeg_read_header_encap(OJPEGState* sp, jpeg_decompress_struct* cinfo, uint8 require_image)
2377 {
2378         return(SETJMP(sp->exit_jmpbuf)?0:(jpeg_read_header(cinfo,require_image),1));
2379 }
2380 #endif
2381
2382 #ifndef LIBJPEG_ENCAP_EXTERNAL
2383 static int
2384 jpeg_start_decompress_encap(OJPEGState* sp, jpeg_decompress_struct* cinfo)
2385 {
2386         return(SETJMP(sp->exit_jmpbuf)?0:(jpeg_start_decompress(cinfo),1));
2387 }
2388 #endif
2389
2390 #ifndef LIBJPEG_ENCAP_EXTERNAL
2391 static int
2392 jpeg_read_scanlines_encap(OJPEGState* sp, jpeg_decompress_struct* cinfo, void* scanlines, uint32 max_lines)
2393 {
2394         return(SETJMP(sp->exit_jmpbuf)?0:(jpeg_read_scanlines(cinfo,scanlines,max_lines),1));
2395 }
2396 #endif
2397
2398 #ifndef LIBJPEG_ENCAP_EXTERNAL
2399 static int
2400 jpeg_read_raw_data_encap(OJPEGState* sp, jpeg_decompress_struct* cinfo, void* data, uint32 max_lines)
2401 {
2402         return(SETJMP(sp->exit_jmpbuf)?0:(jpeg_read_raw_data(cinfo,data,max_lines),1));
2403 }
2404 #endif
2405
2406 #ifndef LIBJPEG_ENCAP_EXTERNAL
2407 static void
2408 jpeg_encap_unwind(TIFF* tif)
2409 {
2410         OJPEGState* sp=(OJPEGState*)tif->tif_data;
2411         LONGJMP(sp->exit_jmpbuf,1);
2412 }
2413 #endif
2414
2415 static void
2416 OJPEGLibjpegJpegErrorMgrOutputMessage(jpeg_common_struct* cinfo)
2417 {
2418         char buffer[JMSG_LENGTH_MAX];
2419         (*cinfo->err->format_message)(cinfo,buffer);
2420         TIFFWarningExt(((TIFF*)(cinfo->client_data))->tif_clientdata,"LibJpeg","%s",buffer);
2421 }
2422
2423 static void
2424 OJPEGLibjpegJpegErrorMgrErrorExit(jpeg_common_struct* cinfo)
2425 {
2426         char buffer[JMSG_LENGTH_MAX];
2427         (*cinfo->err->format_message)(cinfo,buffer);
2428         TIFFErrorExt(((TIFF*)(cinfo->client_data))->tif_clientdata,"LibJpeg","%s",buffer);
2429         jpeg_encap_unwind((TIFF*)(cinfo->client_data));
2430 }
2431
2432 static void
2433 OJPEGLibjpegJpegSourceMgrInitSource(jpeg_decompress_struct* cinfo)
2434 {
2435         (void)cinfo;
2436 }
2437
2438 static boolean
2439 OJPEGLibjpegJpegSourceMgrFillInputBuffer(jpeg_decompress_struct* cinfo)
2440 {
2441         TIFF* tif=(TIFF*)cinfo->client_data;
2442         OJPEGState* sp=(OJPEGState*)tif->tif_data;
2443         void* mem=0;
2444         uint32 len=0U;
2445         if (OJPEGWriteStream(tif,&mem,&len)==0)
2446         {
2447                 TIFFErrorExt(tif->tif_clientdata,"LibJpeg","Premature end of JPEG data");
2448                 jpeg_encap_unwind(tif);
2449         }
2450         sp->libjpeg_jpeg_source_mgr.bytes_in_buffer=len;
2451         sp->libjpeg_jpeg_source_mgr.next_input_byte=mem;
2452         return(1);
2453 }
2454
2455 static void
2456 OJPEGLibjpegJpegSourceMgrSkipInputData(jpeg_decompress_struct* cinfo, long num_bytes)
2457 {
2458         TIFF* tif=(TIFF*)cinfo->client_data;
2459         (void)num_bytes;
2460         TIFFErrorExt(tif->tif_clientdata,"LibJpeg","Unexpected error");
2461         jpeg_encap_unwind(tif);
2462 }
2463
2464 static boolean
2465 OJPEGLibjpegJpegSourceMgrResyncToRestart(jpeg_decompress_struct* cinfo, int desired)
2466 {
2467         TIFF* tif=(TIFF*)cinfo->client_data;
2468         (void)desired;
2469         TIFFErrorExt(tif->tif_clientdata,"LibJpeg","Unexpected error");
2470         jpeg_encap_unwind(tif);
2471         return(0);
2472 }
2473
2474 static void
2475 OJPEGLibjpegJpegSourceMgrTermSource(jpeg_decompress_struct* cinfo)
2476 {
2477         (void)cinfo;
2478 }
2479
2480 #endif
2481
2482
2483 /*
2484  * Local Variables:
2485  * mode: c
2486  * c-basic-offset: 8
2487  * fill-column: 78
2488  * End:
2489  */