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