| Bsoft 1.9 Bernard's software package

- Main Page
- Namespaces
- Classes
- Files

- File List
- File Members

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