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