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