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