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