Line data Source code
1 : /*
2 : * Copyright (c) 1994-1997 Sam Leffler
3 : * Copyright (c) 1994-1997 Silicon Graphics, Inc.
4 : *
5 : * Permission to use, copy, modify, distribute, and sell this software and
6 : * its documentation for any purpose is hereby granted without fee, provided
7 : * that (i) the above copyright notices and this permission notice appear in
8 : * all copies of the software and related documentation, and (ii) the names of
9 : * Sam Leffler and Silicon Graphics may not be used in any advertising or
10 : * publicity relating to the software without the specific, prior written
11 : * permission of Sam Leffler and Silicon Graphics.
12 : *
13 : * THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND,
14 : * EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY
15 : * WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
16 : *
17 : * IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR
18 : * ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND,
19 : * OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
20 : * WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF
21 : * LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
22 : * OF THIS SOFTWARE.
23 : */
24 :
25 : #define WIN32_LEAN_AND_MEAN
26 : #define VC_EXTRALEAN
27 :
28 : #include "tiffiop.h"
29 : #include <stdlib.h>
30 :
31 : #ifdef JPEG_SUPPORT
32 :
33 : /*
34 : * TIFF Library
35 : *
36 : * JPEG Compression support per TIFF Technical Note #2
37 : * (*not* per the original TIFF 6.0 spec).
38 : *
39 : * This file is simply an interface to the libjpeg library written by
40 : * the Independent JPEG Group. You need release 5 or later of the IJG
41 : * code, which you can find on the Internet at ftp.uu.net:/graphics/jpeg/.
42 : *
43 : * Contributed by Tom Lane <tgl@sss.pgh.pa.us>.
44 : */
45 : #include <setjmp.h>
46 :
47 : /* Settings that are independent of libjpeg ABI. Used when reinitializing the */
48 : /* JPEGState from libjpegs 8 bit to libjpeg 12 bits, which have potentially */
49 : /* different ABI */
50 : typedef struct
51 : {
52 : TIFFVGetMethod vgetparent; /* super-class method */
53 : TIFFVSetMethod vsetparent; /* super-class method */
54 : TIFFPrintMethod printdir; /* super-class method */
55 : TIFFStripMethod defsparent; /* super-class method */
56 : TIFFTileMethod deftparent; /* super-class method */
57 :
58 : /* pseudo-tag fields */
59 : void *jpegtables; /* JPEGTables tag value, or NULL */
60 : uint32_t jpegtables_length; /* number of bytes in same */
61 : int jpegquality; /* Compression quality level */
62 : int jpegcolormode; /* Auto RGB<=>YCbCr convert? */
63 : int jpegtablesmode; /* What to put in JPEGTables */
64 :
65 : int ycbcrsampling_fetched;
66 : int max_allowed_scan_number;
67 : int has_warned_about_progressive_mode;
68 : } JPEGOtherSettings;
69 :
70 : int TIFFFillStrip(TIFF *tif, uint32_t strip);
71 : int TIFFFillTile(TIFF *tif, uint32_t tile);
72 : int TIFFReInitJPEG_12(TIFF *tif, const JPEGOtherSettings *otherSettings,
73 : int scheme, int is_encode);
74 : int TIFFJPEGIsFullStripRequired_12(TIFF *tif);
75 :
76 : #include "jerror.h"
77 : #include "jpeglib.h"
78 :
79 : /* Do optional compile-time version check */
80 : #if defined(EXPECTED_JPEG_LIB_VERSION) && !defined(LIBJPEG_12_PATH)
81 : #if EXPECTED_JPEG_LIB_VERSION != JPEG_LIB_VERSION
82 : #error EXPECTED_JPEG_LIB_VERSION != JPEG_LIB_VERSION
83 : #endif
84 : #endif
85 :
86 : /*
87 : * Do we want to do special processing suitable for when JSAMPLE is a
88 : * 16bit value?
89 : */
90 :
91 : /* HAVE_JPEGTURBO_DUAL_MODE_8_12 is defined for libjpeg-turbo >= 3.0 which
92 : * adds a dual-mode 8/12 bit API in the same library.
93 : */
94 :
95 : #if defined(HAVE_JPEGTURBO_DUAL_MODE_8_12)
96 : #define JPEG_DUAL_MODE_8_12
97 : /* Start by undefining BITS_IN_JSAMPLE which is always set to 8 in libjpeg-turbo
98 : * >= 3.0 Cf
99 : * https://github.com/libjpeg-turbo/libjpeg-turbo/commit/8b9bc4b9635a2a047fb23ebe70c9acd728d3f99b
100 : */
101 : #undef BITS_IN_JSAMPLE
102 : /* libjpeg-turbo >= 3.0 adds J12xxxx datatypes for the 12-bit mode. */
103 : #if defined(FROM_TIF_JPEG_12)
104 : #define BITS_IN_JSAMPLE 12
105 : #define TIFF_JSAMPLE J12SAMPLE
106 : #define TIFF_JSAMPARRAY J12SAMPARRAY
107 : #define TIFF_JSAMPIMAGE J12SAMPIMAGE
108 : #define TIFF_JSAMPROW J12SAMPROW
109 : #else
110 : #define BITS_IN_JSAMPLE 8
111 : #define TIFF_JSAMPLE JSAMPLE
112 : #define TIFF_JSAMPARRAY JSAMPARRAY
113 : #define TIFF_JSAMPIMAGE JSAMPIMAGE
114 : #define TIFF_JSAMPROW JSAMPROW
115 : #endif
116 : #else
117 : #define TIFF_JSAMPLE JSAMPLE
118 : #define TIFF_JSAMPARRAY JSAMPARRAY
119 : #define TIFF_JSAMPIMAGE JSAMPIMAGE
120 : #define TIFF_JSAMPROW JSAMPROW
121 : #endif
122 :
123 : #if defined(JPEG_LIB_MK1)
124 : #define JPEG_LIB_MK1_OR_12BIT 1
125 : #elif BITS_IN_JSAMPLE == 12
126 : #define JPEG_LIB_MK1_OR_12BIT 1
127 : #endif
128 :
129 : /*
130 : * We are using width_in_blocks which is supposed to be private to
131 : * libjpeg. Unfortunately, the libjpeg delivered with Cygwin has
132 : * renamed this member to width_in_data_units. Since the header has
133 : * also renamed a define, use that unique define name in order to
134 : * detect the problem header and adjust to suit.
135 : */
136 : #if defined(D_MAX_DATA_UNITS_IN_MCU)
137 : #define width_in_blocks width_in_data_units
138 : #endif
139 :
140 : /*
141 : * On some machines it may be worthwhile to use _setjmp or sigsetjmp
142 : * in place of plain setjmp. These macros will make it easier.
143 : */
144 : #define SETJMP(jbuf) setjmp(jbuf)
145 : #define LONGJMP(jbuf, code) longjmp(jbuf, code)
146 : #define JMP_BUF jmp_buf
147 :
148 : #ifndef TIFF_jpeg_destination_mgr_defined
149 : #define TIFF_jpeg_destination_mgr_defined
150 : typedef struct jpeg_destination_mgr jpeg_destination_mgr;
151 : #endif
152 :
153 : #ifndef TIFF_jpeg_source_mgr_defined
154 : #define TIFF_jpeg_source_mgr_defined
155 : typedef struct jpeg_source_mgr jpeg_source_mgr;
156 : #endif
157 :
158 : #ifndef TIFF_jpeg_error_mgr_defined
159 : #define TIFF_jpeg_error_mgr_defined
160 : typedef struct jpeg_error_mgr jpeg_error_mgr;
161 : #endif
162 :
163 : /*
164 : * State block for each open TIFF file using
165 : * libjpeg to do JPEG compression/decompression.
166 : *
167 : * libjpeg's visible state is either a jpeg_compress_struct
168 : * or jpeg_decompress_struct depending on which way we
169 : * are going. comm can be used to refer to the fields
170 : * which are common to both.
171 : *
172 : * NB: cinfo is required to be the first member of JPEGState,
173 : * so we can safely cast JPEGState* -> jpeg_xxx_struct*
174 : * and vice versa!
175 : */
176 : typedef struct
177 : {
178 : union
179 : {
180 : struct jpeg_compress_struct c;
181 : struct jpeg_decompress_struct d;
182 : struct jpeg_common_struct comm;
183 : } cinfo; /* NB: must be first */
184 : int cinfo_initialized;
185 :
186 : jpeg_error_mgr err; /* libjpeg error manager */
187 : JMP_BUF exit_jmpbuf; /* for catching libjpeg failures */
188 :
189 : struct jpeg_progress_mgr progress;
190 : /*
191 : * The following two members could be a union, but
192 : * they're small enough that it's not worth the effort.
193 : */
194 : jpeg_destination_mgr dest; /* data dest for compression */
195 : jpeg_source_mgr src; /* data source for decompression */
196 : /* private state */
197 : TIFF *tif; /* back link needed by some code */
198 : uint16_t photometric; /* copy of PhotometricInterpretation */
199 : uint16_t h_sampling; /* luminance sampling factors */
200 : uint16_t v_sampling;
201 : tmsize_t bytesperline; /* decompressed bytes per scanline */
202 : /* pointers to intermediate buffers when processing downsampled data */
203 : TIFF_JSAMPARRAY ds_buffer[MAX_COMPONENTS];
204 : int scancount; /* number of "scanlines" accumulated */
205 : int samplesperclump;
206 :
207 : JPEGOtherSettings otherSettings;
208 : } JPEGState;
209 :
210 : #define JState(tif) ((JPEGState *)(tif)->tif_data)
211 :
212 : static int JPEGDecode(TIFF *tif, uint8_t *buf, tmsize_t cc, uint16_t s);
213 : static int JPEGDecodeRaw(TIFF *tif, uint8_t *buf, tmsize_t cc, uint16_t s);
214 : static int JPEGEncode(TIFF *tif, uint8_t *buf, tmsize_t cc, uint16_t s);
215 : static int JPEGEncodeRaw(TIFF *tif, uint8_t *buf, tmsize_t cc, uint16_t s);
216 : static int JPEGInitializeLibJPEG(TIFF *tif, int decode);
217 : static int DecodeRowError(TIFF *tif, uint8_t *buf, tmsize_t cc, uint16_t s);
218 :
219 : #define FIELD_JPEGTABLES (FIELD_CODEC + 0)
220 :
221 : static const TIFFField jpegFields[] = {
222 : {TIFFTAG_JPEGTABLES, -3, -3, TIFF_UNDEFINED, 0, TIFF_SETGET_C32_UINT8,
223 : TIFF_SETGET_C32_UINT8, FIELD_JPEGTABLES, FALSE, TRUE, "JPEGTables", NULL},
224 : {TIFFTAG_JPEGQUALITY, 0, 0, TIFF_ANY, 0, TIFF_SETGET_INT,
225 : TIFF_SETGET_UNDEFINED, FIELD_PSEUDO, TRUE, FALSE, "", NULL},
226 : {TIFFTAG_JPEGCOLORMODE, 0, 0, TIFF_ANY, 0, TIFF_SETGET_INT,
227 : TIFF_SETGET_UNDEFINED, FIELD_PSEUDO, FALSE, FALSE, "", NULL},
228 : {TIFFTAG_JPEGTABLESMODE, 0, 0, TIFF_ANY, 0, TIFF_SETGET_INT,
229 : TIFF_SETGET_UNDEFINED, FIELD_PSEUDO, FALSE, FALSE, "", NULL}};
230 :
231 : /*
232 : * libjpeg interface layer.
233 : *
234 : * We use setjmp/longjmp to return control to libtiff
235 : * when a fatal error is encountered within the JPEG
236 : * library. We also direct libjpeg error and warning
237 : * messages through the appropriate libtiff handlers.
238 : */
239 :
240 : /*
241 : * Error handling routines (these replace corresponding
242 : * IJG routines from jerror.c). These are used for both
243 : * compression and decompression.
244 : */
245 0 : static void TIFFjpeg_error_exit(j_common_ptr cinfo)
246 : {
247 0 : JPEGState *sp = (JPEGState *)cinfo; /* NB: cinfo assumed first */
248 : char buffer[JMSG_LENGTH_MAX];
249 :
250 0 : (*cinfo->err->format_message)(cinfo, buffer);
251 0 : TIFFErrorExtR(sp->tif, "JPEGLib", "%s",
252 : buffer); /* display the error message */
253 0 : jpeg_abort(cinfo); /* clean up libjpeg state */
254 0 : LONGJMP(sp->exit_jmpbuf, 1); /* return to libtiff caller */
255 : }
256 :
257 : /*
258 : * This routine is invoked only for warning messages,
259 : * since error_exit does its own thing and trace_level
260 : * is never set > 0.
261 : */
262 69 : static void TIFFjpeg_output_message(j_common_ptr cinfo)
263 : {
264 : char buffer[JMSG_LENGTH_MAX];
265 :
266 69 : (*cinfo->err->format_message)(cinfo, buffer);
267 69 : TIFFWarningExtR(((JPEGState *)cinfo)->tif, "JPEGLib", "%s", buffer);
268 69 : }
269 :
270 : /* Avoid the risk of denial-of-service on crafted JPEGs with an insane */
271 : /* number of scans. */
272 : /* See
273 : * http://www.libjpeg-turbo.org/pmwiki/uploads/About/TwoIssueswiththeJPEGStandard.pdf
274 : */
275 220796 : static void TIFFjpeg_progress_monitor(j_common_ptr cinfo)
276 : {
277 220796 : JPEGState *sp = (JPEGState *)cinfo; /* NB: cinfo assumed first */
278 220796 : if (cinfo->is_decompressor)
279 : {
280 220796 : const int scan_no = ((j_decompress_ptr)cinfo)->input_scan_number;
281 220796 : if (scan_no >= sp->otherSettings.max_allowed_scan_number)
282 : {
283 2 : TIFFErrorExtR(
284 : ((JPEGState *)cinfo)->tif, "TIFFjpeg_progress_monitor",
285 : "Scan number %d exceeds maximum scans (%d). This limit "
286 : "can be raised through the "
287 : "LIBTIFF_JPEG_MAX_ALLOWED_SCAN_NUMBER "
288 : "environment variable.",
289 : scan_no, sp->otherSettings.max_allowed_scan_number);
290 :
291 2 : jpeg_abort(cinfo); /* clean up libjpeg state */
292 2 : LONGJMP(sp->exit_jmpbuf, 1); /* return to libtiff caller */
293 : }
294 : }
295 220794 : }
296 :
297 : /*
298 : * Interface routines. This layer of routines exists
299 : * primarily to limit side-effects from using setjmp.
300 : * Also, normal/error returns are converted into return
301 : * values per libtiff practice.
302 : */
303 : #define CALLJPEG(sp, fail, op) (SETJMP((sp)->exit_jmpbuf) ? (fail) : (op))
304 : #define CALLVJPEG(sp, op) CALLJPEG(sp, 0, ((op), 1))
305 :
306 2201 : static int TIFFjpeg_create_compress(JPEGState *sp)
307 : {
308 : /* initialize JPEG error handling */
309 2201 : sp->cinfo.c.err = jpeg_std_error(&sp->err);
310 2201 : sp->err.error_exit = TIFFjpeg_error_exit;
311 2201 : sp->err.output_message = TIFFjpeg_output_message;
312 :
313 : /* set client_data to avoid UMR warning from tools like Purify */
314 2201 : sp->cinfo.c.client_data = NULL;
315 :
316 2201 : return CALLVJPEG(sp, jpeg_create_compress(&sp->cinfo.c));
317 : }
318 :
319 175 : static int TIFFjpeg_create_decompress(JPEGState *sp)
320 : {
321 : /* initialize JPEG error handling */
322 175 : sp->cinfo.d.err = jpeg_std_error(&sp->err);
323 175 : sp->err.error_exit = TIFFjpeg_error_exit;
324 175 : sp->err.output_message = TIFFjpeg_output_message;
325 :
326 : /* set client_data to avoid UMR warning from tools like Purify */
327 175 : sp->cinfo.d.client_data = NULL;
328 :
329 175 : return CALLVJPEG(sp, jpeg_create_decompress(&sp->cinfo.d));
330 : }
331 :
332 2201 : static int TIFFjpeg_set_defaults(JPEGState *sp)
333 : {
334 2201 : return CALLVJPEG(sp, jpeg_set_defaults(&sp->cinfo.c));
335 : }
336 :
337 4207 : static int TIFFjpeg_set_colorspace(JPEGState *sp, J_COLOR_SPACE colorspace)
338 : {
339 4207 : return CALLVJPEG(sp, jpeg_set_colorspace(&sp->cinfo.c, colorspace));
340 : }
341 :
342 5387 : static int TIFFjpeg_set_quality(JPEGState *sp, int quality,
343 : boolean force_baseline)
344 : {
345 5387 : return CALLVJPEG(sp,
346 : jpeg_set_quality(&sp->cinfo.c, quality, force_baseline));
347 : }
348 :
349 1179 : static int TIFFjpeg_suppress_tables(JPEGState *sp, boolean suppress)
350 : {
351 1179 : return CALLVJPEG(sp, jpeg_suppress_tables(&sp->cinfo.c, suppress));
352 : }
353 :
354 4208 : static int TIFFjpeg_start_compress(JPEGState *sp, boolean write_all_tables)
355 : {
356 4208 : return CALLVJPEG(sp, jpeg_start_compress(&sp->cinfo.c, write_all_tables));
357 : }
358 :
359 176848 : static int TIFFjpeg_write_scanlines(JPEGState *sp, TIFF_JSAMPARRAY scanlines,
360 : int num_lines)
361 : {
362 : #if defined(HAVE_JPEGTURBO_DUAL_MODE_8_12) && BITS_IN_JSAMPLE == 12
363 : return CALLJPEG(sp, -1,
364 : (int)jpeg12_write_scanlines(&sp->cinfo.c, scanlines,
365 : (JDIMENSION)num_lines));
366 : #else
367 176848 : return CALLJPEG(sp, -1,
368 : (int)jpeg_write_scanlines(&sp->cinfo.c, scanlines,
369 : (JDIMENSION)num_lines));
370 : #endif
371 : }
372 :
373 0 : static int TIFFjpeg_write_raw_data(JPEGState *sp, TIFF_JSAMPIMAGE data,
374 : int num_lines)
375 : {
376 : #if defined(HAVE_JPEGTURBO_DUAL_MODE_8_12) && BITS_IN_JSAMPLE == 12
377 : return CALLJPEG(
378 : sp, -1,
379 : (int)jpeg12_write_raw_data(&sp->cinfo.c, data, (JDIMENSION)num_lines));
380 : #else
381 0 : return CALLJPEG(
382 : sp, -1,
383 : (int)jpeg_write_raw_data(&sp->cinfo.c, data, (JDIMENSION)num_lines));
384 : #endif
385 : }
386 :
387 4207 : static int TIFFjpeg_finish_compress(JPEGState *sp)
388 : {
389 4207 : return CALLVJPEG(sp, jpeg_finish_compress(&sp->cinfo.c));
390 : }
391 :
392 1178 : static int TIFFjpeg_write_tables(JPEGState *sp)
393 : {
394 1178 : return CALLVJPEG(sp, jpeg_write_tables(&sp->cinfo.c));
395 : }
396 :
397 1952 : static int TIFFjpeg_read_header(JPEGState *sp, boolean require_image)
398 : {
399 1952 : return CALLJPEG(sp, -1, jpeg_read_header(&sp->cinfo.d, require_image));
400 : }
401 :
402 1786 : static int TIFFjpeg_has_multiple_scans(JPEGState *sp)
403 : {
404 1786 : return CALLJPEG(sp, 0, jpeg_has_multiple_scans(&sp->cinfo.d));
405 : }
406 :
407 1784 : static int TIFFjpeg_start_decompress(JPEGState *sp)
408 : {
409 : const char *sz_max_allowed_scan_number;
410 : /* progress monitor */
411 1784 : sp->cinfo.d.progress = &sp->progress;
412 1784 : sp->progress.progress_monitor = TIFFjpeg_progress_monitor;
413 1784 : sp->otherSettings.max_allowed_scan_number = 100;
414 1784 : sz_max_allowed_scan_number = getenv("LIBTIFF_JPEG_MAX_ALLOWED_SCAN_NUMBER");
415 1784 : if (sz_max_allowed_scan_number)
416 1 : sp->otherSettings.max_allowed_scan_number =
417 1 : atoi(sz_max_allowed_scan_number);
418 :
419 1784 : return CALLVJPEG(sp, jpeg_start_decompress(&sp->cinfo.d));
420 : }
421 :
422 110094 : static int TIFFjpeg_read_scanlines(JPEGState *sp, TIFF_JSAMPARRAY scanlines,
423 : int max_lines)
424 : {
425 : #if defined(HAVE_JPEGTURBO_DUAL_MODE_8_12) && BITS_IN_JSAMPLE == 12
426 : return CALLJPEG(sp, -1,
427 : (int)jpeg12_read_scanlines(&sp->cinfo.d, scanlines,
428 : (JDIMENSION)max_lines));
429 : #else
430 110094 : return CALLJPEG(sp, -1,
431 : (int)jpeg_read_scanlines(&sp->cinfo.d, scanlines,
432 : (JDIMENSION)max_lines));
433 : #endif
434 : }
435 :
436 0 : static int TIFFjpeg_read_raw_data(JPEGState *sp, TIFF_JSAMPIMAGE data,
437 : int max_lines)
438 : {
439 : #if defined(HAVE_JPEGTURBO_DUAL_MODE_8_12) && BITS_IN_JSAMPLE == 12
440 : return CALLJPEG(
441 : sp, -1,
442 : (int)jpeg12_read_raw_data(&sp->cinfo.d, data, (JDIMENSION)max_lines));
443 : #else
444 0 : return CALLJPEG(
445 : sp, -1,
446 : (int)jpeg_read_raw_data(&sp->cinfo.d, data, (JDIMENSION)max_lines));
447 : #endif
448 : }
449 :
450 1708 : static int TIFFjpeg_finish_decompress(JPEGState *sp)
451 : {
452 1708 : return CALLJPEG(sp, -1, (int)jpeg_finish_decompress(&sp->cinfo.d));
453 : }
454 :
455 1785 : static int TIFFjpeg_abort(JPEGState *sp)
456 : {
457 1785 : return CALLVJPEG(sp, jpeg_abort(&sp->cinfo.comm));
458 : }
459 :
460 2375 : static int TIFFjpeg_destroy(JPEGState *sp)
461 : {
462 2375 : return CALLVJPEG(sp, jpeg_destroy(&sp->cinfo.comm));
463 : }
464 :
465 0 : static JSAMPARRAY TIFFjpeg_alloc_sarray(JPEGState *sp, int pool_id,
466 : JDIMENSION samplesperrow,
467 : JDIMENSION numrows)
468 : {
469 0 : return CALLJPEG(sp, (JSAMPARRAY)NULL,
470 : (*sp->cinfo.comm.mem->alloc_sarray)(
471 : &sp->cinfo.comm, pool_id, samplesperrow, numrows));
472 : }
473 :
474 : /*
475 : * JPEG library destination data manager.
476 : * These routines direct compressed data from libjpeg into the
477 : * libtiff output buffer.
478 : */
479 :
480 4207 : static void std_init_destination(j_compress_ptr cinfo)
481 : {
482 4207 : JPEGState *sp = (JPEGState *)cinfo;
483 4207 : TIFF *tif = sp->tif;
484 :
485 4207 : sp->dest.next_output_byte = (JOCTET *)tif->tif_rawdata;
486 4207 : sp->dest.free_in_buffer = (size_t)tif->tif_rawdatasize;
487 4207 : }
488 :
489 0 : static boolean std_empty_output_buffer(j_compress_ptr cinfo)
490 : {
491 0 : JPEGState *sp = (JPEGState *)cinfo;
492 0 : TIFF *tif = sp->tif;
493 :
494 : /* the entire buffer has been filled */
495 0 : tif->tif_rawcc = tif->tif_rawdatasize;
496 :
497 : #ifdef IPPJ_HUFF
498 : /*
499 : * The Intel IPP performance library does not necessarily fill up
500 : * the whole output buffer on each pass, so only dump out the parts
501 : * that have been filled.
502 : * http://trac.osgeo.org/gdal/wiki/JpegIPP
503 : */
504 : if (sp->dest.free_in_buffer >= 0)
505 : {
506 : tif->tif_rawcc = tif->tif_rawdatasize - sp->dest.free_in_buffer;
507 : }
508 : #endif
509 :
510 0 : if (!TIFFFlushData1(tif))
511 0 : return FALSE;
512 0 : sp->dest.next_output_byte = (JOCTET *)tif->tif_rawdata;
513 0 : sp->dest.free_in_buffer = (size_t)tif->tif_rawdatasize;
514 :
515 0 : return (TRUE);
516 : }
517 :
518 4208 : static void std_term_destination(j_compress_ptr cinfo)
519 : {
520 4208 : JPEGState *sp = (JPEGState *)cinfo;
521 4208 : TIFF *tif = sp->tif;
522 :
523 4208 : tif->tif_rawcp = (uint8_t *)sp->dest.next_output_byte;
524 4208 : tif->tif_rawcc = tif->tif_rawdatasize - (tmsize_t)sp->dest.free_in_buffer;
525 : /* NB: libtiff does the final buffer flush */
526 4208 : }
527 :
528 2201 : static void TIFFjpeg_data_dest(JPEGState *sp, TIFF *tif)
529 : {
530 : (void)tif;
531 2201 : sp->cinfo.c.dest = &sp->dest;
532 2201 : sp->dest.init_destination = std_init_destination;
533 2201 : sp->dest.empty_output_buffer = std_empty_output_buffer;
534 2201 : sp->dest.term_destination = std_term_destination;
535 2201 : }
536 :
537 : /*
538 : * Alternate destination manager for outputting to JPEGTables field.
539 : */
540 :
541 1179 : static void tables_init_destination(j_compress_ptr cinfo)
542 : {
543 1179 : JPEGState *sp = (JPEGState *)cinfo;
544 :
545 : /* while building, otherSettings.jpegtables_length is allocated buffer size
546 : */
547 1179 : sp->dest.next_output_byte = (JOCTET *)sp->otherSettings.jpegtables;
548 1179 : sp->dest.free_in_buffer = (size_t)sp->otherSettings.jpegtables_length;
549 1179 : }
550 :
551 0 : static boolean tables_empty_output_buffer(j_compress_ptr cinfo)
552 : {
553 0 : JPEGState *sp = (JPEGState *)cinfo;
554 : void *newbuf;
555 :
556 : /* the entire buffer has been filled; enlarge it by 1000 bytes */
557 : newbuf =
558 0 : _TIFFreallocExt(sp->tif, (void *)sp->otherSettings.jpegtables,
559 0 : (tmsize_t)(sp->otherSettings.jpegtables_length + 1000));
560 0 : if (newbuf == NULL)
561 0 : ERREXIT1(cinfo, JERR_OUT_OF_MEMORY, 100);
562 0 : sp->dest.next_output_byte =
563 0 : (JOCTET *)newbuf + sp->otherSettings.jpegtables_length;
564 0 : sp->dest.free_in_buffer = (size_t)1000;
565 0 : sp->otherSettings.jpegtables = newbuf;
566 0 : sp->otherSettings.jpegtables_length += 1000;
567 0 : return (TRUE);
568 : }
569 :
570 1178 : static void tables_term_destination(j_compress_ptr cinfo)
571 : {
572 1178 : JPEGState *sp = (JPEGState *)cinfo;
573 :
574 : /* set tables length to number of bytes actually emitted */
575 1178 : sp->otherSettings.jpegtables_length -= (uint32_t)sp->dest.free_in_buffer;
576 1178 : }
577 :
578 1179 : static int TIFFjpeg_tables_dest(JPEGState *sp, TIFF *tif)
579 : {
580 : (void)tif;
581 : /*
582 : * Allocate a working buffer for building tables.
583 : * Initial size is 1000 bytes, which is usually adequate.
584 : */
585 1179 : if (sp->otherSettings.jpegtables)
586 112 : _TIFFfreeExt(tif, sp->otherSettings.jpegtables);
587 1179 : sp->otherSettings.jpegtables_length = 1000;
588 2357 : sp->otherSettings.jpegtables = (void *)_TIFFmallocExt(
589 1179 : tif, (tmsize_t)sp->otherSettings.jpegtables_length);
590 1178 : if (sp->otherSettings.jpegtables == NULL)
591 : {
592 0 : sp->otherSettings.jpegtables_length = 0;
593 0 : TIFFErrorExtR(sp->tif, "TIFFjpeg_tables_dest",
594 : "No space for JPEGTables");
595 0 : return (0);
596 : }
597 1178 : sp->cinfo.c.dest = &sp->dest;
598 1178 : sp->dest.init_destination = tables_init_destination;
599 1178 : sp->dest.empty_output_buffer = tables_empty_output_buffer;
600 1178 : sp->dest.term_destination = tables_term_destination;
601 1178 : return (1);
602 : }
603 :
604 : /*
605 : * JPEG library source data manager.
606 : * These routines supply compressed data to libjpeg.
607 : */
608 :
609 1787 : static void std_init_source(j_decompress_ptr cinfo)
610 : {
611 1787 : JPEGState *sp = (JPEGState *)cinfo;
612 1787 : TIFF *tif = sp->tif;
613 :
614 1787 : sp->src.next_input_byte = (const JOCTET *)tif->tif_rawdata;
615 1787 : sp->src.bytes_in_buffer = (size_t)tif->tif_rawcc;
616 1787 : }
617 :
618 0 : static boolean std_fill_input_buffer(j_decompress_ptr cinfo)
619 : {
620 0 : JPEGState *sp = (JPEGState *)cinfo;
621 : static const JOCTET dummy_EOI[2] = {0xFF, JPEG_EOI};
622 :
623 : #ifdef IPPJ_HUFF
624 : /*
625 : * The Intel IPP performance library does not necessarily read the whole
626 : * input buffer in one pass, so it is possible to get here with data
627 : * yet to read.
628 : *
629 : * We just return without doing anything, until the entire buffer has
630 : * been read.
631 : * http://trac.osgeo.org/gdal/wiki/JpegIPP
632 : */
633 : if (sp->src.bytes_in_buffer > 0)
634 : {
635 : return (TRUE);
636 : }
637 : #endif
638 :
639 : /*
640 : * Normally the whole strip/tile is read and so we don't need to do
641 : * a fill. In the case of CHUNKY_STRIP_READ_SUPPORT we might not have
642 : * all the data, but the rawdata is refreshed between scanlines and
643 : * we push this into the io machinery in JPEGDecode().
644 : * http://trac.osgeo.org/gdal/ticket/3894
645 : */
646 :
647 0 : WARNMS(cinfo, JWRN_JPEG_EOF);
648 : /* insert a fake EOI marker */
649 0 : sp->src.next_input_byte = dummy_EOI;
650 0 : sp->src.bytes_in_buffer = 2;
651 0 : return (TRUE);
652 : }
653 :
654 0 : static void std_skip_input_data(j_decompress_ptr cinfo, long num_bytes)
655 : {
656 0 : JPEGState *sp = (JPEGState *)cinfo;
657 :
658 0 : if (num_bytes > 0)
659 : {
660 0 : if ((size_t)num_bytes > sp->src.bytes_in_buffer)
661 : {
662 : /* oops, buffer overrun */
663 0 : (void)std_fill_input_buffer(cinfo);
664 : }
665 : else
666 : {
667 0 : sp->src.next_input_byte += (size_t)num_bytes;
668 0 : sp->src.bytes_in_buffer -= (size_t)num_bytes;
669 : }
670 : }
671 0 : }
672 :
673 1708 : static void std_term_source(j_decompress_ptr cinfo)
674 : {
675 : /* No work necessary here */
676 : (void)cinfo;
677 1708 : }
678 :
679 340 : static void TIFFjpeg_data_src(JPEGState *sp)
680 : {
681 340 : sp->cinfo.d.src = &sp->src;
682 340 : sp->src.init_source = std_init_source;
683 340 : sp->src.fill_input_buffer = std_fill_input_buffer;
684 340 : sp->src.skip_input_data = std_skip_input_data;
685 340 : sp->src.resync_to_restart = jpeg_resync_to_restart;
686 340 : sp->src.term_source = std_term_source;
687 340 : sp->src.bytes_in_buffer = 0; /* for safety */
688 340 : sp->src.next_input_byte = NULL;
689 340 : }
690 :
691 : /*
692 : * Alternate source manager for reading from JPEGTables.
693 : * We can share all the code except for the init routine.
694 : */
695 :
696 165 : static void tables_init_source(j_decompress_ptr cinfo)
697 : {
698 165 : JPEGState *sp = (JPEGState *)cinfo;
699 :
700 165 : sp->src.next_input_byte = (const JOCTET *)sp->otherSettings.jpegtables;
701 165 : sp->src.bytes_in_buffer = (size_t)sp->otherSettings.jpegtables_length;
702 165 : }
703 :
704 165 : static void TIFFjpeg_tables_src(JPEGState *sp)
705 : {
706 165 : TIFFjpeg_data_src(sp);
707 165 : sp->src.init_source = tables_init_source;
708 165 : }
709 :
710 : /*
711 : * Allocate downsampled-data buffers needed for downsampled I/O.
712 : * We use values computed in jpeg_start_compress or jpeg_start_decompress.
713 : * We use libjpeg's allocator so that buffers will be released automatically
714 : * when done with strip/tile.
715 : * This is also a handy place to compute samplesperclump, bytesperline.
716 : */
717 0 : static int alloc_downsampled_buffers(TIFF *tif, jpeg_component_info *comp_info,
718 : int num_components)
719 : {
720 0 : JPEGState *sp = JState(tif);
721 : int ci;
722 : jpeg_component_info *compptr;
723 : TIFF_JSAMPARRAY buf;
724 0 : int samples_per_clump = 0;
725 :
726 0 : for (ci = 0, compptr = comp_info; ci < num_components; ci++, compptr++)
727 : {
728 0 : samples_per_clump += compptr->h_samp_factor * compptr->v_samp_factor;
729 0 : buf = (TIFF_JSAMPARRAY)TIFFjpeg_alloc_sarray(
730 0 : sp, JPOOL_IMAGE, compptr->width_in_blocks * DCTSIZE,
731 0 : (JDIMENSION)(compptr->v_samp_factor * DCTSIZE));
732 0 : if (buf == NULL)
733 0 : return (0);
734 0 : sp->ds_buffer[ci] = buf;
735 : }
736 0 : sp->samplesperclump = samples_per_clump;
737 0 : return (1);
738 : }
739 :
740 : /*
741 : * JPEG Decoding.
742 : */
743 :
744 : #ifdef CHECK_JPEG_YCBCR_SUBSAMPLING
745 :
746 : #define JPEG_MARKER_SOF0 0xC0
747 : #define JPEG_MARKER_SOF1 0xC1
748 : #define JPEG_MARKER_SOF2 0xC2
749 : #define JPEG_MARKER_SOF9 0xC9
750 : #define JPEG_MARKER_SOF10 0xCA
751 : #define JPEG_MARKER_DHT 0xC4
752 : #define JPEG_MARKER_SOI 0xD8
753 : #define JPEG_MARKER_SOS 0xDA
754 : #define JPEG_MARKER_DQT 0xDB
755 : #define JPEG_MARKER_DRI 0xDD
756 : #define JPEG_MARKER_APP0 0xE0
757 : #define JPEG_MARKER_COM 0xFE
758 : struct JPEGFixupTagsSubsamplingData
759 : {
760 : TIFF *tif;
761 : void *buffer;
762 : uint32_t buffersize;
763 : uint8_t *buffercurrentbyte;
764 : uint32_t bufferbytesleft;
765 : uint64_t fileoffset;
766 : uint64_t filebytesleft;
767 : uint8_t filepositioned;
768 : };
769 : static void JPEGFixupTagsSubsampling(TIFF *tif);
770 : static int
771 : JPEGFixupTagsSubsamplingSec(struct JPEGFixupTagsSubsamplingData *data);
772 : static int
773 : JPEGFixupTagsSubsamplingReadByte(struct JPEGFixupTagsSubsamplingData *data,
774 : uint8_t *result);
775 : static int
776 : JPEGFixupTagsSubsamplingReadWord(struct JPEGFixupTagsSubsamplingData *data,
777 : uint16_t *result);
778 : static void
779 : JPEGFixupTagsSubsamplingSkip(struct JPEGFixupTagsSubsamplingData *data,
780 : uint16_t skiplength);
781 :
782 : #endif
783 :
784 3112 : static int JPEGFixupTags(TIFF *tif)
785 : {
786 : #ifdef CHECK_JPEG_YCBCR_SUBSAMPLING
787 3112 : JPEGState *sp = JState(tif);
788 3112 : if ((tif->tif_dir.td_photometric == PHOTOMETRIC_YCBCR) &&
789 1443 : (tif->tif_dir.td_planarconfig == PLANARCONFIG_CONTIG) &&
790 1443 : (tif->tif_dir.td_samplesperpixel == 3) &&
791 1443 : !sp->otherSettings.ycbcrsampling_fetched)
792 70 : JPEGFixupTagsSubsampling(tif);
793 : #endif
794 :
795 3112 : return (1);
796 : }
797 :
798 : #ifdef CHECK_JPEG_YCBCR_SUBSAMPLING
799 :
800 70 : static void JPEGFixupTagsSubsampling(TIFF *tif)
801 : {
802 : /*
803 : * Some JPEG-in-TIFF produces do not emit the YCBCRSUBSAMPLING values in
804 : * the TIFF tags, but still use non-default (2,2) values within the jpeg
805 : * data stream itself. In order for TIFF applications to work properly
806 : * - for instance to get the strip buffer size right - it is imperative
807 : * that the subsampling be available before we start reading the image
808 : * data normally. This function will attempt to analyze the first strip in
809 : * order to get the sampling values from the jpeg data stream.
810 : *
811 : * Note that JPEGPreDeocode() will produce a fairly loud warning when the
812 : * discovered sampling does not match the default sampling (2,2) or whatever
813 : * was actually in the tiff tags.
814 : *
815 : * See the bug in bugzilla for details:
816 : *
817 : * http://bugzilla.remotesensing.org/show_bug.cgi?id=168
818 : *
819 : * Frank Warmerdam, July 2002
820 : * Joris Van Damme, May 2007
821 : */
822 : static const char module[] = "JPEGFixupTagsSubsampling";
823 : struct JPEGFixupTagsSubsamplingData m;
824 70 : uint64_t fileoffset = TIFFGetStrileOffset(tif, 0);
825 :
826 70 : if (fileoffset == 0)
827 : {
828 : /* Do not even try to check if the first strip/tile does not
829 : yet exist, as occurs when GDAL has created a new NULL file
830 : for instance. */
831 0 : return;
832 : }
833 :
834 70 : m.tif = tif;
835 70 : m.buffersize = 2048;
836 70 : m.buffer = _TIFFmallocExt(tif, m.buffersize);
837 70 : if (m.buffer == NULL)
838 : {
839 0 : TIFFWarningExtR(tif, module,
840 : "Unable to allocate memory for auto-correcting of "
841 : "subsampling values; auto-correcting skipped");
842 0 : return;
843 : }
844 70 : m.buffercurrentbyte = NULL;
845 70 : m.bufferbytesleft = 0;
846 70 : m.fileoffset = fileoffset;
847 70 : m.filepositioned = 0;
848 70 : m.filebytesleft = TIFFGetStrileByteCount(tif, 0);
849 70 : if (!JPEGFixupTagsSubsamplingSec(&m))
850 0 : TIFFWarningExtR(
851 : tif, module,
852 : "Unable to auto-correct subsampling values, likely corrupt JPEG "
853 : "compressed data in first strip/tile; auto-correcting skipped");
854 70 : _TIFFfreeExt(tif, m.buffer);
855 : }
856 :
857 : static int
858 228 : JPEGFixupTagsSubsamplingSec(struct JPEGFixupTagsSubsamplingData *data)
859 : {
860 : static const char module[] = "JPEGFixupTagsSubsamplingSec";
861 : uint8_t m;
862 158 : while (1)
863 : {
864 : while (1)
865 : {
866 228 : if (!JPEGFixupTagsSubsamplingReadByte(data, &m))
867 0 : return (0);
868 228 : if (m == 255)
869 228 : break;
870 : }
871 : while (1)
872 : {
873 228 : if (!JPEGFixupTagsSubsamplingReadByte(data, &m))
874 0 : return (0);
875 228 : if (m != 255)
876 228 : break;
877 : }
878 228 : switch (m)
879 : {
880 70 : case JPEG_MARKER_SOI:
881 : /* this type of marker has no data and should be skipped */
882 70 : break;
883 88 : case JPEG_MARKER_COM:
884 : case JPEG_MARKER_APP0:
885 : case JPEG_MARKER_APP0 + 1:
886 : case JPEG_MARKER_APP0 + 2:
887 : case JPEG_MARKER_APP0 + 3:
888 : case JPEG_MARKER_APP0 + 4:
889 : case JPEG_MARKER_APP0 + 5:
890 : case JPEG_MARKER_APP0 + 6:
891 : case JPEG_MARKER_APP0 + 7:
892 : case JPEG_MARKER_APP0 + 8:
893 : case JPEG_MARKER_APP0 + 9:
894 : case JPEG_MARKER_APP0 + 10:
895 : case JPEG_MARKER_APP0 + 11:
896 : case JPEG_MARKER_APP0 + 12:
897 : case JPEG_MARKER_APP0 + 13:
898 : case JPEG_MARKER_APP0 + 14:
899 : case JPEG_MARKER_APP0 + 15:
900 : case JPEG_MARKER_DQT:
901 : case JPEG_MARKER_SOS:
902 : case JPEG_MARKER_DHT:
903 : case JPEG_MARKER_DRI:
904 : /* this type of marker has data, but it has no use to us and
905 : * should be skipped */
906 : {
907 : uint16_t n;
908 88 : if (!JPEGFixupTagsSubsamplingReadWord(data, &n))
909 0 : return (0);
910 88 : if (n < 2)
911 0 : return (0);
912 88 : n -= 2;
913 88 : if (n > 0)
914 88 : JPEGFixupTagsSubsamplingSkip(data, n);
915 : }
916 88 : break;
917 70 : case JPEG_MARKER_SOF0: /* Baseline sequential Huffman */
918 : case JPEG_MARKER_SOF1: /* Extended sequential Huffman */
919 : case JPEG_MARKER_SOF2: /* Progressive Huffman: normally not allowed
920 : by TechNote, but that doesn't hurt
921 : supporting it */
922 : case JPEG_MARKER_SOF9: /* Extended sequential arithmetic */
923 : case JPEG_MARKER_SOF10: /* Progressive arithmetic: normally not
924 : allowed by TechNote, but that doesn't
925 : hurt supporting it */
926 : /* this marker contains the subsampling factors we're scanning
927 : * for */
928 : {
929 : uint16_t n;
930 : uint16_t o;
931 : uint8_t p;
932 : uint8_t ph, pv;
933 70 : if (!JPEGFixupTagsSubsamplingReadWord(data, &n))
934 0 : return (0);
935 70 : if (n != 8 + data->tif->tif_dir.td_samplesperpixel * 3)
936 0 : return (0);
937 70 : JPEGFixupTagsSubsamplingSkip(data, 7);
938 70 : if (!JPEGFixupTagsSubsamplingReadByte(data, &p))
939 0 : return (0);
940 70 : ph = (p >> 4);
941 70 : pv = (p & 15);
942 70 : JPEGFixupTagsSubsamplingSkip(data, 1);
943 210 : for (o = 1; o < data->tif->tif_dir.td_samplesperpixel; o++)
944 : {
945 140 : JPEGFixupTagsSubsamplingSkip(data, 1);
946 140 : if (!JPEGFixupTagsSubsamplingReadByte(data, &p))
947 0 : return (0);
948 140 : if (p != 0x11)
949 : {
950 0 : TIFFWarningExtR(data->tif, module,
951 : "Subsampling values inside JPEG "
952 : "compressed data "
953 : "have no TIFF equivalent, "
954 : "auto-correction of TIFF "
955 : "subsampling values failed");
956 0 : return (1);
957 : }
958 140 : JPEGFixupTagsSubsamplingSkip(data, 1);
959 : }
960 70 : if (((ph != 1) && (ph != 2) && (ph != 4)) ||
961 70 : ((pv != 1) && (pv != 2) && (pv != 4)))
962 : {
963 0 : TIFFWarningExtR(data->tif, module,
964 : "Subsampling values inside JPEG "
965 : "compressed data have no TIFF "
966 : "equivalent, auto-correction of TIFF "
967 : "subsampling values failed");
968 0 : return (1);
969 : }
970 70 : if ((ph != data->tif->tif_dir.td_ycbcrsubsampling[0]) ||
971 70 : (pv != data->tif->tif_dir.td_ycbcrsubsampling[1]))
972 : {
973 0 : TIFFWarningExtR(
974 : data->tif, module,
975 : "Auto-corrected former TIFF subsampling values "
976 : "[%" PRIu16 ",%" PRIu16
977 : "] to match subsampling values inside JPEG "
978 : "compressed data [%" PRIu8 ",%" PRIu8 "]",
979 0 : data->tif->tif_dir.td_ycbcrsubsampling[0],
980 0 : data->tif->tif_dir.td_ycbcrsubsampling[1], ph, pv);
981 0 : data->tif->tif_dir.td_ycbcrsubsampling[0] = ph;
982 0 : data->tif->tif_dir.td_ycbcrsubsampling[1] = pv;
983 : }
984 : }
985 70 : return (1);
986 0 : default:
987 0 : return (0);
988 : }
989 : }
990 : }
991 :
992 : static int
993 982 : JPEGFixupTagsSubsamplingReadByte(struct JPEGFixupTagsSubsamplingData *data,
994 : uint8_t *result)
995 : {
996 982 : if (data->bufferbytesleft == 0)
997 : {
998 : uint32_t m;
999 70 : if (data->filebytesleft == 0)
1000 0 : return (0);
1001 70 : if (!data->filepositioned)
1002 : {
1003 70 : if (TIFFSeekFile(data->tif, data->fileoffset, SEEK_SET) ==
1004 : (toff_t)-1)
1005 : {
1006 0 : return 0;
1007 : }
1008 70 : data->filepositioned = 1;
1009 : }
1010 70 : m = data->buffersize;
1011 70 : if ((uint64_t)m > data->filebytesleft)
1012 0 : m = (uint32_t)data->filebytesleft;
1013 70 : assert(m < 0x80000000UL);
1014 70 : if (TIFFReadFile(data->tif, data->buffer, (tmsize_t)m) != (tmsize_t)m)
1015 0 : return (0);
1016 70 : data->buffercurrentbyte = data->buffer;
1017 70 : data->bufferbytesleft = m;
1018 70 : data->fileoffset += m;
1019 70 : data->filebytesleft -= m;
1020 : }
1021 982 : *result = *data->buffercurrentbyte;
1022 982 : data->buffercurrentbyte++;
1023 982 : data->bufferbytesleft--;
1024 982 : return (1);
1025 : }
1026 :
1027 : static int
1028 158 : JPEGFixupTagsSubsamplingReadWord(struct JPEGFixupTagsSubsamplingData *data,
1029 : uint16_t *result)
1030 : {
1031 : uint8_t ma;
1032 : uint8_t mb;
1033 158 : if (!JPEGFixupTagsSubsamplingReadByte(data, &ma))
1034 0 : return (0);
1035 158 : if (!JPEGFixupTagsSubsamplingReadByte(data, &mb))
1036 0 : return (0);
1037 158 : *result = (ma << 8) | mb;
1038 158 : return (1);
1039 : }
1040 :
1041 : static void
1042 508 : JPEGFixupTagsSubsamplingSkip(struct JPEGFixupTagsSubsamplingData *data,
1043 : uint16_t skiplength)
1044 : {
1045 508 : if ((uint32_t)skiplength <= data->bufferbytesleft)
1046 : {
1047 508 : data->buffercurrentbyte += skiplength;
1048 508 : data->bufferbytesleft -= skiplength;
1049 : }
1050 : else
1051 : {
1052 : uint16_t m;
1053 0 : m = (uint16_t)(skiplength - data->bufferbytesleft);
1054 0 : if (m <= data->filebytesleft)
1055 : {
1056 0 : data->bufferbytesleft = 0;
1057 0 : data->fileoffset += m;
1058 0 : data->filebytesleft -= m;
1059 0 : data->filepositioned = 0;
1060 : }
1061 : else
1062 : {
1063 0 : data->bufferbytesleft = 0;
1064 0 : data->filebytesleft = 0;
1065 : }
1066 : }
1067 508 : }
1068 :
1069 : #endif
1070 :
1071 181 : static int JPEGSetupDecode(TIFF *tif)
1072 : {
1073 181 : JPEGState *sp = JState(tif);
1074 181 : TIFFDirectory *td = &tif->tif_dir;
1075 :
1076 : #if defined(JPEG_DUAL_MODE_8_12) && !defined(FROM_TIF_JPEG_12)
1077 173 : if (tif->tif_dir.td_bitspersample == 12)
1078 : {
1079 : /* We pass a pointer to a copy of otherSettings, since */
1080 : /* TIFFReInitJPEG_12() will clear sp */
1081 8 : JPEGOtherSettings savedOtherSettings = sp->otherSettings;
1082 8 : return TIFFReInitJPEG_12(tif, &savedOtherSettings, COMPRESSION_JPEG, 0);
1083 : }
1084 : #endif
1085 :
1086 173 : JPEGInitializeLibJPEG(tif, TRUE);
1087 :
1088 173 : assert(sp != NULL);
1089 173 : assert(sp->cinfo.comm.is_decompressor);
1090 :
1091 : /* Read JPEGTables if it is present */
1092 173 : if (TIFFFieldSet(tif, FIELD_JPEGTABLES))
1093 : {
1094 165 : TIFFjpeg_tables_src(sp);
1095 165 : if (TIFFjpeg_read_header(sp, FALSE) != JPEG_HEADER_TABLES_ONLY)
1096 : {
1097 0 : TIFFErrorExtR(tif, "JPEGSetupDecode", "Bogus JPEGTables field");
1098 0 : return (0);
1099 : }
1100 : }
1101 :
1102 : /* Grab parameters that are same for all strips/tiles */
1103 173 : sp->photometric = td->td_photometric;
1104 173 : switch (sp->photometric)
1105 : {
1106 106 : case PHOTOMETRIC_YCBCR:
1107 106 : sp->h_sampling = td->td_ycbcrsubsampling[0];
1108 106 : sp->v_sampling = td->td_ycbcrsubsampling[1];
1109 106 : break;
1110 67 : default:
1111 : /* TIFF 6.0 forbids subsampling of all other color spaces */
1112 67 : sp->h_sampling = 1;
1113 67 : sp->v_sampling = 1;
1114 67 : break;
1115 : }
1116 :
1117 : /* Set up for reading normal data */
1118 173 : TIFFjpeg_data_src(sp);
1119 173 : tif->tif_postdecode = _TIFFNoPostDecode; /* override byte swapping */
1120 173 : return (1);
1121 : }
1122 :
1123 : /* Returns 1 if the full strip should be read, even when doing scanline per */
1124 : /* scanline decoding. This happens when the JPEG stream uses multiple scans. */
1125 : /* Currently only called in CHUNKY_STRIP_READ_SUPPORT mode through */
1126 : /* scanline interface. */
1127 : /* Only reads tif->tif_dir.td_bitspersample, tif->tif_rawdata and */
1128 : /* tif->tif_rawcc members. */
1129 : /* Can be called independently of the usual setup/predecode/decode states */
1130 2 : int TIFFJPEGIsFullStripRequired(TIFF *tif)
1131 : {
1132 : int ret;
1133 : JPEGState state;
1134 :
1135 : #if defined(JPEG_DUAL_MODE_8_12) && !defined(FROM_TIF_JPEG_12)
1136 2 : if (tif->tif_dir.td_bitspersample == 12)
1137 0 : return TIFFJPEGIsFullStripRequired_12(tif);
1138 : #endif
1139 :
1140 2 : memset(&state, 0, sizeof(JPEGState));
1141 2 : state.tif = tif;
1142 :
1143 2 : TIFFjpeg_create_decompress(&state);
1144 :
1145 2 : TIFFjpeg_data_src(&state);
1146 :
1147 2 : if (TIFFjpeg_read_header(&state, TRUE) != JPEG_HEADER_OK)
1148 : {
1149 0 : TIFFjpeg_destroy(&state);
1150 0 : return (0);
1151 : }
1152 2 : ret = TIFFjpeg_has_multiple_scans(&state);
1153 :
1154 2 : TIFFjpeg_destroy(&state);
1155 :
1156 2 : return ret;
1157 : }
1158 :
1159 : /*
1160 : * Set up for decoding a strip or tile.
1161 : */
1162 1785 : /*ARGSUSED*/ static int JPEGPreDecode(TIFF *tif, uint16_t s)
1163 : {
1164 1785 : JPEGState *sp = JState(tif);
1165 1785 : TIFFDirectory *td = &tif->tif_dir;
1166 : static const char module[] = "JPEGPreDecode";
1167 : uint32_t segment_width, segment_height;
1168 : int downsampled_output;
1169 : int ci;
1170 :
1171 1785 : assert(sp != NULL);
1172 :
1173 1785 : if (sp->cinfo.comm.is_decompressor == 0)
1174 : {
1175 14 : tif->tif_setupdecode(tif);
1176 : }
1177 :
1178 1785 : assert(sp->cinfo.comm.is_decompressor);
1179 : /*
1180 : * Reset decoder state from any previous strip/tile,
1181 : * in case application didn't read the whole strip.
1182 : */
1183 1785 : if (!TIFFjpeg_abort(sp))
1184 0 : return (0);
1185 : /*
1186 : * Read the header for this strip/tile.
1187 : */
1188 :
1189 1785 : if (TIFFjpeg_read_header(sp, TRUE) != JPEG_HEADER_OK)
1190 0 : return (0);
1191 :
1192 1785 : tif->tif_rawcp = (uint8_t *)sp->src.next_input_byte;
1193 1785 : tif->tif_rawcc = sp->src.bytes_in_buffer;
1194 :
1195 : /*
1196 : * Check image parameters and set decompression parameters.
1197 : */
1198 1785 : if (isTiled(tif))
1199 : {
1200 512 : segment_width = td->td_tilewidth;
1201 512 : segment_height = td->td_tilelength;
1202 512 : sp->bytesperline = TIFFTileRowSize(tif);
1203 : }
1204 : else
1205 : {
1206 1273 : segment_width = td->td_imagewidth;
1207 1273 : segment_height = td->td_imagelength - tif->tif_row;
1208 1273 : if (segment_height > td->td_rowsperstrip)
1209 1173 : segment_height = td->td_rowsperstrip;
1210 1273 : sp->bytesperline = TIFFScanlineSize(tif);
1211 : }
1212 1785 : if (td->td_planarconfig == PLANARCONFIG_SEPARATE && s > 0)
1213 : {
1214 : /*
1215 : * For PC 2, scale down the expected strip/tile size
1216 : * to match a downsampled component
1217 : */
1218 21 : if (sp->h_sampling == 0 || sp->v_sampling == 0)
1219 : {
1220 0 : TIFFErrorExtR(tif, module,
1221 : "JPEG horizontal or vertical sampling is zero");
1222 0 : return (0);
1223 : }
1224 21 : segment_width = TIFFhowmany_32(segment_width, sp->h_sampling);
1225 21 : segment_height = TIFFhowmany_32(segment_height, sp->v_sampling);
1226 : }
1227 1785 : if (sp->cinfo.d.image_width < segment_width ||
1228 1785 : sp->cinfo.d.image_height < segment_height)
1229 : {
1230 0 : TIFFWarningExtR(tif, module,
1231 : "Improper JPEG strip/tile size, "
1232 : "expected %" PRIu32 "x%" PRIu32 ", got %ux%u",
1233 : segment_width, segment_height, sp->cinfo.d.image_width,
1234 : sp->cinfo.d.image_height);
1235 : }
1236 1785 : if (sp->cinfo.d.image_width == segment_width &&
1237 1784 : sp->cinfo.d.image_height > segment_height &&
1238 2 : tif->tif_row + segment_height == td->td_imagelength && !isTiled(tif))
1239 : {
1240 : /* Some files have a last strip, that should be truncated, */
1241 : /* but their JPEG codestream has still the maximum strip */
1242 : /* height. Warn about this as this is non compliant, but */
1243 : /* we can safely recover from that. */
1244 2 : TIFFWarningExtR(tif, module,
1245 : "JPEG strip size exceeds expected dimensions,"
1246 : " expected %" PRIu32 "x%" PRIu32 ", got %ux%u",
1247 : segment_width, segment_height, sp->cinfo.d.image_width,
1248 : sp->cinfo.d.image_height);
1249 : }
1250 1783 : else if (sp->cinfo.d.image_width > segment_width ||
1251 1782 : sp->cinfo.d.image_height > segment_height)
1252 : {
1253 : /*
1254 : * This case could be dangerous, if the strip or tile size has
1255 : * been reported as less than the amount of data jpeg will
1256 : * return, some potential security issues arise. Catch this
1257 : * case and error out.
1258 : */
1259 1 : TIFFErrorExtR(tif, module,
1260 : "JPEG strip/tile size exceeds expected dimensions,"
1261 : " expected %" PRIu32 "x%" PRIu32 ", got %ux%u",
1262 : segment_width, segment_height, sp->cinfo.d.image_width,
1263 : sp->cinfo.d.image_height);
1264 1 : return (0);
1265 : }
1266 1784 : if (sp->cinfo.d.num_components !=
1267 3540 : (td->td_planarconfig == PLANARCONFIG_CONTIG ? td->td_samplesperpixel
1268 1784 : : 1))
1269 : {
1270 0 : TIFFErrorExtR(tif, module, "Improper JPEG component count");
1271 0 : return (0);
1272 : }
1273 : #ifdef JPEG_LIB_MK1
1274 : if (12 != td->td_bitspersample && 8 != td->td_bitspersample)
1275 : {
1276 : TIFFErrorExtR(tif, module, "Improper JPEG data precision");
1277 : return (0);
1278 : }
1279 : sp->cinfo.d.data_precision = td->td_bitspersample;
1280 : sp->cinfo.d.bits_in_jsample = td->td_bitspersample;
1281 : #else
1282 1784 : if (sp->cinfo.d.data_precision != td->td_bitspersample)
1283 : {
1284 0 : TIFFErrorExtR(tif, module, "Improper JPEG data precision");
1285 0 : return (0);
1286 : }
1287 : #endif
1288 :
1289 1784 : if (sp->cinfo.d.progressive_mode &&
1290 2 : !sp->otherSettings.has_warned_about_progressive_mode)
1291 : {
1292 2 : TIFFWarningExtR(tif, module,
1293 : "The JPEG strip/tile is encoded with progressive mode, "
1294 : "which is normally not legal for JPEG-in-TIFF.\n"
1295 : "libtiff should be able to decode it, but it might "
1296 : "cause compatibility issues with other readers");
1297 2 : sp->otherSettings.has_warned_about_progressive_mode = TRUE;
1298 : }
1299 :
1300 : /* In some cases, libjpeg needs to allocate a lot of memory */
1301 : /* http://www.libjpeg-turbo.org/pmwiki/uploads/About/TwoIssueswiththeJPEGStandard.pdf
1302 : */
1303 1784 : if (TIFFjpeg_has_multiple_scans(sp))
1304 : {
1305 : /* In this case libjpeg will need to allocate memory or backing */
1306 : /* store for all coefficients */
1307 : /* See call to jinit_d_coef_controller() from master_selection() */
1308 : /* in libjpeg */
1309 :
1310 : /* 1 MB for regular libjpeg usage */
1311 2 : toff_t nRequiredMemory = 1024 * 1024;
1312 :
1313 4 : for (ci = 0; ci < sp->cinfo.d.num_components; ci++)
1314 : {
1315 2 : const jpeg_component_info *compptr = &(sp->cinfo.d.comp_info[ci]);
1316 2 : if (compptr->h_samp_factor > 0 && compptr->v_samp_factor > 0)
1317 : {
1318 2 : nRequiredMemory +=
1319 2 : (toff_t)(((compptr->width_in_blocks +
1320 2 : compptr->h_samp_factor - 1) /
1321 2 : compptr->h_samp_factor)) *
1322 2 : ((compptr->height_in_blocks + compptr->v_samp_factor - 1) /
1323 2 : compptr->v_samp_factor) *
1324 : sizeof(JBLOCK);
1325 : }
1326 : }
1327 :
1328 2 : if (sp->cinfo.d.mem->max_memory_to_use > 0 &&
1329 0 : nRequiredMemory > (toff_t)(sp->cinfo.d.mem->max_memory_to_use) &&
1330 0 : getenv("LIBTIFF_ALLOW_LARGE_LIBJPEG_MEM_ALLOC") == NULL)
1331 : {
1332 0 : TIFFErrorExtR(
1333 : tif, module,
1334 : "Reading this image would require libjpeg to allocate "
1335 : "at least %" PRIu64 " bytes. "
1336 : "This is disabled since above the %ld threshold. "
1337 : "You may override this restriction by defining the "
1338 : "LIBTIFF_ALLOW_LARGE_LIBJPEG_MEM_ALLOC environment variable, "
1339 : "or setting the JPEGMEM environment variable to a value "
1340 : "greater "
1341 : "or equal to '%" PRIu64 "M'",
1342 0 : nRequiredMemory, sp->cinfo.d.mem->max_memory_to_use,
1343 0 : (nRequiredMemory + 1000000u - 1u) / 1000000u);
1344 0 : return 0;
1345 : }
1346 : }
1347 :
1348 1784 : if (td->td_planarconfig == PLANARCONFIG_CONTIG)
1349 : {
1350 : /* Component 0 should have expected sampling factors */
1351 1756 : if (sp->cinfo.d.comp_info[0].h_samp_factor != sp->h_sampling ||
1352 1756 : sp->cinfo.d.comp_info[0].v_samp_factor != sp->v_sampling)
1353 : {
1354 0 : TIFFErrorExtR(tif, module,
1355 : "Improper JPEG sampling factors %d,%d\n"
1356 : "Apparently should be %" PRIu16 ",%" PRIu16 ".",
1357 0 : sp->cinfo.d.comp_info[0].h_samp_factor,
1358 0 : sp->cinfo.d.comp_info[0].v_samp_factor,
1359 0 : sp->h_sampling, sp->v_sampling);
1360 0 : return (0);
1361 : }
1362 : /* Rest should have sampling factors 1,1 */
1363 5053 : for (ci = 1; ci < sp->cinfo.d.num_components; ci++)
1364 : {
1365 3297 : if (sp->cinfo.d.comp_info[ci].h_samp_factor != 1 ||
1366 3297 : sp->cinfo.d.comp_info[ci].v_samp_factor != 1)
1367 : {
1368 0 : TIFFErrorExtR(tif, module, "Improper JPEG sampling factors");
1369 0 : return (0);
1370 : }
1371 : }
1372 : }
1373 : else
1374 : {
1375 : /* PC 2's single component should have sampling factors 1,1 */
1376 28 : if (sp->cinfo.d.comp_info[0].h_samp_factor != 1 ||
1377 28 : sp->cinfo.d.comp_info[0].v_samp_factor != 1)
1378 : {
1379 0 : TIFFErrorExtR(tif, module, "Improper JPEG sampling factors");
1380 0 : return (0);
1381 : }
1382 : }
1383 1784 : downsampled_output = FALSE;
1384 1784 : if (td->td_planarconfig == PLANARCONFIG_CONTIG &&
1385 1756 : sp->photometric == PHOTOMETRIC_YCBCR &&
1386 1558 : sp->otherSettings.jpegcolormode == JPEGCOLORMODE_RGB)
1387 : {
1388 : /* Convert YCbCr to RGB */
1389 1558 : sp->cinfo.d.jpeg_color_space = JCS_YCbCr;
1390 1558 : sp->cinfo.d.out_color_space = JCS_RGB;
1391 : }
1392 : else
1393 : {
1394 : /* Suppress colorspace handling */
1395 226 : sp->cinfo.d.jpeg_color_space = JCS_UNKNOWN;
1396 226 : sp->cinfo.d.out_color_space = JCS_UNKNOWN;
1397 226 : if (td->td_planarconfig == PLANARCONFIG_CONTIG &&
1398 198 : (sp->h_sampling != 1 || sp->v_sampling != 1))
1399 0 : downsampled_output = TRUE;
1400 : /* XXX what about up-sampling? */
1401 : }
1402 1784 : if (downsampled_output)
1403 : {
1404 : /* Need to use raw-data interface to libjpeg */
1405 0 : sp->cinfo.d.raw_data_out = TRUE;
1406 : #if JPEG_LIB_VERSION >= 70
1407 0 : sp->cinfo.d.do_fancy_upsampling = FALSE;
1408 : #endif /* JPEG_LIB_VERSION >= 70 */
1409 0 : tif->tif_decoderow = DecodeRowError;
1410 0 : tif->tif_decodestrip = JPEGDecodeRaw;
1411 0 : tif->tif_decodetile = JPEGDecodeRaw;
1412 : }
1413 : else
1414 : {
1415 : /* Use normal interface to libjpeg */
1416 1784 : sp->cinfo.d.raw_data_out = FALSE;
1417 1784 : tif->tif_decoderow = JPEGDecode;
1418 1784 : tif->tif_decodestrip = JPEGDecode;
1419 1784 : tif->tif_decodetile = JPEGDecode;
1420 : }
1421 : /* Start JPEG decompressor */
1422 1784 : if (!TIFFjpeg_start_decompress(sp))
1423 2 : return (0);
1424 : /* Allocate downsampled-data buffers if needed */
1425 1782 : if (downsampled_output)
1426 : {
1427 0 : if (!alloc_downsampled_buffers(tif, sp->cinfo.d.comp_info,
1428 : sp->cinfo.d.num_components))
1429 0 : return (0);
1430 0 : sp->scancount = DCTSIZE; /* mark buffer empty */
1431 : }
1432 1782 : return (1);
1433 : }
1434 :
1435 : /*
1436 : * Decode a chunk of pixels.
1437 : * "Standard" case: returned data is not downsampled.
1438 : */
1439 : #if !JPEG_LIB_MK1_OR_12BIT
1440 10963 : static int JPEGDecode(TIFF *tif, uint8_t *buf, tmsize_t cc, uint16_t s)
1441 : {
1442 10963 : JPEGState *sp = JState(tif);
1443 : tmsize_t nrows;
1444 : (void)s;
1445 :
1446 : /*
1447 : ** Update available information, buffer may have been refilled
1448 : ** between decode requests
1449 : */
1450 10963 : sp->src.next_input_byte = (const JOCTET *)tif->tif_rawcp;
1451 10963 : sp->src.bytes_in_buffer = (size_t)tif->tif_rawcc;
1452 :
1453 10963 : if (sp->bytesperline == 0)
1454 : {
1455 0 : memset(buf, 0, (size_t)cc);
1456 0 : return 0;
1457 : }
1458 :
1459 10963 : nrows = cc / sp->bytesperline;
1460 10963 : if (cc % sp->bytesperline)
1461 0 : TIFFWarningExtR(tif, tif->tif_name, "fractional scanline not read");
1462 :
1463 10963 : if (nrows > (tmsize_t)sp->cinfo.d.image_height)
1464 0 : nrows = sp->cinfo.d.image_height;
1465 :
1466 : /* data is expected to be read in multiples of a scanline */
1467 10963 : if (nrows)
1468 : {
1469 : do
1470 : {
1471 : /*
1472 : * In the libjpeg6b-9a 8bit case. We read directly into
1473 : * the TIFF buffer.
1474 : */
1475 109454 : JSAMPROW bufptr = (JSAMPROW)buf;
1476 :
1477 109454 : if (TIFFjpeg_read_scanlines(sp, &bufptr, 1) != 1)
1478 : {
1479 0 : memset(buf, 0, (size_t)cc);
1480 0 : return (0);
1481 : }
1482 :
1483 109454 : ++tif->tif_row;
1484 109454 : buf += sp->bytesperline;
1485 109454 : cc -= sp->bytesperline;
1486 109454 : } while (--nrows > 0);
1487 : }
1488 :
1489 : /* Update information on consumed data */
1490 10963 : tif->tif_rawcp = (uint8_t *)sp->src.next_input_byte;
1491 10963 : tif->tif_rawcc = sp->src.bytes_in_buffer;
1492 :
1493 : /* Close down the decompressor if we've finished the strip or tile. */
1494 12662 : return sp->cinfo.d.output_scanline < sp->cinfo.d.output_height ||
1495 1699 : TIFFjpeg_finish_decompress(sp);
1496 : }
1497 : #endif /* !JPEG_LIB_MK1_OR_12BIT */
1498 :
1499 : #if JPEG_LIB_MK1_OR_12BIT
1500 9 : /*ARGSUSED*/ static int JPEGDecode(TIFF *tif, uint8_t *buf, tmsize_t cc,
1501 : uint16_t s)
1502 : {
1503 9 : JPEGState *sp = JState(tif);
1504 : tmsize_t nrows;
1505 : (void)s;
1506 :
1507 : /*
1508 : ** Update available information, buffer may have been refilled
1509 : ** between decode requests
1510 : */
1511 9 : sp->src.next_input_byte = (const JOCTET *)tif->tif_rawcp;
1512 9 : sp->src.bytes_in_buffer = (size_t)tif->tif_rawcc;
1513 :
1514 9 : if (sp->bytesperline == 0)
1515 : {
1516 0 : memset(buf, 0, (size_t)cc);
1517 0 : return 0;
1518 : }
1519 :
1520 9 : nrows = cc / sp->bytesperline;
1521 9 : if (cc % sp->bytesperline)
1522 0 : TIFFWarningExtR(tif, tif->tif_name, "fractional scanline not read");
1523 :
1524 9 : if (nrows > (tmsize_t)sp->cinfo.d.image_height)
1525 0 : nrows = sp->cinfo.d.image_height;
1526 :
1527 : /* data is expected to be read in multiples of a scanline */
1528 9 : if (nrows)
1529 : {
1530 9 : TIFF_JSAMPROW line_work_buf = NULL;
1531 :
1532 : /*
1533 : * For 6B, only use temporary buffer for 12 bit imagery.
1534 : * For Mk1 always use it.
1535 : */
1536 9 : if (sp->cinfo.d.data_precision == 12)
1537 : {
1538 9 : line_work_buf = (TIFF_JSAMPROW)_TIFFmallocExt(
1539 9 : tif, sizeof(short) * sp->cinfo.d.output_width *
1540 9 : sp->cinfo.d.num_components);
1541 : }
1542 :
1543 : do
1544 : {
1545 640 : if (line_work_buf != NULL)
1546 : {
1547 : /*
1548 : * In the MK1 case, we always read into a 16bit
1549 : * buffer, and then pack down to 12bit or 8bit.
1550 : * In 6B case we only read into 16 bit buffer
1551 : * for 12bit data, which we need to repack.
1552 : */
1553 640 : if (TIFFjpeg_read_scanlines(sp, &line_work_buf, 1) != 1)
1554 : {
1555 0 : memset(buf, 0, (size_t)cc);
1556 0 : return (0);
1557 : }
1558 :
1559 640 : if (sp->cinfo.d.data_precision == 12)
1560 : {
1561 640 : int value_pairs = (sp->cinfo.d.output_width *
1562 640 : sp->cinfo.d.num_components) /
1563 : 2;
1564 : int iPair;
1565 :
1566 53888 : for (iPair = 0; iPair < value_pairs; iPair++)
1567 : {
1568 53248 : unsigned char *out_ptr =
1569 53248 : ((unsigned char *)buf) + iPair * 3;
1570 53248 : TIFF_JSAMPLE *in_ptr = line_work_buf + iPair * 2;
1571 :
1572 53248 : out_ptr[0] = (unsigned char)((in_ptr[0] & 0xff0) >> 4);
1573 53248 : out_ptr[1] =
1574 53248 : (unsigned char)(((in_ptr[0] & 0xf) << 4) |
1575 53248 : ((in_ptr[1] & 0xf00) >> 8));
1576 53248 : out_ptr[2] = (unsigned char)(((in_ptr[1] & 0xff) >> 0));
1577 : }
1578 : }
1579 0 : else if (sp->cinfo.d.data_precision == 8)
1580 : {
1581 0 : int value_count =
1582 0 : (sp->cinfo.d.output_width * sp->cinfo.d.num_components);
1583 : int iValue;
1584 :
1585 0 : for (iValue = 0; iValue < value_count; iValue++)
1586 : {
1587 0 : ((unsigned char *)buf)[iValue] =
1588 0 : line_work_buf[iValue] & 0xff;
1589 : }
1590 : }
1591 : }
1592 :
1593 640 : ++tif->tif_row;
1594 640 : buf += sp->bytesperline;
1595 640 : cc -= sp->bytesperline;
1596 640 : } while (--nrows > 0);
1597 :
1598 9 : if (line_work_buf != NULL)
1599 9 : _TIFFfreeExt(tif, line_work_buf);
1600 : }
1601 :
1602 : /* Update information on consumed data */
1603 9 : tif->tif_rawcp = (uint8_t *)sp->src.next_input_byte;
1604 9 : tif->tif_rawcc = sp->src.bytes_in_buffer;
1605 :
1606 : /* Close down the decompressor if we've finished the strip or tile. */
1607 18 : return sp->cinfo.d.output_scanline < sp->cinfo.d.output_height ||
1608 9 : TIFFjpeg_finish_decompress(sp);
1609 : }
1610 : #endif /* JPEG_LIB_MK1_OR_12BIT */
1611 :
1612 0 : /*ARGSUSED*/ static int DecodeRowError(TIFF *tif, uint8_t *buf, tmsize_t cc,
1613 : uint16_t s)
1614 :
1615 : {
1616 : (void)buf;
1617 : (void)cc;
1618 : (void)s;
1619 :
1620 0 : TIFFErrorExtR(
1621 : tif, "TIFFReadScanline",
1622 : "scanline oriented access is not supported for downsampled JPEG "
1623 : "compressed images, consider enabling TIFFTAG_JPEGCOLORMODE as "
1624 : "JPEGCOLORMODE_RGB.");
1625 0 : return 0;
1626 : }
1627 :
1628 : /*
1629 : * Decode a chunk of pixels.
1630 : * Returned data is downsampled per sampling factors.
1631 : */
1632 0 : /*ARGSUSED*/ static int JPEGDecodeRaw(TIFF *tif, uint8_t *buf, tmsize_t cc,
1633 : uint16_t s)
1634 : {
1635 0 : JPEGState *sp = JState(tif);
1636 : tmsize_t nrows;
1637 0 : TIFFDirectory *td = &tif->tif_dir;
1638 : (void)s;
1639 :
1640 0 : nrows = sp->cinfo.d.image_height;
1641 : /* For last strip, limit number of rows to its truncated height */
1642 : /* even if the codestream height is larger (which is not compliant, */
1643 : /* but that we tolerate) */
1644 0 : if ((uint32_t)nrows > td->td_imagelength - tif->tif_row && !isTiled(tif))
1645 0 : nrows = td->td_imagelength - tif->tif_row;
1646 :
1647 : #if defined(JPEG_LIB_MK1_OR_12BIT)
1648 0 : unsigned short *tmpbuf = NULL;
1649 : #endif
1650 :
1651 : /* data is expected to be read in multiples of a scanline */
1652 0 : if (nrows != 0)
1653 : {
1654 :
1655 : /* Cb,Cr both have sampling factors 1, so this is correct */
1656 0 : JDIMENSION clumps_per_line = sp->cinfo.d.comp_info[1].downsampled_width;
1657 0 : int samples_per_clump = sp->samplesperclump;
1658 :
1659 : #if defined(JPEG_LIB_MK1_OR_12BIT)
1660 0 : tmpbuf = _TIFFmallocExt(tif, sizeof(unsigned short) *
1661 0 : sp->cinfo.d.output_width *
1662 0 : sp->cinfo.d.num_components);
1663 0 : if (tmpbuf == NULL)
1664 : {
1665 0 : TIFFErrorExtR(tif, "JPEGDecodeRaw", "Out of memory");
1666 0 : return 0;
1667 : }
1668 : #endif
1669 :
1670 : do
1671 : {
1672 : jpeg_component_info *compptr;
1673 : int ci, clumpoffset;
1674 :
1675 0 : if (cc < sp->bytesperline)
1676 : {
1677 0 : TIFFErrorExtR(
1678 : tif, "JPEGDecodeRaw",
1679 : "application buffer not large enough for all data.");
1680 0 : goto error;
1681 : }
1682 :
1683 : /* Reload downsampled-data buffer if needed */
1684 0 : if (sp->scancount >= DCTSIZE)
1685 : {
1686 0 : int n = sp->cinfo.d.max_v_samp_factor * DCTSIZE;
1687 0 : if (TIFFjpeg_read_raw_data(sp, sp->ds_buffer, n) != n)
1688 0 : goto error;
1689 0 : sp->scancount = 0;
1690 : }
1691 : /*
1692 : * Fastest way to unseparate data is to make one pass
1693 : * over the scanline for each row of each component.
1694 : */
1695 0 : clumpoffset = 0; /* first sample in clump */
1696 0 : for (ci = 0, compptr = sp->cinfo.d.comp_info;
1697 0 : ci < sp->cinfo.d.num_components; ci++, compptr++)
1698 : {
1699 0 : int hsamp = compptr->h_samp_factor;
1700 0 : int vsamp = compptr->v_samp_factor;
1701 : int ypos;
1702 :
1703 0 : for (ypos = 0; ypos < vsamp; ypos++)
1704 : {
1705 0 : TIFF_JSAMPLE *inptr =
1706 0 : sp->ds_buffer[ci][sp->scancount * vsamp + ypos];
1707 : JDIMENSION nclump;
1708 : #if defined(JPEG_LIB_MK1_OR_12BIT)
1709 0 : TIFF_JSAMPLE *outptr = (TIFF_JSAMPLE *)tmpbuf + clumpoffset;
1710 : #else
1711 0 : TIFF_JSAMPLE *outptr = (TIFF_JSAMPLE *)buf + clumpoffset;
1712 0 : if (cc < (tmsize_t)(clumpoffset +
1713 0 : (tmsize_t)samples_per_clump *
1714 0 : (clumps_per_line - 1) +
1715 : hsamp))
1716 : {
1717 0 : TIFFErrorExtR(
1718 : tif, "JPEGDecodeRaw",
1719 : "application buffer not large enough for all data, "
1720 : "possible subsampling issue");
1721 0 : goto error;
1722 : }
1723 : #endif
1724 :
1725 0 : if (hsamp == 1)
1726 : {
1727 : /* fast path for at least Cb and Cr */
1728 0 : for (nclump = clumps_per_line; nclump-- > 0;)
1729 : {
1730 0 : outptr[0] = *inptr++;
1731 0 : outptr += samples_per_clump;
1732 : }
1733 : }
1734 : else
1735 : {
1736 : int xpos;
1737 :
1738 : /* general case */
1739 0 : for (nclump = clumps_per_line; nclump-- > 0;)
1740 : {
1741 0 : for (xpos = 0; xpos < hsamp; xpos++)
1742 0 : outptr[xpos] = *inptr++;
1743 0 : outptr += samples_per_clump;
1744 : }
1745 : }
1746 0 : clumpoffset += hsamp;
1747 : }
1748 : }
1749 :
1750 : #if defined(JPEG_LIB_MK1_OR_12BIT)
1751 : {
1752 0 : if (sp->cinfo.d.data_precision == 8)
1753 : {
1754 0 : int i = 0;
1755 0 : int len =
1756 0 : sp->cinfo.d.output_width * sp->cinfo.d.num_components;
1757 0 : for (i = 0; i < len; i++)
1758 : {
1759 0 : ((unsigned char *)buf)[i] = tmpbuf[i] & 0xff;
1760 : }
1761 : }
1762 : else
1763 : { /* 12-bit */
1764 0 : int value_pairs = (sp->cinfo.d.output_width *
1765 0 : sp->cinfo.d.num_components) /
1766 : 2;
1767 : int iPair;
1768 0 : for (iPair = 0; iPair < value_pairs; iPair++)
1769 : {
1770 0 : unsigned char *out_ptr =
1771 0 : ((unsigned char *)buf) + iPair * 3;
1772 0 : JSAMPLE *in_ptr = (JSAMPLE *)(tmpbuf + iPair * 2);
1773 0 : out_ptr[0] = (unsigned char)((in_ptr[0] & 0xff0) >> 4);
1774 0 : out_ptr[1] =
1775 0 : (unsigned char)(((in_ptr[0] & 0xf) << 4) |
1776 0 : ((in_ptr[1] & 0xf00) >> 8));
1777 0 : out_ptr[2] = (unsigned char)(((in_ptr[1] & 0xff) >> 0));
1778 : }
1779 : }
1780 : }
1781 : #endif
1782 :
1783 0 : sp->scancount++;
1784 0 : tif->tif_row += sp->v_sampling;
1785 :
1786 0 : buf += sp->bytesperline;
1787 0 : cc -= sp->bytesperline;
1788 :
1789 0 : nrows -= sp->v_sampling;
1790 0 : } while (nrows > 0);
1791 :
1792 : #if defined(JPEG_LIB_MK1_OR_12BIT)
1793 0 : _TIFFfreeExt(tif, tmpbuf);
1794 : #endif
1795 : }
1796 :
1797 : /* Close down the decompressor if done. */
1798 0 : return sp->cinfo.d.output_scanline < sp->cinfo.d.output_height ||
1799 0 : TIFFjpeg_finish_decompress(sp);
1800 :
1801 0 : error:
1802 : #if defined(JPEG_LIB_MK1_OR_12BIT)
1803 0 : _TIFFfreeExt(tif, tmpbuf);
1804 : #endif
1805 0 : return 0;
1806 : }
1807 :
1808 : /*
1809 : * JPEG Encoding.
1810 : */
1811 :
1812 1741 : static void unsuppress_quant_table(JPEGState *sp, int tblno)
1813 : {
1814 : JQUANT_TBL *qtbl;
1815 :
1816 1741 : if ((qtbl = sp->cinfo.c.quant_tbl_ptrs[tblno]) != NULL)
1817 1741 : qtbl->sent_table = FALSE;
1818 1741 : }
1819 :
1820 8292 : static void suppress_quant_table(JPEGState *sp, int tblno)
1821 : {
1822 : JQUANT_TBL *qtbl;
1823 :
1824 8292 : if ((qtbl = sp->cinfo.c.quant_tbl_ptrs[tblno]) != NULL)
1825 8292 : qtbl->sent_table = TRUE;
1826 8292 : }
1827 :
1828 22 : static void unsuppress_huff_table(JPEGState *sp, int tblno)
1829 : {
1830 : JHUFF_TBL *htbl;
1831 :
1832 22 : if ((htbl = sp->cinfo.c.dc_huff_tbl_ptrs[tblno]) != NULL)
1833 22 : htbl->sent_table = FALSE;
1834 22 : if ((htbl = sp->cinfo.c.ac_huff_tbl_ptrs[tblno]) != NULL)
1835 22 : htbl->sent_table = FALSE;
1836 22 : }
1837 :
1838 1870 : static void suppress_huff_table(JPEGState *sp, int tblno)
1839 : {
1840 : JHUFF_TBL *htbl;
1841 :
1842 1870 : if ((htbl = sp->cinfo.c.dc_huff_tbl_ptrs[tblno]) != NULL)
1843 1870 : htbl->sent_table = TRUE;
1844 1870 : if ((htbl = sp->cinfo.c.ac_huff_tbl_ptrs[tblno]) != NULL)
1845 1870 : htbl->sent_table = TRUE;
1846 1870 : }
1847 :
1848 1179 : static int prepare_JPEGTables(TIFF *tif)
1849 : {
1850 1179 : JPEGState *sp = JState(tif);
1851 :
1852 : /* Initialize quant tables for current quality setting */
1853 1179 : if (!TIFFjpeg_set_quality(sp, sp->otherSettings.jpegquality, FALSE))
1854 0 : return (0);
1855 : /* Mark only the tables we want for output */
1856 : /* NB: chrominance tables are currently used only with YCbCr */
1857 1179 : if (!TIFFjpeg_suppress_tables(sp, TRUE))
1858 0 : return (0);
1859 1179 : if (sp->otherSettings.jpegtablesmode & JPEGTABLESMODE_QUANT)
1860 : {
1861 1175 : unsuppress_quant_table(sp, 0);
1862 1175 : if (sp->photometric == PHOTOMETRIC_YCBCR)
1863 445 : unsuppress_quant_table(sp, 1);
1864 : }
1865 1179 : if (sp->otherSettings.jpegtablesmode & JPEGTABLESMODE_HUFF)
1866 : {
1867 16 : unsuppress_huff_table(sp, 0);
1868 16 : if (sp->photometric == PHOTOMETRIC_YCBCR)
1869 6 : unsuppress_huff_table(sp, 1);
1870 : }
1871 : /* Direct libjpeg output into otherSettings.jpegtables */
1872 1179 : if (!TIFFjpeg_tables_dest(sp, tif))
1873 0 : return (0);
1874 : /* Emit tables-only datastream */
1875 1178 : if (!TIFFjpeg_write_tables(sp))
1876 0 : return (0);
1877 :
1878 1178 : return (1);
1879 : }
1880 :
1881 : #if defined(JPEG_LIB_VERSION_MAJOR) && \
1882 : (JPEG_LIB_VERSION_MAJOR > 9 || \
1883 : (JPEG_LIB_VERSION_MAJOR == 9 && JPEG_LIB_VERSION_MINOR >= 4))
1884 : /* This is a modified version of std_huff_tables() from jcparam.c
1885 : * in libjpeg-9d because it no longer initializes default Huffman
1886 : * tables in jpeg_set_defaults(). */
1887 : static void TIFF_std_huff_tables(j_compress_ptr cinfo)
1888 : {
1889 :
1890 : if (cinfo->dc_huff_tbl_ptrs[0] == NULL)
1891 : {
1892 : (void)jpeg_std_huff_table((j_common_ptr)cinfo, TRUE, 0);
1893 : }
1894 : if (cinfo->ac_huff_tbl_ptrs[0] == NULL)
1895 : {
1896 : (void)jpeg_std_huff_table((j_common_ptr)cinfo, FALSE, 0);
1897 : }
1898 : if (cinfo->dc_huff_tbl_ptrs[1] == NULL)
1899 : {
1900 : (void)jpeg_std_huff_table((j_common_ptr)cinfo, TRUE, 1);
1901 : }
1902 : if (cinfo->ac_huff_tbl_ptrs[1] == NULL)
1903 : {
1904 : (void)jpeg_std_huff_table((j_common_ptr)cinfo, FALSE, 1);
1905 : }
1906 : }
1907 : #endif
1908 :
1909 3381 : static int JPEGSetupEncode(TIFF *tif)
1910 : {
1911 3381 : JPEGState *sp = JState(tif);
1912 3381 : TIFFDirectory *td = &tif->tif_dir;
1913 : static const char module[] = "JPEGSetupEncode";
1914 :
1915 : #if defined(JPEG_DUAL_MODE_8_12) && !defined(FROM_TIF_JPEG_12)
1916 2201 : if (tif->tif_dir.td_bitspersample == 12)
1917 : {
1918 : /* We pass a pointer to a copy of otherSettings, since */
1919 : /* TIFFReInitJPEG_12() will clear sp */
1920 1180 : JPEGOtherSettings savedOtherSettings = sp->otherSettings;
1921 1180 : return TIFFReInitJPEG_12(tif, &savedOtherSettings, COMPRESSION_JPEG, 1);
1922 : }
1923 : #endif
1924 :
1925 2201 : JPEGInitializeLibJPEG(tif, FALSE);
1926 :
1927 2201 : assert(sp != NULL);
1928 2201 : assert(!sp->cinfo.comm.is_decompressor);
1929 :
1930 2201 : sp->photometric = td->td_photometric;
1931 :
1932 : /*
1933 : * Initialize all JPEG parameters to default values.
1934 : * Note that jpeg_set_defaults needs legal values for
1935 : * in_color_space and input_components.
1936 : */
1937 2201 : if (td->td_planarconfig == PLANARCONFIG_CONTIG)
1938 : {
1939 2194 : sp->cinfo.c.input_components = td->td_samplesperpixel;
1940 2194 : if (sp->photometric == PHOTOMETRIC_YCBCR)
1941 : {
1942 809 : if (sp->otherSettings.jpegcolormode == JPEGCOLORMODE_RGB)
1943 : {
1944 809 : sp->cinfo.c.in_color_space = JCS_RGB;
1945 : }
1946 : else
1947 : {
1948 0 : sp->cinfo.c.in_color_space = JCS_YCbCr;
1949 : }
1950 : }
1951 : else
1952 : {
1953 1385 : if ((td->td_photometric == PHOTOMETRIC_MINISWHITE ||
1954 1385 : td->td_photometric == PHOTOMETRIC_MINISBLACK) &&
1955 658 : td->td_samplesperpixel == 1)
1956 73 : sp->cinfo.c.in_color_space = JCS_GRAYSCALE;
1957 1312 : else if (td->td_photometric == PHOTOMETRIC_RGB &&
1958 721 : td->td_samplesperpixel == 3)
1959 86 : sp->cinfo.c.in_color_space = JCS_RGB;
1960 1226 : else if (td->td_photometric == PHOTOMETRIC_SEPARATED &&
1961 6 : td->td_samplesperpixel == 4)
1962 6 : sp->cinfo.c.in_color_space = JCS_CMYK;
1963 : else
1964 1220 : sp->cinfo.c.in_color_space = JCS_UNKNOWN;
1965 : }
1966 : }
1967 : else
1968 : {
1969 7 : sp->cinfo.c.input_components = 1;
1970 7 : sp->cinfo.c.in_color_space = JCS_UNKNOWN;
1971 : }
1972 2201 : if (!TIFFjpeg_set_defaults(sp))
1973 0 : return (0);
1974 :
1975 : /* mozjpeg by default enables progressive JPEG, which is illegal in
1976 : * JPEG-in-TIFF */
1977 : /* So explicitly disable it. */
1978 2201 : if (sp->cinfo.c.num_scans != 0 &&
1979 0 : (sp->otherSettings.jpegtablesmode & JPEGTABLESMODE_HUFF) != 0)
1980 : {
1981 : /* it has been found that mozjpeg could create corrupt strips/tiles */
1982 : /* in non optimize_coding mode. */
1983 0 : TIFFWarningExtR(
1984 : tif, module,
1985 : "mozjpeg library likely detected. Disable emission of "
1986 : "Huffman tables in JpegTables tag, and use optimize_coding "
1987 : "to avoid potential issues");
1988 0 : sp->otherSettings.jpegtablesmode &= ~JPEGTABLESMODE_HUFF;
1989 : }
1990 2201 : sp->cinfo.c.num_scans = 0;
1991 2201 : sp->cinfo.c.scan_info = NULL;
1992 :
1993 : /* Set per-file parameters */
1994 2201 : switch (sp->photometric)
1995 : {
1996 809 : case PHOTOMETRIC_YCBCR:
1997 809 : sp->h_sampling = td->td_ycbcrsubsampling[0];
1998 809 : sp->v_sampling = td->td_ycbcrsubsampling[1];
1999 809 : if (sp->h_sampling == 0 || sp->v_sampling == 0)
2000 : {
2001 0 : TIFFErrorExtR(tif, module,
2002 : "Invalig horizontal/vertical sampling value");
2003 0 : return (0);
2004 : }
2005 809 : if (td->td_bitspersample > 16)
2006 : {
2007 0 : TIFFErrorExtR(tif, module,
2008 : "BitsPerSample %" PRIu16 " not allowed for JPEG",
2009 0 : td->td_bitspersample);
2010 0 : return (0);
2011 : }
2012 :
2013 : /*
2014 : * A ReferenceBlackWhite field *must* be present since the
2015 : * default value is inappropriate for YCbCr. Fill in the
2016 : * proper value if application didn't set it.
2017 : */
2018 : {
2019 : float *ref;
2020 809 : if (!TIFFGetField(tif, TIFFTAG_REFERENCEBLACKWHITE, &ref))
2021 : {
2022 : float refbw[6];
2023 446 : long top = 1L << td->td_bitspersample;
2024 446 : refbw[0] = 0;
2025 446 : refbw[1] = (float)(top - 1L);
2026 446 : refbw[2] = (float)(top >> 1);
2027 446 : refbw[3] = refbw[1];
2028 446 : refbw[4] = refbw[2];
2029 446 : refbw[5] = refbw[1];
2030 446 : TIFFSetField(tif, TIFFTAG_REFERENCEBLACKWHITE, refbw);
2031 : }
2032 : }
2033 809 : break;
2034 0 : case PHOTOMETRIC_PALETTE: /* disallowed by Tech Note */
2035 : case PHOTOMETRIC_MASK:
2036 0 : TIFFErrorExtR(tif, module,
2037 : "PhotometricInterpretation %" PRIu16
2038 : " not allowed for JPEG",
2039 0 : sp->photometric);
2040 0 : return (0);
2041 1392 : default:
2042 : /* TIFF 6.0 forbids subsampling of all other color spaces */
2043 1392 : sp->h_sampling = 1;
2044 1392 : sp->v_sampling = 1;
2045 1392 : break;
2046 : }
2047 :
2048 : /* Verify miscellaneous parameters */
2049 :
2050 : /*
2051 : * This would need work if libtiff ever supports different
2052 : * depths for different components, or if libjpeg ever supports
2053 : * run-time selection of depth. Neither is imminent.
2054 : */
2055 : #ifdef JPEG_LIB_MK1
2056 : /* BITS_IN_JSAMPLE now permits 8 and 12 --- dgilbert */
2057 : if (td->td_bitspersample != 8 && td->td_bitspersample != 12)
2058 : #else
2059 2201 : if (td->td_bitspersample != BITS_IN_JSAMPLE)
2060 : #endif
2061 : {
2062 0 : TIFFErrorExtR(tif, module,
2063 : "BitsPerSample %" PRIu16 " not allowed for JPEG",
2064 0 : td->td_bitspersample);
2065 0 : return (0);
2066 : }
2067 2201 : sp->cinfo.c.data_precision = td->td_bitspersample;
2068 : #ifdef JPEG_LIB_MK1
2069 : sp->cinfo.c.bits_in_jsample = td->td_bitspersample;
2070 : #endif
2071 2201 : if (isTiled(tif))
2072 : {
2073 63 : if ((td->td_tilelength % (sp->v_sampling * DCTSIZE)) != 0)
2074 : {
2075 0 : TIFFErrorExtR(tif, module,
2076 : "JPEG tile height must be multiple of %" PRIu32,
2077 0 : (uint32_t)(sp->v_sampling * DCTSIZE));
2078 0 : return (0);
2079 : }
2080 63 : if ((td->td_tilewidth % (sp->h_sampling * DCTSIZE)) != 0)
2081 : {
2082 0 : TIFFErrorExtR(tif, module,
2083 : "JPEG tile width must be multiple of %" PRIu32,
2084 0 : (uint32_t)(sp->h_sampling * DCTSIZE));
2085 0 : return (0);
2086 : }
2087 : }
2088 : else
2089 : {
2090 2138 : if (td->td_rowsperstrip < td->td_imagelength &&
2091 30 : (td->td_rowsperstrip % (sp->v_sampling * DCTSIZE)) != 0)
2092 : {
2093 0 : TIFFErrorExtR(tif, module,
2094 : "RowsPerStrip must be multiple of %" PRIu32
2095 : " for JPEG",
2096 0 : (uint32_t)(sp->v_sampling * DCTSIZE));
2097 0 : return (0);
2098 : }
2099 : }
2100 :
2101 : /* Create a JPEGTables field if appropriate */
2102 2201 : if (sp->otherSettings.jpegtablesmode &
2103 : (JPEGTABLESMODE_QUANT | JPEGTABLESMODE_HUFF))
2104 : {
2105 2194 : if (sp->otherSettings.jpegtables == NULL ||
2106 1127 : memcmp(sp->otherSettings.jpegtables, "\0\0\0\0\0\0\0\0\0", 8) == 0)
2107 : {
2108 : #if defined(JPEG_LIB_VERSION_MAJOR) && \
2109 : (JPEG_LIB_VERSION_MAJOR > 9 || \
2110 : (JPEG_LIB_VERSION_MAJOR == 9 && JPEG_LIB_VERSION_MINOR >= 4))
2111 : if ((sp->otherSettings.jpegtablesmode & JPEGTABLESMODE_HUFF) != 0 &&
2112 : (sp->cinfo.c.dc_huff_tbl_ptrs[0] == NULL ||
2113 : sp->cinfo.c.dc_huff_tbl_ptrs[1] == NULL ||
2114 : sp->cinfo.c.ac_huff_tbl_ptrs[0] == NULL ||
2115 : sp->cinfo.c.ac_huff_tbl_ptrs[1] == NULL))
2116 : {
2117 : /* libjpeg-9d no longer initializes default Huffman tables in */
2118 : /* jpeg_set_defaults() */
2119 : TIFF_std_huff_tables(&sp->cinfo.c);
2120 : }
2121 : #endif
2122 :
2123 1179 : if (!prepare_JPEGTables(tif))
2124 0 : return (0);
2125 : /* Mark the field present */
2126 : /* Can't use TIFFSetField since BEENWRITING is already set! */
2127 1178 : tif->tif_flags |= TIFF_DIRTYDIRECT;
2128 1178 : TIFFSetFieldBit(tif, FIELD_JPEGTABLES);
2129 : }
2130 : }
2131 : else
2132 : {
2133 : /* We do not support application-supplied JPEGTables, */
2134 : /* so mark the field not present */
2135 7 : TIFFClrFieldBit(tif, FIELD_JPEGTABLES);
2136 : }
2137 :
2138 : /* Direct libjpeg output to libtiff's output buffer */
2139 2200 : TIFFjpeg_data_dest(sp, tif);
2140 :
2141 2201 : return (1);
2142 : }
2143 :
2144 : /*
2145 : * Set encoding state at the start of a strip or tile.
2146 : */
2147 4208 : static int JPEGPreEncode(TIFF *tif, uint16_t s)
2148 : {
2149 4208 : JPEGState *sp = JState(tif);
2150 4208 : TIFFDirectory *td = &tif->tif_dir;
2151 : static const char module[] = "JPEGPreEncode";
2152 : uint32_t segment_width, segment_height;
2153 : int downsampled_input;
2154 :
2155 4208 : assert(sp != NULL);
2156 :
2157 4208 : if (sp->cinfo.comm.is_decompressor == 1)
2158 : {
2159 2 : tif->tif_setupencode(tif);
2160 : }
2161 :
2162 4208 : assert(!sp->cinfo.comm.is_decompressor);
2163 : /*
2164 : * Set encoding parameters for this strip/tile.
2165 : */
2166 4208 : if (isTiled(tif))
2167 : {
2168 516 : segment_width = td->td_tilewidth;
2169 516 : segment_height = td->td_tilelength;
2170 516 : sp->bytesperline = TIFFTileRowSize(tif);
2171 : }
2172 : else
2173 : {
2174 3692 : segment_width = td->td_imagewidth;
2175 3692 : segment_height = td->td_imagelength - tif->tif_row;
2176 3692 : if (segment_height > td->td_rowsperstrip)
2177 1544 : segment_height = td->td_rowsperstrip;
2178 3692 : sp->bytesperline = TIFFScanlineSize(tif);
2179 : }
2180 4207 : if (td->td_planarconfig == PLANARCONFIG_SEPARATE && s > 0)
2181 : {
2182 : /* for PC 2, scale down the strip/tile size
2183 : * to match a downsampled component
2184 : */
2185 221 : if (sp->h_sampling == 0 || sp->v_sampling == 0)
2186 : {
2187 0 : TIFFErrorExtR(tif, module,
2188 : "JPEG horizontal or vertical sampling is zero");
2189 0 : return (0);
2190 : }
2191 221 : segment_width = TIFFhowmany_32(segment_width, sp->h_sampling);
2192 221 : segment_height = TIFFhowmany_32(segment_height, sp->v_sampling);
2193 : }
2194 4207 : if (segment_width > (uint32_t)JPEG_MAX_DIMENSION ||
2195 : segment_height > (uint32_t)JPEG_MAX_DIMENSION)
2196 : {
2197 0 : TIFFErrorExtR(tif, module,
2198 : "Strip/tile too large for JPEG. Maximum dimension is %d",
2199 : (int)JPEG_MAX_DIMENSION);
2200 0 : return (0);
2201 : }
2202 4207 : sp->cinfo.c.image_width = segment_width;
2203 4207 : sp->cinfo.c.image_height = segment_height;
2204 4207 : downsampled_input = FALSE;
2205 4207 : if (td->td_planarconfig == PLANARCONFIG_CONTIG)
2206 : {
2207 3877 : sp->cinfo.c.input_components = td->td_samplesperpixel;
2208 3877 : if (sp->photometric == PHOTOMETRIC_YCBCR)
2209 : {
2210 1998 : if (sp->otherSettings.jpegcolormode != JPEGCOLORMODE_RGB)
2211 : {
2212 0 : if (sp->h_sampling != 1 || sp->v_sampling != 1)
2213 0 : downsampled_input = TRUE;
2214 : }
2215 1998 : if (!TIFFjpeg_set_colorspace(sp, JCS_YCbCr))
2216 0 : return (0);
2217 : /*
2218 : * Set Y sampling factors;
2219 : * we assume jpeg_set_colorspace() set the rest to 1
2220 : */
2221 1998 : sp->cinfo.c.comp_info[0].h_samp_factor = sp->h_sampling;
2222 1998 : sp->cinfo.c.comp_info[0].v_samp_factor = sp->v_sampling;
2223 : }
2224 : else
2225 : {
2226 1879 : if (!TIFFjpeg_set_colorspace(sp, sp->cinfo.c.in_color_space))
2227 0 : return (0);
2228 : /* jpeg_set_colorspace set all sampling factors to 1 */
2229 : }
2230 : }
2231 : else
2232 : {
2233 330 : if (!TIFFjpeg_set_colorspace(sp, JCS_UNKNOWN))
2234 0 : return (0);
2235 330 : sp->cinfo.c.comp_info[0].component_id = s;
2236 : /* jpeg_set_colorspace() set sampling factors to 1 */
2237 330 : if (sp->photometric == PHOTOMETRIC_YCBCR && s > 0)
2238 : {
2239 0 : sp->cinfo.c.comp_info[0].quant_tbl_no = 1;
2240 0 : sp->cinfo.c.comp_info[0].dc_tbl_no = 1;
2241 0 : sp->cinfo.c.comp_info[0].ac_tbl_no = 1;
2242 : }
2243 : }
2244 : /* ensure libjpeg won't write any extraneous markers */
2245 4207 : sp->cinfo.c.write_JFIF_header = FALSE;
2246 4207 : sp->cinfo.c.write_Adobe_marker = FALSE;
2247 : /* set up table handling correctly */
2248 : /* calling TIFFjpeg_set_quality() causes quantization tables to be flagged
2249 : */
2250 : /* as being to be emitted, which we don't want in the JPEGTABLESMODE_QUANT
2251 : */
2252 : /* mode, so we must manually suppress them. However TIFFjpeg_set_quality()
2253 : */
2254 : /* should really be called when dealing with files with directories with */
2255 : /* mixed qualities. see http://trac.osgeo.org/gdal/ticket/3539 */
2256 4207 : if (!TIFFjpeg_set_quality(sp, sp->otherSettings.jpegquality, FALSE))
2257 0 : return (0);
2258 4208 : if (sp->otherSettings.jpegtablesmode & JPEGTABLESMODE_QUANT)
2259 : {
2260 4147 : suppress_quant_table(sp, 0);
2261 4146 : suppress_quant_table(sp, 1);
2262 : }
2263 : else
2264 : {
2265 61 : unsuppress_quant_table(sp, 0);
2266 61 : unsuppress_quant_table(sp, 1);
2267 : }
2268 4207 : if (sp->otherSettings.jpegtablesmode & JPEGTABLESMODE_HUFF)
2269 : {
2270 : /* Explicit suppression is only needed if we did not go through the */
2271 : /* prepare_JPEGTables() code path, which may be the case if updating */
2272 : /* an existing file */
2273 935 : suppress_huff_table(sp, 0);
2274 935 : suppress_huff_table(sp, 1);
2275 935 : sp->cinfo.c.optimize_coding = FALSE;
2276 : }
2277 : else
2278 3272 : sp->cinfo.c.optimize_coding = TRUE;
2279 4207 : if (downsampled_input)
2280 : {
2281 : /* Need to use raw-data interface to libjpeg */
2282 0 : sp->cinfo.c.raw_data_in = TRUE;
2283 0 : tif->tif_encoderow = JPEGEncodeRaw;
2284 0 : tif->tif_encodestrip = JPEGEncodeRaw;
2285 0 : tif->tif_encodetile = JPEGEncodeRaw;
2286 : }
2287 : else
2288 : {
2289 : /* Use normal interface to libjpeg */
2290 4207 : sp->cinfo.c.raw_data_in = FALSE;
2291 4207 : tif->tif_encoderow = JPEGEncode;
2292 4207 : tif->tif_encodestrip = JPEGEncode;
2293 4207 : tif->tif_encodetile = JPEGEncode;
2294 : }
2295 : /* Start JPEG compressor */
2296 4207 : if (!TIFFjpeg_start_compress(sp, FALSE))
2297 0 : return (0);
2298 : /* Allocate downsampled-data buffers if needed */
2299 4208 : if (downsampled_input)
2300 : {
2301 0 : if (!alloc_downsampled_buffers(tif, sp->cinfo.c.comp_info,
2302 : sp->cinfo.c.num_components))
2303 0 : return (0);
2304 : }
2305 4208 : sp->scancount = 0;
2306 :
2307 4208 : return (1);
2308 : }
2309 :
2310 : /*
2311 : * Encode a chunk of pixels.
2312 : * "Standard" case: incoming data is not downsampled.
2313 : */
2314 8255 : static int JPEGEncode(TIFF *tif, uint8_t *buf, tmsize_t cc, uint16_t s)
2315 : {
2316 8255 : JPEGState *sp = JState(tif);
2317 : tmsize_t nrows;
2318 : TIFF_JSAMPROW bufptr[1];
2319 8255 : short *line16 = NULL;
2320 8255 : int line16_count = 0;
2321 :
2322 : (void)s;
2323 8255 : assert(sp != NULL);
2324 : /* data is expected to be supplied in multiples of a scanline */
2325 8255 : nrows = cc / sp->bytesperline;
2326 8255 : if (cc % sp->bytesperline)
2327 0 : TIFFWarningExtR(tif, tif->tif_name, "fractional scanline discarded");
2328 :
2329 : /* The last strip will be limited to image size */
2330 8255 : if (!isTiled(tif) && tif->tif_row + nrows > tif->tif_dir.td_imagelength)
2331 0 : nrows = tif->tif_dir.td_imagelength - tif->tif_row;
2332 :
2333 8255 : if (sp->cinfo.c.data_precision == 12)
2334 : {
2335 1181 : line16_count = (int)((sp->bytesperline * 2) / 3);
2336 1181 : line16 = (short *)_TIFFmallocExt(tif, sizeof(short) * line16_count);
2337 1181 : if (!line16)
2338 : {
2339 0 : TIFFErrorExtR(tif, "JPEGEncode", "Failed to allocate memory");
2340 :
2341 0 : return 0;
2342 : }
2343 : }
2344 :
2345 185107 : while (nrows-- > 0)
2346 : {
2347 :
2348 176849 : if (sp->cinfo.c.data_precision == 12)
2349 : {
2350 :
2351 19200 : int value_pairs = line16_count / 2;
2352 : int iPair;
2353 :
2354 19200 : bufptr[0] = (TIFF_JSAMPROW)line16;
2355 :
2356 495872 : for (iPair = 0; iPair < value_pairs; iPair++)
2357 : {
2358 476672 : unsigned char *in_ptr = ((unsigned char *)buf) + iPair * 3;
2359 476672 : TIFF_JSAMPLE *out_ptr = (TIFF_JSAMPLE *)(line16 + iPair * 2);
2360 :
2361 476672 : out_ptr[0] = (in_ptr[0] << 4) | ((in_ptr[1] & 0xf0) >> 4);
2362 476672 : out_ptr[1] = ((in_ptr[1] & 0x0f) << 8) | in_ptr[2];
2363 : }
2364 : }
2365 : else
2366 : {
2367 157649 : bufptr[0] = (TIFF_JSAMPROW)buf;
2368 : }
2369 176849 : if (TIFFjpeg_write_scanlines(sp, bufptr, 1) != 1)
2370 0 : return (0);
2371 176852 : if (nrows > 0)
2372 168596 : tif->tif_row++;
2373 176852 : buf += sp->bytesperline;
2374 : }
2375 :
2376 8258 : if (sp->cinfo.c.data_precision == 12)
2377 : {
2378 1181 : _TIFFfreeExt(tif, line16);
2379 : }
2380 :
2381 8254 : return (1);
2382 : }
2383 :
2384 : /*
2385 : * Encode a chunk of pixels.
2386 : * Incoming data is expected to be downsampled per sampling factors.
2387 : */
2388 0 : static int JPEGEncodeRaw(TIFF *tif, uint8_t *buf, tmsize_t cc, uint16_t s)
2389 : {
2390 0 : JPEGState *sp = JState(tif);
2391 : TIFF_JSAMPLE *inptr;
2392 : TIFF_JSAMPLE *outptr;
2393 : tmsize_t nrows;
2394 : JDIMENSION clumps_per_line, nclump;
2395 : int clumpoffset, ci, xpos, ypos;
2396 : jpeg_component_info *compptr;
2397 0 : int samples_per_clump = sp->samplesperclump;
2398 : tmsize_t bytesperclumpline;
2399 :
2400 : (void)s;
2401 0 : assert(sp != NULL);
2402 : /* data is expected to be supplied in multiples of a clumpline */
2403 : /* a clumpline is equivalent to v_sampling desubsampled scanlines */
2404 : /* TODO: the following calculation of bytesperclumpline, should substitute
2405 : * calculation of sp->bytesperline, except that it is per v_sampling lines
2406 : */
2407 0 : bytesperclumpline =
2408 0 : ((((tmsize_t)sp->cinfo.c.image_width + sp->h_sampling - 1) /
2409 0 : sp->h_sampling) *
2410 0 : ((tmsize_t)sp->h_sampling * sp->v_sampling + 2) *
2411 0 : sp->cinfo.c.data_precision +
2412 : 7) /
2413 : 8;
2414 :
2415 0 : nrows = (cc / bytesperclumpline) * sp->v_sampling;
2416 0 : if (cc % bytesperclumpline)
2417 0 : TIFFWarningExtR(tif, tif->tif_name, "fractional scanline discarded");
2418 :
2419 : /* Cb,Cr both have sampling factors 1, so this is correct */
2420 0 : clumps_per_line = sp->cinfo.c.comp_info[1].downsampled_width;
2421 :
2422 0 : while (nrows > 0)
2423 : {
2424 : /*
2425 : * Fastest way to separate the data is to make one pass
2426 : * over the scanline for each row of each component.
2427 : */
2428 0 : clumpoffset = 0; /* first sample in clump */
2429 0 : for (ci = 0, compptr = sp->cinfo.c.comp_info;
2430 0 : ci < sp->cinfo.c.num_components; ci++, compptr++)
2431 : {
2432 0 : int hsamp = compptr->h_samp_factor;
2433 0 : int vsamp = compptr->v_samp_factor;
2434 0 : int padding = (int)(compptr->width_in_blocks * DCTSIZE -
2435 0 : clumps_per_line * hsamp);
2436 0 : for (ypos = 0; ypos < vsamp; ypos++)
2437 : {
2438 0 : inptr = ((TIFF_JSAMPLE *)buf) + clumpoffset;
2439 0 : outptr = sp->ds_buffer[ci][sp->scancount * vsamp + ypos];
2440 0 : if (hsamp == 1)
2441 : {
2442 : /* fast path for at least Cb and Cr */
2443 0 : for (nclump = clumps_per_line; nclump-- > 0;)
2444 : {
2445 0 : *outptr++ = inptr[0];
2446 0 : inptr += samples_per_clump;
2447 : }
2448 : }
2449 : else
2450 : {
2451 : /* general case */
2452 0 : for (nclump = clumps_per_line; nclump-- > 0;)
2453 : {
2454 0 : for (xpos = 0; xpos < hsamp; xpos++)
2455 0 : *outptr++ = inptr[xpos];
2456 0 : inptr += samples_per_clump;
2457 : }
2458 : }
2459 : /* pad each scanline as needed */
2460 0 : for (xpos = 0; xpos < padding; xpos++)
2461 : {
2462 0 : *outptr = outptr[-1];
2463 0 : outptr++;
2464 : }
2465 0 : clumpoffset += hsamp;
2466 : }
2467 : }
2468 0 : sp->scancount++;
2469 0 : if (sp->scancount >= DCTSIZE)
2470 : {
2471 0 : int n = sp->cinfo.c.max_v_samp_factor * DCTSIZE;
2472 0 : if (TIFFjpeg_write_raw_data(sp, sp->ds_buffer, n) != n)
2473 0 : return (0);
2474 0 : sp->scancount = 0;
2475 : }
2476 0 : tif->tif_row += sp->v_sampling;
2477 0 : buf += bytesperclumpline;
2478 0 : nrows -= sp->v_sampling;
2479 : }
2480 0 : return (1);
2481 : }
2482 :
2483 : /*
2484 : * Finish up at the end of a strip or tile.
2485 : */
2486 4208 : static int JPEGPostEncode(TIFF *tif)
2487 : {
2488 4208 : JPEGState *sp = JState(tif);
2489 :
2490 4208 : if (sp->scancount > 0)
2491 : {
2492 : /*
2493 : * Need to emit a partial bufferload of downsampled data.
2494 : * Pad the data vertically.
2495 : */
2496 : int ci, ypos, n;
2497 : jpeg_component_info *compptr;
2498 :
2499 0 : for (ci = 0, compptr = sp->cinfo.c.comp_info;
2500 0 : ci < sp->cinfo.c.num_components; ci++, compptr++)
2501 : {
2502 0 : int vsamp = compptr->v_samp_factor;
2503 0 : tmsize_t row_width =
2504 0 : compptr->width_in_blocks * DCTSIZE * sizeof(JSAMPLE);
2505 0 : for (ypos = sp->scancount * vsamp; ypos < DCTSIZE * vsamp; ypos++)
2506 : {
2507 0 : _TIFFmemcpy((void *)sp->ds_buffer[ci][ypos],
2508 0 : (void *)sp->ds_buffer[ci][ypos - 1], row_width);
2509 : }
2510 : }
2511 0 : n = sp->cinfo.c.max_v_samp_factor * DCTSIZE;
2512 0 : if (TIFFjpeg_write_raw_data(sp, sp->ds_buffer, n) != n)
2513 0 : return (0);
2514 : }
2515 :
2516 4208 : return (TIFFjpeg_finish_compress(JState(tif)));
2517 : }
2518 :
2519 5380 : static void JPEGCleanup(TIFF *tif)
2520 : {
2521 5380 : JPEGState *sp = JState(tif);
2522 :
2523 5380 : assert(sp != 0);
2524 :
2525 5380 : tif->tif_tagmethods.vgetfield = sp->otherSettings.vgetparent;
2526 5380 : tif->tif_tagmethods.vsetfield = sp->otherSettings.vsetparent;
2527 5380 : tif->tif_tagmethods.printdir = sp->otherSettings.printdir;
2528 5380 : if (sp->cinfo_initialized)
2529 2357 : TIFFjpeg_destroy(sp); /* release libjpeg resources */
2530 5381 : if (sp->otherSettings.jpegtables) /* tag value */
2531 5349 : _TIFFfreeExt(tif, sp->otherSettings.jpegtables);
2532 5381 : _TIFFfreeExt(tif, tif->tif_data); /* release local state */
2533 5379 : tif->tif_data = NULL;
2534 :
2535 5379 : _TIFFSetDefaultCompressionState(tif);
2536 5379 : }
2537 :
2538 4577 : static void JPEGResetUpsampled(TIFF *tif)
2539 : {
2540 4577 : JPEGState *sp = JState(tif);
2541 4577 : TIFFDirectory *td = &tif->tif_dir;
2542 :
2543 : /*
2544 : * Mark whether returned data is up-sampled or not so TIFFStripSize
2545 : * and TIFFTileSize return values that reflect the true amount of
2546 : * data.
2547 : */
2548 4577 : tif->tif_flags &= ~TIFF_UPSAMPLED;
2549 4577 : if (td->td_planarconfig == PLANARCONFIG_CONTIG)
2550 : {
2551 4531 : if (td->td_photometric == PHOTOMETRIC_YCBCR &&
2552 2787 : sp->otherSettings.jpegcolormode == JPEGCOLORMODE_RGB)
2553 : {
2554 1232 : tif->tif_flags |= TIFF_UPSAMPLED;
2555 : }
2556 : else
2557 : {
2558 : #ifdef notdef
2559 : if (td->td_ycbcrsubsampling[0] != 1 ||
2560 : td->td_ycbcrsubsampling[1] != 1)
2561 : ; /* XXX what about up-sampling? */
2562 : #endif
2563 : }
2564 : }
2565 :
2566 : /*
2567 : * Must recalculate cached tile size in case sampling state changed.
2568 : * Should we really be doing this now if image size isn't set?
2569 : */
2570 4577 : if (tif->tif_tilesize > 0)
2571 640 : tif->tif_tilesize = isTiled(tif) ? TIFFTileSize(tif) : (tmsize_t)(-1);
2572 4577 : if (tif->tif_scanlinesize > 0)
2573 3757 : tif->tif_scanlinesize = TIFFScanlineSize(tif);
2574 4577 : }
2575 :
2576 43976 : static int JPEGVSetField(TIFF *tif, uint32_t tag, va_list ap)
2577 : {
2578 43976 : JPEGState *sp = JState(tif);
2579 : const TIFFField *fip;
2580 : uint32_t v32;
2581 :
2582 43976 : assert(sp != NULL);
2583 :
2584 43976 : switch (tag)
2585 : {
2586 3107 : case TIFFTAG_JPEGTABLES:
2587 3107 : v32 = (uint32_t)va_arg(ap, uint32_t);
2588 3107 : if (v32 == 0)
2589 : {
2590 : /* XXX */
2591 0 : return (0);
2592 : }
2593 3107 : _TIFFsetByteArrayExt(tif, &sp->otherSettings.jpegtables,
2594 3107 : va_arg(ap, void *), v32);
2595 3107 : sp->otherSettings.jpegtables_length = v32;
2596 3107 : TIFFSetFieldBit(tif, FIELD_JPEGTABLES);
2597 3107 : break;
2598 3222 : case TIFFTAG_JPEGQUALITY:
2599 3222 : sp->otherSettings.jpegquality = (int)va_arg(ap, int);
2600 3222 : return (1); /* pseudo tag */
2601 1277 : case TIFFTAG_JPEGCOLORMODE:
2602 1277 : sp->otherSettings.jpegcolormode = (int)va_arg(ap, int);
2603 1277 : JPEGResetUpsampled(tif);
2604 1277 : return (1); /* pseudo tag */
2605 3300 : case TIFFTAG_PHOTOMETRIC:
2606 : {
2607 3300 : int ret_value = (*sp->otherSettings.vsetparent)(tif, tag, ap);
2608 3300 : JPEGResetUpsampled(tif);
2609 3300 : return ret_value;
2610 : }
2611 3699 : case TIFFTAG_JPEGTABLESMODE:
2612 3699 : sp->otherSettings.jpegtablesmode = (int)va_arg(ap, int);
2613 3699 : return (1); /* pseudo tag */
2614 1430 : case TIFFTAG_YCBCRSUBSAMPLING:
2615 : /* mark the fact that we have a real ycbcrsubsampling! */
2616 1430 : sp->otherSettings.ycbcrsampling_fetched = 1;
2617 : /* should we be recomputing upsampling info here? */
2618 1430 : return (*sp->otherSettings.vsetparent)(tif, tag, ap);
2619 27941 : default:
2620 27941 : return (*sp->otherSettings.vsetparent)(tif, tag, ap);
2621 : }
2622 :
2623 3107 : if ((fip = TIFFFieldWithTag(tif, tag)) != NULL)
2624 : {
2625 3107 : TIFFSetFieldBit(tif, fip->field_bit);
2626 : }
2627 : else
2628 : {
2629 0 : return (0);
2630 : }
2631 :
2632 3107 : tif->tif_flags |= TIFF_DIRTYDIRECT;
2633 3107 : return (1);
2634 : }
2635 :
2636 33352 : static int JPEGVGetField(TIFF *tif, uint32_t tag, va_list ap)
2637 : {
2638 33352 : JPEGState *sp = JState(tif);
2639 :
2640 33352 : assert(sp != NULL);
2641 :
2642 33352 : switch (tag)
2643 : {
2644 6973 : case TIFFTAG_JPEGTABLES:
2645 6973 : *va_arg(ap, uint32_t *) = sp->otherSettings.jpegtables_length;
2646 6973 : *va_arg(ap, const void **) = sp->otherSettings.jpegtables;
2647 6973 : break;
2648 0 : case TIFFTAG_JPEGQUALITY:
2649 0 : *va_arg(ap, int *) = sp->otherSettings.jpegquality;
2650 0 : break;
2651 558 : case TIFFTAG_JPEGCOLORMODE:
2652 558 : *va_arg(ap, int *) = sp->otherSettings.jpegcolormode;
2653 558 : break;
2654 1070 : case TIFFTAG_JPEGTABLESMODE:
2655 1070 : *va_arg(ap, int *) = sp->otherSettings.jpegtablesmode;
2656 1070 : break;
2657 24751 : default:
2658 24751 : return (*sp->otherSettings.vgetparent)(tif, tag, ap);
2659 : }
2660 8601 : return (1);
2661 : }
2662 :
2663 0 : static void JPEGPrintDir(TIFF *tif, FILE *fd, long flags)
2664 : {
2665 0 : JPEGState *sp = JState(tif);
2666 :
2667 0 : assert(sp != NULL);
2668 : (void)flags;
2669 :
2670 0 : if (sp != NULL)
2671 : {
2672 0 : if (TIFFFieldSet(tif, FIELD_JPEGTABLES))
2673 0 : fprintf(fd, " JPEG Tables: (%" PRIu32 " bytes)\n",
2674 : sp->otherSettings.jpegtables_length);
2675 0 : if (sp->otherSettings.printdir)
2676 0 : (*sp->otherSettings.printdir)(tif, fd, flags);
2677 : }
2678 0 : }
2679 :
2680 53 : static uint32_t JPEGDefaultStripSize(TIFF *tif, uint32_t s)
2681 : {
2682 53 : JPEGState *sp = JState(tif);
2683 53 : TIFFDirectory *td = &tif->tif_dir;
2684 :
2685 53 : s = (*sp->otherSettings.defsparent)(tif, s);
2686 53 : if (s < td->td_imagelength)
2687 36 : s = TIFFroundup_32(s, td->td_ycbcrsubsampling[1] * DCTSIZE);
2688 53 : return (s);
2689 : }
2690 :
2691 0 : static void JPEGDefaultTileSize(TIFF *tif, uint32_t *tw, uint32_t *th)
2692 : {
2693 0 : JPEGState *sp = JState(tif);
2694 0 : TIFFDirectory *td = &tif->tif_dir;
2695 :
2696 0 : (*sp->otherSettings.deftparent)(tif, tw, th);
2697 0 : *tw = TIFFroundup_32(*tw, td->td_ycbcrsubsampling[0] * DCTSIZE);
2698 0 : *th = TIFFroundup_32(*th, td->td_ycbcrsubsampling[1] * DCTSIZE);
2699 0 : }
2700 :
2701 : /*
2702 : * The JPEG library initialized used to be done in TIFFInitJPEG(), but
2703 : * now that we allow a TIFF file to be opened in update mode it is necessary
2704 : * to have some way of deciding whether compression or decompression is
2705 : * desired other than looking at tif->tif_mode. We accomplish this by
2706 : * examining {TILE/STRIP}BYTECOUNTS to see if there is a non-zero entry.
2707 : * If so, we assume decompression is desired.
2708 : *
2709 : * This is tricky, because TIFFInitJPEG() is called while the directory is
2710 : * being read, and generally speaking the BYTECOUNTS tag won't have been read
2711 : * at that point. So we try to defer jpeg library initialization till we
2712 : * do have that tag ... basically any access that might require the compressor
2713 : * or decompressor that occurs after the reading of the directory.
2714 : *
2715 : * In an ideal world compressors or decompressors would be setup
2716 : * at the point where a single tile or strip was accessed (for read or write)
2717 : * so that stuff like update of missing tiles, or replacement of tiles could
2718 : * be done. However, we aren't trying to crack that nut just yet ...
2719 : *
2720 : * NFW, Feb 3rd, 2003.
2721 : */
2722 :
2723 2374 : static int JPEGInitializeLibJPEG(TIFF *tif, int decompress)
2724 : {
2725 2374 : JPEGState *sp = JState(tif);
2726 :
2727 2374 : if (sp->cinfo_initialized)
2728 : {
2729 16 : if (!decompress && sp->cinfo.comm.is_decompressor)
2730 2 : TIFFjpeg_destroy(sp);
2731 14 : else if (decompress && !sp->cinfo.comm.is_decompressor)
2732 14 : TIFFjpeg_destroy(sp);
2733 : else
2734 0 : return 1;
2735 :
2736 16 : sp->cinfo_initialized = 0;
2737 : }
2738 :
2739 : /*
2740 : * Initialize libjpeg.
2741 : */
2742 2374 : if (decompress)
2743 : {
2744 173 : if (!TIFFjpeg_create_decompress(sp))
2745 0 : return (0);
2746 : }
2747 : else
2748 : {
2749 2201 : if (!TIFFjpeg_create_compress(sp))
2750 0 : return (0);
2751 : #ifndef TIFF_JPEG_MAX_MEMORY_TO_USE
2752 : #define TIFF_JPEG_MAX_MEMORY_TO_USE (10 * 1024 * 1024)
2753 : #endif
2754 : /* libjpeg turbo 1.5.2 honours max_memory_to_use, but has no backing */
2755 : /* store implementation, so better not set max_memory_to_use ourselves.
2756 : */
2757 : /* See https://github.com/libjpeg-turbo/libjpeg-turbo/issues/162 */
2758 2201 : if (sp->cinfo.c.mem->max_memory_to_use > 0)
2759 : {
2760 : /* This is to address bug related in ticket GDAL #1795. */
2761 30 : if (getenv("JPEGMEM") == NULL)
2762 : {
2763 : /* Increase the max memory usable. This helps when creating
2764 : * files */
2765 : /* with "big" tile, without using libjpeg temporary files. */
2766 : /* For example a 512x512 tile with 3 bands */
2767 : /* requires 1.5 MB which is above libjpeg 1MB default */
2768 0 : if (sp->cinfo.c.mem->max_memory_to_use <
2769 : TIFF_JPEG_MAX_MEMORY_TO_USE)
2770 0 : sp->cinfo.c.mem->max_memory_to_use =
2771 : TIFF_JPEG_MAX_MEMORY_TO_USE;
2772 : }
2773 : }
2774 : }
2775 :
2776 2374 : sp->cinfo_initialized = TRUE;
2777 :
2778 2374 : return 1;
2779 : }
2780 :
2781 : /* Common to tif_jpeg.c and tif_jpeg_12.c */
2782 6568 : static void TIFFInitJPEGCommon(TIFF *tif)
2783 : {
2784 : JPEGState *sp;
2785 :
2786 6568 : sp = JState(tif);
2787 6568 : sp->tif = tif; /* back link */
2788 :
2789 : /* Default values for codec-specific fields */
2790 6568 : sp->otherSettings.jpegtables = NULL;
2791 6568 : sp->otherSettings.jpegtables_length = 0;
2792 6568 : sp->otherSettings.jpegquality = 75; /* Default IJG quality */
2793 6568 : sp->otherSettings.jpegcolormode = JPEGCOLORMODE_RAW;
2794 6568 : sp->otherSettings.jpegtablesmode =
2795 : JPEGTABLESMODE_QUANT | JPEGTABLESMODE_HUFF;
2796 6568 : sp->otherSettings.ycbcrsampling_fetched = 0;
2797 :
2798 6568 : tif->tif_tagmethods.vgetfield = JPEGVGetField; /* hook for codec tags */
2799 6568 : tif->tif_tagmethods.vsetfield = JPEGVSetField; /* hook for codec tags */
2800 6568 : tif->tif_tagmethods.printdir = JPEGPrintDir; /* hook for codec tags */
2801 :
2802 : /*
2803 : * Install codec methods.
2804 : */
2805 6568 : tif->tif_fixuptags = JPEGFixupTags;
2806 6568 : tif->tif_setupdecode = JPEGSetupDecode;
2807 6568 : tif->tif_predecode = JPEGPreDecode;
2808 6568 : tif->tif_decoderow = JPEGDecode;
2809 6568 : tif->tif_decodestrip = JPEGDecode;
2810 6568 : tif->tif_decodetile = JPEGDecode;
2811 6568 : tif->tif_setupencode = JPEGSetupEncode;
2812 6568 : tif->tif_preencode = JPEGPreEncode;
2813 6568 : tif->tif_postencode = JPEGPostEncode;
2814 6568 : tif->tif_encoderow = JPEGEncode;
2815 6568 : tif->tif_encodestrip = JPEGEncode;
2816 6568 : tif->tif_encodetile = JPEGEncode;
2817 6568 : tif->tif_cleanup = JPEGCleanup;
2818 :
2819 6568 : tif->tif_defstripsize = JPEGDefaultStripSize;
2820 6568 : tif->tif_deftilesize = JPEGDefaultTileSize;
2821 6568 : tif->tif_flags |= TIFF_NOBITREV; /* no bit reversal, please */
2822 6568 : sp->cinfo_initialized = FALSE;
2823 6568 : }
2824 :
2825 5380 : int TIFFInitJPEG(TIFF *tif, int scheme)
2826 : {
2827 : JPEGState *sp;
2828 :
2829 : (void)scheme;
2830 5380 : assert(scheme == COMPRESSION_JPEG);
2831 :
2832 : /*
2833 : * Merge codec-specific tag information.
2834 : */
2835 5380 : if (!_TIFFMergeFields(tif, jpegFields, TIFFArrayCount(jpegFields)))
2836 : {
2837 0 : TIFFErrorExtR(tif, "TIFFInitJPEG",
2838 : "Merging JPEG codec-specific tags failed");
2839 0 : return 0;
2840 : }
2841 :
2842 : /*
2843 : * Allocate state block so tag methods have storage to record values.
2844 : */
2845 5380 : tif->tif_data = (uint8_t *)_TIFFmallocExt(tif, sizeof(JPEGState));
2846 :
2847 5380 : if (tif->tif_data == NULL)
2848 : {
2849 0 : TIFFErrorExtR(tif, "TIFFInitJPEG", "No space for JPEG state block");
2850 0 : return 0;
2851 : }
2852 5380 : _TIFFmemset(tif->tif_data, 0, sizeof(JPEGState));
2853 :
2854 5380 : sp = JState(tif);
2855 : /*
2856 : * Override parent get/set field methods.
2857 : */
2858 5380 : sp->otherSettings.vgetparent = tif->tif_tagmethods.vgetfield;
2859 5380 : sp->otherSettings.vsetparent = tif->tif_tagmethods.vsetfield;
2860 5380 : sp->otherSettings.printdir = tif->tif_tagmethods.printdir;
2861 :
2862 5380 : sp->otherSettings.defsparent = tif->tif_defstripsize;
2863 5380 : sp->otherSettings.deftparent = tif->tif_deftilesize;
2864 :
2865 5380 : TIFFInitJPEGCommon(tif);
2866 :
2867 : /*
2868 : ** Create a JPEGTables field if no directory has yet been created.
2869 : ** We do this just to ensure that sufficient space is reserved for
2870 : ** the JPEGTables field. It will be properly created the right
2871 : ** size later.
2872 : */
2873 5380 : if (tif->tif_diroff == 0)
2874 : {
2875 : #define SIZE_OF_JPEGTABLES 2000
2876 : /*
2877 : The following line assumes incorrectly that all JPEG-in-TIFF files will
2878 : have a JPEGTABLES tag generated and causes null-filled JPEGTABLES tags
2879 : to be written when the JPEG data is placed with TIFFWriteRawStrip. The
2880 : field bit should be set, anyway, later when actual JPEGTABLES header is
2881 : generated, so removing it here hopefully is harmless.
2882 : TIFFSetFieldBit(tif, FIELD_JPEGTABLES);
2883 : */
2884 2268 : sp->otherSettings.jpegtables_length = SIZE_OF_JPEGTABLES;
2885 2268 : sp->otherSettings.jpegtables =
2886 2268 : (void *)_TIFFmallocExt(tif, sp->otherSettings.jpegtables_length);
2887 2268 : if (sp->otherSettings.jpegtables)
2888 : {
2889 2268 : _TIFFmemset(sp->otherSettings.jpegtables, 0, SIZE_OF_JPEGTABLES);
2890 : }
2891 : else
2892 : {
2893 0 : TIFFErrorExtR(tif, "TIFFInitJPEG",
2894 : "Failed to allocate memory for JPEG tables");
2895 0 : return 0;
2896 : }
2897 : #undef SIZE_OF_JPEGTABLES
2898 : }
2899 5380 : return 1;
2900 : }
2901 : #endif /* JPEG_SUPPORT */
|
