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