[LIBTIFF] Update to version 4.1.0. CORE-16550
[reactos.git] / dll / 3rdparty / libtiff / tif_ojpeg.c
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},
180 {TIFFTAG_JPEGQTABLES,TIFF_VARIABLE2,TIFF_VARIABLE2,TIFF_LONG8,0,TIFF_SETGET_C32_UINT64,TIFF_SETGET_UNDEFINED,FIELD_OJPEG_JPEGQTABLES,FALSE,TRUE,"JpegQTables",NULL},
181 {TIFFTAG_JPEGDCTABLES,TIFF_VARIABLE2,TIFF_VARIABLE2,TIFF_LONG8,0,TIFF_SETGET_C32_UINT64,TIFF_SETGET_UNDEFINED,FIELD_OJPEG_JPEGDCTABLES,FALSE,TRUE,"JpegDcTables",NULL},
182 {TIFFTAG_JPEGACTABLES,TIFF_VARIABLE2,TIFF_VARIABLE2,TIFF_LONG8,0,TIFF_SETGET_C32_UINT64,TIFF_SETGET_UNDEFINED,FIELD_OJPEG_JPEGACTABLES,FALSE,TRUE,"JpegAcTables",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;
219 typedef struct jpeg_common_struct jpeg_common_struct;
220 typedef struct jpeg_decompress_struct jpeg_decompress_struct;
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;
253 uint64 file_size;
254 uint32 image_width;
255 uint32 image_length;
256 uint32 strile_width;
257 uint32 strile_length;
258 uint32 strile_length_total;
259 uint8 samples_per_pixel;
260 uint8 plane_sample_offset;
261 uint8 samples_per_pixel_per_plane;
262 uint64 jpeg_interchange_format;
263 uint64 jpeg_interchange_format_length;
264 uint8 jpeg_proc;
265 uint8 subsamplingcorrect;
266 uint8 subsamplingcorrect_done;
267 uint8 subsampling_tag;
268 uint8 subsampling_hor;
269 uint8 subsampling_ver;
270 uint8 subsampling_force_desubsampling_inside_decompression;
271 uint8 qtable_offset_count;
272 uint8 dctable_offset_count;
273 uint8 actable_offset_count;
274 uint64 qtable_offset[3];
275 uint64 dctable_offset[3];
276 uint64 actable_offset[3];
277 uint8* qtable[4];
278 uint8* dctable[4];
279 uint8* actable[4];
280 uint16 restart_interval;
281 uint8 restart_index;
282 uint8 sof_log;
283 uint8 sof_marker_id;
284 uint32 sof_x;
285 uint32 sof_y;
286 uint8 sof_c[3];
287 uint8 sof_hv[3];
288 uint8 sof_tq[3];
289 uint8 sos_cs[3];
290 uint8 sos_tda[3];
291 struct {
292 uint8 log;
293 OJPEGStateInBufferSource in_buffer_source;
294 uint32 in_buffer_next_strile;
295 uint64 in_buffer_file_pos;
296 uint64 in_buffer_file_togo;
297 } sos_end[3];
298 uint8 readheader_done;
299 uint8 writeheader_done;
300 uint16 write_cursample;
301 uint32 write_curstrile;
302 uint8 libjpeg_session_active;
303 uint8 libjpeg_jpeg_query_style;
304 jpeg_error_mgr libjpeg_jpeg_error_mgr;
305 jpeg_decompress_struct libjpeg_jpeg_decompress_struct;
306 jpeg_source_mgr libjpeg_jpeg_source_mgr;
307 uint8 subsampling_convert_log;
308 uint32 subsampling_convert_ylinelen;
309 uint32 subsampling_convert_ylines;
310 uint32 subsampling_convert_clinelen;
311 uint32 subsampling_convert_clines;
312 uint32 subsampling_convert_ybuflen;
313 uint32 subsampling_convert_cbuflen;
314 uint32 subsampling_convert_ycbcrbuflen;
315 uint8* subsampling_convert_ycbcrbuf;
316 uint8* subsampling_convert_ybuf;
317 uint8* subsampling_convert_cbbuf;
318 uint8* subsampling_convert_crbuf;
319 uint32 subsampling_convert_ycbcrimagelen;
320 uint8** subsampling_convert_ycbcrimage;
321 uint32 subsampling_convert_clinelenout;
322 uint32 subsampling_convert_state;
323 uint32 bytes_per_line; /* if the codec outputs subsampled data, a 'line' in bytes_per_line */
324 uint32 lines_per_strile; /* and lines_per_strile means subsampling_ver desubsampled rows */
325 OJPEGStateInBufferSource in_buffer_source;
326 uint32 in_buffer_next_strile;
327 uint32 in_buffer_strile_count;
328 uint64 in_buffer_file_pos;
329 uint8 in_buffer_file_pos_log;
330 uint64 in_buffer_file_togo;
331 uint16 in_buffer_togo;
332 uint8* in_buffer_cur;
333 uint8 in_buffer[OJPEG_BUFFER];
334 OJPEGStateOutState out_state;
335 uint8 out_buffer[OJPEG_BUFFER];
336 uint8* skip_buffer;
337 } OJPEGState;
338
339 static int OJPEGVGetField(TIFF* tif, uint32 tag, va_list ap);
340 static int OJPEGVSetField(TIFF* tif, uint32 tag, va_list ap);
341 static void OJPEGPrintDir(TIFF* tif, FILE* fd, long flags);
342
343 static int OJPEGFixupTags(TIFF* tif);
344 static int OJPEGSetupDecode(TIFF* tif);
345 static int OJPEGPreDecode(TIFF* tif, uint16 s);
346 static int OJPEGPreDecodeSkipRaw(TIFF* tif);
347 static int OJPEGPreDecodeSkipScanlines(TIFF* tif);
348 static int OJPEGDecode(TIFF* tif, uint8* buf, tmsize_t cc, uint16 s);
349 static int OJPEGDecodeRaw(TIFF* tif, uint8* buf, tmsize_t cc);
350 static int OJPEGDecodeScanlines(TIFF* tif, uint8* buf, tmsize_t cc);
351 static void OJPEGPostDecode(TIFF* tif, uint8* buf, tmsize_t cc);
352 static int OJPEGSetupEncode(TIFF* tif);
353 static int OJPEGPreEncode(TIFF* tif, uint16 s);
354 static int OJPEGEncode(TIFF* tif, uint8* buf, tmsize_t cc, uint16 s);
355 static int OJPEGPostEncode(TIFF* tif);
356 static void OJPEGCleanup(TIFF* tif);
357
358 static void OJPEGSubsamplingCorrect(TIFF* tif);
359 static int OJPEGReadHeaderInfo(TIFF* tif);
360 static int OJPEGReadSecondarySos(TIFF* tif, uint16 s);
361 static int OJPEGWriteHeaderInfo(TIFF* tif);
362 static void OJPEGLibjpegSessionAbort(TIFF* tif);
363
364 static int OJPEGReadHeaderInfoSec(TIFF* tif);
365 static int OJPEGReadHeaderInfoSecStreamDri(TIFF* tif);
366 static int OJPEGReadHeaderInfoSecStreamDqt(TIFF* tif);
367 static int OJPEGReadHeaderInfoSecStreamDht(TIFF* tif);
368 static int OJPEGReadHeaderInfoSecStreamSof(TIFF* tif, uint8 marker_id);
369 static int OJPEGReadHeaderInfoSecStreamSos(TIFF* tif);
370 static int OJPEGReadHeaderInfoSecTablesQTable(TIFF* tif);
371 static int OJPEGReadHeaderInfoSecTablesDcTable(TIFF* tif);
372 static int OJPEGReadHeaderInfoSecTablesAcTable(TIFF* tif);
373
374 static int OJPEGReadBufferFill(OJPEGState* sp);
375 static int OJPEGReadByte(OJPEGState* sp, uint8* byte);
376 static int OJPEGReadBytePeek(OJPEGState* sp, uint8* byte);
377 static void OJPEGReadByteAdvance(OJPEGState* sp);
378 static int OJPEGReadWord(OJPEGState* sp, uint16* word);
379 static int OJPEGReadBlock(OJPEGState* sp, uint16 len, void* mem);
380 static void OJPEGReadSkip(OJPEGState* sp, uint16 len);
381
382 static int OJPEGWriteStream(TIFF* tif, void** mem, uint32* len);
383 static void OJPEGWriteStreamSoi(TIFF* tif, void** mem, uint32* len);
384 static void OJPEGWriteStreamQTable(TIFF* tif, uint8 table_index, void** mem, uint32* len);
385 static void OJPEGWriteStreamDcTable(TIFF* tif, uint8 table_index, void** mem, uint32* len);
386 static void OJPEGWriteStreamAcTable(TIFF* tif, uint8 table_index, void** mem, uint32* len);
387 static void OJPEGWriteStreamDri(TIFF* tif, void** mem, uint32* len);
388 static void OJPEGWriteStreamSof(TIFF* tif, void** mem, uint32* len);
389 static void OJPEGWriteStreamSos(TIFF* tif, void** mem, uint32* len);
390 static int OJPEGWriteStreamCompressed(TIFF* tif, void** mem, uint32* len);
391 static void OJPEGWriteStreamRst(TIFF* tif, void** mem, uint32* len);
392 static void OJPEGWriteStreamEoi(TIFF* tif, void** mem, uint32* len);
393
394 #ifdef LIBJPEG_ENCAP_EXTERNAL
395 extern int jpeg_create_decompress_encap(OJPEGState* sp, jpeg_decompress_struct* cinfo);
396 extern int jpeg_read_header_encap(OJPEGState* sp, jpeg_decompress_struct* cinfo, uint8 require_image);
397 extern int jpeg_start_decompress_encap(OJPEGState* sp, jpeg_decompress_struct* cinfo);
398 extern int jpeg_read_scanlines_encap(OJPEGState* sp, jpeg_decompress_struct* cinfo, void* scanlines, uint32 max_lines);
399 extern int jpeg_read_raw_data_encap(OJPEGState* sp, jpeg_decompress_struct* cinfo, void* data, uint32 max_lines);
400 extern void jpeg_encap_unwind(TIFF* tif);
401 #else
402 static int jpeg_create_decompress_encap(OJPEGState* sp, jpeg_decompress_struct* j);
403 static int jpeg_read_header_encap(OJPEGState* sp, jpeg_decompress_struct* cinfo, uint8 require_image);
404 static int jpeg_start_decompress_encap(OJPEGState* sp, jpeg_decompress_struct* cinfo);
405 static int jpeg_read_scanlines_encap(OJPEGState* sp, jpeg_decompress_struct* cinfo, void* scanlines, uint32 max_lines);
406 static int jpeg_read_raw_data_encap(OJPEGState* sp, jpeg_decompress_struct* cinfo, void* data, uint32 max_lines);
407 static void jpeg_encap_unwind(TIFF* tif);
408 #endif
409
410 static void OJPEGLibjpegJpegErrorMgrOutputMessage(jpeg_common_struct* cinfo);
411 static void OJPEGLibjpegJpegErrorMgrErrorExit(jpeg_common_struct* cinfo);
412 static void OJPEGLibjpegJpegSourceMgrInitSource(jpeg_decompress_struct* cinfo);
413 static boolean OJPEGLibjpegJpegSourceMgrFillInputBuffer(jpeg_decompress_struct* cinfo);
414 static void OJPEGLibjpegJpegSourceMgrSkipInputData(jpeg_decompress_struct* cinfo, long num_bytes);
415 static boolean OJPEGLibjpegJpegSourceMgrResyncToRestart(jpeg_decompress_struct* cinfo, int desired);
416 static void OJPEGLibjpegJpegSourceMgrTermSource(jpeg_decompress_struct* cinfo);
417
418 int
419 TIFFInitOJPEG(TIFF* tif, int scheme)
420 {
421 static const char module[]="TIFFInitOJPEG";
422 OJPEGState* sp;
423
424 assert(scheme==COMPRESSION_OJPEG);
425
426 /*
427 * Merge codec-specific tag information.
428 */
429 if (!_TIFFMergeFields(tif, ojpegFields, TIFFArrayCount(ojpegFields))) {
430 TIFFErrorExt(tif->tif_clientdata, module,
431 "Merging Old JPEG codec-specific tags failed");
432 return 0;
433 }
434
435 /* state block */
436 sp=_TIFFmalloc(sizeof(OJPEGState));
437 if (sp==NULL)
438 {
439 TIFFErrorExt(tif->tif_clientdata,module,"No space for OJPEG state block");
440 return(0);
441 }
442 _TIFFmemset(sp,0,sizeof(OJPEGState));
443 sp->tif=tif;
444 sp->jpeg_proc=1;
445 sp->subsampling_hor=2;
446 sp->subsampling_ver=2;
447 TIFFSetField(tif,TIFFTAG_YCBCRSUBSAMPLING,2,2);
448 /* tif codec methods */
449 tif->tif_fixuptags=OJPEGFixupTags;
450 tif->tif_setupdecode=OJPEGSetupDecode;
451 tif->tif_predecode=OJPEGPreDecode;
452 tif->tif_postdecode=OJPEGPostDecode;
453 tif->tif_decoderow=OJPEGDecode;
454 tif->tif_decodestrip=OJPEGDecode;
455 tif->tif_decodetile=OJPEGDecode;
456 tif->tif_setupencode=OJPEGSetupEncode;
457 tif->tif_preencode=OJPEGPreEncode;
458 tif->tif_postencode=OJPEGPostEncode;
459 tif->tif_encoderow=OJPEGEncode;
460 tif->tif_encodestrip=OJPEGEncode;
461 tif->tif_encodetile=OJPEGEncode;
462 tif->tif_cleanup=OJPEGCleanup;
463 tif->tif_data=(uint8*)sp;
464 /* tif tag methods */
465 sp->vgetparent=tif->tif_tagmethods.vgetfield;
466 tif->tif_tagmethods.vgetfield=OJPEGVGetField;
467 sp->vsetparent=tif->tif_tagmethods.vsetfield;
468 tif->tif_tagmethods.vsetfield=OJPEGVSetField;
469 sp->printdir=tif->tif_tagmethods.printdir;
470 tif->tif_tagmethods.printdir=OJPEGPrintDir;
471 /* Some OJPEG files don't have strip or tile offsets or bytecounts tags.
472 Some others do, but have totally meaningless or corrupt values
473 in these tags. In these cases, the JpegInterchangeFormat stream is
474 reliable. In any case, this decoder reads the compressed data itself,
475 from the most reliable locations, and we need to notify encapsulating
476 LibTiff not to read raw strips or tiles for us. */
477 tif->tif_flags|=TIFF_NOREADRAW;
478 return(1);
479 }
480
481 static int
482 OJPEGVGetField(TIFF* tif, uint32 tag, va_list ap)
483 {
484 OJPEGState* sp=(OJPEGState*)tif->tif_data;
485 switch(tag)
486 {
487 case TIFFTAG_JPEGIFOFFSET:
488 *va_arg(ap,uint64*)=(uint64)sp->jpeg_interchange_format;
489 break;
490 case TIFFTAG_JPEGIFBYTECOUNT:
491 *va_arg(ap,uint64*)=(uint64)sp->jpeg_interchange_format_length;
492 break;
493 case TIFFTAG_YCBCRSUBSAMPLING:
494 if (sp->subsamplingcorrect_done==0)
495 OJPEGSubsamplingCorrect(tif);
496 *va_arg(ap,uint16*)=(uint16)sp->subsampling_hor;
497 *va_arg(ap,uint16*)=(uint16)sp->subsampling_ver;
498 break;
499 case TIFFTAG_JPEGQTABLES:
500 *va_arg(ap,uint32*)=(uint32)sp->qtable_offset_count;
501 *va_arg(ap,void**)=(void*)sp->qtable_offset;
502 break;
503 case TIFFTAG_JPEGDCTABLES:
504 *va_arg(ap,uint32*)=(uint32)sp->dctable_offset_count;
505 *va_arg(ap,void**)=(void*)sp->dctable_offset;
506 break;
507 case TIFFTAG_JPEGACTABLES:
508 *va_arg(ap,uint32*)=(uint32)sp->actable_offset_count;
509 *va_arg(ap,void**)=(void*)sp->actable_offset;
510 break;
511 case TIFFTAG_JPEGPROC:
512 *va_arg(ap,uint16*)=(uint16)sp->jpeg_proc;
513 break;
514 case TIFFTAG_JPEGRESTARTINTERVAL:
515 *va_arg(ap,uint16*)=sp->restart_interval;
516 break;
517 default:
518 return (*sp->vgetparent)(tif,tag,ap);
519 }
520 return (1);
521 }
522
523 static int
524 OJPEGVSetField(TIFF* tif, uint32 tag, va_list ap)
525 {
526 static const char module[]="OJPEGVSetField";
527 OJPEGState* sp=(OJPEGState*)tif->tif_data;
528 uint32 ma;
529 uint64* mb;
530 uint32 n;
531 const TIFFField* fip;
532
533 switch(tag)
534 {
535 case TIFFTAG_JPEGIFOFFSET:
536 sp->jpeg_interchange_format=(uint64)va_arg(ap,uint64);
537 break;
538 case TIFFTAG_JPEGIFBYTECOUNT:
539 sp->jpeg_interchange_format_length=(uint64)va_arg(ap,uint64);
540 break;
541 case TIFFTAG_YCBCRSUBSAMPLING:
542 sp->subsampling_tag=1;
543 sp->subsampling_hor=(uint8)va_arg(ap,uint16_vap);
544 sp->subsampling_ver=(uint8)va_arg(ap,uint16_vap);
545 tif->tif_dir.td_ycbcrsubsampling[0]=sp->subsampling_hor;
546 tif->tif_dir.td_ycbcrsubsampling[1]=sp->subsampling_ver;
547 break;
548 case TIFFTAG_JPEGQTABLES:
549 ma=(uint32)va_arg(ap,uint32);
550 if (ma!=0)
551 {
552 if (ma>3)
553 {
554 TIFFErrorExt(tif->tif_clientdata,module,"JpegQTables tag has incorrect count");
555 return(0);
556 }
557 sp->qtable_offset_count=(uint8)ma;
558 mb=(uint64*)va_arg(ap,uint64*);
559 for (n=0; n<ma; n++)
560 sp->qtable_offset[n]=mb[n];
561 }
562 break;
563 case TIFFTAG_JPEGDCTABLES:
564 ma=(uint32)va_arg(ap,uint32);
565 if (ma!=0)
566 {
567 if (ma>3)
568 {
569 TIFFErrorExt(tif->tif_clientdata,module,"JpegDcTables tag has incorrect count");
570 return(0);
571 }
572 sp->dctable_offset_count=(uint8)ma;
573 mb=(uint64*)va_arg(ap,uint64*);
574 for (n=0; n<ma; n++)
575 sp->dctable_offset[n]=mb[n];
576 }
577 break;
578 case TIFFTAG_JPEGACTABLES:
579 ma=(uint32)va_arg(ap,uint32);
580 if (ma!=0)
581 {
582 if (ma>3)
583 {
584 TIFFErrorExt(tif->tif_clientdata,module,"JpegAcTables tag has incorrect count");
585 return(0);
586 }
587 sp->actable_offset_count=(uint8)ma;
588 mb=(uint64*)va_arg(ap,uint64*);
589 for (n=0; n<ma; n++)
590 sp->actable_offset[n]=mb[n];
591 }
592 break;
593 case TIFFTAG_JPEGPROC:
594 sp->jpeg_proc=(uint8)va_arg(ap,uint16_vap);
595 break;
596 case TIFFTAG_JPEGRESTARTINTERVAL:
597 sp->restart_interval=(uint16)va_arg(ap,uint16_vap);
598 break;
599 default:
600 return (*sp->vsetparent)(tif,tag,ap);
601 }
602 fip = TIFFFieldWithTag(tif,tag);
603 if( fip == NULL ) /* shouldn't happen */
604 return(0);
605 TIFFSetFieldBit(tif,fip->field_bit);
606 tif->tif_flags|=TIFF_DIRTYDIRECT;
607 return(1);
608 }
609
610 static void
611 OJPEGPrintDir(TIFF* tif, FILE* fd, long flags)
612 {
613 OJPEGState* sp=(OJPEGState*)tif->tif_data;
614 uint8 m;
615 (void)flags;
616 assert(sp!=NULL);
617 if (TIFFFieldSet(tif,FIELD_OJPEG_JPEGINTERCHANGEFORMAT))
618 fprintf(fd," JpegInterchangeFormat: " TIFF_UINT64_FORMAT "\n",(TIFF_UINT64_T)sp->jpeg_interchange_format);
619 if (TIFFFieldSet(tif,FIELD_OJPEG_JPEGINTERCHANGEFORMATLENGTH))
620 fprintf(fd," JpegInterchangeFormatLength: " TIFF_UINT64_FORMAT "\n",(TIFF_UINT64_T)sp->jpeg_interchange_format_length);
621 if (TIFFFieldSet(tif,FIELD_OJPEG_JPEGQTABLES))
622 {
623 fprintf(fd," JpegQTables:");
624 for (m=0; m<sp->qtable_offset_count; m++)
625 fprintf(fd," " TIFF_UINT64_FORMAT,(TIFF_UINT64_T)sp->qtable_offset[m]);
626 fprintf(fd,"\n");
627 }
628 if (TIFFFieldSet(tif,FIELD_OJPEG_JPEGDCTABLES))
629 {
630 fprintf(fd," JpegDcTables:");
631 for (m=0; m<sp->dctable_offset_count; m++)
632 fprintf(fd," " TIFF_UINT64_FORMAT,(TIFF_UINT64_T)sp->dctable_offset[m]);
633 fprintf(fd,"\n");
634 }
635 if (TIFFFieldSet(tif,FIELD_OJPEG_JPEGACTABLES))
636 {
637 fprintf(fd," JpegAcTables:");
638 for (m=0; m<sp->actable_offset_count; m++)
639 fprintf(fd," " TIFF_UINT64_FORMAT,(TIFF_UINT64_T)sp->actable_offset[m]);
640 fprintf(fd,"\n");
641 }
642 if (TIFFFieldSet(tif,FIELD_OJPEG_JPEGPROC))
643 fprintf(fd," JpegProc: %u\n",(unsigned int)sp->jpeg_proc);
644 if (TIFFFieldSet(tif,FIELD_OJPEG_JPEGRESTARTINTERVAL))
645 fprintf(fd," JpegRestartInterval: %u\n",(unsigned int)sp->restart_interval);
646 if (sp->printdir)
647 (*sp->printdir)(tif, fd, flags);
648 }
649
650 static int
651 OJPEGFixupTags(TIFF* tif)
652 {
653 (void) tif;
654 return(1);
655 }
656
657 static int
658 OJPEGSetupDecode(TIFF* tif)
659 {
660 static const char module[]="OJPEGSetupDecode";
661 TIFFWarningExt(tif->tif_clientdata,module,"Depreciated and troublesome old-style JPEG compression mode, please convert to new-style JPEG compression and notify vendor of writing software");
662 return(1);
663 }
664
665 static int
666 OJPEGPreDecode(TIFF* tif, uint16 s)
667 {
668 OJPEGState* sp=(OJPEGState*)tif->tif_data;
669 uint32 m;
670 if (sp->subsamplingcorrect_done==0)
671 OJPEGSubsamplingCorrect(tif);
672 if (sp->readheader_done==0)
673 {
674 if (OJPEGReadHeaderInfo(tif)==0)
675 return(0);
676 }
677 if (sp->sos_end[s].log==0)
678 {
679 if (OJPEGReadSecondarySos(tif,s)==0)
680 return(0);
681 }
682 if (isTiled(tif))
683 m=tif->tif_curtile;
684 else
685 m=tif->tif_curstrip;
686 if ((sp->writeheader_done!=0) && ((sp->write_cursample!=s) || (sp->write_curstrile>m)))
687 {
688 if (sp->libjpeg_session_active!=0)
689 OJPEGLibjpegSessionAbort(tif);
690 sp->writeheader_done=0;
691 }
692 if (sp->writeheader_done==0)
693 {
694 sp->plane_sample_offset=(uint8)s;
695 sp->write_cursample=s;
696 sp->write_curstrile=s*tif->tif_dir.td_stripsperimage;
697 if ((sp->in_buffer_file_pos_log==0) ||
698 (sp->in_buffer_file_pos-sp->in_buffer_togo!=sp->sos_end[s].in_buffer_file_pos))
699 {
700 sp->in_buffer_source=sp->sos_end[s].in_buffer_source;
701 sp->in_buffer_next_strile=sp->sos_end[s].in_buffer_next_strile;
702 sp->in_buffer_file_pos=sp->sos_end[s].in_buffer_file_pos;
703 sp->in_buffer_file_pos_log=0;
704 sp->in_buffer_file_togo=sp->sos_end[s].in_buffer_file_togo;
705 sp->in_buffer_togo=0;
706 sp->in_buffer_cur=0;
707 }
708 if (OJPEGWriteHeaderInfo(tif)==0)
709 return(0);
710 }
711 while (sp->write_curstrile<m)
712 {
713 if (sp->libjpeg_jpeg_query_style==0)
714 {
715 if (OJPEGPreDecodeSkipRaw(tif)==0)
716 return(0);
717 }
718 else
719 {
720 if (OJPEGPreDecodeSkipScanlines(tif)==0)
721 return(0);
722 }
723 sp->write_curstrile++;
724 }
725 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;
1021 _TIFFSetDefaultCompressionState(tif);
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);
1034 if ((tif->tif_dir.td_samplesperpixel!=3) || ((tif->tif_dir.td_photometric!=PHOTOMETRIC_YCBCR) &&
1035 (tif->tif_dir.td_photometric!=PHOTOMETRIC_ITULAB)))
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;
1116 if (tif->tif_dir.td_planarconfig==PLANARCONFIG_CONTIG)
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 {
2477 jpeg_read_header(cinfo,require_image);
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 {
2503 jpeg_read_scanlines(cinfo,scanlines,max_lines);
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 {
2516 jpeg_read_raw_data(cinfo,data,max_lines);
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 */