thirdparty/libtiff/tif_ojpeg.c

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