/* * Copyright (c) 1994-1997 Sam Leffler * Copyright (c) 1994-1997 Silicon Graphics, Inc. * * Permission to use, copy, modify, distribute, and sell this software and * its documentation for any purpose is hereby granted without fee, provided * that (i) the above copyright notices and this permission notice appear in * all copies of the software and related documentation, and (ii) the names of * Sam Leffler and Silicon Graphics may not be used in any advertising or * publicity relating to the software without the specific, prior written * permission of Sam Leffler and Silicon Graphics. * * THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND, * EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY * WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. * * IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR * ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND, * OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, * WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF * LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE * OF THIS SOFTWARE. */ #define WIN32_LEAN_AND_MEAN #define VC_EXTRALEAN #include "tiffiop.h" #include <stdlib.h> #ifdef JPEG_SUPPORT /* * TIFF Library * * JPEG Compression support per TIFF Technical Note #2 * (*not* per the original TIFF 6.0 spec). * * This file is simply an interface to the libjpeg library written by * the Independent JPEG Group. You need release 5 or later of the IJG * code, which you can find on the Internet at ftp.uu.net:/graphics/jpeg/. * * Contributed by Tom Lane <[email protected]>. */ #include <setjmp.h> /* Settings that are independent of libjpeg ABI. Used when reinitializing the */ /* JPEGState from libjpegs 8 bit to libjpeg 12 bits, which have potentially */ /* different ABI */ JPEGOtherSettings; int TIFFFillStrip(TIFF *tif, uint32_t strip); int TIFFFillTile(TIFF *tif, uint32_t tile); int TIFFReInitJPEG_12(TIFF *tif, const JPEGOtherSettings *otherSettings, int scheme, int is_encode); int TIFFJPEGIsFullStripRequired_12(TIFF *tif); /* We undefine FAR to avoid conflict with JPEG definition */ #ifdef FAR #undef FAR #endif /* Libjpeg's jmorecfg.h defines INT16 and INT32, but only if XMD_H is not defined. Unfortunately, the MinGW and Borland compilers include a typedef for INT32, which causes a conflict. MSVC does not include a conflicting typedef given the headers which are included. */ #if defined(__BORLANDC__) || defined(__MINGW32__) #define XMD_H … #endif /* The windows RPCNDR.H file defines boolean, but defines it with the unsigned char size. You should compile JPEG library using appropriate definitions in jconfig.h header, but many users compile library in wrong way. That causes errors of the following type: "JPEGLib: JPEG parameter struct mismatch: library thinks size is 432, caller expects 464" For such users we will fix the problem here. See install.doc file from the JPEG library distribution for details. */ /* Define "boolean" as unsigned char, not int, per Windows custom. */ #if defined(__WIN32__) && !defined(__MINGW32__) #ifndef __RPCNDR_H__ /* don't conflict if rpcndr.h already read */ typedef unsigned char boolean; #endif #define HAVE_BOOLEAN … #endif #if defined(USE_SYSTEM_LIBJPEG) #include <jerror.h> #include <jpeglib.h> #elif defined(USE_LIBJPEG_TURBO) #include "third_party/libjpeg_turbo/jerror.h" #include "third_party/libjpeg_turbo/jpeglib.h" #else #include "third_party/libjpeg/jerror.h" #include "third_party/libjpeg/jpeglib.h" #endif /* Do optional compile-time version check */ #if defined(EXPECTED_JPEG_LIB_VERSION) && !defined(LIBJPEG_12_PATH) #if EXPECTED_JPEG_LIB_VERSION != JPEG_LIB_VERSION #error EXPECTED_JPEG_LIB_VERSION != JPEG_LIB_VERSION #endif #endif /* * Do we want to do special processing suitable for when JSAMPLE is a * 16bit value? */ /* HAVE_JPEGTURBO_DUAL_MODE_8_12 is defined for libjpeg-turbo >= 2.2 which * adds a dual-mode 8/12 bit API in the same library. */ #if defined(HAVE_JPEGTURBO_DUAL_MODE_8_12) #define JPEG_DUAL_MODE_8_12 /* Start by undefining BITS_IN_JSAMPLE which is always set to 8 in libjpeg-turbo * >= 2.2 Cf * https://github.com/libjpeg-turbo/libjpeg-turbo/commit/8b9bc4b9635a2a047fb23ebe70c9acd728d3f99b */ #undef BITS_IN_JSAMPLE /* libjpeg-turbo >= 2.2 adds J12xxxx datatypes for the 12-bit mode. */ #if defined(FROM_TIF_JPEG_12) #define BITS_IN_JSAMPLE … #define TIFF_JSAMPLE … #define TIFF_JSAMPARRAY … #define TIFF_JSAMPIMAGE … #define TIFF_JSAMPROW … #else #define BITS_IN_JSAMPLE … #define TIFF_JSAMPLE … #define TIFF_JSAMPARRAY … #define TIFF_JSAMPIMAGE … #define TIFF_JSAMPROW … #endif #else #define TIFF_JSAMPLE … #define TIFF_JSAMPARRAY … #define TIFF_JSAMPIMAGE … #define TIFF_JSAMPROW … #endif #if defined(JPEG_LIB_MK1) #define JPEG_LIB_MK1_OR_12BIT … #elif BITS_IN_JSAMPLE == 12 #define JPEG_LIB_MK1_OR_12BIT … #endif /* * We are using width_in_blocks which is supposed to be private to * libjpeg. Unfortunately, the libjpeg delivered with Cygwin has * renamed this member to width_in_data_units. Since the header has * also renamed a define, use that unique define name in order to * detect the problem header and adjust to suit. */ #if defined(D_MAX_DATA_UNITS_IN_MCU) #define width_in_blocks … #endif /* * On some machines it may be worthwhile to use _setjmp or sigsetjmp * in place of plain setjmp. These macros will make it easier. */ #define SETJMP(jbuf) … #define LONGJMP(jbuf, code) … #define JMP_BUF … jpeg_destination_mgr; jpeg_source_mgr; jpeg_error_mgr; /* * State block for each open TIFF file using * libjpeg to do JPEG compression/decompression. * * libjpeg's visible state is either a jpeg_compress_struct * or jpeg_decompress_struct depending on which way we * are going. comm can be used to refer to the fields * which are common to both. * * NB: cinfo is required to be the first member of JPEGState, * so we can safely cast JPEGState* -> jpeg_xxx_struct* * and vice versa! */ JPEGState; #define JState(tif) … static int JPEGDecode(TIFF *tif, uint8_t *buf, tmsize_t cc, uint16_t s); static int JPEGDecodeRaw(TIFF *tif, uint8_t *buf, tmsize_t cc, uint16_t s); static int JPEGEncode(TIFF *tif, uint8_t *buf, tmsize_t cc, uint16_t s); static int JPEGEncodeRaw(TIFF *tif, uint8_t *buf, tmsize_t cc, uint16_t s); static int JPEGInitializeLibJPEG(TIFF *tif, int decode); static int DecodeRowError(TIFF *tif, uint8_t *buf, tmsize_t cc, uint16_t s); #define FIELD_JPEGTABLES … static const TIFFField jpegFields[] = …; /* * libjpeg interface layer. * * We use setjmp/longjmp to return control to libtiff * when a fatal error is encountered within the JPEG * library. We also direct libjpeg error and warning * messages through the appropriate libtiff handlers. */ /* * Error handling routines (these replace corresponding * IJG routines from jerror.c). These are used for both * compression and decompression. */ static void TIFFjpeg_error_exit(j_common_ptr cinfo) { … } /* * This routine is invoked only for warning messages, * since error_exit does its own thing and trace_level * is never set > 0. */ static void TIFFjpeg_output_message(j_common_ptr cinfo) { … } /* Avoid the risk of denial-of-service on crafted JPEGs with an insane */ /* number of scans. */ /* See * http://www.libjpeg-turbo.org/pmwiki/uploads/About/TwoIssueswiththeJPEGStandard.pdf */ static void TIFFjpeg_progress_monitor(j_common_ptr cinfo) { … } /* * Interface routines. This layer of routines exists * primarily to limit side-effects from using setjmp. * Also, normal/error returns are converted into return * values per libtiff practice. */ #define CALLJPEG(sp, fail, op) … #define CALLVJPEG(sp, op) … static int TIFFjpeg_create_compress(JPEGState *sp) { … } static int TIFFjpeg_create_decompress(JPEGState *sp) { … } static int TIFFjpeg_set_defaults(JPEGState *sp) { … } static int TIFFjpeg_set_colorspace(JPEGState *sp, J_COLOR_SPACE colorspace) { … } static int TIFFjpeg_set_quality(JPEGState *sp, int quality, boolean force_baseline) { … } static int TIFFjpeg_suppress_tables(JPEGState *sp, boolean suppress) { … } static int TIFFjpeg_start_compress(JPEGState *sp, boolean write_all_tables) { … } static int TIFFjpeg_write_scanlines(JPEGState *sp, TIFF_JSAMPARRAY scanlines, int num_lines) { … } static int TIFFjpeg_write_raw_data(JPEGState *sp, TIFF_JSAMPIMAGE data, int num_lines) { … } static int TIFFjpeg_finish_compress(JPEGState *sp) { … } static int TIFFjpeg_write_tables(JPEGState *sp) { … } static int TIFFjpeg_read_header(JPEGState *sp, boolean require_image) { … } static int TIFFjpeg_has_multiple_scans(JPEGState *sp) { … } static int TIFFjpeg_start_decompress(JPEGState *sp) { … } static int TIFFjpeg_read_scanlines(JPEGState *sp, TIFF_JSAMPARRAY scanlines, int max_lines) { … } static int TIFFjpeg_read_raw_data(JPEGState *sp, TIFF_JSAMPIMAGE data, int max_lines) { … } static int TIFFjpeg_finish_decompress(JPEGState *sp) { … } static int TIFFjpeg_abort(JPEGState *sp) { … } static int TIFFjpeg_destroy(JPEGState *sp) { … } static JSAMPARRAY TIFFjpeg_alloc_sarray(JPEGState *sp, int pool_id, JDIMENSION samplesperrow, JDIMENSION numrows) { … } /* * JPEG library destination data manager. * These routines direct compressed data from libjpeg into the * libtiff output buffer. */ static void std_init_destination(j_compress_ptr cinfo) { … } static boolean std_empty_output_buffer(j_compress_ptr cinfo) { … } static void std_term_destination(j_compress_ptr cinfo) { … } static void TIFFjpeg_data_dest(JPEGState *sp, TIFF *tif) { … } /* * Alternate destination manager for outputting to JPEGTables field. */ static void tables_init_destination(j_compress_ptr cinfo) { … } static boolean tables_empty_output_buffer(j_compress_ptr cinfo) { … } static void tables_term_destination(j_compress_ptr cinfo) { … } static int TIFFjpeg_tables_dest(JPEGState *sp, TIFF *tif) { … } /* * JPEG library source data manager. * These routines supply compressed data to libjpeg. */ static void std_init_source(j_decompress_ptr cinfo) { … } static boolean std_fill_input_buffer(j_decompress_ptr cinfo) { … } static void std_skip_input_data(j_decompress_ptr cinfo, long num_bytes) { … } static void std_term_source(j_decompress_ptr cinfo) { … } static void TIFFjpeg_data_src(JPEGState *sp) { … } /* * Alternate source manager for reading from JPEGTables. * We can share all the code except for the init routine. */ static void tables_init_source(j_decompress_ptr cinfo) { … } static void TIFFjpeg_tables_src(JPEGState *sp) { … } /* * Allocate downsampled-data buffers needed for downsampled I/O. * We use values computed in jpeg_start_compress or jpeg_start_decompress. * We use libjpeg's allocator so that buffers will be released automatically * when done with strip/tile. * This is also a handy place to compute samplesperclump, bytesperline. */ static int alloc_downsampled_buffers(TIFF *tif, jpeg_component_info *comp_info, int num_components) { … } /* * JPEG Decoding. */ #ifdef CHECK_JPEG_YCBCR_SUBSAMPLING #define JPEG_MARKER_SOF0 … #define JPEG_MARKER_SOF1 … #define JPEG_MARKER_SOF2 … #define JPEG_MARKER_SOF9 … #define JPEG_MARKER_SOF10 … #define JPEG_MARKER_DHT … #define JPEG_MARKER_SOI … #define JPEG_MARKER_SOS … #define JPEG_MARKER_DQT … #define JPEG_MARKER_DRI … #define JPEG_MARKER_APP0 … #define JPEG_MARKER_COM … struct JPEGFixupTagsSubsamplingData { … }; static void JPEGFixupTagsSubsampling(TIFF *tif); static int JPEGFixupTagsSubsamplingSec(struct JPEGFixupTagsSubsamplingData *data); static int JPEGFixupTagsSubsamplingReadByte(struct JPEGFixupTagsSubsamplingData *data, uint8_t *result); static int JPEGFixupTagsSubsamplingReadWord(struct JPEGFixupTagsSubsamplingData *data, uint16_t *result); static void JPEGFixupTagsSubsamplingSkip(struct JPEGFixupTagsSubsamplingData *data, uint16_t skiplength); #endif static int JPEGFixupTags(TIFF *tif) { … } #ifdef CHECK_JPEG_YCBCR_SUBSAMPLING static void JPEGFixupTagsSubsampling(TIFF *tif) { … } static int JPEGFixupTagsSubsamplingSec(struct JPEGFixupTagsSubsamplingData *data) { … } static int JPEGFixupTagsSubsamplingReadByte(struct JPEGFixupTagsSubsamplingData *data, uint8_t *result) { … } static int JPEGFixupTagsSubsamplingReadWord(struct JPEGFixupTagsSubsamplingData *data, uint16_t *result) { … } static void JPEGFixupTagsSubsamplingSkip(struct JPEGFixupTagsSubsamplingData *data, uint16_t skiplength) { … } #endif static int JPEGSetupDecode(TIFF *tif) { … } /* Returns 1 if the full strip should be read, even when doing scanline per */ /* scanline decoding. This happens when the JPEG stream uses multiple scans. */ /* Currently only called in CHUNKY_STRIP_READ_SUPPORT mode through */ /* scanline interface. */ /* Only reads tif->tif_dir.td_bitspersample, tif->tif_rawdata and */ /* tif->tif_rawcc members. */ /* Can be called independently of the usual setup/predecode/decode states */ int TIFFJPEGIsFullStripRequired(TIFF *tif) { … } /* * Set up for decoding a strip or tile. */ /*ARGSUSED*/ static int JPEGPreDecode(TIFF *tif, uint16_t s) { … } /* * Decode a chunk of pixels. * "Standard" case: returned data is not downsampled. */ #if !JPEG_LIB_MK1_OR_12BIT static int JPEGDecode(TIFF *tif, uint8_t *buf, tmsize_t cc, uint16_t s) { … } #endif /* !JPEG_LIB_MK1_OR_12BIT */ #if JPEG_LIB_MK1_OR_12BIT /*ARGSUSED*/ static int JPEGDecode(TIFF *tif, uint8_t *buf, tmsize_t cc, uint16_t s) { JPEGState *sp = JState(tif); tmsize_t nrows; (void)s; /* ** Update available information, buffer may have been refilled ** between decode requests */ sp->src.next_input_byte = (const JOCTET *)tif->tif_rawcp; sp->src.bytes_in_buffer = (size_t)tif->tif_rawcc; if (sp->bytesperline == 0) return 0; nrows = cc / sp->bytesperline; if (cc % sp->bytesperline) TIFFWarningExtR(tif, tif->tif_name, "fractional scanline not read"); if (nrows > (tmsize_t)sp->cinfo.d.image_height) nrows = sp->cinfo.d.image_height; /* data is expected to be read in multiples of a scanline */ if (nrows) { TIFF_JSAMPROW line_work_buf = NULL; /* * For 6B, only use temporary buffer for 12 bit imagery. * For Mk1 always use it. */ if (sp->cinfo.d.data_precision == 12) { line_work_buf = (TIFF_JSAMPROW)_TIFFmallocExt( tif, sizeof(short) * sp->cinfo.d.output_width * sp->cinfo.d.num_components); } do { if (line_work_buf != NULL) { /* * In the MK1 case, we always read into a 16bit * buffer, and then pack down to 12bit or 8bit. * In 6B case we only read into 16 bit buffer * for 12bit data, which we need to repack. */ if (TIFFjpeg_read_scanlines(sp, &line_work_buf, 1) != 1) return (0); if (sp->cinfo.d.data_precision == 12) { int value_pairs = (sp->cinfo.d.output_width * sp->cinfo.d.num_components) / 2; int iPair; for (iPair = 0; iPair < value_pairs; iPair++) { unsigned char *out_ptr = ((unsigned char *)buf) + iPair * 3; TIFF_JSAMPLE *in_ptr = line_work_buf + iPair * 2; out_ptr[0] = (unsigned char)((in_ptr[0] & 0xff0) >> 4); out_ptr[1] = (unsigned char)(((in_ptr[0] & 0xf) << 4) | ((in_ptr[1] & 0xf00) >> 8)); out_ptr[2] = (unsigned char)(((in_ptr[1] & 0xff) >> 0)); } } else if (sp->cinfo.d.data_precision == 8) { int value_count = (sp->cinfo.d.output_width * sp->cinfo.d.num_components); int iValue; for (iValue = 0; iValue < value_count; iValue++) { ((unsigned char *)buf)[iValue] = line_work_buf[iValue] & 0xff; } } } ++tif->tif_row; buf += sp->bytesperline; cc -= sp->bytesperline; } while (--nrows > 0); if (line_work_buf != NULL) _TIFFfreeExt(tif, line_work_buf); } /* Update information on consumed data */ tif->tif_rawcp = (uint8_t *)sp->src.next_input_byte; tif->tif_rawcc = sp->src.bytes_in_buffer; /* Close down the decompressor if we've finished the strip or tile. */ return sp->cinfo.d.output_scanline < sp->cinfo.d.output_height || TIFFjpeg_finish_decompress(sp); } #endif /* JPEG_LIB_MK1_OR_12BIT */ /*ARGSUSED*/ static int DecodeRowError(TIFF *tif, uint8_t *buf, tmsize_t cc, uint16_t s) { … } /* * Decode a chunk of pixels. * Returned data is downsampled per sampling factors. */ /*ARGSUSED*/ static int JPEGDecodeRaw(TIFF *tif, uint8_t *buf, tmsize_t cc, uint16_t s) { … } /* * JPEG Encoding. */ static void unsuppress_quant_table(JPEGState *sp, int tblno) { … } static void suppress_quant_table(JPEGState *sp, int tblno) { … } static void unsuppress_huff_table(JPEGState *sp, int tblno) { … } static void suppress_huff_table(JPEGState *sp, int tblno) { … } static int prepare_JPEGTables(TIFF *tif) { … } #if defined(JPEG_LIB_VERSION_MAJOR) && \ (JPEG_LIB_VERSION_MAJOR > 9 || \ (JPEG_LIB_VERSION_MAJOR == 9 && JPEG_LIB_VERSION_MINOR >= 4)) /* This is a modified version of std_huff_tables() from jcparam.c * in libjpeg-9d because it no longer initializes default Huffman * tables in jpeg_set_defaults(). */ static void TIFF_std_huff_tables(j_compress_ptr cinfo) { if (cinfo->dc_huff_tbl_ptrs[0] == NULL) { (void)jpeg_std_huff_table((j_common_ptr)cinfo, TRUE, 0); } if (cinfo->ac_huff_tbl_ptrs[0] == NULL) { (void)jpeg_std_huff_table((j_common_ptr)cinfo, FALSE, 0); } if (cinfo->dc_huff_tbl_ptrs[1] == NULL) { (void)jpeg_std_huff_table((j_common_ptr)cinfo, TRUE, 1); } if (cinfo->ac_huff_tbl_ptrs[1] == NULL) { (void)jpeg_std_huff_table((j_common_ptr)cinfo, FALSE, 1); } } #endif static int JPEGSetupEncode(TIFF *tif) { … } /* * Set encoding state at the start of a strip or tile. */ static int JPEGPreEncode(TIFF *tif, uint16_t s) { … } /* * Encode a chunk of pixels. * "Standard" case: incoming data is not downsampled. */ static int JPEGEncode(TIFF *tif, uint8_t *buf, tmsize_t cc, uint16_t s) { … } /* * Encode a chunk of pixels. * Incoming data is expected to be downsampled per sampling factors. */ static int JPEGEncodeRaw(TIFF *tif, uint8_t *buf, tmsize_t cc, uint16_t s) { … } /* * Finish up at the end of a strip or tile. */ static int JPEGPostEncode(TIFF *tif) { … } static void JPEGCleanup(TIFF *tif) { … } static void JPEGResetUpsampled(TIFF *tif) { … } static int JPEGVSetField(TIFF *tif, uint32_t tag, va_list ap) { … } static int JPEGVGetField(TIFF *tif, uint32_t tag, va_list ap) { … } static void JPEGPrintDir(TIFF *tif, FILE *fd, long flags) { … } static uint32_t JPEGDefaultStripSize(TIFF *tif, uint32_t s) { … } static void JPEGDefaultTileSize(TIFF *tif, uint32_t *tw, uint32_t *th) { … } /* * The JPEG library initialized used to be done in TIFFInitJPEG(), but * now that we allow a TIFF file to be opened in update mode it is necessary * to have some way of deciding whether compression or decompression is * desired other than looking at tif->tif_mode. We accomplish this by * examining {TILE/STRIP}BYTECOUNTS to see if there is a non-zero entry. * If so, we assume decompression is desired. * * This is tricky, because TIFFInitJPEG() is called while the directory is * being read, and generally speaking the BYTECOUNTS tag won't have been read * at that point. So we try to defer jpeg library initialization till we * do have that tag ... basically any access that might require the compressor * or decompressor that occurs after the reading of the directory. * * In an ideal world compressors or decompressors would be setup * at the point where a single tile or strip was accessed (for read or write) * so that stuff like update of missing tiles, or replacement of tiles could * be done. However, we aren't trying to crack that nut just yet ... * * NFW, Feb 3rd, 2003. */ static int JPEGInitializeLibJPEG(TIFF *tif, int decompress) { … } /* Common to tif_jpeg.c and tif_jpeg_12.c */ static void TIFFInitJPEGCommon(TIFF *tif) { … } int TIFFInitJPEG(TIFF *tif, int scheme) { … } #endif /* JPEG_SUPPORT */
Codebase Browser
chromium